open-index/open-npm huggingface dataset:
npm package: @socit/react-chart
Description: React Chart
Latest version: 0.3.5

### This Package and it's Document will be more helpful in near future. (Developing...)
<br />



# React Chart

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://gitlab.com/socit/react-chart/blob/master/LICENSE)
[![npm version](https://img.shields.io/npm/v/@socit/react-chart)](https://www.npmjs.com/package/@socit/react-chart)

React-Chart is a library for creating svg base charts with react.

## Installation
```
$ npm install --save @socit/react-chart
```

## Basic Usage
```jsx
import React from 'react';
import ReactChart from 'react-chart';

import './App.css';

function App() {

    const data = [
      { x: [1398, 6, 1], y: 1 },
      { x: [1398, 6, 2], y: 2 },
      { x: [1398, 6, 3], y: 3 },
      { x: [1398, 6, 4], y: 4 },
      { x: [1398, 6, 5], y: 5 },
      { x: [1398, 6, 6], y: 6 },
      { x: [1398, 6, 8], y: 7 },
      { x: [1398, 6, 9], y: 8 },
      { x: [1398, 6, 10], y: 10 }
    ];

    const data2 = [
      { x: 1, open: 2, close: 3, high: 4, low: 1 },
      { x: 2, open: 3, close: 4, high: 5, low: 2 },
      { x: 3, open: 4, close: 6, high: 7, low: 2 },
      { x: 4, open: 5, close: 3, high: 6, low: 2 },
      { x: 5, open: 4, close: 3, high: 5, low: 1 },
      { x: 6, open: 4, close: 5, high: 6, low: 2 },
      { x: 7, open: 4, close: 5, high: 7, low: 3 },
      { x: 8, open: 5, close: 6, high: 6, low: 4 },
      { x: 9, open: 6, close: 3, high: 7, low: 3 }
  ];

  return (
    <div className="App">
      <ReactChart
        width={700}
        height={300}
        axisX={true}
        axisY={true}
        charts={[
          { type: 'line', color: '#f00', data: data }
        ]}
      />

      <ReactChart
        width={500}
        height={200}
        axisX={true}
        axisY={true}
        charts={[
          { type: 'candlestick', upperColor: '#0f0', lowerColor: '#f00', data: data2 }
        ]}
      />
    </div>
  );
}

export default App;
```

### Documentation

For documentation see [socit.gitlab.io/react-chart](https://socit.gitlab.io/react-chart).

### License

React-Chart is under the terms of [MIT licensed](https://gitlab.com/socit/react-chart/blob/master/License).
npm package: @socit/react-persian-datepicker
Description: React Persian Datepicker
Latest version: 0.3.1

### This Package and it's Document will be more helpful in near future. (Developing...)
<br />



# React Persian Datepicker 

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://gitlab.com/socit/react-persian-datepicker/blob/master/LICENSE)
[![npm version](https://img.shields.io/npm/v/@socit/react-persian-datepicker)](https://www.npmjs.com/package/@socit/react-persian-datepicker)

Persian-Datepicker is a library for pick date from jalali calendar.

## Installation
```
$ npm install --save @socit/react-persian-datepicker
```

## Basic Usage
```jsx
import React from 'react';
import ReactPersianDatepicker from '@socit/react-persian-datepicker';

import './App.css';

function App() {
  return (
    <div className="App">
      <ReactPersianDatepicker
        onChange={(date) => { console.log(date); }}
      />
    </div>
  );
}

export default App;
```

## Types
Currently we have two types of picker. <br />

Standalone
![@socit/react-persian-datepicker](https://i.ibb.co/Tw8N984/standalone.png ":size=300")

and, <br />

input
![@socit/react-persian-datepicker](https://i.ibb.co/7gC56jK/input.png ":size=300")

### Documentation

For documentation see [socit.gitlab.io/react-persian-datepicker](https://socit.gitlab.io/react-persian-datepicker).

### License

React-Persian-Datepicker is under the terms of [MIT licensed](https://gitlab.com/socit/react-persian-datepicker/blob/master/License).
npm package: @socker210/event-emitter
Description: Simple event emitter like a node
Author: socker210
Latest version: 1.0.2

# Event emitter

Simple event emitter like a node

## Installation

With npm
```
npm install @socker210/event-emitter
```

With yarn
```
yarn add @socker210/event-emitter
```

## Usage

```javascript
const EventEmitter = require('@socker210/event-emitter')

const eventEmitter = new EventEmitter()

const cb = () => console.log('callback')

// Register event
eventEmitter.on('print', cb)

// Execute event
eventEmitter.emit('print')

// Check if event is registered
eventEmitter.hasEvent('print')

// Check if event and callback is registered
eventEmitter.hasCallback('print', cb)

// Remove callback
eventEmitter.off('print', cb)
```

## LICENSE

MIT
npm package: @socket-lync/js-client
Description: ```bash $ npm install @socket-lync/js-client ```
Author: derpierre65
Latest version: 1.0.0-alpha.2

## Installation

```bash
$ npm install @socket-lync/js-client
```

## Usage

Example:

```js
import SocketLync from '@socket-lync/js-client';

const socketLync = new SocketLync({
	client: io,
	socketOptions: {
		host: 'wss://ws.derpierre65.dev/app/APP-ID',
		reconnection: true,
		reconnectionDelayMax: 2_500,
		timeout: 10_000,
	},
});

socketLync.privateChannel('MyPrivateChannel.1312')
	.subscribed(() => console.log('PrivateChannel subscribed'))
	.listen('Notification', () => console.log('New Notification (private)'));

socketLync.channel('MyPublicChannel.1337')
          .subscribed(() => console.log('Channel subscribed'))
          .listen('Notification', () => console.log('New Notification (public)'));

socketLync.presenceChannel('MyPresenceChannel.42')
          .here((members) => console.log('PresenceChannel subscribed, members:', members))
          .listen('Notification', () => console.log('New Notification (presence)'));
```
npm package: @socket-lync/vue
Description: ```bash $ npm install @socket-lync/vue ```
Author: derpierre65
Latest version: 1.0.0-alpha.1

## Installation

```bash
$ npm install @socket-lync/vue
```

## Usage

Example [_app.js_](./src/dev/main.js):

```js
import {createApp} from 'vue';
import App from './App.vue';
import SocketLyncVue from '@socket-lync/vue';
import io from 'socket.io-client';

const app = createApp(App);

app.use(SocketLyncVue, {
	host: 'https://ws.derpierre65.dev/app/APP-ID',
	client: io,
	autoConnect: false,
	autoLeave: true,
	debug: true,
});

app.mount('#app');
```

Example [_App.vue_](./src/dev/App.vue):

```vue
<script>
import {defineComponent, ref} from 'vue';
import {useSocketLync} from '@socket-lync/vue';

export default defineComponent({
	setup() {
		return {
			...useSocketLync(),
		};
	},
	created() {
		this.socketLync
			.subscribeChannel('Test.1234')
			.subscribed(() => {
				console.log(`channel subscribed`);
			})
			.listen('Test', (data) => {
				console.log('channel event', data);
			});

		this.socketLync
			.subscribePrivate('Test.1234') // will prefixed with private-
			.subscribed(() => {
				console.log(`private channel subscribed`);
			})
			.listen('Test', (data) => {
				console.log('Private channel event', data);
			});
	},
});
</script>
```
npm package: @socket-mesh/async-stream-emitter
Description: An alternantive to EventEmitter using consumable streams.
Author: Jonathan Gros-Dubois
Latest version: 7.2.3

# async-stream-emitter
EventEmitter using ConsumableStream.

## Main methods:

- emit(eventName, data)
- listener(eventName)
- closeListener(eventName)
- closeAllListeners()
- killListener(eventName)
- killAllListeners()
- getListenerBackpressure(eventName)
- getAllListenersBackpressure()

## Usage examples

```js
let emitter = new AsyncStreamEmitter();

(async () => {
  await wait(10);
  emitter.emit('foo', 'hello');

  // This will cause all for-await-of loops for that event to exit.
  // Note that you can also use the 'break' statement inside
  // individual for-await-of loops.
  emitter.closeListener('foo');
})();

(async () => {
  for await (let data of emitter.listener('foo')) {
    // data is 'hello'
  }
  console.log('The listener was closed.');
})();

// Utility function.
function wait(duration) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve();
    }, duration);
  });
}
```
npm package: @socket-mesh/consumable-stream
Description: A readable async stream which can be iterated over using a for-await-of loop.
Author: Jonathan Gros-Dubois
Latest version: 3.3.3

# consumable-stream
A readable stream which can be iterated over using a for-await-of loop or using a while loop with await inside.

The `ConsumableStream` constructor is an abstract class which must be subclassed. Its `next()` and `createConsumer()` methods must be overriden.

For a concrete subclass of `ConsumableStream`, see `WritableConsumableStream`: https://github.com/SocketCluster/writable-consumable-stream

## Installation

```
npm install @socket-mesh/consumable-stream
```

## Usage

The `ConsumableStream` class exposes the following methods:

- `[Symbol.asyncIterator]`: Makes the instance iterable using a for-await-of loop.
- `next`: Returns a `Promise` which will resolve an object in the form `{value: data, done: boolean}` whenever some data is received or when the stream ends.
- `once`: Similar to `next()` except that the resolved value will be the raw data and it will not resolve when the stream ends. Note that once `once()` is called, it cannot be cancelled; the affected closure will stay in memory until either `once()` resolves or until the stream is ended or garbage collected.

```js
// Consume data objects from consumableStream as they are written to the stream.
(async () => {
  for await (let data of consumableStream) {
    console.log(data);
  }
})();

// Consume only the next data object which is written to the stream.
(async () => {
  let data = await consumableStream.once();
  console.log(data);
})();
```
npm package: @socket-mesh/local-storage
Description: W3C localStorage for Node.JS
Author: AJ ONeal
Latest version: 1.0.5

# localStorage

An inefficient, but as W3C-compliant as possible using only pure JavaScript, `localStorage` implementation.

## Purpose

This is meant for the purpose of being able to run unit-tests and such for browser-y modules in node.

## Usage

    var localStorage = require('localStorage')
      , myValue = { foo: 'bar', baz: 'quux' }
      ;

    localStorage.setItem('myKey', JSON.stringify(myValue));
    myValue = localStorage.getItem('myKey');

## API

  * getItem(key)
  * setItem(key, value)
  * removeItem(key)
  * clear()
  * key(n)
  * length

## Tests

    null === localStorage.getItem('key');

    0 === localStorage.length;
    null === localStorage.getItem('doesn't exist');
    undefined === localStorage['doesn't exist'];

    localStorage.setItem('myItem');
    "undefined" === localStorage.getItem('myItem');
    1 === localStorage.length;

    localStorage.setItem('myItem', 0);
    "0" === localStorage.getItem('myItem');

    localStorage.removeItem('myItem', 0);
    0 === localStorage.length;

    localStorage.clear();
    0 === localStorage.length;

TODO / Bugs
---

  * Doesn't not emit `Storage` events
npm package: @socket-mesh/skeleton-rendezvous
Description: Module for performing fast rendezvous (HRW) hashing with skeleton - Can efficiently handle a large number of machines/sites.
Latest version: 1.0.0

# skeleton-rendezvous
Node.js module for performing fast rendezvous (HRW) hashing with skeleton - Can efficiently handle a large number of machines/sites.

This approach is slower than consistent hashing but provides much more even distribution of keys across sites - Particularly when there are a large number of sites and keys;
the distribution gets progressively better as you add more keys. It can be configured to prioritize different features (e.g. distribution, performance, remapping %).

Last test results:

![Test results](https://raw.github.com/SocketCluster/skeleton-rendezvous/master/assets/skeleton-rendezvous-tests.png)
npm package: @socket-mesh/stream-demux
Description: A consumable stream demultiplexer.
Author: Jonathan Gros-Dubois
Latest version: 10.2.5

# stream-demux
An consumable stream demultiplexer.

Lets you write data to multiple consumable streams from a central place without keeping any references to those streams.
The `StreamDemux` class returns streams of class `DemuxedConsumableStream` (base class `ConsumableStream`).  
See https://github.com/SocketCluster/consumable-stream

This library uses a queue which is implemented as a singly-linked list; this allows each loop to consume at its own pace without missing any events (supports nested await statements). An 'event' in the queue can be garbage-collected as soon as the slowest consumer moves its pointer past it.

## Installation

```
npm install stream-demux
```

## Usage

### Consuming using async loops

```js
let demux = new StreamDemux();

(async () => {
  // Consume data from 'abc' stream.
  let substream = demux.stream('abc');
  for await (let packet of substream) {
    console.log('ABC:', packet);
  }
})();

(async () => {
  // Consume data from 'def' stream.
  let substream = demux.stream('def');
  for await (let packet of substream) {
    console.log('DEF:', packet);
  }
})();

(async () => {
  // Consume data from 'def' stream.
  // Can also work with a while loop for older environments.
  // Can have multiple loops consuming the same stream at
  // the same time.
  // Note that you can optionally pass a number n to the
  // createConsumer(n) method to force the iteration to
  // timeout after n milliseconds of inactivity.
  let consumer = demux.stream('def').createConsumer();
  while (true) {
    let packet = await consumer.next();
    if (packet.done) break;
    console.log('DEF (while loop):', packet.value);
  }
})();

(async () => {
  for (let i = 0; i < 10; i++) {
    await wait(10);
    demux.write('abc', 'message-abc-' + i);
    demux.write('def', 'message-def-' + i);
  }
  demux.close('abc');
  demux.close('def');
})();

// Utility function for using setTimeout() with async/await.
function wait(duration) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve();
    }, duration);
  });
}
```

### Consuming using the once method

```js
// Log the next received packet from the abc stream.
(async () => {
  // The returned promise never times out.
  let packet = await demux.stream('abc').once();
  console.log('Packet:', packet);
})();

// Same as above, except with a timeout of 10 seconds.
(async () => {
  try {
    let packet = await demux.stream('abc').once(10000);
    console.log('Packet:', packet);
  } catch (err) {
    // If no packets are written to the 'abc' stream before
    // the timeout, an error will be thrown and handled here.
    // The err.name property will be 'TimeoutError'.
    console.log('Error:', err);
  }
})();
```

## Goal

The goal of this module is to facilitate functional programming patterns which decrease the probability of memory leaks and race conditions.
It serves as an alternative to callback-based event handling.
npm package: @socket-override-override/date
Description: internal package for 10x'ly made
Latest version: 1.0.8

# @socket-override-override/date

zero dependency replacement for [date](https://npmjs.com/date)

## wai?
@socketregistry/date doesn't include the cache.js file, which isn't even supposed to be requirable, but one 10xly package needs it. and we needed a zero-dependency override instead of just the date package for the lolite-browser package which also doubles as a lightweight one-dependency replacement for normal lolite.