open-index/open-npm huggingface dataset:
npm package: @rebox/android
Description: Set of helpers to deal with React Native applications on Android
Latest version: 5.0.0

# @rebox/android ![npm](https://flat.badgen.net/npm/v/@rebox/android)

Set of helpers to deal with React Native applications on Android.

## Install

```sh
$ yarn add @rebox/android
```

## Setup

### macOS

```sh
brew update
brew tap homebrew/cask-versions
brew install --cask adoptopenjdk8
brew install --cask android-sdk
brew install --cask intel-haxm
```

```sh
export ANDROID_HOME=$(brew --prefix)/share/android-sdk
export PATH=$ANDROID_HOME/tools:$PATH
export PATH=$ANDROID_HOME/emulator:$PATH
export PATH=$ANDROID_HOME/platform-tools:$PATH
```

```sh
exec $SHELL -l
```

```sh
mkdir $HOME/.android/
touch $HOME/.android/repositories.cfg
yes | sdkmanager --licenses
sdkmanager "platform-tools" "platforms;android-29" "build-tools;29.0.3" "emulator" "extras;android;m2repository" "system-images;android-29;google_apis;x86"
```

## API

```ts
type TLinkAndroidDependencyOptions = {
  projectPath: string,
  dependencyName: string
}

const linkAndroidDependency: (options: TLinkAndroidDependencyOptions) => Promise<void>
```

```ts
type TBuildAndroidAppDebugOptions = {
  projectPath: string,
  appName: string,
  appId: string
}

const buildAndroidAppDebug: (options: TBuildAndroidAppDebugOptions) => Promise<void>
```

```ts
type TInstallAndroidAppOptions = {
  appPath: string,
  deviceId?: string
}

const installAndroidApp: (options: TInstallAndroidAppOptions) => Promise<void>
```

```ts
type TUninstallAndroidAppOptions = {
  appId: string,
  deviceId?: string // booted one by default
}

const uninstallAndroidApp: (options: TUninstallAndroidAppOptions) => Promise<void>
```

```ts
type TRunAndroidEmulatorOptions = {
  portsToForward: number[],
  isHeadless?: boolean // false by default
}

const runAndroidEmulator: (options: TRunAndroidEmulatorOptions) => Promise<() => void>
```

```ts
type TLaunchAndroidAppOptions = {
  appId: string,
  deviceId?: string // booted one by default
}

const launchAndroidApp: (options: TLaunchAndroidAppOptions) => Promise<void>
```

```ts
type TRunAndroidAppOptions = {
  appName: string,
  appId: string,
  entryPointPath: string,
  portsToForward?: number[], // additional ports to forward from host to emulator's VM
  fontsDir?: string, // directory with `.ttf` or `.otf` files
  dependencyNames?: string[], // installed NPM package names
  isHeadless?: boolean, // false by default
  logMessage?: (msg: string) => void
}

const runAndroidApp: (options: TRunAndroidAppOptions) => Promise<() => void
```

## Usage

```ts
// App.tsx
import { FC } from 'react'
import { Svg, Circle } from 'react-native-svg'

export const App: FC<{}> = () => (
  <Svg height={100} width={100} viewBox="0 0 100 100">
    <Circle
      cx="50"
      cy="50"
      r="45"
      stroke="blue"
      strokeWidth="2.5"
      fill="green"
    />
  </Svg>
)
```

```ts
// run.ts
import { runAndroidApp } from '@rebox/android'

await runAndroidApp({
  appName: 'Test',
  appId: 'org.nextools.test',
  entryPointPath: './App.tsx',
  dependencyNames: ['react-native-svg'],
  logMessage: console.log
})
```
npm package: @rebox/ios
Description: Set of helpers to deal with React Native applications on iOS
Latest version: 7.0.0

# @rebox/ios ![npm](https://flat.badgen.net/npm/v/@rebox/ios)

Set of helpers to deal with React Native applications on iOS.

## Install

```sh
$ yarn add @rebox/ios
```

## Requirements

* Xcode
* iOS Simulator

## Setup

```sh
brew install cocoapods
```

## API

```ts
type TLinkIosDependencyOptions = {
  projectPath: string,
  dependencyName: string
}

const linkIosDependency: (options: TLinkIosDependencyOptions) => Promise<void>
```

```ts
type TBuildIosAppDebugOptions = {
  projectPath: string,
  iOSVersion: string,
  platformName: string,
  appName: string,
  appId: string
}

const buildIosAppDebug: (options: TBuildIosAppDebugOptions) => Promise<void>
```

```ts
type TInstallIosAppOptions = {
  appPath: string,
  deviceId?: string // booted one by default
}

const installIosApp: (options: TInstallIosAppOptions) => Promise<void>
```

```ts
type TUninstallIosAppOptions = {
  appId: string,
  deviceId?: string // booted one by default
}

const uninstallIosApp: (options: TUninstallIosAppOptions) => Promise<void>
```

```ts
type TRunSimulatorOptions = {
  iPhoneVersion: number,
  iOSVersion: string,
  isHeadless?: boolean // false by default
}

const runIosSimulator: (options: TRunSimulatorOptions) => Promise<() => void>
```

```ts
type TLaunchIosAppOptions = {
  appId: string,
  deviceId?: string // booted one by default
}

const launchIosApp: (options: TLaunchIosAppOptions) => Promise<void>
```

```ts
type TRunIosOptions = {
  appName: string,
  appId: string,
  entryPointPath: string,
  iOSVersion: string, // for example `13.2`
  iPhoneVersion: number, // for example `8`
  fontsDir?: string, // directory with `.ttf` or `.otf` files
  dependencyNames?: string[], // installed NPM package names
  isHeadless?: boolean, // false by default
  logMessage?: (msg: string) => void
}

const runIosApp: (options: TRunIosOptions) => Promise<() => void>
```

## Usage

```ts
// App.tsx
import { FC } from 'react'
import { Svg, Circle } from 'react-native-svg'

export const App: FC<{}> = () => (
  <Svg height={100} width={100} viewBox="0 0 100 100">
    <Circle
      cx="50"
      cy="50"
      r="45"
      stroke="blue"
      strokeWidth="2.5"
      fill="green"
    />
  </Svg>
)
```

```ts
// run.ts
import { runAndroidApp } from '@rebox/android'

await runAndroidApp({
  appName: 'Test',
  appId: 'org.nextools.test',
  entryPointPath: './App.tsx',
  dependencyNames: ['react-native-svg'],
  isHeadless: false,
  logMessage: console.log
})
```
npm package: @rebox/native-utils
Description: Set of common helpers to deal with React Native on iOS and Android
Latest version: 5.0.0

# @rebox/native-utils ![npm](https://flat.badgen.net/npm/v/@rebox/native-utils)

Set of common helpers to deal with React Native on iOS and Android.

## Install

```sh
$ yarn add @rebox/native-utils
```

## API

```ts
type TBuildJsBundleOptions = {
  entryPointPath: string,
  outputPath: string,
  platform: 'ios' | 'android'
}

const buildNativeJsBundle: (options: TBuildJsBundleOptions) => Promise<string>
```

```ts
type TServeNativeJsBundleOptions = {
  entryPointPath: string,
  port: number,
  platform: 'ios' | 'android',
  isDev?: boolean, // `&dev=`, true by default
  shouldMinify?: boolean // `&minify=`, false by default
}

const serveNativeJsBundle: (options: TServeNativeJsBundleOptions) => Promise<() => void>

```

```ts
type TCopyNativeTemplateOptions = {
  projectPath: string,
  platform: 'ios' | 'android'
}

const copyNativeTemplate: (options: TCopyNativeTemplateOptions) => Promise<void>
```
npm package: @rebox/web
Description: Set of helpers to deal with React applications using our Babel config
Latest version: 5.0.0

# @rebox/web ![npm](https://flat.badgen.net/npm/v/@rebox/web)

Set of helpers to deal with React applications using [our Babel config](https://github.com/nextools/metarepo/blob/master/packages/nextools/babel-config/src/web.js).

## Install

```sh
$ yarn add @rebox/web
```

## API

```ts
type TBuildWebAppReleaseOptions = {
  entryPointPath: string,
  htmlTemplatePath: string,
  outputPath: string,
  browsersList?: string[], // ['defaults'] by default
  globalConstants?: {
    [key: string]: string
  },
  globalAliases?: {
    [key: string]: string
  },
  props?: TJsonValue,
  isQuiet?: boolean, // false by default
  shouldGenerateSourceMaps?: boolean, // false by default
  shouldGenerateBundleAnalyzerReport?: boolean // false by default
}

const buildWebAppRelease: (userOptions: TBuildWebAppReleaseOptions) => Promise<void>
```

```ts
type TRunWebAppOptions = {
  entryPointPath: string,
  htmlTemplatePath: string,
  browsersList?: string[], // ['last 1 Chrome version', 'last 1 Firefox version'] by default
  assetsPath?: string,
  props?: TJsonValue,
  isQuiet?: boolean, // false by default
  shouldOpenBrowser?: boolean // false by default
}

const runWebApp: (options: TRunWebAppOptions) => Promise<() => Promise<void>>
```

## Usage

```ts
// App.tsx
import { FC } from 'react'

export type TApp = {
  color: string
}

export const App: FC<TApp> = ({ color }) => (
  <h1 style={{ color }}>Test</h1>
)
```

```html
<!-- template.html -->
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8"/>
    <title>Test</title>
    <style>
      body { margin: 0 }
    </style>
  </head>
  <body>
    <div id="root"></div>
  </body>
</html>
```

```ts
// build.ts
import { buildWebAppRelease } from '@rebox/web'

await buildWebAppRelease({
  entryPointPath: './App.tsx',
  htmlTemplatePath: './template.html',
  outputPath: './build/',
  props: {
    color: '#ff0000'
  }
})
```

```ts
// run.ts
import { runWebApp } from '@rebox/web'

await runWebApp({
  entryPointPath: './App.tsx',
  htmlTemplatePath: './template.html',
  props: {
    color: '#ff0000'
  }
})
```
npm package: @rebrickableapi/fetch
Description: Tiny wrapper around fetch that returns type-safe responses
Latest version: 0.0.12

# `@rebrickableapi/fetch`

This package provides a tiny wrapper around native fetch to call the Rebrickable API that returns typesafe responses.

## Usage

```ts
import { fetchRebrickableAPI } from '@rebrickableapiapi/fetch';

const item = await fetchRebrickableAPI('/api/v3/colors');
// -> { id: number, name: string, ... }
```

## Installation

```sh
npm i @rebrickableapi/fetch
```

## Contributing

See [parent readme](../../README.md#contributing).

## License

Licensed under the [MIT License](./LICENSE).
npm package: @rebundled/postgrest-js
Description: Isomorphic PostgREST client
Author: Supabase
Latest version: 0.0.0-next.2

⚠️⚠️ **This is a [rebundled](https://github.com/mmkal/rebundled) version of @rebundled/postgrest-js**! ⚠️⚠️

# `postgrest-js`

[![Build](https://github.com/supabase/postgrest-js/workflows/CI/badge.svg)](https://github.com/supabase/postgrest-js/actions?query=branch%3Amaster)
[![Package](https://img.shields.io/npm/v/@supabase/postgrest-js)](https://www.npmjs.com/package/@supabase/postgrest-js)
[![License: MIT](https://img.shields.io/npm/l/@supabase/postgrest-js)](#license)

Isomorphic JavaScript client for [PostgREST](https://postgrest.org). The goal of this library is to make an "ORM-like" restful interface.

Full documentation can be found [here](https://supabase.github.io/postgrest-js/v2).

### Quick start

Install

```bash
npm install @supabase/postgrest-js
```

Usage

```js
import { PostgrestClient } from '@supabase/postgrest-js'

const REST_URL = 'http://localhost:3000'
const postgrest = new PostgrestClient(REST_URL)
```

- select(): https://supabase.com/docs/reference/javascript/select
- insert(): https://supabase.com/docs/reference/javascript/insert
- update(): https://supabase.com/docs/reference/javascript/update
- delete(): https://supabase.com/docs/reference/javascript/delete

#### Custom `fetch` implementation

`postgrest-js` uses the [`cross-fetch`](https://www.npmjs.com/package/cross-fetch) library to make HTTP requests, but an alternative `fetch` implementation can be provided as an option. This is most useful in environments where `cross-fetch` is not compatible, for instance Cloudflare Workers:

```js
import { PostgrestClient } from '@supabase/postgrest-js'

const REST_URL = 'http://localhost:3000'
const postgrest = new PostgrestClient(REST_URL, {
  fetch: (...args) => fetch(...args),
})
```

## License

This repo is licensed under MIT License.

## Sponsors

We are building the features of Firebase using enterprise-grade, open source products. We support existing communities wherever possible, and if the products don’t exist we build them and open source them ourselves. Thanks to these sponsors who are making the OSS ecosystem better for everyone.

[![New Sponsor](https://user-images.githubusercontent.com/10214025/90518111-e74bbb00-e198-11ea-8f88-c9e3c1aa4b5b.png)](https://github.com/sponsors/supabase)
npm package: @reburn-ui/core
Description: Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
Latest version: 0.2.3

# create-svelte

Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).

Read more about creating a library [in the docs](https://svelte.dev/docs/kit/packaging).

## Creating a project

If you're seeing this, you've probably already done this step. Congrats!

```bash
# create a new project in the current directory
npx sv create

# create a new project in my-app
npx sv create my-app
```

## Developing

Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:

```bash
npm run dev

# or start the server and open the app in a new browser tab
npm run dev -- --open
```

Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.

## Building

To build your library:

```bash
npm run package
```

To create a production version of your showcase app:

```bash
npm run build
```

You can preview the production build with `npm run preview`.

> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.

## Publishing

Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).

To publish your library to [npm](https://www.npmjs.com):

```bash
npm publish
```
npm package: @rebz/scraper
Description: More scraping, less coding.
Author: Chris Johnson
Latest version: 0.0.5

# Scraper

> WIP &mdash; Scrape data from a website, pass an object with `{key: '#selector'}` and receive `{key: 'selector value'}`

## Goals of Project

- Create `SiteModel` that will be fed into a new Scraper Class
- Scraper class will accept a URI and config defining what to scrape
- An optional pagination selector may be passed into the Scraper Class to enable pagination
- Scraped data will be passed back to `SiteModel` where data will be saved

## Install

`npm i @rebz/scraper`

# Example usage

```js
// index.js
const Scraper = require('./dist/index').default

const config = {
    uri: 'http://example.com',
    pagination: { // custom pagination handler
        selector: 'div.prev_next', // element/classname selector of target
        // custom handler for determining next page
        handler: async (currentUri, uris) => {
            const url = new URL(currentUri)
            const newPath = uris[Object.keys(uris).filter(k => k.indexOf('Prev') != -1)[0]]
            return url.origin+newPath
        }
    },
    selectors: {
        key1: 'span#key1selector',
        key2: 'span#key2selector',
        key3: 'span#key3selector',
    }
};

// your custom scrape function
(async () => {

    // Handler to save scraped data
    const saveData = (data) => console.log(data)

    // Handler for errors
    const customErrorHandler = (error) => console.error(error)

    // Setup Scraper
    const scraper = Scraper().setConfig(config);

    // Define a custom Error Handler, returns URI and Error
    await scraper.errors(customErrorHandler)

    // Scrape page and save
    await scraper.scrape()
    await saveData(scraper.getData())

    // ...go to another page, scrape, and save
    await scraper.scrape('http://example.com')
    await saveData(scraper.getData())

    // ...or listen for scrape and apply handler
    await scraper.listen(saveData)

    // if pagination is set you may auto scrape
    await scraper.autoScrape()

    // close the active browser session when finished
    await scraper.stop()
})()
```

`node index.js` will produce:

```
// scrape
{ 
    uri: 'http://example.com',
    scraped: { 
        key1: 'example.com: innerHTML from selector',
        key2: 'example.com: innerHTML from selector',
        key3: 'example.com: innerHTML from selector'
    } 
}
// scrape
{ 
    uri: 'http://example2.com',
    scraped: { 
        key1: 'example2.com: innerHTML from selector',
        key2: 'example2.com: innerHTML from selector',
        key3: 'example2.com: innerHTML from selector'
    } 
}
// ...auto scrape objects after
```

# TODO
1. `ScraperJob`
    - define `frequency` number
    - define `proxies` array
    - ...
1. `ScraperSiteInterface`
    - Used for Model
    - `save()` method to save to "DB"
    - ...
1. Expand sanitization of retrieved values
1. Root configs setup (tslint, tsconfig, etc)
1. Unit Tests (Mocha)
npm package: @rec-math/math
Description: Mathematics for the browser (and TypeScript, JavaScript).
Author: pbuk
Latest version: 1.3.0

# RecMath mathematics module.

> Mathematics for the browser (and TypeScript/Javascript).

## Getting started - in the browser

Load `RecMath` from a CDN

```html
<script src="https://cdn.jsdelivr.net/npm/@rec-math/math@1"></script>
```

## Getting started - Node.js

Install the package with `npm i @rec-math/math` and import what you want.

```Javascript
import * as RecMath from '@rec-math/math';
```

## Usage

### Numerical integration (quadrature)

```Javascript
const [result, info] = RecMath.numerical.quad(
  (x) => Math.exp(-x), // A function to integrate.
  [0, Infinity], // A range to integrate over.
);
console.log(result); // 1
console.log(info);
// { steps: 14, errorEstimate: 3.384539692172424e-16, depth: 7 }
```

The range can have intermediate points:

```Javascript
const [result, { steps, points }] = RecMath.numerical.quad(
  // Normal distribution.
  (t) => Math.exp(-0.5 * t * t) / Math.sqrt(2 * Math.PI),
  [-Infinity, -3, -2, -1, 1, 2, 3, Infinity],
);

console.log(result, steps); // { result: 1, steps: 32 }

// 68%, 96% and 99.7% confidence intervals.
const oneSigma = points[3][0];
const twoSigma = oneSigma + points[2][0] + points[4][0];
const threeSigma = 1 - points[0][0] - points[6][0];

console.log({ oneSigma, twoSigma, threeSigma });
// {
//   oneSigma: 0.682689492137086,
//   twoSigma: 0.9544997361036417,
//   threeSigma: 0.9973002039367398
// }
```
npm package: @rec/serverless-nextjs
Description: Deploy Serverless Next.js apps with Serverless Components
Author: REC
Latest version: 0.3.0

# @rec/serverless-nextjs

**Deploy Serverless Next.js apps with Serverless Components**
This is still a work in progress and is very heavily based on [@danielcondemarin/serverless-nextjs-component](https://github.com/danielcondemarin/serverless-next.js/tree/master/packages/serverless-nextjs-component) project.

## Main differences [@danielcondemarin/serverless-nextjs-component](https://github.com/danielcondemarin/serverless-next.js/tree/master/packages/serverless-nextjs-component)

- Same `domain` format (as a string) to the other @serverless components.
- Same code style to the other @serverless components.
- **No dependencies**.
- Same `input.code` format with working hook like the other @serverless components.
- Dynamic routes using Next.js `routes-manifest.json` to ensure maximum compatibility.

## Example

```yml
api:
  component: '@serverless/backend'
  inputs:
    code:
      src: ./api
    env:
      SOME_ENV: testing
    domain: api.example.com

web:
  component: '@rec/serverless-nextjs'
  inputs:
    code:
      root: ./web
      src: .next/serverless
      hook: npm run build
    env:
      API_URL: ${api.domain}
    domain: example.com
```

## LICENSE

MIT License

Copyright (c) 2019 Rodrigo Espinosa Curbelo

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

---

_(The same [CODE_OF_CONDUCT](./CODE_OF_CONDUCT.md) applies as other official Serverless components)._
npm package: @recalibratedsystems/bclient
Description: Bcoin node and wallet client
Author: Overphoenix
Latest version: 0.1.21

# bclient

REST and RPC clients for bcoin.

## Usage

``` js
const {NodeClient, WalletClient} = require('bclient');
```

## Contribution and License Agreement

If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. `</legalese>`

## License

- Copyright (c) 2017, Christopher Jeffrey (MIT License).

See LICENSE for more info.