open-index/open-npm huggingface dataset:
npm package: @parisholley/road-runner
Description: The fastest path resolver for URL routing on modern Node.JS
Author: Paris Holley
Latest version: 1.1.8

# Road Runner Router

[![travis](https://img.shields.io/travis/parisholley/road-runner)][travis]
![dependencies](https://img.shields.io/depfu/parisholley/road-runner)
[![version](https://img.shields.io/npm/v/@parisholley/road-runner)][npm]
[![coverage](https://img.shields.io/coveralls/github/parisholley/road-runner)][coveralls]
![size](https://img.shields.io/bundlephobia/min/@parisholley/road-runner)
![supported](https://img.shields.io/node/v/@parisholley/road-runner)

A router for when latency is Wile E. Coyote :) Inspired by
[julienschmidt/httprouter](https://github.com/julienschmidt/httprouter)
and partly derived from  
[steambap/koa-tree-router](https://www.npmjs.com/package/koa-tree-router).

## Why is it fast?

[![chart](https://github.com/parisholley/router-benchmark/raw/master/results.png)][chart]

* Params are detected and provided as objects, but no regex or value casting, strings only
* Case sensitive (use .toLowerCase() when inserting/retrieving if you want case-insensitivity)
* Limited validation (assuming you are going to pass in valid paths and HTTP methods)
* No URL parsing, most environments provide some type of req.path functionality

## Getting Started

The following snippet is the basic setup of the router, remember, it is
up to you to tie into your favorite HTTP library and execute the handler
code and return a response (if any):

```typescript
import {RoadRunner} from "@parisholley/road-runner";

const router = RoadRunner();

router.addRoute('GET', '/path', () => {});

// handler === {value: "() => {}", params: {}}
const result = router.lookupRoute('GET', '/path');

result.value();

router.addRoute('GET', '/path/:nested', () => {});

// handler === {value: "() => {}", params: {nested: 'foobar'}}
const result2 = router.lookupRoute('GET', '/path/foobar');

result2.value();
```

## Supported Path Syntax

* /foo
* /:foo
* /*
* /foo/:bar
* /foo/\*
* /foo/:bar/baz
* /foo/\*/baz
* /foo/:bar/baz/:bum
* /foo/\*/baz/\*
* /foo/:bar/baz/\*
* /foo/*/baz/:bum

## Unsupported Path  Syntax

* /foo/:bar-:baz
* /foo/bar:baz
* /foo/bar-*

## API Versioning

This library categorizes paths into `buckets`, which ultimately are up
to you to decide the format of. Most developers will likely pass in the
`HTTP Method` when adding routes, but you can choose any string value
you would like. In the case of switching behavior based on an API
version provided in the header, you could do something like this:

```typescript
import {RoadRunner} from "@parisholley/road-runner";

const router = RoadRunner();

router.addRoute(`POST:2.1`, '/document/:id', () => {});

function doLookup(headers:Record<string,string>){
  const result = router.lookupRoute(`POST:${headers['version']}`, '/document/:id');
  
  result.value();
}
````

[chart]: https://github.com/parisholley/router-benchmark
[travis]: https://travis-ci.org/parisholley/road-runner
[npm]: https://www.npmjs.com/package/@parisholley/road-runner
[coveralls]: https://coveralls.io/github/parisholley/road-runner
npm package: @paristech/eslint-config
Description: ESLint configuration used by Paristech.
Author: Alex-Paris
Latest version: 3.1.0

# Paristech ESLint config

## Whats included?

- Standard config base;
- React plugin;
- React Hooks plugin;
- JSX a11y plugin;
- Import Helpers plugin;
- Automatic tailwind class sorting;
- Prettier;

## Setup

### React (with Next.js)

Install dependencies:
```
npm i -D eslint @paristech/eslint-config
```
Inside `eslint.config.js`
```
import paristechConfig from "@paristech/eslint-config/next";

export default [...paristechConfig]
```
(Optional) For a better experience using Import Helpers you can change the path in `tsconfig.json`. This will let the configured path bellow paths components
```
"paths": {
  "~/*": ["./*"]
}
```

### React (without Next.js)

Install dependencies:
```
npm i -D eslint @paristech/eslint-config
```
Inside `eslint.config.js`
```
import paristechConfig from "@paristech/eslint-config/react";

export default [...paristechConfig]
```
(Optional) For a better experience using Import Helpers you can change the path in `tsconfig.json`. This will let the configured path bellow paths components
```
"paths": {
  "~/*": ["./*"]
}
```

### Node.js

Install dependencies:
```
npm i -D eslint @paristech/eslint-config
```
Inside `eslint.config.js`
```
import paristechConfig from "@paristech/eslint-config/node";

export default [...paristechConfig]
}
```
(Optional) For a better experience using Import Helpers you can change the path in `tsconfig.json`. This will let the configured path bellow paths components
```
"paths": {
  "~/*": ["./*"]
}
```
npm package: @parity/abi
Description: Ethereum ABI encoder and decoder
Author: Parity Team
Latest version: 5.1.19

# @parity/abi

A port of [https://github.com/paritytech/ethabi](https://github.com/paritytech/ethabi) to JavaScript

[![Build Status](https://travis-ci.org/paritytech/js-libs.svg?branch=master)](https://travis-ci.org/paritytech/js-libs)
[![npm (scoped)](https://img.shields.io/npm/v/@parity/abi.svg)](https://www.npmjs.com/package/@parity/abi)
[![npm](https://img.shields.io/npm/dw/@parity/abi.svg)](https://www.npmjs.com/package/@parity/abi)
[![dependencies Status](https://david-dm.org/paritytech/js-libs/status.svg?path=packages/abi)](https://david-dm.org/paritytech/js-libs?path=packages/abi)
[![docs](https://img.shields.io/badge/docs-passing-green.svg)](https://paritytech.github.io/js-libs/abi/)

## [Full Documentation](https://paritytech.github.io/js-libs/abi/)

## Contributing

Clone the repo and install dependencies via `npm install`. Tests can be executed via `npm run test`

## Installation

Install the package with `npm install --save @parity/abi` from [@parity/abi](https://www.npmjs.com/package/@parity/abi)

## Implementation

### Approach

- this version tries to stay as close to the original Rust version in intent, function names & purpose
- it is a basic port of the Rust version, relying on effectively the same test-suite (expanded where deemed appropriate)
- it is meant as a library to be used in other projects, i.e. [@parity/api](https://www.npmjs.com/package/@parity/api)

### Differences to original Rust version

- internally the library operates on string binary representations as opposed to Vector bytes, lengths are therefore 64 bytes as opposed to 32 bytes
- function names are adapted from the Rust standard snake_case to the JavaScript standard camelCase
- due to the initial library focus, the cli component (as implemented by the original) is not supported nor implemented
npm package: @parity/api
Description: The Parity Promise-based API library for interfacing with Ethereum over RPC
Author: Parity Team
Latest version: 5.1.19

# @parity/api

Parity.js is a thin, fast, Promise-based wrapper around the Ethereum APIs.

[![Build Status](https://travis-ci.org/paritytech/js-libs.svg?branch=master)](https://travis-ci.org/paritytech/js-libs)
[![npm (scoped)](https://img.shields.io/npm/v/@parity/api.svg)](https://www.npmjs.com/package/@parity/api)
[![npm](https://img.shields.io/npm/dw/@parity/api.svg)](https://www.npmjs.com/package/@parity/api)
[![dependencies Status](https://david-dm.org/paritytech/js-libs/status.svg?path=packages/api)](https://david-dm.org/paritytech/js-libs?path=packages/api)

## installation

Install the package with `npm install --save @parity/api`

## usage

### initialisation

```javascript
// import the actual Api class
import Api from '@parity/api';

// do the setup
const provider = new Api.Provider.Http('http://localhost:8545');
const api = new Api(provider);
```

### making calls

perform a call

```javascript
api.eth.coinbase().then(coinbase => {
  console.log(`The coinbase is ${coinbase}`);
});
```

multiple promises

```javascript
Promise.all([api.eth.coinbase(), api.net.listening()]).then(
  ([coinbase, listening]) => {
    // do stuff here
  }
);
```

chaining promises

```javascript
api.eth
  .newFilter({...})
  .then((filterId) => api.eth.getFilterChanges(filterId))
  .then((changes) => {
    console.log(changes);
  });
```

### contracts

attach contract

```javascript
const abi = [{ name: 'callMe', inputs: [{ type: 'bool', ...}, { type: 'string', ...}]}, ...abi...];
const address = '0x123456...9abc';
const contract = api.newContract(abi, address);
```

find & call a function

```javascript
contract.instance.callMe
  .call({ gas: 21000 }, [true, 'someString']) // or estimateGas or postTransaction
  .then(result => {
    console.log(`the result was ${result}`);
  });
```

## apis

APIs implement the calls as exposed in the [Ethcore JSON Ethereum RPC](https://github.com/paritytech/js-api) definitions. Mapping follows the naming conventions of the originals, i.e. `eth_call` becomes `eth.call`, `personal_accounts` becomes `personal.accounts`, etc.

## public node

For operation within a public node, the following peerDependencies needs to be added (this functionality will be moved shortly) -
npm package: @parity/contracts
Description: Parity's contracts as ES6 classes.
Author: Parity Team
Latest version: 5.1.19

# @parity/contracts

Parity's [contracts](https://github.com/parity-contracts) as ES6 classes.

[![Build Status](https://travis-ci.org/paritytech/js-libs.svg?branch=master)](https://travis-ci.org/paritytech/js-libs)
[![npm (scoped)](https://img.shields.io/npm/v/@parity/contracts.svg)](https://www.npmjs.com/package/@parity/contracts)
[![npm](https://img.shields.io/npm/dw/@parity/contracts.svg)](https://www.npmjs.com/package/@parity/contracts)
[![dependencies Status](https://david-dm.org/paritytech/js-libs/status.svg?path=packages/contracts)](https://david-dm.org/paritytech/js-libs?path=packages/contracts)

## Installation

```bash
yarn add @parity/contracts
```

## Usage

### The Contracts object

```javascript
import Api from '@parity/api';
import Contracts from '@parity/contracts';

const ethereumProvider = ...; // Put your Ethereum provider here, e.g. from MetaMask
const api = new Api(ethereumProvider);

const contracts = Contracts.get(api);

// The contracts object exposes the following contracts:
contracts.badgerefg
contracts.dappref
contracts.githubhint
contracts.registry
contracts.signaturereg
contracts.tokenreg
```

See the [docs/](docs) folder to see the properties of each of those contracts.

### Import ABIs

```javascript
import { eip20 } from '@parity/contracts/lib/abi';
```

The list of available ABIs is in the [src/abi/](src/abi) folder.
npm package: @parity/light.js-react
Description: A HOC to easily use @parity/light.js with React.
Author: Parity Team
Latest version: 5.1.19

# @parity/light.js-react

A HOC to easily use [@parity/light.js](https://github.com/paritytech/js-libs/packages/light.js) with React.

[![Build Status](https://travis-ci.org/paritytech/js-libs.svg?branch=master)](https://travis-ci.org/paritytech/js-libs)
[![npm (scoped)](https://img.shields.io/npm/v/@parity/light.js-react.svg)](https://www.npmjs.com/package/@parity/light.js-react)
[![npm](https://img.shields.io/npm/dw/@parity/light.js-react.svg)](https://www.npmjs.com/package/@parity/light.js-react)
[![dependencies Status](https://david-dm.org/paritytech/js-libs/status.svg?path=packages/light.js-react)](https://david-dm.org/paritytech/js-libs?path=packages/light.js-react)

## Usage

The libray provides a higher-order component (HOC) to use `@parity/light.js`'s Observables easily with React apps.

```javascript
import light from '@parity/light.js-react';
import { myBalance$, syncStatus$ } from '@parity/light.js';

@light({
  myBalance: myBalance$, // myBalance will be a BigNumber
  mySyncVariable: syncStatus$
})
class MyClass extends React.Component {
  render() {
    return (
      <div>
        My balance is {this.props.myBalance.toFormat()}.<br />
        The sync status is {JSON.stringify(this.props.mySyncVariable)}.
      </div>
    );
  }
}
```

The UI will automatically update when the sync status changes.