open-index/open-npm huggingface dataset:
npm package: @jbakse/together
Description: Pre-release! An easy to use library for simple multi-user sketches with p5.js.
Author: Justin Bakse
Latest version: 0.1.0
Deprecated: This package has been renamed to p5.party

<!-- PROJECT LOGO -->
<!--
<p align="center">
  <a href="https://github.com/othneildrew/Best-README-Template">
    <img src="images/logo.png" alt="Logo" width="80" height="80">
  </a>

  <h3 align="center">Best-README-Template</h3>

  <p align="center">
    An awesome README template to jumpstart your projects!
    <br />
    <a href="https://github.com/othneildrew/Best-README-Template"><strong>Explore the docs »</strong></a>
    <br />
    <br />
    <a href="https://github.com/othneildrew/Best-README-Template">View Demo</a>
    ·
    <a href="https://github.com/othneildrew/Best-README-Template/issues">Report Bug</a>
    ·
    <a href="https://github.com/othneildrew/Best-README-Template/issues">Request Feature</a>
  </p>
</p> -->

## About Together

Together is a simple library for sharing data between users. Use it with [p5.js](https://p5js.org/) to make real-time, multi-user sketches, apps, and games.

### Features:

- Designed for sketching
- Easy
- Multiple Apps on One Server
- Minimal Server Setup

### What it ISN'T:

- Designed for production
- Powerful
- Secure

### Built With

- [Deepstream](https://deepstream.io/)
- [sindresorhus/on-change](https://github.com/sindresorhus/on-change)

## Getting Started

### Prerequisites

### Installation

## Usage

### Connecting

### Setting Shared Values

### Reading Shard Values

<!--
## Contributing

Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.

1. Fork the Project
2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the Branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request -->

## License

Distributed under the MIT License. See `license` for more information.

## Acknowledgements

- [Best-README-Template](https://github.com/othneildrew/Best-README-Template)
npm package: @jbaldwin/craiyon
Description: Craiyon (ex DALL-E Mini) API client library for Node.js
Author: József Sallai @jozsefsallai
Latest version: 1.1.0

# node-craiyon

Unofficial Node.js API client for [Craiyon][craiyon-url] (formerly DALL-E Mini).

## Getting Started

Install the module using npm:

```
npm install craiyon
```

or Yarn:

```
yarn add craiyon
```

## Basic Usage

```js
const { Client } = require('craiyon');

const craiyon = new Client();
const result = await craiyon.generate({
  prompt: 'Painting of a dachshund drinking water in the style of Van Gogh',
});
```

You can then use any of the methods available in `result` to get the generated
images in any way you want.

You can learn more about the supported methods in the [documentation][docs-url].

## Customization

By default, the library will retry a request 3 times if something goes wrong.
You may change this behavior either by instantiating the client with a custom
number of maximum retries (for all generations):

```js
const craiyon = new Client().withMaxRetries(5);
```

or by setting a custom number of retries for a specific generation:

```js
const result = await craiyon.generate({
  prompt: 'Painting of a dachshund drinking water in the style of Van Gogh',
  maxRetries: 5,
});
```

## Notice

Please note that this is using a reverse-engineered backend endpoint provided by
Craiyon. The endpoint could, at any point in time, change the request and/or
response, or become unavailable for public use altogether. If you encounter any
problems with the library, please open an issue on [GitHub][github-issues-url].

## For Contributors

`node-craiyon` is written in TypeScript, therefore, you have to compile it to
JavaScript if you'd like to test your changes. You may do so using the following
command:

```
npm run build
```

The library does not currently employ any unit testing measures, however, if you
would like to contribute to the library, please make sure that your changes pass
linting. You can run the following command to check:

```
npm run lint
```

## License

MIT. Please read the LICENSE file for more information.

[craiyon-url]: https://www.craiyon.com/
[docs-url]: https://jozsefsallai.github.io/node-craiyon/
[github-issues-url]: https://github.com/jozsefsallai/node-craiyon/issues
npm package: @jballands/vespyr
Description: UI components for jonathanballands.me
Author: Jon Ballands
Latest version: 1.1.0

# vespyr

Vespyr is a UI library for my personal website,  [jonathanballands.me](https://github.com/jballands/jonathanballands.me). 
It is written in React.

You can go [here](https://jballands.github.io/vespyr) to see all that Vespyr offers.

## Getting Started

To use Vespyr, simply install it with NPM or Yarn:

```
$ yarn add @jballands/vespyr
```

To import a UI element, you can reference `index.js`:

```
import { BoldButton } from '@jballands/vespyr';
```

However, for a slimmer bundle, you should import the element 
directly from `lib`:

```
import BoldButton from '@jballands/vespyr/lib/BoldButton';
```

Since Vespyr uses [Styled Components](https://github.com/styled-components/styled-components)
to style itself, there is no CSS that you need to import; Vespyr
should be styled right out of the box. :nail_care:

## Developing

> Note: Node 7+ is recommended.

Install all of Vespyr's dependencies:

```
$ yarn
```

Then run the [Storybook](https://github.com/storybooks/storybook)
and hit `http://localhost:9001`:

```
$ yarn storybook
```

You can build the `lib` directory like this:

```
$ yarn build
```
npm package: @jbangdev/jbang
Description: NPM for JBang - Java Script in your JavaScript
Author: JBang Developers
Latest version: 0.7.1

# jbang-npm - Java Script in your JavaScript <!-- omit in toc -->

Install and use [JBang](https://www.jbang.dev) from NPM based projects.

![](java_script.png)

Lets you use your own local scripts, [JBang AppStore](https://jbang.dev/appstore) alias or any network reachable jar or Maven artifact.

# Table of Contents <!-- omit in toc -->

- [Installation](#installation)
- [Usage](#usage)
  - [As a library](#as-a-library)
    - [exec(string)](#execstring)
  - [As a CLI](#as-a-cli)
- [Behind the scenes](#behind-the-scenes)
- [Using as a dependency](#using-as-a-dependency)

## Installation

`npm i @jbangdev/jbang --save`

Prefer installing the package globally if you want to use it as a CLI wrapper of `JBang`:

`npm i -g @jbangdev/jbang`

## Usage

You can find the complete documentation about arguments you can pass to the `jbang` executable here: https://www.jbang.dev/documentation/guide/latest/cli/jbang.html.

### As a library

```js
const jbang = require('@jbangdev/jbang');
```

`jbang` is an object exposing the following.

#### exec(string)

The `jbang.exec()` function accepts a string that will be passed as the command-line arguments to the `jbang` executable.

Example:

```js
jbang.exec('app install --name karate-core com.intuit.karate:karate-core:RELEASE:all');
```

#### spawnSync(string)

Use `spawnSync` to run the command in the same process/stdin/signals.

```js
await jbang.spawnSync('app install --name karate-core com.intuit.karate:karate-core:RELEASE:all');
```

Primarily used by the `jbang-npm` CLI.

### As a CLI

Package preferably installed globally, you can run in a shell the command named `jbang-npm`. `jbang-npm` is a simple wrapper of the installed `jbang` executable which prevents you to manually add the command to your path.

Example:

`jbang-npm app install --name karate-core com.intuit.karate:karate-core:RELEASE:all`

You can also use `npx`:

`npx jbang quarkus@quarkusio`

## Behind the scenes

This will look for jbang in path and if not available install it before executing jbang.

## Using as a dependency

In most cases you should be able to use JBang directly in node scripts.

But if you want to provide more customization you can create your own "wrapper" NPM package. One of the advantages is that you can pre-install the library dependencies needed at the time of `npm install` (just by calling `--help` or a similar "no op" command) so that the user-experience when running the first command after install is better.

For an example, refer to the [`@karatelabs/karate`](https://github.com/karatelabs/karate-npm) NPM package.
npm package: @jbateson/eslint-config
Description: My personal eslint config
Author: Joe Bateson
Latest version: 2.3.0

# @jbateson/eslint-config

[![npm (scoped)](https://badgen.net/npm/v/@jbateson/eslint-config)](https://www.npmjs.com/package/@jbateson/eslint-config)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release) [![Dependabot enabled](https://badgen.net/dependabot/jdb8/eslint-config/?icon=dependabot)](#)
[![Actions Status](https://github.com/jdb8/eslint-config/workflows/main/badge.svg)](https://github.com/jdb8/eslint-config/actions)




`yarn add -D @jbateson/eslint-config`

And make sure you install the required peer dependencies required for this config:

```
$ yarn global add install-peerdeps
$ install-peerdeps --dev @jbateson/eslint-config
```

In .eslintrc:

```json
{
    "extends": "@jbateson"
}
```

Don't forget to include your custom `prettier` settings (if you have any) in your app's `package.json`/`.prettierrc`/etc. Otherwise prettier will be invoked with the defaults.
npm package: @jbauch-ignite-ui/docs
Description: This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
Latest version: 1.0.0

# React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

## Expanding the ESLint configuration

If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:

- Configure the top-level `parserOptions` property like this:

```js
export default {
  // other rules...
  parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module',
    project: ['./tsconfig.json', './tsconfig.node.json'],
    tsconfigRootDir: __dirname,
  },
}
```

- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list
npm package: @jbbrejon/react-modal
Description: React Modal Component
Author: Jean-Baptiste BREJON
Latest version: 1.3.0

# oc-da-p14-component
OpenClassrooms - DA JS/React - Projet 14 : Faites passer une librairie jQuery (component)

## Author

- [@jbbrejon](https://github.com/jbbrejon)

## Requirements

- NodeJS (version >=16.14)
- Npm
- Editor : Visual Studio code recommended


## Descripton
React component : Modal

## Installation

Run :```npm install @jbbrejon/react-modal```

## How to use this component
```
import React from 'react'
import { useState } from 'react'
import Modal from "@jbbrejon/react-modal";
import '@jbbrejon/react-modal/dist/style.css'

function App() {

    // Local state
    const [displayModal, setDisplayModal] = useState(false)

    // Set message that will be displayed in the modal
    const message = "Type your message"

    // This function will toggle the display of the modal by updating the local state of this component
    function toggleModal() {
        setDisplayModal(!displayModal)
    }

    return (
        <div>
            <button onClick={toggleModal}>Display Modal</button>
            {displayModal ? <Modal message={message} toggle={toggleModal} /> : null}
        </div>
  );
};

export default App;
```
npm package: @jbcampbell/ksuid
Description: React Native implementation of K-Sortable Globally Unique IDs
Latest version: 2.4.0

# ksuid

A Node.js implementation of [Segment's KSUID
library](https://github.com/segmentio/ksuid). Supports Node.js 6, 8 and 10.

You may also be interested in
[`ksuid-cli`](https://www.npmjs.com/package/ksuid-cli).

## Installation

```console
$ npm install ksuid
```

## Usage

Require the module:

```js
const KSUID = require('ksuid')
```

Or, using [TypeScript](https://www.typescriptlang.org/):

```typescript
import KSUID = require('ksuid')
```

### Creation

You can create a new instance synchronously:

```js
const ksuidFromSync = KSUID.randomSync()
```

Or asynchronously:

```js
const ksuidFromAsync = await KSUID.random()
```

Or you can compose it using a timestamp and a 16-byte payload:

```js
const crypto = require('crypto')
const yesterdayInMs = Date.now() - 86400 * 1000
const payload = crypto.randomBytes(16)
const yesterdayKSUID = KSUID.fromParts(yesterdayInMs, payload)
```

You can parse a valid string-encoded KSUID:

```js
const maxKsuid = KSUID.parse('aWgEPTl1tmebfsQzFP4bxwgy80V')
```

Finally, you can create a KSUID from a 20-byte buffer:

```js
const fromBuffer = new KSUID(buffer)
```

### Properties

Once the KSUID has been created, use it:

```js
ksuidFromSync.string // The KSUID encoded as a fixed-length string
ksuidFromSync.raw // The KSUID as a 20-byte buffer
ksuidFromSync.date // The timestamp portion of the KSUID, as a `Date` object
ksuidFromSync.timestamp // The raw timestamp portion of the KSUID, as a number
ksuidFromSync.payload // A Buffer containing the 16-byte payload of the KSUID (typically a random value)
```

### Comparisons

You can compare KSUIDs:

```js
todayKSUID.compare(yesterdayKSUID) // 1
todayKSUID.compare(todayKSUID) // 0
yesterdayKSUID.compare(todayKSUID) // -1
```

And check for equality:

```js
todayKSUID.equals(todayKSUID) // true
todayKSUID.equals(yesterdayKSUID) // false
```

### Validation

You can check whether a particular buffer is a valid KSUID:

```js
KSUID.isValid(buffer) // Boolean
```
npm package: @jbcampbell/rn-splash
Description: Automatic splash screen cropping for React Native
Latest version: 2.0.4

# rn-splash

Automatic splash screen generator for React Native. Based on [cordova-splash](https://github.com/AlexDisler/cordova-splash). Create a splash screen once in the root folder of your React Native project and use rn-splash to automatically crop and copy it for all the platforms your project supports.

The splash screen image should be 2208x2208 px with a center square of about 1200x1200 px. The image may be cropped around the center square. You can also use larger images with similar proportions.

### Installation

    $ sudo npm install rn-splash -g

### Requirements

- ImageMagick installed (*Mac*: `brew install imagemagick`, *Debian/Ubuntu*: `sudo apt-get install imagemagick`, *Windows*: [See here, install "Legacy tools"](http://www.imagemagick.org/script/binary-releases.php#windows))
- React Natives app.json file must exist in the root folder

### Usage

Create a `splash.png` file in the root folder of your RN project and run:

    $ rn-splash

You also can specify manually a location for your `config.xml` or `splash.png`:

    $ rn-splash --config=config.xml --splash=splash.png

### Icons

Check out [app-icon](https://github.com/dwmkerr/app-icon)

### License

MIT