open-index/open-npm huggingface dataset:
npm package: @skoging/react-app-rewire-source-map-loader
Description: Add [source-map-loader](https://github.com/webpack-contrib/source-map-loader) to a [react-app-rewired](https://github.com/timarney/react-app-rewired) config.
Author: Tore Hammervoll
Latest version: 1.0.9

# react-app-rewire-source-map-loader

Add [source-map-loader](https://github.com/webpack-contrib/source-map-loader) to a [react-app-rewired](https://github.com/timarney/react-app-rewired) config.

```js
/* config-overrides.js */

const rewireSourceMap = require('react-app-rewire-source-map-loader')

module.exports = function override(config, env) {
    // ...
    rewireSourceMap(config, env)
    // ...
    return config
}
```
npm package: @skoiy/seedrandom
Description: A fork from David Bau's seedrandom library with TypeScript support and ES module compatibility as well as worklets and no node dependencies
Author: Pedro Silva
Latest version: 1.1.0

# @skoiy/seedrandom

A TypeScript fork of David Bau's seedrandom library with TypeScript support and ES module compatibility as well as worklets and no node dependencies.

This library provides seeded random number generation for JavaScript/TypeScript applications, including React Native worklets.

## Installation

```sh
npm install @skoiy/seedrandom
```

## Features

### TypeScript Support
- Full TypeScript definitions included
- Modern TypeScript features and strict type checking
- IntelliSense support in IDEs
- Type-safe API with proper interfaces

### Worklets Support
- Compatible with React Native worklets
- Can be used in UI thread animations and interactions
- Optimized for performance in React Native applications
- Worklet-safe random number generation

### No Node Dependencies
- Zero runtime dependencies
- Works in browsers, React Native, and any JavaScript environment
- Uses `globalThis` for cross-platform compatibility
- No Node.js specific APIs required

## Usage

```typescript
import seedrandom from '@skoiy/seedrandom'

// Create a seeded random number generator
const rng = seedrandom('my-seed')

// Generate random numbers
console.log(rng()) // 0.123456...
console.log(rng.int32()) // Random 32-bit integer
console.log(rng.quick()) // Quick random number
console.log(rng.double()) // Same as rng()

// Use with state saving
const rngWithState = seedrandom('seed', { state: true })
const state = rngWithState.state()
const restoredRng = seedrandom(state)
```

## API

### `seedrandom(seed?, options?, callback?)`

- `seed`: String or number to seed the generator
- `options`: Configuration object or boolean for entropy
- `callback`: Optional callback function

Returns a PRNG function with additional methods.

### PRNG Methods

- `()`: Returns a random number between 0 and 1
- `int32()`: Returns a random 32-bit integer
- `quick()`: Returns a quick random number
- `double()`: Alias for `()`
- `state()`: Returns the current state (if enabled)

## Development

```sh
$ npm run dev
```

## Build

```sh
$ npm run build
```

## Test

```sh
$ npm run test
```
npm package: @skokenes/manymerge
Description: ManyMerge is a protocol for synchronizing Automerge documents. It's a replacement for `Automerge.Connection` that supports many-to-many and one-to-many relationships.
Author: Evan Conrad
Latest version: 2.7.2

# ManyMerge

ManyMerge is a protocol for synchronizing Automerge documents. It's a replacement for `Automerge.Connection` that supports many-to-many and one-to-many relationships.

## Install

```
npm install --save manymerge
```

## Usage

Manymerge comes with two different types of connections that work together: **Peers** and **Hubs**.

### Peers

A Peer is **a 1-1 relationship** that can talk to a Hub or another Peer. Your peer will need to create a `sendMsg` function that takes a ManyMerge `Message` and sends it to the network. Typically that looks like this:

```ts
import { Peer } from 'manymerge';

function sendMsg(msg) {
  MyNetwork.emit('to-server', msg);
}

const peer = new Peer(sendMsg);
```

When a peer wants to alert it's counterpart that it changed a document, it should call the `notify` function:

```ts
import Automerge from 'automerge';

let myDoc = Automerge.from({ title: 'cool doc' });
peer.notify(myDoc);
```

When a peer gets a message from the network, it should run `applyMessage`, which will return a new document with any changes applied. If the document is not updated, it will return nothing. In this case, you should not update the doc.

```ts
let myDoc = Automerge.from({ title: 'cool doc' });

MyNetwork.on('from-server', msg => {
  const doc = peer.applyMessage(msg, myDoc);
  if (doc) {
    myDoc = newDoc;
  }
});
```

### Hubs

Hubs are a **many-to-many (or 1-to-many) relationship** that can talk to many Peers or other Hubs. Unlike Peers, Hubs need the ability to "broadcast" a message to everyone on the network (or at least as many people as possible). To save time, Hubs will also cache Peer's they've seen recently and directly communicate directly with them.

To set this up, create `broadcastMsg` and `sendMsgTo` functions:

```ts
import { Hub } from 'manymerge';

function sendMsgTo(peerId, msg) {
  MyNetwork.to(peerId).emit('msg', msg);
}

function broadcastMsg(msg) {
  MyNetwork.on('some-channel').emit('msg', msg);
}

const hub = new Hub(sendMsgTo, broadcastMsg);
```

Then, hub works like a peer, it can notify others of documents:

```ts
// Tell folks about our doc
hub.notify(myDoc);
```

Unlike the peer, when it gets a message, it'll need to know the unique id of the connection sending it. It will use this later in the `sendMsgTo` function.

```ts
MyNetwork.on('msg', (from, msg) => {
  newDoc = hub.applyMessage(from, msg, myDoc);
  if (newDoc) {
    myDoc = newDoc;
  }
});
```

## Differences from Automerge.Connection

**ManyMerge does not use DocSet.** Unlike Automerge.Connection, ManyMerge does not know how you store your documents. If it did, all the hubs would have to store many, many documents of many different peers in memory, which doesn't scale well.

**ManyMerge does not multiplex many document updates over the same network.** If you want, you can implement this yourself by just batching messages in your `sendMsg` function.
npm package: @skolawole/adonis-sql-to-migration
Description: This package helps create  database migration from  existing database schema
Author: Salami Kola
Latest version: 1.0.3


# Adonis-sql-to-migration

Adonis-sql-to-migration is a powerful and flexible package that simplifies the process of managing database schema changes in Adonis5 applications. It provides developers with an easy and efficient way to generate migration files from an existing database schema.


### NOTE
Only MySQL and PostgreSQL are supported as and now. SQLite and MSSQL are currently in the works.



## Motivation

This package is inspired by my love for creating database schema using DB GUIs such as Pgadmin, workbench and the likes because it saves time and increases productivity. Migration importance can't be overstated, so I needed a script tha can create migration from an existing DB, the script has morphed into a package.
## Installation


To get the latest version of adonis-sql-to-migration on your project, require it from "npm":

```bash
  $ npm i @skolawole/adonis-sql-to-migration
```
    
Or you can add it directly in your composer.json file:

```bash
 {
    "require": {
        "@skolawole/adonis-sql-to-migration": "^1.0.2"
    }
}
```
## Usage


Go to your project root terminal and register the command in your adonis project using the command 

```
node ace configure @skolawole/adonis-sql-to-migration

```

Run the command to generate migration files from your database

```
node ace sql:to_migration

```

### Flags

Exclude some tables from being parsed by the migration generator by using --ignores

--ignores can take multiple inputs

```
node ace sql:to_migration --ignores="users"

```

```
node ace sql:to_migration --ignores="users" --ignores="accounts"

```


Add tables to be parsed by the migration generator by using --tables

--tables can take multiple inputs just like ignores

```
node ace sql:to_migration --tables="transactions"

```


Add the path of the folder to create the migrations files in by using the --path flag

If path is not specified, default database/migration will be used

```
node ace sql:to_migration  --path="database/custom_migration"

```

Specify the name of the database to generate migration files for by using the --dbname flag 

If dbname is not specified, the set database for the project will be used

```
node ace sql:to_migration  --dbname="vale_bill_service"

```

#### Note

This package will select your set database connection from the env configuration.

## Authors

- [@salamikola](https://www.github.com/salamikola)

## License

[MIT](https://choosealicense.com/licenses/mit/)
## ISSUES

If you encounter any issues or bugs relating to this package please report through our github issues.

[issues](https://github.com/salamikola/sql-to-adonis-migration/issues)

## 🚀 About Me
You can catch me goofing around on my webspace www.weekreed.com
## Acknowledgement

## Acknowledgements

 - [The Adonis Team / Ecosysytem](https://adonisjs.com/)
 - [Adocast](https://adocasts.com/)
 - [Adomastery](https://adonismastery.com/)
 - [Vale App](https://vale.ng)
npm package: @skoleosho97/ddragon
Description: API Wrapper for Riot's Data Dragon API.
Author: Samson Koleosho
Latest version: 0.1.1

## DataDragon API
<div align="left">
	<p>
		<a href="https://www.npmjs.com/package/@skoleosho97/ddragon"><img src="https://img.shields.io/badge/npm-0.1.0-orange?style=flat-square&logo=appveyor" alt="npm" /></a>
	</p>
</div>
An API Wrapper creating with Node.js for Riot's DataDragon API. Not affiliated with Riot Games. This project is currently in an "open beta" phase, with many features still not yet implemented and still in the planning stage.

This module was built as both a learning experience and a resource for anyone learning how to handle requests and create their own library. Most of my own code here is not the best, but I hope people are able to take something new away from looking through it.

This module only applies to the DataDragon API at this time. There may be a future update that implement's Riot's other API as well, but for now, that is unavailable at this time.

### Installation
Install the library by running the following line in the terminal:

    $ npm install @skoleosho97/ddragon

### Usage
Initialize a new class below like so:

    // Initialize the class.
    const API = require('data-dragon-api');
    const DataDragon = new API('en_US');

From here you will be able to use the library's functions and query data. All functions utilize ``async/await``, so data will have to be properly resolved before it can be used. For example:

    // In this example, get all items with the ``Mana`` tag.
    const Example = () => {
        let items = await DataDragon.item.filter_by_tag('Mana');

        console.log(items);
    }

    Example();

## Documentation
Coming soon!