open-index/open-npm huggingface dataset:
npm package: @jeremy.zhang2013/sdk
Description: [Mantle] Tools for working with Mantle
Author: Mantle PBC
Latest version: 0.1.4

[![codecov](https://codecov.io/gh/mantlenetworkio/mantle/branch/main/graph/badge.svg?token=0VTG7PG7YR&flag=sdk)](https://codecov.io/gh/mantlenetworkio/mantle)

# @mantleio/sdk

The `@mantleio/sdk` package provides a set of tools for interacting with Mantle.

## Installation

```
npm install @mantleio/sdk
```

## Docs

You can find auto-generated API documentation over at [sdk.mantle.xyz](https://sdk.mantle.xyz).

## Using the SDK

### CrossChainMessenger

The [`CrossChainMessenger`](https://github.com/mantlenetworkio/mantle/blob/main/packages/sdk/src/cross-chain-messenger.ts) class simplifies the process of moving assets and data between Ethereum and Mantle.
You can use this class to, for example, initiate a withdrawal of ERC20 tokens from Mantle back to Ethereum, accurately track when the withdrawal is ready to be finalized on Ethereum, and execute the finalization transaction after the challenge period has elapsed.
The `CrossChainMessenger` can handle deposits and withdrawals of ETH and any ERC20-compatible token.
Detailed API descriptions can be found at [sdk.mantle.xyz](https://sdk.mantle.xyz/classes/crosschainmessenger).
The `CrossChainMessenger` automatically connects to all relevant contracts so complex configuration is not necessary.

### L2Provider and related utilities

The Mantle SDK includes [various utilities](https://github.com/mantlenetworkio/mantle/blob/main/packages/sdk/src/l2-provider.ts) for handling Mantle's [transaction fee model](https://community.mantle.xyz/docs/developers/build/transaction-fees/).
For instance, [`estimateTotalGasCost`](https://sdk.mantle.xyz/modules.html#estimateTotalGasCost) will estimate the total cost (in wei) to send at transaction on mantle including both the L2 execution cost and the L1 data cost.
You can also use the [`asL2Provider`](https://sdk.mantle.xyz/modules.html#asL2Provider) function to wrap an ethers Provider object into an `L2Provider` which will have all of these helper functions attached.

### Other utilities

The SDK contains other useful helper functions and constants.
For a complete list, refer to the auto-generated [SDK documentation](https://sdk.mantle.xyz/)
npm package: @jeremy1l/mytest-library
Description: React NPM library starter kit based on Facebook's create react app
Author: Dimitri Mikadze
Latest version: 1.1.0

# React NPM library starter kit

[![Build Status](https://travis-ci.org/DimiMikadze/create-react-library.svg?branch=master)](https://travis-ci.org/DimiMikadze/create-react-library)
[![Dependencies](https://img.shields.io/david/DimiMikadze/create-react-library.svg)]()
[![Dev Dependencies](https://img.shields.io/david/dev/DimiMikadze/create-react-library.svg)]()

based on Facebook's <a href="https://github.com/facebookincubator/create-react-app" target="_blank">Create react app</a>.
We are constantly updating repository with the updates of `create-react-app`, so we have all new features and bug fixes of it.

## Converted to custom setup

Moved all dependencies to dev dependencies because we don't need extra dependencies for our library after build, but we want all this features while developing: 

* React, JSX, ES6, and Flow syntax support.
* Language extras beyond ES6 like the object spread operator.
* A dev server that lints for common errors.
* Import CSS and image files directly from JavaScript.
* Autoprefixed CSS, so you don’t need `-webkit` or other prefixes.
* A `build` script to bundle JS, CSS, and images for production.

## Getting Started

Clone repo

````
git clone https://github.com/DimiMikadze/create-react-library.git
````

Install dependencies

`npm install` or `yarn install`

Start development server

`npm start` or `yarn start`

Runs the demo app in development mode.
Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

## Library files

All library files are located inside `src/lib`  

## Demo app

Is located inside `src/demo` directory, here you can test your library while developing

## Testing

`npm run test` or `yarn run test`

## Build library

`npm run build` or `yarn run build`

Produces production version of library under the `build` folder.

## Publish library

`npm publish`

## Example library built with this starter kit

https://github.com/DimiMikadze/react-under-construction
npm package: @jeremybanks/speedruns
Description: Unofficial tools for mirring speedrun.com API data
Author: Jeremy Banks
Latest version: 0.21.6-dev.36

# speedruns

Unofficial tools for mirroring [speedrun.com](https://www.speedrun.com/) API data. Using Rust, TypeScript, GraphQL, and React.

## Legal

### Disclosure

This project is not associated with or endorsed by speedrun.com.

### Code License

Copyright Jeremy Banks, released under [the MIT License](LICENSE).

### Content License

See <https://www.speedrun.com/legal> for details. All data is from speedrun.com
contributors, and is used and distributed under the Creative Commons
Attribution-NonCommercial 4.0 International license.

## Development

### Environment

Install [rustup](https://rustup.rs/) to manage the Rust toolchain and [nvm](https://github.com/nvm-sh/nvm) to manage the JavaScript toolchain, following instructions on their respective pages.

Install and activate our expected version of npm using nvm, then install [the Yarn package manager](https://yarnpkg.com/):

```
nvm install
nvm use
npm install -g yarn@^1
```

### Run Server

You can start the backend and frontend servers together using our yarn `start` script. You'll probably want to open the frontend in your browser at http://localhost:3000.

```
yarn start
```

Initially, this will load a test fixture data set only intended for development.

### Import Data

If you want to use the real data set, you'll need to import it.

(Optional) You may want to start by downloading archived copies of `{runs,users,games}.jsonl.gz` from
https://archive.org/download/speedrun.com-2020-02-01, and putting them in `data/api`, to reduce the amount you load through the API (which can take a long time).

Download any new data by running:

```
cargo run download
```

This can take a long time (potentially a full day if you're starting from scratch). This won't include changes or deletions of existing items, we assume they're unchanged. If you want to be sure that every record is up to date, you need to delete the downloaded data and start from scratch.

Validate and convert the downloaded API data into our internal format by running:

```
cargo run import
```

Any records that don't match our expected format (missing now-required fields, inconsistent timing methods, or niche options we don't support) **will be discarded**, so our leaderboards might not match speedrun.com (whose software robustly accomidates old data of varied shapes).

Restart the server to load the new data.
npm package: @jeremybarbet/contentful-typescript-codegen
Description: Generate TypeScript types from your Contentful environment.
Author: Steven Petryk
Latest version: 1.0.0

# contentful-typescript-codegen

Generate typings from your Contentful environment.

- Content Types become interfaces.
- Locales (and your default locale) become string types.
- Assets and Rich Text link to Contentful's types.

At Intercom, we use this in our [marketing site] to increase developer confidence and productivity,
ensure that breaking changes to our Content Types don't cause an outage, and because it's neat.

[marketing site]: https://www.intercom.com

## Usage

```sh
yarn add --dev contentful-typescript-codegen
```

Then, add the following to your `package.json`:

```jsonc
{
  // ...
  "scripts": {
    "contentful-typescript-codegen": "contentful-typescript-codegen --output @types/generated/contentful.d.ts"
  }
}
```

Feel free to change the output path to whatever you like.

Next, the codegen will expect you to have created a file called `getContentfulEnvironment.js` in the
root of your project directory, and it should export a promise that resolves with your Contentful
environment.

The reason for this is that you can do whatever you like to set up your Contentful Management
Client. Here's an example:

```js
const contentfulManagement = require("contentful-management")

module.exports = function() {
  const contentfulClient = contentfulManagement.createClient({
    accessToken: process.env.CONTENTFUL_MANAGEMENT_API_ACCESS_TOKEN,
  })

  return contentfulClient
    .getSpace(process.env.CONTENTFUL_SPACE_ID)
    .then(space => space.getEnvironment(process.env.CONTENTFUL_ENVIRONMENT))
}
```

### Command line options

```
Usage
  $ contentful-typescript-codegen --output <file> <options>

Options
  --output,      -o  Where to write to
  --poll,        -p  Continuously refresh types
  --interval N,  -i  The interval in seconds at which to poll (defaults to 15)
```

## Example output

Here's an idea of what the output will look like for a Content Type:

```ts
interface IBlogPostFields {
  /** Title */
  title: string

  /** Body */
  body: Document

  /** Author link */
  author: IAuthor

  /** Image */
  image: Asset

  /** Published? */
  published: boolean | null

  /** Tags */
  tags: string[]

  /** Blog CTA variant */
  ctaVariant: "new-cta" | "old-cta"
}

/**
 * A blog post.
 */
export interface IBlogPost extends Entry<IBlogPostFields> {}
```

You can see that a few things are handled for you:

- Documentation comments are automatically generated from Contentful descriptions.
- Links, like `author`, are resolved to other TypeScript interfaces.
- Assets are handled properly.
- Validations on symbols and text fields are expanded to unions.
- Non-required attributes automatically have `| null` appended to their type.
- The output is formatted using **your** Prettier config.
npm package: @jeremybarbet/flash-list
Description: FlashList is a more performant FlatList replacement
Author: shopify
Latest version: 1.7.3

![FlashList Image](./FlashList.png)

<div align="center">
  <a href="https://shopify.github.io/flash-list/">Website</a> •
  <a href="https://discord.gg/k2gzABTfav">Discord</a> •
  <a href="https://shopify.github.io/flash-list/docs/">Getting started</a> •
  <a href="https://shopify.github.io/flash-list/docs/usage">Usage</a> •
  <a href="https://shopify.github.io/flash-list/docs/performance-troubleshooting">Performance</a> •
  <a href="https://shopify.github.io/flash-list/docs/fundamentals/performant-components">Writing performant components</a> •
  <a href="https://shopify.github.io/flash-list/docs/known-issues">Known Issues</a>
<br><br>

**Fast & performant React Native list. No more blank cells.**

Swap from FlatList in seconds. Get instant performance.

</div>

## Installation

Add the package to your project via `yarn add @jeremybarbet/flash-list` and run `pod install` in the `ios` directory.

## Usage

We recommend reading the detailed documentation for using `FlashList` [here](https://shopify.github.io/flash-list/docs/usage).

But if you are familiar with [FlatList](https://reactnative.dev/docs/flatlist), you already know how to use `FlashList`. You can try out `FlashList` by changing the component name and adding the `estimatedItemSize` prop or refer to the example below:

```jsx
import React from "react";
import { View, Text } from "react-native";
import { FlashList } from "@jeremybarbet/flash-list";

const DATA = [
  {
    title: "First Item",
  },
  {
    title: "Second Item",
  },
];

const MyList = () => {
  return (
    <FlashList
      data={DATA}
      renderItem={({ item }) => <Text>{item.title}</Text>}
      estimatedItemSize={200}
    />
  );
};
```

To avoid common pitfalls, you can also follow these steps for migrating from `FlatList`, based on our own experiences:

1. Switch from `FlatList` to `FlashList` and render the list once. You should see a warning about missing `estimatedItemSize` and a suggestion. Set this value as the prop directly.
2. **Important**: Scan your [`renderItem`](https://shopify.github.io/flash-list/docs/usage/#renderitem) hierarchy for explicit `key` prop definitions and remove them. If you’re doing a `.map()` use indices as keys.
3. Check your [`renderItem`](https://shopify.github.io/flash-list/docs/usage/#renderitem) hierarchy for components that make use of `useState` and verify whether that state would need to be reset if a different item is passed to that component (see [Recycling](https://shopify.github.io/flash-list/docs/recycling))
4. If your list has heterogenous views, pass their types to `FlashList` using [`getItemType`](https://shopify.github.io/flash-list/docs/usage/#getitemtype) prop to improve performance.
5. Do not test performance with JS dev mode on. Make sure you’re in release mode. `FlashList` can appear slower while in dev mode due to a small render buffer.

## App / Playground

The [fixture](https://github.com/Shopify/flash-list/tree/main/fixture) is an example app showing how to use the library.
npm package: @jeremybarbet/react-native-purchase-kit
Description: Latest StoreKit and BillingClient modules for react-native
Author: Jérémy Barbet
Latest version: 0.1.12

# @jeremybarbet/react-native-purchase-kit

Latest StoreKit and BillingClient modules for react-native

## Installation

```sh
npm install @jeremybarbet/react-native-purchase-kit
```
npm package: @jeremybyu/asyncastar
Description: Asynchronous A* Path Planner
Latest version: 0.0.12

# AsyncAStar

This module allows one to execute A* search in an Asynchronous pattern. It is very similar to [EasyStar](https://easystarjs.com/), however this module can be used for more than 2D planning for game development as EasyStar is designed for. It allows one to specify a generic `Generate Successors` function, not needing to know anything about the graph. In other words, this module only cares about the *algorithm* of A*, not the graph, which is from your specific problem domain. It could be 2D, 3D, or however many dimensions you may need (though A* performance suffers greatly at higher dimensions).


## Getting Started

Install : `npm  install asyncastar`

### Simple 2D or 3D Path Planning
Since most people will probably do 2D or 3D path planning, there is a simple wrapper for `AsyncAStar` called
`createPlanner` that assumes a 3D discretized space using `ndarray` as the data holder of this space. The demonstration below shows 3D planning within a plane (basically 2D).

```js
import { createPlanner} from '../lib/util';
const start = [0, 0, 0]
const goal = [2, 2, 0]
const maze = ndarray([0,0,0,0,0,0,0,0,0], [3,3,1]) // Empty 3X3X1 Maze
planner = createPlanner(maze, mazeTest.start, mazeTest.goal);

let result = planner.searchAsync(1) // only 1 expansion
console.log(result)


result = planner.searchAsync(3) // allow 3 more expansions
console.log(result)


```

Full API: https://jeremybyu.github.io/AsyncAstar/


## Issues/Bugs/Feature Requests

Feel free to file any issues (bugs), or feature requests.  Please follow the Issue template however.

## Development

First download, pull, and run tests.  Make sure its all working!

1. `git pull https://github.com/JeremyBYU/AsyncAstar.git`
2. `npm install`
3. `npm run test`

Then submit any PR's, following the contributing guidelines.



X and Y might be flipped in NDARRAY






<!-- ### Options

Initialize it- 
User Defined
* Node Class
  * equality
  * Hashing function
  * x, y z

* Successor Function as well as edge cost
  * returns list of nodes as well as cost (travel cost + heat map)

* Stop Node

* Start Node

* Num Expansions

Library
* NodeCost Class
  * Encapsulates Node Class
  * Has g, f, closed, frontier

* Member Attributes
  * NodeSet (dict, or Map)
  * Frontier (Open List) Priority Queue
* Member Functions
  * addNode()
  * Initialize Routine
    * Add start PriorityQueue
    * Set the hashing function
  * GenerateSuccesors
    * Call the user one
    * Remove those in the closed list
  * ExpandRoutine
    * CurrentNode = Pop frontier (chceck empty)
    * Goal Check
    * Add Closed Bit to node (curNode.closed = true)
    * Generate successor and costs arrays
    * Skip those in closed list
    * Calclate a temporary path cost 
  * 



```
updateItem = (array, item, cmp=defaultCmp) ->
  pos = array.indexOf(item)
  return if pos is -1
  _siftdown(array, 0, pos, cmp)
  _siftup(array, pos, cmp)
``` -->
npm package: @jeremyckahn/lateralus-components
Description: A set of general-use components for Lateralus
Author: Jeremy Kahn
Latest version: 0.2.0

# Lateralus Components

This is a collection of general-use UI components that can be used to enhance a [Lateralus](https://github.com/Jellyvision/lateralus) app.  Each component has its own README file, so please explore the directory of the component which you would like to know more about.

To wire up a component in your app, set it up as an [AMD package](http://requirejs.org/docs/api.html#packages), like so:


````javascript
require.config({
  baseUrl: '/',
  packages: [{
    name: 'lateralus',
    location: 'node_modules/lateralus/scripts',
    main: 'lateralus'
  }, {
    name: 'lateralus.component.tabs',
    location: 'node_modules/lateralus-components/tabs'
  }, {
    name: 'lateralus.component.model-editor',
    location: 'node_modules/lateralus-components/model-editor'
  }
});
````