open-index/open-npm huggingface dataset:
npm package: @haifeng-fe/tslint-config
Description: TSlint for HaiFengFE
Author: HaiFengFE
Latest version: 1.0.0

> TSLint config for haifengfe


#### Getting Started

1. Install: `yarn add @haifeng-fe/eslint-config -D`.

2. Usage in your tslint.json:

    ```
    { "extends": "@haifeng-fe/tslint-config" }
    ```

    **OR**, if you are using the tslint.yml:
    ```yml
    extends: '@haifeng-fe/tslint-config'
    ```


#### LICENSE

**MIT**
npm package: @haifeng-fe/ubt
Description: [more docs](https://via-ubt.now.sh/)
Latest version: 0.2.4

## via-ubt
[more docs](https://via-ubt.now.sh/)

### How to use

  **With NPM**
  
  - install: `yarn add @haifeng-fe/ubt`.

  - import `import UBT from '@haifeng-fe/ubt'`.

  **With UMD**
  
  - import by script tag: `<script src="//cdn.jsdelivr.net/npm/@haifeng-fe/ubt/dist/index.js></script>`
  
  - use by window: `const UBT = window.UBT`
  

### Start

  1. create project: `const project = new UBT('projectID')`
  
  2. create scene branch: `const UBTScene = project.createScene('scene branch id')`
  
  3. send basic data: `UBTScene.sendBasicAnalytics()`
  
  4. send custom data: 
  
    ```js
    UBTScene.sendEvent({
      id: 'eventID',
      message: 'hello',
      params: {
      },
    })
    ```

### LICENSE
[MIT](LICENSE)
npm package: @haifeng-fe/via
Description: [more docs](https://via.lambdas.dev/)
Latest version: 0.2.0

## via-tool
[more docs](https://via.lambdas.dev/)

### How to use

  **With NPM**
  
  - install: `yarn add @haifeng-fe/via`.

  - import `import Via from '@haifeng-fe/via'`.

  **With UMD**
  
  - import by script tag: `<script src="//cdn.jsdelivr.net/npm/@haifeng-fe/via/dist/index.js></script>`
  
  
### LICENSE
[MIT](LICENSE)
npm package: @haihongli/tiny
Description: Removes all spaces from a string
Latest version: 2.0.2

# @haihongli/tiny

![npm (scoped)](https://img.shields.io/npm/v/@haihongli/tiny)

Removes all spaces from a string.

## Install

```
$ npm install @haihongli/tiny
```

## Usage

```
const tiny = require('@haihongli/tiny')

tiny('So much space!')
//=> Somuchspace!

tiny(1337);
//=> Uncaught TypeError: Tiny wants a string!
```
npm package: @haihun/components
Description: A react library developed with dumi
Latest version: 0.0.2

# @haihun/components

[![NPM version](https://img.shields.io/npm/v/@haihun/components.svg?style=flat)](https://npmjs.org/package/@haihun/components)
[![NPM downloads](http://img.shields.io/npm/dm/@haihun/components.svg?style=flat)](https://npmjs.org/package/@haihun/components)

A react library developed with dumi

## Usage

TODO

## Options

TODO

## Development

```bash
# install dependencies
$ pnpm install

# develop library by docs demo
$ pnpm start

# build library source code
$ pnpm run build

# build library source code in watch mode
$ pnpm run build:watch

# build docs
$ pnpm run docs:build

# Locally preview the production build.
$ pnpm run docs:preview

# check your project for potential problems
$ pnpm run doctor
```

## LICENSE

MIT
npm package: @haiilo/catalyst-angular
Description: Angular wrapper for Catalyst Design System
Latest version: 14.6.0

# Catalyst

This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 12.2.0.

## Code scaffolding

Run `ng generate component component-name --project catalyst` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project catalyst`.
> Note: Don't forget to add `--project catalyst` or else it will be added to the default project in your `angular.json` file. 

## Build

Run `ng build catalyst` to build the project. The build artifacts will be stored in the `dist/` directory.

## Publishing

After building your library with `ng build catalyst`, go to the dist folder `cd dist/catalyst` and run `npm publish`.

## Running unit tests

Run `ng test catalyst` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
npm package: @haiilo/catalyst-angular-formly
Description: Angular Formly bindings for Catalyst Design System
Latest version: 14.6.0

# Catalyst

This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 12.2.0.

## Code scaffolding

Run `ng generate component component-name --project catalyst-formly` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project catalyst-formly`.
> Note: Don't forget to add `--project catalyst-formly` or else it will be added to the default project in your `angular.json` file. 

## Build

Run `ng build catalyst-formly` to build the project. The build artifacts will be stored in the `dist/` directory.

## Publishing

After building your library with `ng build catalyst-formly`, go to the dist folder `cd dist/catalyst-formly` and run `npm publish`.

## Running unit tests

Run `ng test catalyst-formly` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
npm package: @haiilo/catalyst-react
Description: React wrapper for Catalyst Design System
Latest version: 14.6.0

# stencil-ds-react-template

This is an example repo of building plugins.

## Step 1.

- Update the `package.json` to have the correct package name for this repo.
- Replace `component-library` under `dependencies` with your core stencil package name.

## Step 2.

- Build your core stencil package.

## Step 3.

- Run build on this package.
npm package: @haiilo/catalyst-tokens
Description: Design tokens for Catalyst Design System
Latest version: 14.6.0

# Catalyst: Tokens

[![Tokens: build & test](https://github.com/haiilo/catalyst/actions/workflows/tokens.yml/badge.svg)](https://github.com/haiilo/catalyst/actions/workflows/tokens.yml)

This project contains all design tokens for the Catalyst design system.

Tokens are being transformed using
[Amazon Style Dictionary](https://amzn.github.io/style-dictionary/#/).

> Style Dictionary is a build system that allows you to define styles once, in
> a way for any platform or language to consume. A single place to create and
> edit your styles, and a single command exports these rules to all the places
> you need them - iOS, Android, CSS, JS, HTML, sketch files, style
> documentation, or anything you can think of. It is available as a CLI through
> npm, but can also be used like any normal node module if you want to extend
> its functionality.

## Getting started

Install `@haiilo/catalyst-tokens` in your Node.js powered apps with the
[npm package](https://www.npmjs.com/package/@haiilo/catalyst-tokens):

```shell
npm install @haiilo/catalyst-tokens
```

## Contributing

If you want to add or update tokens in this repository, please make sure to
adhere to the design token structure outlined at
[Design token structure](https://amzn.github.io/style-dictionary/#/tokens?id=design-token-structure).

### Package management

This project is using [npm](https://www.npmjs.com/) as a package manager. This
is especially important if you want to add new dependencies to a project and
fail to provide an updated `package-lock.json`. This will cause the CI build to
fail. If dependencies in the package lock do not match those in `package.json`,
npm will exit with an error in the CI build, instead of updating the package
lock.

### Build

Run `npm run build` to build the project. The build artifacts will be stored in
the `dist` directory. Artifacts will automatically be generated on the basis of
the output configuration defined in `config.js`.

### Publishing

The library can be published by running `npm publish`. However, the preferred
way to publish a new version of the library is via the CI setup. A new version
of the library will automatically be published to
[npm](https://www.npmjs.com/package/@haiilo/catalyst-tokens) when pushing a new
tag on the main branch. To simplify this process, you can use the following npm
commands:

 * **npm run release:major** releases a new *major* version
 * **npm run release:minor** releases a new *minor* version
 * **npm run release:patch** releases a new *patch* version

These commands will automatically increase the version number in the
`package.json` and `package-lock.json`, commit the changed files, create a
corresponding git tag and push everything to the remote branch. This will then
automatically publish a new library version.

## License

The license is available within the main repository in the
[LICENSE](https://github.com/haiilo/catalyst/blob/main/LICENSE) file.
npm package: @haiiro2gou/eslint-config
Description: ESLint configuration for JavaScript / TypeScript
Author: haiiro2gou
Latest version: 1.4.2

# ESLint Config

[![stars](https://img.shields.io/github/stars/haiiro2gou/eslint-config?logo=github)](https://github.com/haiiro2gou/eslint-config/stargazers)
[![Gitmoji](https://img.shields.io/badge/gitmoji-%20😜%20😍-FFDD67.svg)](https://gitmoji.carloscuesta.me/)
[![NPM Downloads](https://img.shields.io/npm/dw/%40haiiro2gou%2Feslint-config?label=Downloads)](https://www.npmjs.com/package/%40haiiro2gou/eslint-config)

# Installation

```bash
npm install --save-dev @haiiro2gou/eslint-config
```
# Usage
Create a `eslint.config.js` file in your project root with the following content:
```javascript
import { essentials, node, typescript } from "@haiiro2gou/eslint-config";

export default [
    ...essentials,
    ...node,
    ...typescript,
];
```

If you want to use the config with TypeScript, make sure to install the necessary dependencies.
```bash
npm install --save-dev eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin
```

### License

This repository is licensed under [MIT License](LICENSE).

### Contact

**Discord: haiiro2gou**  
**X(Twitter): [@blanoir3298](https://x.com/blanoir3298)**  
**Youtube: [はいいろ](https://www.youtube.com/@haiiro2gou)**
npm package: @haiix/aseq
Description: A JavaScript module that allows asynchronous iterators to use array-like methods.
Author: haiix
Latest version: 0.1.3
Deprecated: This package is no longer maintained

# ⚠️ This project is no longer maintained

This repository is no longer actively maintained.
Please consider using alternative libraries.

# aseq.mjs

A JavaScript module that allows asynchronous iterators to use array-like methods.

There is also a synchronous version: https://github.com/haiix/seq

## Installation

```
npm install @haiix/aseq
```

## Usage

```javascript
import aseq from '@haiix/aseq'
```

## Examples

1.  By passing the natural number N to the aseq function, an async iterator is created that increments between 0 and N.
    You can use array-like methods (map, join, etc.) on the created async iterator.

    ```javascript
    await aseq(3).join() // "0,1,2"
    ```

    ```javascript
    await aseq(4).map(x => x + 1).join() // "1,2,3,4"
    ```

2.  You can pass an async iterable object (with the [Symbol.asyncIterator] method) to the aseq function.

    ```javascript
    async function* myFunc () {
      for (let n = 10; n <= 30; n += 10) {
        await new Promise(resolve => setTimeout(resolve, 100))
        yield n
      }
    }
    await aseq(myFunc()).map(x => x + 1).join() // "11,21,31"
    ```

3.  There are no methods implemented that rewrite themselves.
    If you want to use those methods, convert them to arrays once.
    You can use the toArray method for that.

    ```javascript
    //aseq(5).reverse() // Error
    (await aseq(5).toArray()).reverse() // [4, 3, 2, 1, 0]
    ```

4.  In this example, the value is returned when the result of indexOf is found, without waiting for the original processing to finish.

    ```javascript
    await aseq(100).map(x => x * 2).filter(x => x % 3 > 0).indexOf(16) // 5
    ```

5.  The iterator created by the aseq function can be used in a for-await-of statement.
    Use in processing with side effects.

    ```javascript
    for await (const n of aseq(3)) {
      console.log(n) // 0, 1, 2
    }
    ```

    ```javascript
    for await (const elem of aseq(3).map(n => document.createElement('input'))) {
      document.body.appendChild(elem)
    }
    ```
npm package: @haiix/idb
Description: A lightweight, promise-based wrapper for IndexedDB that simplifies database operations with async/await syntax.
Author: haiix
Latest version: 0.1.1

# @haiix/idb

A lightweight, promise-based wrapper for IndexedDB that simplifies database operations with async/await syntax.

## Features

- 🚀 Full Promise/async-await support
- 🔒 Type-safe with TypeScript
- 💡 Intuitive API design
- 🔄 Automatic transaction management
- 📑 Support for indexes
- ⚡ Efficient cursor operations

## Installation

```bash
npm install @haiix/idb
```

## Basic Usage

```typescript
import idb from '@haiix/idb';

// Open or create a database
const db = idb.open('myDatabase');

// Create an object store
const store = db.objectStore('myStore', {
  keyPath: 'id',
  autoIncrement: true
});

// Add data
await store.add({ name: 'John', age: 30 });

// Retrieve data
const john = await store.get(1);

// Update data
await store.put({ id: 1, name: 'John', age: 31 });

// Delete data
await store.delete(1);
```

## Transaction Optimization

This library automatically optimizes database transactions by batching synchronous operations. When multiple database operations are executed using `Promise.all`, they are automatically combined into a single transaction, improving performance.

### Transaction Batching

#### Sequential Operations (Multiple Transactions)
When operations are executed sequentially with await, each operation creates its own transaction:

```typescript
// Creates TWO separate transactions
await store.add('value1', 'key1');  // Transaction #1
await store.add('value2', 'key2');  // Transaction #2
```

#### Parallel Operations (Single Transaction)
When operations are executed in parallel using Promise.all, they are automatically batched into a single transaction:

```typescript
// Creates ONE transaction for both operations
await Promise.all([
  store.add('value1', 'key1'),
  store.add('value2', 'key2')
]);
```

### Best Practices for Transaction Optimization

To make the most of transaction batching:

1. Group Related Operations:
```typescript
// Good: Single transaction
await Promise.all([
  userStore.add(userData),
  profileStore.add(profileData),
  settingsStore.add(settingsData)
]);

// Less efficient: Multiple transactions
await userStore.add(userData);
await profileStore.add(profileData);
await settingsStore.add(settingsData);
```

2. Use Promise.all for Parallel Operations:
```typescript
// Efficient batch processing
const users = [{id: 1, name: 'John'}, {id: 2, name: 'Jane'}];
await Promise.all(users.map(user => store.add(user)));
```

3. Balance Between Batching and Response Time:
```typescript
// For large datasets, consider batching in chunks
const BATCH_SIZE = 100;
const chunks = [];
for (let i = 0; i < items.length; i += BATCH_SIZE) {
  chunks.push(items.slice(i, i + BATCH_SIZE));
}

for (const chunk of chunks) {
  await Promise.all(chunk.map(item => store.add(item)));
}
```

## API Reference

[API Reference](https://github.com/haiix/idb/wiki/api_reference)

## License

MIT License - see the [LICENSE](LICENSE) file for details.