open-index/open-npm huggingface dataset:
npm package: @piscale/expo-correct-android-namespace
Description: Expo Plugin to correct Android Namespace on prebuild
Author: PiScale Developer
Latest version: 0.0.1

# Expo Correct Android Namespace Plugin

Expo Plugin to correct Android Namespace on prebuild

# Install

```bash
yarn add @piscale/expo-correct-android-namespace --dev
```

# Usage

```json title='./app.json'
{
  "expo": {
    ...,
    "plugins": [
      "@piscale/expo-correct-android-namespace",
      ...
    ]
  }
}
```
npm package: @piscina/fastify
Description: A Fastify Piscina Plugin
Author: James M Snell
Latest version: 6.0.2

# fastify-piscina - A Piscina plugin for Fastify

## Example

```js
const fastify = require('fastify')();
const { resolve} = require('path');

fastify.register(require('fastify-piscina'), {
  // Piscina Options object. See Piscina docs for details
  filename: resolve(__dirname, 'worker.js')
});

// Declare a route
fastify.get('/', async (request, reply) => {
  reply.send({ hello: `world [${await fastify.runTask({ a: 1, b: 2 })}]` });
});

// Run the server!
fastify.listen(3000, function (err, address) {
  if (err) {
    fastify.log.error(err);
    process.exit(1);
  }
  fastify.log.info(`server listening on ${address}`);
});
```

Once registered, the plugin decorates the `fastify` instance
with two new properties:

* `fastify.piscina` {`Piscina`} The Piscina instance.
* `fastify.runTask()` {`Function`} The Piscina runTask function.

See the [Piscina docs][] for more information.

## The Team

* James M Snell <jasnell@gmail.com>
* Anna Henningsen <anna@addaleax.net>
* Matteo Collina <matteo.collina@gmail.com>

## Acknowledgements

Piscina development is sponsored by [NearForm Research][].

[Piscina docs]: https://github.com/jasnell/piscina
[NearForm Research]: https://www.nearform.com/research/
npm package: @piscina/fastify-locks
Description: A Fastify Web Locks API Plugin
Author: James M Snell
Latest version: 4.0.1

# fastify-locks - A Piscina Locks plugin for Fastify

## Example

```js
const fastify = require('fastify')();

fastify.register(require('fastify-locks'), {});

// Declare a route
fastify.get('/', async (request, reply) => {
  await fastify.locks.request('hello', () => {
    // Do something that requires an exclusive lock,
    // such as updating a shared resource.
  });
  reply.send('hello world');
});

// Run the server!
fastify.listen(3000, function (err, address) {
  if (err) {
    fastify.log.error(err);
    process.exit(1);
  }
  fastify.log.info(`server listening on ${address}`);
});
```

Once registered, the plugin decorates the `fastify` instance
with a new `locks` property:

* `fastify.locks.request(name[, options], callback)`
* `fastify.locks.query()`

See the [Piscina-locks docs][] for more information.

## The Team

* James M Snell <jasnell@gmail.com>

## Acknowledgements

Piscina development is sponsored by [NearForm Research][].

[Piscina-locks docs]: https://github.com/piscinajs/piscina-locks
[NearForm Research]: https://www.nearform.com/research/
npm package: @piscina/locks
Description: A Web Locks API implementation for Node.js
Author: James M Snell
Latest version: 4.0.2

# Piscina-locks

Piscina-locks is an implementation of the [Web Locks API][] for Node.js.

The Web Locks API allows code to acquire a lock, perform work while the lock
is held, then have the lock automatically released when the work is complete.

Written using TypeScript and N-API.

For Node.js 12.x and higher.

[MIT Licensed][].

## Example

```js
const { request } = require('piscina-locks');
const { setTimeout } = require('timers/promises');

(async function() {
  return await request('resource', async (lock) => {
    await setTimeout(1000);
    return lock.name;
  });
})();
```

Using workers:

```js
const { request } = require('piscina-locks');
const { Worker, isMainThread } = require('worker_threads');
const { promisify } = require('util');
const sleep = promisify(setTimeout);

request('shared-resource', async () => {
  console.log(isMainThread);
  await sleep(1000);
});

if (isMainThread) {
  // eslint-disable-next-line no-new
  new Worker(__filename);
}
```

## `request(name\[, options], callback)`

* `name` (`string`) The name of the lock to acquire.
* `options` (`object`)
  * `mode` (`string`) Must be `'exclusive'` or `'shared'`. Defaults to
    `'exclusive'`. There can be only one holder of an `'exclusive'`
    lock at a time but multiple holders of `'shared'` locks.
  * `ifAvailable` (`boolean`) When `true`, the request will fail if
    the lock cannot be granted immediately. Defaults to `false`.
  * `steal` (`boolean`) When `true`, any existing held locks are released
    and the associated Promises rejected with an `AbortError` and the
    requested lock will be granted. Defaults to `false`.
  * `signal` (`AbortSignal` | `EventEmitter`) An `AbortSignal` that can
    be used to cancel a pending lock request.
* `callback` (`function`) Invoked when the lock is acquired. The callback
  is invoked with the granted `Lock` as the only argument. If `ifAvailable`
  is `true` and the lock is not available, the argument will be `null`. The
  callback may be a regular function or an async function.

Returns a `Promise` that resolves with the return value of `callback` after
the granted `Lock` is released. The `Promise` will be rejected if the lock
request is canceled, the granted lock is stolen, or `callback` throws.

## `query()`

* Returns `object`
  * `pending` (`object[]`)
    * `name` (`string`)
    * `mode` (`string`)
  * `held` (`object[]`)
    * `name` (`string`)
    * `mode` (`string`)

The `query()` method is a diagnostic utility that lists the pending lock
requests and currently held locks. It is useful for debugging purposes only.

## The Team

* James M Snell <jasnell@gmail.com>

## Acknowledgements

Piscina development is sponsored by [NearForm Research][].

[MIT Licensed]: LICENSE.md
[NearForm Research]: https://www.nearform.com/research/
[Web Locks API]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
npm package: @piscina/priority-queue
Description: A Priority TaskQueue implementation for Piscina
Author: James M Snell
Latest version: 4.0.0

# @piscina/priority-queue - A Priority Queue for Piscina

![CI](https://github.com/jasnell/piscina/workflows/CI/badge.svg)

## Example

```js
const Piscina = require('piscina');
const PiscinaPriorityQueue = require('@piscina/priority-queue');
const { resolve } = require('path');

const pool = new Piscina({
  filename: resolve(__dirname, 'worker.js'),
  taskQueue: new PiscinaPriorityQueue()
});

const priority_1_task = PiscinaPriorityQueue.makeTask({ a: 1 }, 1);
const priority_2_task = PiscinaPriorityQueue.makeTask({ a: 1 }, 2);

(async () => {
  await Promise.all([
    pool.runTask(priority_1_task),
    pool.runTask(priority_2_task)
  ]);
})();
```

## The Team

* James M Snell <jasnell@gmail.com>
* Anna Henningsen <anna@addaleax.net>
* Matteo Collina <matteo.collina@gmail.com>

## Acknowledgements

Piscina development is sponsored by [NearForm Research][].

[NearForm Research]: https://www.nearform.com/research/
npm package: @piscium2010/lime
Description: Lime is an extremly lightweight react-based UI kit for building UI components.
Author: piscium2010
Latest version: 2.3.8

# Lime - React UI parts

Lime is an extremly lightweight react-based UI kit for building UI components. It consists of a few essential thing like Collapsible, Layer, List, Ripple and Scroll, with which you can build your own UI component from scratch.


## Why lime?

U probably have seen a lot of UI libraries that is fully featured, API rich and powerful. Then comes a time that you need something a little bit different from the library and you are doomed. 

The fully featured component is also fully complex, hard to understand and customize. Well, good news is that Lime is stupid and dead simple. Instead of providing component we provide stories built with Lime to show you how to build a component yourself.

## For more information

There is none. But we do have **a live demo at [codeburnt.com](http://www.codeburnt.com)**.

## Licenses

MIT
npm package: @pisell/build-plugin-lowcode
Description: build plugin for component-to-lowcode
Latest version: 1.0.13

## 概述

## 使用文档

```
export interface LowcodeOptions {
  builtinAssets?: Array<string|Assets>; // 会作为内置资产保存到构建产物中
  extraAssets?: Array<string|Assets>; // 只在调试环境加载到资产包中
  noParse?: boolean; // 关闭自动解析生成 lowcode meta
  categories?: string[]; // 组件在组件面板中的分类
  groups?: string[]; // 组件在组件面板中的 tab 分组
  baseLibrary?: 'react'|'rax';
  setterMap?: SetterMap; // 注入 setter
}

export interface SetterMap {
  [SetterName: string]: string;
}

```
## 开发调试
### 组件开发

`demo/component` 目录下是测试组件的项目，改项目引用了 build-plugin-lowcode ，相关配置在 `demo/component/build.lowcode.js` 中；

可以修改 build-plugin-lowcode 的代码、修改 demo/component/build.lowcode.js 的配置进行调试；

```
在 build-plugin-lowcode 根目录下执行启动调试环境
npm run component:dev
```
npm package: @pisell/docs
Description: pisell docs
Latest version: 0.0.1

# Pisell Design 文档系统

基于 dumi 构建的 Pisell Design 组件库文档系统，提供完整的组件文档、API 参考和使用指南。

## 功能特性

- 📚 **完整的文档** - 涵盖所有组件的使用指南和 API 文档
- 🎨 **实时预览** - 组件演示代码可在线编辑和预览
- 📱 **响应式** - 支持移动端访问，随时随地查看文档
- 🔍 **搜索功能** - 快速搜索组件和 API
- 🌙 **主题切换** - 支持明暗主题切换
- 🌐 **多语言** - 支持国际化配置

## 快速开始

### 安装依赖

```bash
# 安装依赖
pnpm install

# 启动开发服务器
pnpm run dev:docs

# 构建文档
pnpm run build:docs
```

### 访问文档

开发服务器启动后，访问 http://localhost:8000 即可查看文档。

## 目录结构

```
application/docs/
├── docs/                   # 文档内容
│   ├── guide/             # 指南文档
│   ├── components/        # 组件文档
│   └── api/              # API 文档
├── src/                   # 文档组件源码
├── .dumirc.ts            # dumi 配置文件
├── package.json          # 项目依赖
└── README.md            # 说明文档
```

## 文档编写指南

### 文档结构

每个文档文件都应该包含以下 frontmatter：

```md
---
nav:
  title: 组件
  order: 2
group:
  title: 通用
  order: 1
title: Button 按钮
order: 1
---
```

### 组件演示

使用代码块来展示组件使用示例：
npm package: @pisell/icon
Description: pisell icon
Latest version: 0.0.11

# @pisell/icon

pisell svg 图标组件库

## 使用方法

要使用 @pisell/icon 组件库，按照以下步骤操作：

1. 在你的项目中，从 `@pisell/icon` 中导入所需的图标组件并使用，例如：

```react
    import { GoogleChrome } from '@pisell/icon';
    const MyComponent = () => {
        return (<GoogleChrome />);
};
```

## 添加图标

为了添加新的图标到组件库中，请按照以下步骤进行操作：

1. 将 SVG 文件放置于 `originalSvg` 文件夹下。
2. 运行 `npm run generate` 脚本来生成 `src` 目录文件下的新文件。

## 发布

要发布组件库，按照以下步骤进行操作：

1. 生成完整 `src` 目录后 执行 `npm run build` 打包 ES和lib版本。
2. 执行 `npm run publish` 命令进行发布。
npm package: @pisell/pisellos
Description: 一个可扩展的前端模块化SDK框架，支持插件系统
Author: Your Name
Latest version: 2.2.118

# PisellOS 前端 SDK 框架

PisellOS 是一个灵活的、可扩展的前端 SDK 框架，专为构建模块化应用设计。它支持插件系统，允许在不同运行环境中无缝集成功能。

## 特性

- **模块化架构**：支持各种功能模块（如购物车、结账流程等）的插入和管理
- **插件系统**：通过插件提供环境抽象，解决跨环境兼容性问题
- **事件驱动**：基于事件总线的模块间通信机制
- **类型安全**：使用 TypeScript 构建，提供完整的类型定义
- **轻量级**：核心框架轻量，按需加载模块

## 安装

```bash
npm install pisell-os
```

## 快速开始

### 基本用法

```typescript
import PisellOSCore, { plugins, modules } from "pisell-os";

// 创建 PisellOS 实例
const pisellOS = new PisellOSCore({
	debug: true, // 开启调试日志
	plugins: [{ plugin: plugins.window }, { plugin: plugins.request }],
	modules: [
		{
			module: modules.cart,
			options: {
				plugins: ["window", "request"], // 依赖的插件
			},
		},
	],
});

// 获取购物车模块并使用
const cartModule = pisellOS.getModuleExports("cart");
await cartModule.addItem({
	id: "product-001",
	name: "商品1",
	price: 99.9,
	quantity: 1,
});

// 使用插件
const windowPlugin = pisellOS.getPlugin("window");
windowPlugin.localStorage.setItem("key", "value");
```

## 架构

PisellOS 的核心架构包括四个主要部分：

1. **核心框架**：负责模块和插件的注册、管理和生命周期控制
2. **插件系统**：为不同环境提供统一接口，如 window、request 等
3. **模块系统**：提供业务功能实现，可依赖插件和其他模块
4. **解决方案**：解决方案是 pisell_os 中对业务流程层的抽象，用于将多个独立的模块（Module）编排成一个完整的业务解决方案。
它本质上是一个特殊的“业务 orchestrator”，负责协调模块调用、控制数据流动和处理统一状态管理。

### 核心 API

```typescript
// 创建实例
const pisellOS = new PisellOSCore(options);

// 注册插件
pisellOS.registerPlugin(plugin, options);

// 注册模块
pisellOS.registerModule(module, options);

// 获取插件
const plugin = pisellOS.getPlugin<PluginType>(name);

// 获取模块
const module = pisellOS.getModule<ModuleType>(name);

// 获取模块导出的 API
const api = pisellOS.getModuleExports<ApiType>(name);

// 事件机制
pisellOS.on(event, handler);
pisellOS.emit(event, data);
```

## 内置插件

PisellOS 提供了几个内置插件以简化开发：

- **window**：提供 window 对象模拟，包括 localStorage、setTimeout 等
- **request**：提供网络请求功能，支持各种 HTTP 方法和拦截器

## 内置模块

- **cart**：购物车模块，提供商品管理、数量更新等功能

## 自定义扩展

### 创建自定义插件

```typescript
import { Plugin } from "pisell-os";

class MyPlugin implements Plugin {
	name = "my-plugin";
	version = "1.0.0";

	initialize() {
		console.log("My plugin initialized");
	}

	destroy() {
		console.log("My plugin destroyed");
	}

	// 自定义方法
	myMethod() {
		return "Hello from my plugin";
	}
}

export default new MyPlugin();
```

### 创建自定义模块

```typescript
import { Module, PisellCore } from "pisell-os";

class MyModule implements Module {
	name = "my-module";
	version = "1.0.0";

	private core: PisellCore;

	// 导出 API
	exports = {
		doSomething: () => this.doSomething(),
	};

	initialize(core: PisellCore) {
		this.core = core;
		console.log("My module initialized");
	}

	destroy() {
		console.log("My module destroyed");
	}

	private doSomething() {
		return "Hello from my module";
	}
}

export default new MyModule();
```

## 开发

```bash
# 安装依赖
npm install

# 构建项目
npm run build

# 运行示例
npm run example

# 开发模式
npm run dev
```

## 许可

MIT License