open-index/open-npm huggingface dataset:
npm package: @hello.softis/eslint-config
Description: ESLint configuration used by Softis.
Latest version: 1.0.1

# Softis ESLint config

## Whats included?

- Standard config base;
- React plugin;
- React Hooks plugin;
- JSX a11y plugin;
- Prettier;

## Setup

### React (with Next.js)

Install dependencies:
```
npm i -D eslint @hello.softis/eslint-config
```
Inside `.eslintrc.json`
```
{
  "extends": [
    "@hello.softis/eslint-config/next", 
    "next/core-web-vitals"
  ]
}
```

### React (without Next.js)

Install dependencies:
```
npm i -D eslint @hello.softis/eslint-config
```
Inside `.eslintrc.json`
```
{
  "extends": "@hello.softis/eslint-config/react"
}
```

### Node.js

Install dependencies:
```
npm i -D eslint @hello.softis/eslint-config
```
Inside `.eslintrc.json`
```
{
  "extends": "@hello.softis/eslint-config/node"
}
```
npm package: @hello10/classie
Description: oh, react you dumb dumby fuck
Author: Stephen Handley
Latest version: 1.1.1
Deprecated: no longer maintained

# classie
![](/classie.jpg)

```
const classes = classie('Honk Donk!');

if (something) {
  classes({
    Funk: true,
    Dirk: 0 === 0,
    No: null,
    Nope: undefined,
    Narp: ()=> {
      return false;
    },
    'Derp?!': ()=> {
      return true;
    }
  });
}

Assert.equal(`${classes}`, 'Honk Donk! Funk Dirk Derp?!');
```
npm package: @hello10/eslint-config
Description: [eslint-config-airbnb-base](https://github.com/airbnb/javascript/tree/master/packages/eslint-config-airbnb-base) with some more opinions
Author: Stephen Handley
Latest version: 1.0.2

[eslint-config-airbnb-base](https://github.com/airbnb/javascript/tree/master/packages/eslint-config-airbnb-base) with some more opinions
npm package: @hello10/eslint-config-react
Description: [@hello10/eslint-config](https://github.com/Hello10/eslint-config) + [eslint-plugin-react](https://github.com/yannickcr/eslint-plugin-react)
Author: Stephen Handley
Latest version: 1.0.2

[@hello10/eslint-config](https://github.com/Hello10/eslint-config) + [eslint-plugin-react](https://github.com/yannickcr/eslint-plugin-react)
npm package: @hello10/logger
Description: Logger
Author: Stephen Handley
Latest version: 0.0.8

# Logger
![](/logger.jpg)

## What?
Log json in an easily consumable and readable format.

## Why?
You want visibility across both applications and their dependencies easily configured using environment variables, with messsage filtering/addressability based on both logger name and level in order avoid having to do [this](https://github.com/trentm/node-bunyan#level-suggestions). Based on parts of [bunyan](https://github.com/trentm/node-bunyan) and [debug](https://github.com/visionmedia/debug).

## Example

```JavaScript
// LOGGER="foo:bar*|error,ping:pong|info,-ping:pong:pork" node example.js

import Logger from '@hello10/logger';

let logger = new Logger({name: 'foo', something: 'wow'});
// this will be ignored because name fails to match and level too low
logger.info('hi');
// this will be ignored because name fails to match
logger.error('wow');

// Create a new child logger
logger = logger.child('bar');
// This will be shown
logger.error('oh no');

// Create another logger
let logger2 = new Logger({name: 'ping:pong', funk: 'derp'});
// This will be ignored because level is too low
logger2.debug('derp');
// This will be shown
logger2.error(new Error('dorf'));

logger2 = logger2.child('pork');
// This will be ignored because of the explicit exclude
logger2.fatal('bork');
```

### Output
```
oh no { name: 'foo:bar',
  something: 'wow',
  message: 'oh no',
  time: '2020-07-03T00:51:22.975Z' }
dorf { name: 'ping:pong',
  funk: 'derp',
  message: 'dorf',
  error:
   '{"stack":"Error: dorf ...<STACKTRACE HERE>","message":"dorf"}',
  time: '2020-07-03T00:51:22.985Z' }
```

## Todo
- Add configured payload serializers (i.e. `error`, `request`, `response`)
- Allow configurability for fixed keys i.e . `time`, `error` and `message` so people can use `ts`, `err`, `msg` etc.
- Allow for not logging the message as prefix
npm package: @hello10/react-hooks
Description: Utility React hooks
Author: Stephen Handley
Latest version: 2.0.0
Deprecated: no longer maintained

# Hooks
React Hooks

## Singleton

Excerpted from [example app]("./test/example/")

### Implementation of `useTheme` hook using `Singleton`
```
import {Singleton} from '@hello10/react-hooks';

export interface ThemeState {
  mode: ThemeMode;
  primary: string;
}

export enum ThemeMode {
  light = 'light',
  dark = 'dark'
}

export interface ThemeOptions extends SingletonOptions<ThemeState> {
  state: ()=> Partial<ThemeState>;
  upper: (s: string)=> string;
}

class Theme extends Singleton<ThemeState, ThemeOptions> {
  initialize (state: Partial<ThemeState>) {
    console.log('initializing...', state);
    return {
      mode: ThemeMode.light,
      primary: '#000000',
      ...state
    };
  }

  toggleMode = ()=> {
    const {mode} = this.state;
    const new_mode = mode === ThemeMode.light ? ThemeMode.dark : ThemeMode.light;
    console.log(`changing to ${new_mode} mode`);
    this.setState({mode: new_mode});
  };

  set primary (primary) {
    this.setState({primary});
  }

  get primary (): string {
    return this.state.primary;
  }

  get mode (): ThemeMode {
    return this.state.mode;
  }

  isDark () {
    return (this.mode === ThemeMode.dark);
  }

  isLight () {
    return (this.mode === ThemeMode.light);
  }

  get name () {
    return this.options.upper(this.mode);
  }
}

export function useTheme (): Theme {
  return Theme.use<ThemeState, ThemeOptions, Theme>({
    state: ()=> {
      return {
        primary: '#663399'
      };
    },
    upper: (s: string)=> s.toUpperCase()
  });
}

export default useTheme;
```

### Consumption of `useTheme` hook
```
import React from 'react';

import useTheme from './useTheme';

export default function Button () {
  const theme = useTheme();
  return (
    <button
      onClick={theme.toggleMode}
      style={{
        borderColor: theme.primary,
        color: theme.primary
      }}
    >
      toggle
    </button>
  );
}
```
npm package: @hello10/util
Description: Utility functions
Author: Stephen Handley
Latest version: 1.13.0

# TODO

Used to have this as default on charkeys but that seemed like a questionable default
```
it('should group keys with same first letter by array', ()=> {
  const input = {
    xylophone: 1,
    xonkey: 2,
    xebra: 3,
    zebra: 4
  };
  const output = somethingsomething(input);
  Assert.deepEqual(output, {x: [1, 2, 3], z: 4});
});
```
npm package: @hello3/core
Description: Core functionalities of Hello3 authentication, eg. verifying tokens.
Author: Xander Deseyn
Latest version: 0.1.4

# @hello3/core

Core package that contains functionality that is needed on both client & server.
Currently this exposes a single function `verifyToken()` which verifies a [VerifiableIdentityToken](https://verifiableidentity.xyz/).

# Installation

```js
npm install @hello3/core
```

# Usage

```js
import { verifyToken } from '@hello3/core'

...

const result = await verifyToken(token)
```

More documentation on integrating Hello3 is available on the [docs website](https://docs.hello3.io).
npm package: @helloacent/ace-sdk
Description: 🛠 An SDK for building applications on top of VVS.
Latest version: 11.0.0

# VVS Swap SDK

Forked from the [Uniswap SDK](https://github.com/Uniswap/uniswap-v2-sdk/commit/a88048e9c4198a5bdaea00883ca00c8c8e582605).

You can refer to the Uniswap SDK documentation [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

Move into the vvs-swap-sdk working directory

```sh
cd packages/vvs-swap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```
npm package: @helloacent/new-uikit
Description: Set of UI components for pancake projects
Latest version: 11.0.0

# 🥞 Pancake UIkit

[![Version](https://img.shields.io/npm/v/@pancakeswap-libs/uikit)](https://www.npmjs.com/package/@pancakeswap-libs/uikit) [![Size](https://img.shields.io/bundlephobia/min/@pancakeswap-libs/uikit)](https://www.npmjs.com/package/@pancakeswap-libs/uikit)

Pancake UIkit is a set of React components and hooks used to build pages on Pancake's apps. It also contains a theme file for dark and light mode.

## Install

`yarn add @pancakeswap-libs/uikit`

## Setup

### Theme

Before using Pancake UIkit, you need to provide the theme file to styled-component.

```
import { ThemeProvider } from 'styled-components'
import { light, dark } from '@pancakeswap-libs/uikit'
...
<ThemeProvider theme={isDark}>...</ThemeProvider>
```

### Reset

A reset CSS is available as a global styled component.

```
import { ResetCSS } from '@pancakeswap-libs/uikit'
...
<ResetCSS />
```

### Types

This project is built with Typescript and export all the relevant types.

## How to use the UIkit

If you want to use components from the UIkit, check the [Storybook documentation](https://pancakeswap.github.io/pancake-uikit/)
npm package: @helloample/netlify-plugin-replace
Description: Replace strings in your publish directory
Author: https://github.com/tcmacdonald
Latest version: 1.1.4

# netlify-plugin-replace

[![build status](https://api.travis-ci.com/ample/netlify-plugin-replace.svg)](https://travis-ci.com/github/ample/netlify-plugin-replace) [![npm version](https://badge.fury.io/js/%40helloample%2Fnetlify-plugin-replace.svg)](https://www.npmjs.com/package/@helloample/netlify-plugin-replace)

Replace environment variables in your publish directory _before_ Netlify processes your build. Check out an example implementation [here](https://github.com/ample/netlify-plugin-replace-demo).

## Why?

Netlify will deploy whatever you stick in your publish directory. This is great for simple use-cases but for projects that span multiple environments or rely heavily on environment variables, it can be tricky manage those differences without resorting to gnarly sed scripts or other unmentionable approaches.

This build plugin solves that problem by replacing references to environment variables _after_ your project is built. A great example of this plugin's power is dynamically updating your `_redirects` file based on its deployment context.

## Install

Add the plugin to your project's `package.json` file...

```
$ npm i @helloample/netlify-plugin-replace -D
```

Add the plugin to your project's `netlify.toml` file (see [configuration](https://github.com/ample/netlify-plugin-replace#configuration) for available options)...

```
[[plugins]]
  package = "@helloample/netlify-plugin-replace"
```

Commit & push changes back to your repository.

## Usage

By default, this plugin will look for strings that match the following pattern...

```
${env:SOME_VALUE}
```

...and will attempt to replace that string with the value of the ENV variable by the same name. If the variable doesn't exist, it will not be replaced.

Following this example, any file in your build's output directory containing the string `${env:SOME_VALUE}` will have that string replaced with the contents of `process.env.SOME_VALUE` when this plugin runs.

## Configuration

This plugin offers some limited customization options as described below. Simply add these key/values to `netlify.toml` to customize the behavior for your needs.

- `delimiter`: Regex pattern that tells the plugin how to find values to replace. Note, this pattern should contain a single capture group which encapsulates the entire name of the variable
- `fileTypes`: Regex pattern defining the extension of the files to operate upon

The default configuration, if none is specified, is:

```
[[plugins]]
  package = "@helloample/netlify-plugin-replace"
  [plugins.inputs]
    delimiter = "\${env:([^}]_)}"
    fileTypes = ".*$"
```

## License

This project is licensed under the [MIT License](https://github.com/ample/netlify-plugin-replace/blob/main/LICENSE).
npm package: @helloandre/tini
Description: A Tini Web Framework
Author: Andre Bluehs
Latest version: 2.0.0

# Tini

A tiny web framework

# Installation

- `npm i @helloandre/tini`

# API

## tini(fn)

a function that expects a function as it's only parameter, and is passed an object containing the routing api.

```
import tini from '@helloandre/tini'

tini(router => {
  router.get('/:key', req => req.params.key);
})
```

## Router

### Convenience methods

- **get(route: string, ...callbacks: Function)**
- **post(route: string, ...callbacks: Function)**
- **put(route: string, ...callbacks: Function)**
- **del(route: string, ...callbacks: Function)**
- **route(method: string, route: string, ...callbacks: Function)** - a generic catch all for any other methods you may need to support

### Nested Routers

- **with(router: Router)**

# Examples

For more in depth route path documentation, see [path-to-regexp](https://github.com/pillarjs/path-to-regexp#readme)

**Return String**

```
tini(router => {
  router.get('/someroute', req => {
    return 'Hello, World!';
  });
});
```

**Route Parameters + Query String**

```
// url: /myKey?p=1
tini(router => {
  router.get('/:key', req => {
    // outputs "myKey, 1"
    return `${req.params.key}, ${req.query.p}`;
  });
});
```

**Return JSON**

```
tini(router => {
  router.get('/someroute', req => {
    return { hello: 'world' };
  });
});
```

**Return A Promise**

```
tini(router => {
  router.get('/someroute', req => {
    return Promise.resolve('hello, world');
  });
});
```

**Return A Response**

```
tini(router => {
  router.get('/someroute', req => {
    return new Response("Not Found", { status: 404 });
  });
});
```

**Middleware**

```
tini(router => {
  router.get('/someroute',
    req => {
      req.intermediateValue = 'somevalue';

      if (req.query.secret !== 'mysecret') {
        return new Response('Unauthorized', { status: 401 });
      }
    },
    req => {
      return req.intermediateValue;
    }
  );
});
```

**Nested Routers**

```
tini(router => {
  const api = new TiniRouter(`/api/v1`);
  api.get('/:name', (req) => ({ params: req.params, query: req.query }));
  router.with(api);

  router.get('(.*)', () => new Response("Not Found", { status: 404 }));
});
```

# License

MIT
npm package: @helloandre/tini-extras
Description: Extra utilities for @helloandre/tini
Author: Andre Bluehs
Latest version: 0.1.0

# Tini Extras

Some helper methods for common things to do with @helloandre/tini

# Installation

- `npm i @helloandre/tini-extras`

# API

- **respondJSON(json?: object, status?: number)**
- **tiniSPA(options? Partial<TiniSPAOptions>)**

# License

MIT
npm package: @helloao/tools
Description: A set of tools for managing HelloAO's Free Bible API
Author: Kallyn Gowdy
Latest version: 0.1.0

## Hello AO Tools

Tools for the [Free Use Bible API](https://bible.helloao.org).

### Features

-   Parse [USFM](https://ubsicap.github.io/usfm/), [USX](https://ubsicap.github.io/usx/), and Codex (JSON) files and understand some basic structure.
-   Generate JSON from USFM, USX, and other formats.

### Installation

```
$ npm install @helloao/tools
```

### Usage

#### Parse a USX File

```typescript
import { parser } from '@helloao/tools';
// Used to parse XML
const parser = new DOMParser();
const usx = new parser.USXParser(parser);
const parseTree = usx.parse('YOUR USX');
console.log(parseTree);
```

#### Generate the API Files for a translation

```typescript
import { parser, generation } from '@helloao/tools';

// Used to parse XML
const domParser = new DOMParser();

// Each input file needs some metadata about the translation that it is associated with
const translation: generation.ParseTreeMetadata = {
    translation: {
        // The ID of the translation
        // this should be unique for the translation
        id: 'my translation id',

        // The name of the translation in the translation's language
        name: 'my translation name',

        // The name of the translation in English
        englishName: 'my translation name',

        // The website that hosts information about the translation
        website: 'translation website',

        // The URL that hosts information about the license that the
        // translation is shared under
        licenseUrl: 'translation license',

        // The ISO 639 letter language tag that the translation is primarily in.
        language: 'eng',

        // The direction that the text is written in.
        // "ltr" means "left to right" and "rtl" means "right to left"
        direction: 'ltr',
    },
};

// The list of files that should be processed.
const files: generation.InputFile[] = [
    {
        // the metadata about the translation for this file
        metadata: translation,

        // The content contained in the file
        content: 'YOUR USX',

        // The type of the file.
        // One of "usx", "usfm", and "json"
        fileType: 'usx',
    },
];

// Generate a dataset from the files
// Datasets organize all the files and their content
// by translation, book, chapter, and verse
const dataset = generation.dataset.generateDataset(files, domParser);

// Generate an API representation from the files
// This adds links between chapters and additional metadata.
const api = generation.api.generateApiForDataset(dataset);

// Generate output files from the API representation.
// This will give us a list of files and file paths that represent
// the entire API.
const outputFiles = generation.api.generateFilesForApi(api);

for (let file of outputFiles) {
    console.log(file.path, file.content);
}
```
npm package: @hellobardo/open-ai-sdk
Description: An Open AI API wrapper built in Typescript
Author: Gustavo Hekel
Latest version: 1.0.7

# OPEN-AI-SDK

A library that wraps the Open AI API built in TypeScript

## Installation

`npm i @hellobardo/open-ai-sdk`

## Usage

### Completion

Completion takes 2 parameters

- engine: a string representing the engine to be used
- configuration: an object with the configuration to be sent described here
  -> https://beta.openai.com/docs/api-reference/create-completion

```js
const {OpenAI} = require("@hellobardo/open-ai-sdk");

const oa = new OpenAI('YOUR_API_KEY', 'ORGANIZATION_KEY_IF_ANY')

oa.completion('davinci', {
    prompt    : 'This is a ...',
    max_tokens: 5
})
    .then(response => console.log(response.data))
    .catch(e => console.error(e))
```

### Search

Search takes 2 parameters

- engine: a string representing the engine to be used
- configuration: an object with the search configuration

```js
const {OpenAI} = require("@hellobardo/open-ai-sdk");

const oa = new OpenAI('YOUR_API_KEY', 'ORGANIZATION_KEY_IF_ANY')

oa.search('davinci', {
    documents: [
        "White House",
        "hospital",
        "school"
    ],
    query    : "the president"
})
    .then(response => console.log(response.data))
    .catch(e => console.error(e))
```

### Get Engines

Retrieve all engines

```js
const {OpenAI} = require("@hellobardo/open-ai-sdk");

const oa = new OpenAI('YOUR_API_KEY', 'ORGANIZATION_KEY_IF_ANY')

oa.getEngines()
    .then(response => console.log(response.data))
    .catch(e => console.error(e))
```

### Get Engine

Retrieve a single engine
```js
const {OpenAI} = require("@hellobardo/open-ai-sdk");

const oa = new OpenAI('YOUR_API_KEY', 'ORGANIZATION_KEY_IF_ANY')

oa.getEngine('davinci')
        .then(response => console.log(response.data))
        .catch(e => console.error(e))
```