open-index/open-npm huggingface dataset:
npm package: @sashimiswap/sdk
Description: 🛠 An SDK for building applications on top of Sashimiswap, forked with @uniswap/sdk.
Latest version: 1.0.3

# Uniswap SDK

[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
[![Actions Status](https://github.com/Uniswap/uniswap-sdk/workflows/CI/badge.svg)](https://github.com/Uniswap/uniswap-sdk)
[![npm version](https://img.shields.io/npm/v/@uniswap/sdk/latest.svg)](https://www.npmjs.com/package/@uniswap/sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/sdk/latest.svg)](https://bundlephobia.com/result?p=@uniswap/sdk@latest)

In-depth documentation on this SDK is available at [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.

First clone the repository:

```sh
git clone https://github.com/Uniswap/uniswap-sdk.git
```

Move into the uniswap-sdk working directory

```sh
cd uniswap-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: @sashimo/ui
Description: A stunning, sleek dashboard for Admin AI
Latest version: 9.7.0

# Sashi UI - Internal AI-Powered Admin Interface

Sashi UI is the internal frontend component of the Sashi AI-powered admin tool. This package is private and should not be installed or used outside of the Sashi platform.

## Overview

Sashi UI provides the chat interface for interacting with Sashi-labeled functions and performing admin tasks using AI within the Sashi ecosystem.

## Features

- AI-powered chat interface for executing admin tasks
- Seamless integration with Sashi-labeled functions
- User-friendly interaction using natural language
- Support for sensitive function confirmation
- Real-time updates and responses

## Usage

This package is used internally within the Sashi platform. It is not intended for external installation or use.

## Development

For Sashi team members working on this package:

1. Ensure you have access to the Sashi monorepo.
2. Navigate to the `packages/sashi-ui` directory.
3. Install dependencies:

```bash
npm install
```

4. Run development server:

```bash
npm run dev
```

## Testing

Run the test suite with:

```bash
npm test
```

## Building

To build the package:

```bash
npm run build
```

## Documentation

Internal documentation for this package can be found in the Sashi team's documentation system.

## Contributing

For Sashi team members: Please refer to our internal contributing guidelines when working on this package.

## Security

As an internal package, security is paramount. Always follow our security best practices and never expose sensitive information.

## License

This is proprietary software owned by Sashi. Unauthorized use, modification, or distribution is strictly prohibited.
npm package: @sashite/feen
Description: Instantiate Chess positions and apply Chess moves.
Author: Cyril Kato
Latest version: 1.2.0

# FEEN.js

[![Build Status](https://travis-ci.org/sashite/feen.js.svg?branch=master)](https://travis-ci.org/sashite/feen.js)

> __FEEN__ (Forsyth–Edwards Expanded Notation) support for the JavaScript language.

## Overview

This is an implementation of [FEEN](https://developer.sashite.com/specs/forsyth-edwards-expanded-notation), a generic format that can be used for serializing and deserializing chess positions.

The main chess variants are supported, including [Chess](https://en.wikipedia.org/wiki/Chess), [Janggi](https://en.wikipedia.org/wiki/Janggi), [Makruk](https://en.wikipedia.org/wiki/Makruk), [Shogi](https://en.wikipedia.org/wiki/Shogi), [Xiangqi](https://en.wikipedia.org/wiki/Xiangqi).

More exotic variants are also supported, like: [Dai dai shogi](https://en.wikipedia.org/wiki/Dai_dai_shogi), [Four-player chess](https://en.wikipedia.org/wiki/Four-player_chess), or [Three-dimensional chess](https://en.wikipedia.org/wiki/Three-dimensional_chess) 🖖

![3D chess on Star Trek (from the episode "Court Martial")](https://github.com/sashite/feen.rb/raw/master/star-trek-chess.jpg)

## Installation

```shell
npm install @sashite/feen
```

## Usage

```javascript
// Dump a classic Tsume Shogi problem
FEEN.dump({
  inHand: ['S', 'r', 'r', 'b', 'g', 'g', 'g', 'g', 's', 'n', 'n', 'n', 'n', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p'],
  shape: [9, 9],
  sideId: 0,
  square: {
     3: 's',
     4: 'k',
     5: 's',
    22: '+P',
    43: '+B'
  }
});
// => '3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s'

// Parse a classic Tsume Shogi problem
FEEN.parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s");
// => {
//      inHand: ['S', 'b', 'g', 'g', 'g', 'g', 'n', 'n', 'n', 'n', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'r', 'r', 's'],
//      shape: [9, 9],
//      sideId: 0,
//      square: {
//         3: 's',
//         4: 'k',
//         5: 's',
//        22: '+P',
//        43: '+B'
//      }
//    }
```

## TODO

- [ ] More than two dimensions board support
- [ ] More than two players support

## License

The code is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

## About Sashite

This [package](https://www.npmjs.com/package/@sashite/feen) is maintained by [Sashite](https://sashite.com/).

With some [lines of code](https://github.com/sashite/), let's share the beauty of Chinese, Japanese and Western cultures through the game of chess!
npm package: @sashite/qi
Description: Instantiate Chess positions and apply Chess moves.
Author: Cyril Kato
Latest version: 2.0.0

# Qi.js

[![Build Status](https://travis-ci.org/sashite/qi.js.svg?branch=master)](https://travis-ci.org/sashite/qi.js)

> `Qi` (棋) is an abstraction for initializing and updating positions of chess variants (including Chess, Janggi, Markruk, Shogi, Xiangqi).

## Installation

```shell
npm install @sashite/qi
```

## Usage

Let's replay [The Shortest Possible Game](https://userpages.monmouth.com/~colonel/shortshogi.html) of [Shogi](https://en.wikipedia.org/wiki/Shogi):

```javascript
const Qi = require('./index');

var startingPosition = new Qi(
  [],
  {
     0: "l",
     1: "n",
     2: "s",
     3: "g",
     4: "k",
     5: "g",
     6: "s",
     7: "n",
     8: "l",
    10: "r",
    16: "b",
    18: "p",
    19: "p",
    20: "p",
    21: "p",
    22: "p",
    23: "p",
    24: "p",
    25: "p",
    26: "p",
    54: "P",
    55: "P",
    56: "P",
    57: "P",
    58: "P",
    59: "P",
    60: "P",
    61: "P",
    62: "P",
    64: "B",
    70: "R",
    72: "L",
    73: "N",
    74: "S",
    75: "G",
    76: "K",
    77: "G",
    78: "S",
    79: "N",
    80: "L"
  }
);

// List of moves generated from PMN (https://developer.sashite.com/specs/portable-move-notation)
var moves = [
  [   56, 47, 'P'       ],  [ 3, 11, 'g' ],
  [   64, 24, '+B', 'P' ],  [ 5, 14, 'g' ],
  [   24, 14, '+B', 'G' ],  [ 4,  3, 'k' ],
  [ null, 13, 'G'       ]
];

var lastPosition = moves.reduce(function(position, move) {
  return position.play(move);
}, startingPosition);

lastPosition.inHand;
// => [ 'P' ]

lastPosition.square;
// =>  {
//       '0': 'l',
//       '1': 'n',
//       '2': 's',
//       '3': 'k',
//       '6': 's',
//       '7': 'n',
//       '8': 'l',
//       '10': 'r',
//       '11': 'g',
//       '13': 'G',
//       '14': '+B',
//       '16': 'b',
//       '18': 'p',
//       '19': 'p',
//       '20': 'p',
//       '21': 'p',
//       '22': 'p',
//       '23': 'p',
//       '25': 'p',
//       '26': 'p',
//       '47': 'P',
//       '54': 'P',
//       '55': 'P',
//       '57': 'P',
//       '58': 'P',
//       '59': 'P',
//       '60': 'P',
//       '61': 'P',
//       '62': 'P',
//       '70': 'R',
//       '72': 'L',
//       '73': 'N',
//       '74': 'S',
//       '75': 'G',
//       '76': 'K',
//       '77': 'G',
//       '78': 'S',
//       '79': 'N',
//       '80': 'L'
//     }
```

## License

The code is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

## About Sashite

This [package](https://www.npmjs.com/package/@sashite/qi) is maintained by [Sashite](https://sashite.com/).

With some [lines of code](https://github.com/sashite/), let's share the beauty of Chinese, Japanese and Western cultures through the game of chess!
npm package: @sashke-er/chartjs-plugin-crosshair
Description: Chart.js plugin to draw and sync vertical crosshair lines
Latest version: 1.1.4


<div align="center">
    <centering>
    <img src="header.png" width='600px'/>
    </centering>
</div>


[Chart.js](http://www.chartjs.org/) plugin to draw vertical crosshair, zoom, interpolate values and sync chart interactions.

Requires [Chart.js](https://github.com/chartjs/Chart.js/releases) **2.6.0** or later.

## Documentation

- [Installation](https://chartjs-plugin-crosshair.netlify.com/installation)
- [Options](https://chartjs-plugin-crosshair.netlify.com/options)
- [Samples](https://chartjs-plugin-crosshair.netlify.com/samples)

## Example

```javascript
const chart = new Chart(ctx, {
  // ... data ...
  options: {
    // ... other options ...
    data: {
        datasets: [
            {
                /// ... more data
                crosshair: {
                  pointBackgroundColor: color,
                  pointBorderColor: '#2f3136',
                  pointBorderWidth: 1,
                  pointRadius: 5,
                },
            }
        ],
    },
    tooltips: {
      mode: 'interpolate',
      intersect: false
    },
    plugins: {
      crosshair: {
        line: {
          color: '#F66',  // crosshair line color
          width: 1        // crosshair line width
        },
        sync: {
          enabled: true,            // enable trace line syncing with other charts
          group: 1,                 // chart group
          suppressTooltips: false   // suppress tooltips when showing a synced tracer
        },
        zoom: {
          enabled: true,                                      // enable zooming
          zoomboxBackgroundColor: 'rgba(66,133,244,0.2)',     // background color of zoom box 
          zoomboxBorderColor: '#48F',                         // border color of zoom box
          zoomButtonText: 'Reset Zoom',                       // reset zoom button text
          zoomButtonClass: 'reset-zoom',                      // reset zoom button class
        },
        callbacks: {
          beforeZoom: function(start, end) {                  // called before zoom, return false to prevent zoom
            return true;
          },
          afterZoom: function(start, end) {                   // called after zoom
          }
        }
      }
    }
  }
});

// For zooming programmatically
chart.crosshair.zoom(start, end);
```

## Development

You first need to install node dependencies (requires [Node.js](https://nodejs.org/)):

    > npm install

The following commands will then be available from the repository root:

    > gulp build            // build dist files
    > gulp build --watch    // build and watch for changes
    > gulp lint             // perform code linting
    > gulp docs             // generate GitBook documentation (`dist/docs`)
    > gulp samples          // prepare samples for release (`dist/samples`)
    > gulp package          // create an archive with dist files and samples
    > gulp netlify          // prepare Netlify artifacts (`dist/www`)

## License

`chartjs-plugin-crosshair` is available under the [MIT license](LICENSE.md).
npm package: @sasho/flow-to-ts
Description: [![Actions Status](https://github.com/Khan/flow-to-ts/workflows/Node%20CI/badge.svg)](https://github.com/Khan/flow-to-ts/actions) [![codecov](https://codecov.io/gh/Khan/flow-to-ts/branch/master/graph/badge.svg)](https://codecov.io/gh/Khan/flow-to-ts)
Latest version: 0.1.8

# flow-to-ts

[![Actions Status](https://github.com/Khan/flow-to-ts/workflows/Node%20CI/badge.svg)](https://github.com/Khan/flow-to-ts/actions)
[![codecov](https://codecov.io/gh/Khan/flow-to-ts/branch/master/graph/badge.svg)](https://codecov.io/gh/Khan/flow-to-ts)

Convert Flow code to TypeScript.

The goal of this project is to provide a tool that can translate 95% of Flow
to TypeScript while maintaining a high percentage of the existing type
information. We don't want to convert code and end up with everything using
`any`. We also want to avoid having to make a lot of manual changes to files
afterwards, e.g. changing `SyntheticEvent` to `React.Event`.

# Quick start

- `yarn global add @khanacademy/flow-to-ts`
- `flow-to-ts [options] <file globs>`

# Playground

https://flow-to-ts.netlify.com

# Principles

- when exact translation isn't possible:
  - downgrade to `any` when possible and provide a gentle warning
  - when it isn't possible to downgrade (e.g. `%checks`), remove the syntax
    and provide a forceful warning that the code in question will need a human
    to convert it manually.
- best effort to maintain blank lines and the position comments, this isn't
  always possible so warn in those situations where we can't, e.g. converting
  object type spreads to intersection types.

# Contibuting

## Bugs

Bug reports for converting Flow to TypeScript should include a link to the
playground with an example of a minimal reproducible example of the bug.

## Feature Requests

Feature requests are welcome.

## Pull Requests

Please make sure there is a GitHub issue first before creating a pull request
except for small things. Also, please sign our [Contributor License Agreement](https://docs.google.com/forms/d/e/1FAIpQLSdyXYrc8ogVoA46J9KXyIj5nKlZzNkOnQG-4A1R7X_BWGTShQ/viewform).

Pull requests that fix a bug in the conversion code should include one or more
test cases and should have 100% diff coverage.

## Dev quick start

```bash
git clone git@github.com:Khan/flow-to-ts.git
cd flow-to-ts
yarn
yarn test
```

## Helpful resources

- https://github.com/niieani/typescript-vs-flowtype
- https://astexplorer.net/
npm package: @sashystik89/basic-ds
Description: A lightweight React-friendly design system created to enhance and update existing pet projects, providing:
Latest version: 3.0.4

# Basic Design System (@sashystik89/basic-ds)

A lightweight React-friendly design system created to enhance and update existing pet projects, providing:

- Variables: colors, typography, spacing, border-radius, and more

- Utility Classes: quick CSS helpers for padding, margin, flex/grid, text styles, etc.

- Components: reusable UI components (e.g., buttons, cards, form elements)

- Storybook: interactive component and style previews

## Installation

```sh
npm install @sashystik89/basic-ds
```

or

```sh
yarn add @sashystik89/basic-ds
```

## Compatibility

**Supported React: 18 → 19**
(You must use a single copy of React in your app.)

- React / React-DOM: 18.x, 19.x,
- Node: 18+ (Node 20 recommended)
- Module formats: ESM (default) + CJS
- Bundlers: Vite, Webpack, Next.js (app/router) - as long as only one React is present

## Usage

### Load the stylesheet (required)

Import the design system CSS once at your app entry:

```ts
// src/index.tsx (or App.tsx) in your app
import '@sashystik89/basic-ds/styles.css'
```

Then use components as usual:

```ts
import { Button } from '@sashystik89/basic-ds'

export function Example() {
  return <Button label="Click me" variant="primary" />
}
```

⚠️ 🚧 A Work-in-progress

### Using with Vite (important)

To avoid React runtime duplication and weird “owner stack” errors, add this to your consumer app config:

```js
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [
    // Only transform your own source files
    react({ jsxRuntime: 'classic', include: ['src/**/*.{js,jsx,ts,tsx}'] })
  ],
  resolve: {
    // ensure a single React instance
    dedupe: ['react', 'react-dom']
  },
  optimizeDeps: {
    // do NOT prebundle the design system or JSX runtimes
    exclude: ['@sashystik89/basic-ds', 'react/jsx-runtime', 'react/jsx-dev-runtime']
  }
})
```

After changing config or dependencies, clear Vite’s cache:

```sh
  rm -rf node_modules/.vite
```

### Version changing

```sh
   npx changeset add
```

```sh
  npx changeset version
```

## Contributing

⚠️ 🚧 A Work-in-progress

## License

This project is licensed under the MIT License. Feel free to use and adapt it in your own projects.