open-index/open-npm huggingface dataset:
npm package: @jim-y/web-components
Description: Webcomponent web-components following open-wc recommendations
Author: Attila Kling
Latest version: 1.1.0

# \<web-components>

This webcomponent follows the [open-wc](https://github.com/open-wc/open-wc) recommendation.

## Installation
```bash
npm i web-components
```

## Usage
```html
<script type="module">
  import 'web-components/web-components.js';
</script>

<web-components></web-components>
```

## Linting with ESLint, Prettier, and Types
To scan the project for linting errors, run
```bash
npm run lint
```

You can lint with ESLint and Prettier individually as well
```bash
npm run lint:eslint
```
```bash
npm run lint:prettier
```

To automatically fix many linting errors, run
```bash
npm run format
```

You can format using ESLint and Prettier individually as well
```bash
npm run format:eslint
```
```bash
npm run format:prettier
```

## Demoing with Storybook
To run a local instance of Storybook for your component, run
```bash
npm run storybook
```

To build a production version of Storybook, run
```bash
npm run storybook:build
```


## Tooling configs

For most of the tools, the configuration is in the `package.json` to reduce the amount of files in your project.

If you customize the configuration a lot, you can consider moving them to individual files.

## Local Demo with `web-dev-server`
```bash
npm start
```
To run a local development server that serves the basic demo located in `demo/index.html`
npm package: @jim.catts/run-script-os
Description: run-script-os is a tool that will let you use generic npm script commands that will pass through to os specific commands.
Author: Charlie Guse
Latest version: 1.1.4

# Why does this fork exists?
This fork was made to fix #20 in the original repo. Please check in there if you want to have a well supported version.
There's also a couple of changes that were implemented to improve the readibility and allow for easier fixes in the future, I sure hope @charlesguse don't mind too much!

# run-script-os

You will be able to use OS specific operations in npm scripts.

## Who would want this?
If you have experienced the pain of trying to make npm scripts usable across different operating system, this package is for you! Looking at you `rm` and `del`!

## Installation
`npm install --save-dev run-script-os`

## Usage

Set `run-script-os` (or `run-os`) as the value of the npm script field that you want different functionality per OS. In the example below, we set `test`, but it can be any npm script. It also uses `pre` and `post` commands (explained more below).

Then create OS specific scripts. In the example below, you can see:

* `test:win32`
* `test:linux:darwin`
* `test:default`

Those can have OS specific logic.

`package.json`
```
{
  ...
  "scripts": {
    ...
    "test": "run-script-os",
    "test:win32": "echo 'del whatever you want in Windows 32/64'",
    "test:darwin:linux": "echo 'You can combine OS tags and rm all the things!'",
    "test:default": "echo 'This will run on any platform that does not have its own script'"
    ...
  },
  ...
}
```

**Windows Output:**
```
> npm test
del whatever you want in Windows 32/64
```

**macOS and Linux Output:**
```
> npm test
You can combine OS tags and rm all the things!
```

### Aliases

You can use the following aliases:

* `:windows` - Alias for win32
* `:macos` - Alias for darwin
* `:nix` - This will run on anything considered to be a *nix OS (aix, darwin, freebsd, linux, openbsd, sunos, android)
* `:default` - This will run if no platform-specific scripts are found

### Override detection settings for linux-based shells on Windows

By default, run-script-os will detect cygwin/git bash as Windows. If you would rather your platform be detected as Linux under these environments:

Set environment variable:

```
RUN_OS_WINBASH_IS_LINUX=true
```

### NPM Scripts Order
When you call a script like `npm test`, npm will first call `pretest` if it exists. It will then call `test`, which, if you are using `run-script-os`, it will then call `npm run test:YOUR OS`, which in turn will call `pretest:YOUR OS` before actually running `test:YOUR OS`. Then `posttest:YOUR OS` will run, and then after that `posttest` will finally execute.

There is an example showing `pre` and `post` commands found in the [`package.json` of this repository](https://github.com/charlesguse/run-script-os/blob/master/package.json).

OS Options: `darwin`, `freebsd`, `linux`, `sunos`, `win32`

More information can be found in [Node's `process.platform`](https://nodejs.org/api/process.html#process_process_platform) and [Node's `os.platform()`](https://nodejs.org/api/os.html#os_os_platform).
npm package: @jim2212001/remix-lib
Description: Ethereum IDE and tools for the web
Author: cpp-ethereum team
Latest version: 0.4.12-r1

# `remix-lib`

Provides:

    {
        EventManager: EventManager,
        helpers: {
            trace: traceHelper,
            ui: uiHelper
        },
        vm: {
            Web3Providers: Web3Providers,
            DummyProvider: DummyProvider,
            Web3VMProvider: Web3VMProvider
        },
        SourceMappingDecoder: SourceMappingDecoder,
        SourceLocationTracker: SourceLocationTracker,
        init: init,
        util: util,
        AstWalker: AstWalker,
        ui: {
            styleGuide: styleGuide
        }
    }
npm package: @jim380/uniswapx-sdk
Description: UniswapX SDK with HyperEVM support, forked from @uniswap/uniswapx-sdk
Author: jim380
Latest version: 1.0.5

# uniswapx-sdk

SDK for the UniswapX protocol

## Usage

The SDK contains bindings for two main flows: parsing serialized orders & building new orders.

### Building & Signing Orders

```ts
import { DutchOrder, NonceManager } from '@uniswap/uniswapx-sdk';
import { ethers } from 'ethers';

const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
const account = await provider.getSigner().getAddress(); 
const nonceMgr = new NonceManager(provider, 1); 
const nonce = await nonceMgr.useNonce(account); 

const chainId = 1;
const builder = new DutchOrderBuilder(chainId);
const order = builder
  .deadline(deadline)
  .decayEndTime(deadline)
  .decayStartTime(deadline - 100)
  .nonce(nonce)
  .input({
    token: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
    amount: BigNumber.from('1000000'),
  })
  .output({
    token: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    startAmount: BigNumber.from('1000000000000000000'),
    endAmount: BigNumber.from('900000000000000000'),
    recipient: '0x0000000000000000000000000000000000000000',
  })
  .build();
 
// Sign the built order 
const { domain, types, values } = order.permitData();
const signature = wallet._signTypedData(domain, types, values);

const serializedOrder = order.serialize();
// submit serializedOrder and signature to order pool
```

### Parsing Orders
```ts
import { DutchOrder, Order } from '@uniswap/uniswapx-sdk';

const serializedOrder = '0x1111222233334444555500000000234300234...';
const chainId = 1; 

const order: Order = DutchOrder.parse(serializedOrder, chainId);

const orderData = order.info;
const orderHash = order.hash();
```
### Validating Orders 
```ts
import { ethers } from 'ethers';
import { OrderValidator } from 'uniswapx-sdk';

const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
const validator = new OrderValidator(provider, CHAIN_ID); 
const orders: SignedOrder[] = [
  {
    order: order1, 
    signature: signature1
  }, 
  {
    order: order2, 
    signature: signature2
  }
]; 

try {
  const statusList: OrderValidation[] = await validator.validateBatch(orders); 
  // Do something with list of statuses 
}
catch(e) {
  // Handle error
}

```

### Order Object

**serialize()**

Returns an abi-encoded serialization of the order. This serialized format is passed into the corresponding reactor contract for execution.


**getSigner(signature)**

Recovers the address which created the given signature over the order. Used to determine the order maker.


**permitData()**

Returns the domain, types, and values used to generate an EIP-712 signature over the order. Note that this signature both approves the release of the order's input tokens _and_ the execution of the order itself.


**hash()**

Returns the order hash. This is used as a key to track order fulfillment on-chain. It may also be useful as a unique order identifier for off-chain purposes.
npm package: @jim_wilde/design-system
Description: OctopusMoney design system
Author: jim_wilde
Latest version: 0.0.26

# React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

## Expanding the ESLint configuration

If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:

- Configure the top-level `parserOptions` property like this:

```js
export default {
  // other rules...
  parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module',
    project: ['./tsconfig.json', './tsconfig.node.json'],
    tsconfigRootDir: __dirname,
  },
}
```

- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list
npm package: @jim_wilde/learnstorybook-design-system
Description: Storybook design systems tutorial
Author: jim_wilde
Latest version: 0.2.0

# Storybook design system tutorial

The Storybook design system tutorial is a subset of the full [Storybook design system](https://github.com/storybookjs/design-system/), created as a learning resource for those interested in learning how to write and publish a design system using best in practice techniques.

Learn more in [Storybook tutorials](https://storybook.js.org/tutorials/).
npm package: @jiman24/commandment
Description: discord.js command handling framework
Author: issadarkthing
Latest version: 1.4.0

# Commandment
Simple [discord.js](https://discord.js.org/#/) command framework.


## Why
Because I find myself repeating over and over again doing command handling. This
library will certainly reduce the development time with powerful command
handling for the bot.

## Features
- one command per file
- multiple instance blocking i.e. prevent user from running the same command
  while the other command is still running
- lightweight
- easy to use
- command throttling

## Installing
```sh
$ npm install @jiman24/commandment
```

## Documentation
You can read about the documentation [here](https://commandment.vercel.app/)

## Example
`index.ts`
```ts
import { Client } from "discord.js";
import { CommandManager } from "../index";
import path from "path";

const COMMAND_PREFIX = "!";
const client = new Client({ intents: ["GUILDS", "GUILD_MESSAGES"] });
const commandManager = new CommandManager(COMMAND_PREFIX);

commandManager.verbose = true;
commandManager.registerCommands(path.resolve(__dirname, "./commands"));

commandManager.registerCommandNotFoundHandler((msg, cmdName) => {
  msg.channel.send(`Cannot find command "${cmdName}"`);
})

commandManager.registerCommandOnThrottleHandler((msg, cmd, timeLeft) => {
  const time = (timeLeft / 1000).toFixed(2);
  msg.channel.send(`You cannot run ${cmd.name} command after ${time} s`);
})

client.on("ready", () => console.log(client.user?.username, "is ready!"))
client.on("messageCreate", msg => commandManager.handleMessage(msg));

client.login(process.env.BOT_TOKEN);
```

`commands/Ping.ts`
```ts
import { Message } from "discord.js";
import { Command } from "../../index";

export default class extends Command {
  name = "ping";
  aliases = ["p"];
  throttle = 10 * 1000; // 10 seconds

  exec(msg: Message, args: string[]) {
    msg.channel.send("pong");
  }
}
```

`commands/Wait.ts`
```ts
import { Message } from "discord.js";
import { Command } from "../../index";

export default class extends Command {
  name = "wait";
  block = true;

  private sleep(ms: number) {
    return new Promise((resolve) => {
      setTimeout(resolve, ms);
    })
  }

  async exec(msg: Message, args: string[]) {
    msg.channel.sendTyping();
    const [ms] = args;

    await this.sleep(parseInt(ms))
    msg.channel.send("done");
  }
}
```
npm package: @jiman24/discordjs-rpg
Description: discord rpg framework
Author: issadarkthing
Latest version: 6.0.2

# discordjs-rpg
Simple RPG framework which to be used for my personal projects. Though, this
library is freely available to be used by anyone as it is MIT licensed.

## Features
- Battle system
- Armor system
- Pet system
- Skill system
- Extensible
- No database constraint

## Required package
This package requires `discord.js@v14` in order to work.

### Documentation
discordjs-rpg documentation website -
[here](https://discordjs-rpg.vercel.app/index.html)

Examples - [here](./src/test/)
npm package: @jiman24/discordjs-utils
Description: helper utility package
Author: jiman
Latest version: 0.4.1

## Discord.js utils

Helper functions which I often use in every project. Hope this may help everyone
who are trying to build discord bot as well. Read the documentation [here](./docs/modules.md)

### Installation

```bash
npm install @jiman24/discordjs-utils
```