open-index/open-npm huggingface dataset:
npm package: @openorgus/react
Description: A comprehensive React component library with 81 production-ready components by OpenOrgus.
Author: OpenOrgus
Latest version: 0.1.12

# @openorgus/react

OpenGrid Design System - A comprehensive React component library with 81 production-ready components.

## 🚀 Installation

```bash
npm install @openorgus/react
# or
yarn add @openorgus/react
# or
pnpm add @openorgus/react
```

## 📦 Components

### Basic Components (15)
Alert, Avatar, Badge, Box, Breadcrumbs, Card, Chip, Container, Divider, Link, List, Paper, Skeleton, Stack, Tooltip

### Form Components (14)
Autocomplete, Checkbox, ColorPicker, DatePicker, NumberField, Radio, Select, Signature, Slider, Switch, TextArea, TextField, Upload, VerificationCode

### Navigation Components (7)
AppBar, BottomNavigation, Menu, Pagination, SpeedDial, Stepper, Tabs

### Feedback Components (6)
Backdrop, Dialog, Modal, Progress, Snackbar, Loader

### Data Display Components (7)
Charts, ImageList, Rating, Table, TransferList, TreeView, OrderSummary

### Interactive Components (8)
Button, ButtonGroup, FloatingActionButton, ToggleButton, Drawer, ActionSheet, Camera, Map

### Advanced/AI Components (11)
AIChatbot, CodeGenerator, ImageGenerator, TextGenerator, VideoGenerator, VoiceChatbot, VoiceUI, DataQuery, Whiteboard, QRCode, CreditCard

### Media/Visual Components (9)
AnimationPreview, EmojisPreview, IconsPreview, IllustrationsPreview, VideoPlayer, TypographyPreview, FontAwesomeWrapper, ShoppingCart, VirtualKeyboard

### Effects/Decorative (4)
InteractiveCursor, MagnetLines, PixelTrail, DecayCard

## 💡 Usage

```jsx
import { Button, Card, TextField } from '@openorgus/react';

function App() {
  return (
    <Card>
      <TextField label="Name" />
      <Button variant="primary">Submit</Button>
    </Card>
  );
}
```

## 🎨 Features

- ✅ 81 Production-ready components
- ✅ TypeScript support
- ✅ Fully customizable
- ✅ Responsive design
- ✅ Dark mode support
- ✅ Accessibility compliant
- ✅ Tree-shakeable
- ✅ Zero dependencies (except peer deps)

## 📖 Documentation

Visit [https://opengrid.design](https://opengrid.design) for full documentation.

## 📄 License

MIT © OpenGrid Team
npm package: @openoscom/sdk-core
Description: ⚒️ An SDK for building applications on top of Uniswap V3
Latest version: 1.1.0

# Uniswap SDK Core

[![Unit Tests](https://github.com/Uniswap/uniswap-sdk-core/workflows/Unit%20Tests/badge.svg)](https://github.com/Uniswap/uniswap-sdk-core/actions?query=workflow%3A%22Unit+Tests%22)
[![Lint](https://github.com/Uniswap/uniswap-sdk-core/workflows/Lint/badge.svg)](https://github.com/Uniswap/uniswap-sdk-core/actions?query=workflow%3ALint)
[![npm version](https://img.shields.io/npm/v/@uniswap/sdk-core/latest.svg)](https://www.npmjs.com/package/@uniswap/sdk-core/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/sdk-core/latest.svg)](https://bundlephobia.com/result?p=@uniswap/sdk-core@latest)

This code is shared across Uniswap TypeScript SDKs.
npm package: @openovate/babel-plugin-file-loader
Description: Shim of sheerun/babel-plugin-file-loader
Author: Adam Stankiewicz
Latest version: 2.0.3

# babel-plugin-file-loader

This is a 2021 fork of [babel-plugin-file-loader](https://github.com/sheerun/babel-plugin-file-loader) by [@sheerun](https://github.com/sheerun)
and is a temporary shim that fixes importing SVGs from `node_modules` until the original plugin is updated. see [issue #8](https://github.com/sheerun/babel-plugin-file-loader/issues/8) for more information.

## Installation

```bash
yarn add @openovate/babel-plugin-file-loader
```

Or if you like npm:

```bash
npm install @openovate/babel-plugin-file-loader --save
```

Then put following `@openovate/babel-plugin-file-loader` as plugin in `.babelrc`:

```json
{
  "plugins": ["@openovate/babel-plugin-file-loader"]
}
```

This is equivalent to following default configuration:

```json
{
  "plugins": [
    [
      "@openovate/babel-plugin-file-loader",
      {
        "name": "[hash].[ext]",
        "extensions": ["png", "jpg", "jpeg", "gif", "svg"],
        "publicPath": "/public",
        "outputPath": "/public",
        "context": "",
        "limit": 0
      }
    ]
  ]
}
```

## Matching with Webpack 5 file-loader

In Babel. *(.babelrc)*

```json
{
  "plugins": [
    [
      "@openovate/babel-plugin-file-loader",
      {
        "extensions": ["png", "jpg", "jpeg", "gif", "svg"],
        "name": "[md5:hash:base64:7].[ext]",
        "publicPath": "/public/assets"
      }
    ]
  ]
}
```

In webpack using [file-loader](https://www.npmjs.com/package/file-loader). *(webpack.config.js)*

```js
{
  ...
  module: {
    rules: [
      ...
      {
        test: /\.(png|jpe?g|gif|svg)$/i,
        use: [
          {
            loader: 'file-loader',
            options: {
              name: '[md5:hash:base64:7].[ext]',
              publicPath: '/public/assets',
              outputPath: 'assets'
            }
          }
        ]
      }
      ...
    ]
  }
}
```

## More Info

See the original ([babel-plugin-file-loader](https://github.com/sheerun/babel-plugin-file-loader)) documentation.
npm package: @openovate/eventrpc
Description: Emit server events via HTTP and JSON RPC
Author: Christian Blanquera
Latest version: 0.0.1

# Event RPC

Emit server events via HTTP and JSON RPC

## Install

```bash
$ npm i --save @openovate/eventrpc
```

## Usage

To use Event RPC, you will need to configure both the server and client.

### Server

The following shows how to setup an HTTP server using Event RPC.


```js
const eventrpc = require('@openovate/eventrpc');

//setup eventrpc
const events = eventrpc('/events');
events.on('api-call', (params) => { params.bar = 'foo' });

//setup server
const server = http.createServer(events);
server.listen(3000);
```

You can also separate the event listener and use it as a middleware like the following.

```js
const eventrpc = require('@openovate/eventrpc');

//setup events
const emitter = eventrpc.EventEmitter();
emitter.on('api-call', (params) => { params.bar = 'foo' });

//setup eventrpc
const events = eventrpc('/events');
events.use(emitter);

//setup server
const server = http.createServer(events);
server.listen(3000);
```

It is possible to use Event RPC with Express like the following.

```js
const express = require('express');
const eventrpc = require('@openovate/eventrpc');

//setup eventrpc
const events = eventrpc('/events');
events.on('api-call', (params) => { params.bar = 'foo' });

//setup express
const app = express();
app.use(events);

//setup server
const server = http.createServer(app);
server.listen(3000);
```

### Client

The following shows how to quickly setup the client side.

```js
<script type="text/javascript" src="/eventrpc/eventrpc.js"></script>
<script type="text/javascript">
const emit = eventrpc('http://localhost:3000/events', { fetch });
//http event call
const results = await emit('api-call', { foo: 'bar'});
</script>
```

It is possible to `require` Event RPC using webpack like the following.

```js
const eventrpc = require('eventrpc');
```
npm package: @openovate/jsm
Description: JavaScript Modules that Work in Node, and Browser
Author: Christian Blanquera
Latest version: 0.0.19

# jsm

JavaScript Modules that Work in Node, and Browser

## Install

```bash
$ npm i @openovate/jsm
```

## EventEmitter Usage

```js
const { EventEmitter } = require('@openovate/jsm')

const emitter = new EventEmitter;

emitter.on('trigger something', async x => {
  console.log('something triggered', x + 1)
})

emitter.on(/trigger (something)/, async x => {
  await Helper.sleep(2000)
  console.log('(something) triggered', x + 2)
}, 2)

await emitter.emit('trigger something', 1)
```

## Exception Usage

```js
const { Exception } = require('@openovate/jsm')

throw Exception.for('Something %s is %s', 'good', 'bad')
```

## Registry Usage

```js
const { Registry } = require('@openovate/jsm')

const registry = Registry.load()

registry.set('foo', 'bar', 'zoo')
registry.set('foo', 'zoo', ['foo', 'bar', 'zoo'])

console.log(registry.has('foo', 'bar'))
console.log(registry.has('bar', 'foo'))
console.log(registry.get('foo', 'zoo', 1))

registry.remove('foo', 'bar')

console.log(registry.has('foo', 'bar'))
console.log(registry.has('foo', 'zoo'))
```

## TaskQueue Usage

```js
const { TaskQueue } = require('@openovate/jsm')

const queue = new TaskQueue;

queue.push(async x => {
  console.log(x + 1)
})

queue.shift(async x => {
  await Helper.sleep(2000)
  console.log(x + 2)
})

queue.add(async x => {
  console.log(x + 3)
}, 10)

await queue.run(1)
```

## Reflection Usage

```js
class Foo {
  foo(x, y, z) {
    return x + y + z;
  }
}

const foo = new Foo;
const names = reflect(foo.foo).getArgumentNames(); //--> x, y, z

const descriptors1 = reflect(Foo1).getDescriptors(); //--> {foo: {...}}
const descriptors2 = reflect(foo).getDescriptors(); //--> {foo: {...}}

const methods1 = reflect(Foo1).getMethods(); //--> {foo: function}
const methods2 = reflect(foo).getMethods(); //--> {foo: function}
```

## traits Usage

```js
const { traits } = require('@openovate/jsm')

class Bar {
  bar() {}
}

class Zoo {
  zoo() {}
}

class Foo2 extends traits(Bar, Zoo) {
  foo() {}
}

const foo = new Foo2

foo.foo()
foo.bar()
foo.zoo()
```
npm package: @openovate/socketio-router
Description: Router for Socket.io
Author: Christian Blanquera
Latest version: 0.0.2

# socketio-router
Event Router for Socket.io

## Install

```bash
$ npm i --save @openovate/socketio-router
```

## Usage

```js
//FILE: app.js

//1. make some routes
const router = require('@openovate/express-router');
const routes = router();
routes.get('/', (req, res) => {
  res.content.set('Hello World');
});

routes.get('/message/create', async(req, res) => {
  await events.emit('message-create', req, res);
});

routes.route('/socketio').get(async(req, res) => {
  res.setHeader('Content-Type', 'text/html');
  res.content.set(fs.createReadStream(__dirname + '/socketio.html'));
});

router.route('/jquery.min.js').get(async(req, res) => {
  res.setHeader('Content-Type', 'text/javascript');
  res.content.set(fs.createReadStream(__dirname + '/jquery.min.js'));
});

//2. make express
const express = require('express');
const app = express();
app.use(routes);

//3. make server
const http = require('http');
const server = http.createServer(app);
server.listen(3000);

//4. make some events
const emitter = require('@openovate/socketio-router');
const events = emitter();
events.on('message-create', function(req, res) {
  res.route.channel = 'all';
  res.rest.set('error', false);
  res.rest.set('results', req.stage.get('message'));
});

//5. make socketio
const socketio = require('socket.io');
socketio(server).use(events);
```

See the complete example in `test/sample`
npm package: @openovate/webpack-jailbreak
Description: Break out of Webpack's filesystem! This allows you to plugin virtual files and folders easily.
Author: Christian Blanquera
Latest version: 0.0.6

# Webpack Jailbreak Plugin

Break out of Webpack's filesystem! This allows you to plugin virtual files and
folders easily.

## Installation

> Note: this has only been tested for Webpack 4 *(though it should work for Webpack 3)*

```bash
npm i @openovate/webpack-jailbreak --save-dev
```

## Usage

The following example makes a virtual file denoted by `some/virtual/path.js` as
well as a virtual directory denoted by `some/virtual/path/in/entry/folder`
which is based on an actual directory denoted by `actual/location/of/path`.

```js
//# FILE: webpack.config.json
const JailbreakPlugin = require('@openovate/webpack-jailbreak');

module.exports = {
  ...
  plugins: [
    new JailbreakPlugin({
      files: {
        'some/virtual/path.js': 'console.log("Hello World")';
      },
      folders: {
        'some/virtual/path/in/entry/folder': path.resolve(__dirname, 'actual/location/of/path')
      }
    })
  ]
  ...
};
```

You can now use your virtual directories relatively anywhere.

```js
const path = require('./some/virtual/path');
const foo = require('./some/virtual/path/in/entry/folder/foo');
```

## Example

For this example we will be using `require` instead of `import` though the
`import` equivalent should work.

 * (1) In your project root folder denoted as `[PROJECT_ROOT]` create a file called
 `[PROJECT_ROOT]/src/index.js` with the following contents.

```js
const { name } = require('./product')
console.log(name)
```

 * (2) Create a file called `[PROJECT_ROOT]/product/index.js` with the following contents.

```js
module.exports = { name: 'iPhone' }
```

> Notice that `[PROJECT_ROOT]/product/index.js` is not in the `[PROJECT_ROOT]/src/`.

 * (3) Create a file called `[PROJECT_ROOT]/webpack.config.js` with the following contents.

```js
const path = require('path');
const JailbreakPlugin = require('@openovate/webpack-jailbreak');

module.exports = {
  mode: 'development',
  entry: {
    index: './src/index.js'
  },
  output: {
    filename: '[name].bundle.js',
    path: path.resolve(__dirname, 'public')
  },
  plugins: [
    new JailbreakPlugin({
      folders: {
        'src/product': path.resolve(__dirname, '/product')
      }
    })
  ]
};
```

 * (4) Run the following commands in terminal

```bash
$ npm init -y
$ npm i webpack webpack-cli @openovate/webpack-JailbreakPlugin --save-dev
$ npx webpack --config webpack.config.js
```

## Why

Webpack assumes that all of your project files should either be located in `node_modules`
or relative to the `entry` directory. To include directories into the entry directory,
webpack suggests to use [symlinks](https://webpack.js.org/configuration/resolve/#resolvesymlinks).
This is a programatic way to bundle external directories without symlinking.

## Inspiration

This project is inspired by [webpack-virtual-modules](https://github.com/sysgears/webpack-virtual-modules/issues)
*(and also extends it)*.
npm package: @openovate/webpack-virtual-folders
Description: Webpack Virtual Folders is a webpack plugin that lets you build virtual directories relative to the entry file instead of symlinking.
Author: Christian Blanquera
Latest version: 0.0.3
Deprecated: Moved to @openovate/webpack-jailbreak

> DEPRECATION NOTICE: Moved to [@openovate/webpack-jailbreak](https://github.com/Openovate/webpack-jailbreak)

# Webpack Virtual Folders

**Webpack Virtual Folders** is a webpack plugin that lets you build virtual
directories relative to the entry file instead of symlinking.

## Installation

> Note: this has only been tested for Webpack 4 *(though it should work for Webpack 3)*

```bash
npm i @openovate/webpack-virtual-folders --save-dev
```

## Usage

The following example makes a virtual directory denoted by
`some/virtual/path/in/entry/folder` which is based on an actual directory
denoted by `actual/location/of/path`.

```js
//# FILE: webpack.config.json
const VirtualFoldersPlugin = require('@openovate/webpack-virtual-folders');

module.exports = {
  ...
  plugins: [
    new VirtualFoldersPlugin({
      'some/virtual/path/in/entry/folder': path.resolve(__dirname, 'actual/location/of/path')
    })
  ]
  ...
};
```

You can now use your virtual directories relatively anywhere.

```js
const foo = require('./some/virtual/path/in/entry/folder/foo');
```

## Example

For this example we will be using `require` instead of `import` though the
`import` equivalent should work.

 * (1) In your project root folder denoted as `[PROJECT_ROOT]` create a file called
 `[PROJECT_ROOT]/src/index.js` with the following contents.

```js
const { name } = require('./product')
console.log(name)
```

 * (2) Create a file called `[PROJECT_ROOT]/product/index.js` with the following contents.

```js
module.exports = { name: 'iPhone' }
```

> Notice that `[PROJECT_ROOT]/product/index.js` is not in the `[PROJECT_ROOT]/src/`.

 * (3) Create a file called `[PROJECT_ROOT]/webpack.config.js` with the following contents.

```js
const path = require('path');
const VirtualFoldersPlugin = require('@openovate/webpack-virtual-folders');

module.exports = {
  mode: 'development',
  entry: {
    index: './src/index.js'
  },
  output: {
    filename: '[name].bundle.js',
    path: path.resolve(__dirname, 'public')
  },
  plugins: [
    new VirtualFoldersPlugin({
      'src/product': path.resolve(__dirname, '/product')
    })
  ]
};
```

 * (4) Run the following commands in terminal

```bash
$ npm init -y
$ npm i webpack webpack-cli @openovate/webpack-virtual-folders --save-dev
$ npx webpack --config webpack.config.js
```

## Why

Webpack assumes that all of your project files should either be located in `node_modules`
or relative to the `entry` directory. To include directories into the entry directory,
webpack suggests to use [symlinks](https://webpack.js.org/configuration/resolve/#resolvesymlinks).
This is a programatic way to bundle external directories without symlinking.

## Inspiration

This project is inspired by [webpack-virtual-modules](https://github.com/sysgears/webpack-virtual-modules/issues)
*(and also extends it)*.