open-index/open-npm huggingface dataset:
npm package: @pizca/esbuild-inline-or-path
Description: An esbuild plugin to toggle exporting static assets either as data URLs (inline) or as customized relative paths, enabling flexible asset handling for development and production environments.
Author: pizca
Latest version: 1.0.3

# @pizca/esbuild-inline-or-path

An esbuild plugin that exports static assets either as inline data URLs or as relative paths based on custom mappings.

## Installation

```bash
npm i -D @pizca/esbuild-inline-or-path
```

## Usage

Import the plugin and add it to your esbuild build configuration:

```js
import esbuild from 'esbuild';
import inlineOrPathPlugin from '@pizca/esbuild-inline-or-path';

esbuild.build({
  entryPoints: ['src/index.ts'],
  bundle: true,
  outdir: 'dist',
  plugins: [
    inlineOrPathPlugin({
      inline: false, // true to inline as data URL, false to export relative paths
      filter: /\.(png|webp)$/, // files to process
      paths: { 'public/images': '/images' } // required if inline is false
    }),
  ],
}).catch(() => process.exit(1));
```

Example in a TypeScript file:

```ts
import myImage from '../public/images/my_image.webp';

const image = new Image();
image.src = myImage;
```

To avoid TypeScript type errors, create a `res.d.ts` or another file with a `.d.ts` extension file with the following declarations in your rootdir `src`:

```ts
declare module '*.webp' {
  const content: string;
  export default content;
}

declare module '*.png' {
  const content: string;
  export default content;
}
```

## What it does

* When `inline` is `true`, this plugin reads the matched files and exports them as data URLs, embedding the content directly in your bundle.
* When `inline` is `false`, it exports the file paths relative to custom base paths defined in the `paths` option, allowing you to control how asset URLs are generated.
* Throws an error if a file is outside of the configured paths when `inline` is `false`.

This lets you easily switch between embedding assets inline or referencing them by relative paths, depending on your build needs.
npm package: @pizca/esbuild-reset
Description: esbuild plugin to clean the output directory before build.
Author: pizca
Latest version: 1.1.3

# @pizca/esbuild-reset

An esbuild plugin that clears the output directory (`outdir`) before each build.

## Installation

```bash
npm i -D @pizca/esbuild-reset
```

## Usage

Import the plugin and add it to your esbuild build configuration:

```js
import esbuild from 'esbuild';
import resetPlugin from '@pizca/esbuild-reset';

esbuild.build({
    entryPoints: [
        'src/index.ts'
    ],
    bundle: true,
    outdir: 'dist',
    plugins: [
        resetPlugin(),
        // other plugins...
    ],
}).catch(() => process.exit(1));
```

## What it does

Before the build starts, this plugin clears the contents of the `outdir` folder to ensure a clean output directory without leftover files.
npm package: @pizca/esbuild-sass
Description: Esbuild plugin to compile Sass/SCSS files using sass-embedded.
Author: pizca
Latest version: 1.0.9

# @pizca/esbuild-sass

An esbuild plugin that compiles Sass/SCSS files using [`sass-embedded`](https://www.npmjs.com/package/sass-embedded).

## Installation

```bash
npm i -D @pizca/esbuild-sass
```

## Usage

Import the plugin and add it to your esbuild build configuration:

```js
import esbuild from 'esbuild';
import sassPlugin from '@pizca/esbuild-sass';

esbuild.build({
    entryPoints: ['src/index.ts'],
    bundle: true,
    outdir: 'dist',
    plugins: [
        sassPlugin() // <- sass plugin
    ],
}).catch(() => process.exit(1));
```

## What it does

This plugin enables native support for `.scss` files in your esbuild pipeline. It uses [`sass-embedded`](https://www.npmjs.com/package/sass-embedded) to compile stylesheets and injects the resulting CSS into your build.
npm package: @pizca/esbuild-server
Description: Esbuild plugin providing an HTTP server to enable watch mode with automatic reload on rebuild.
Author: pizca
Latest version: 1.1.10

# @pizca/esbuild-server

An esbuild plugin that creates an HTTP server to enable watch mode with automatic reload on rebuild.

## Installation

```bash
npm i -D @pizca/esbuild-server
```

## Usage

Import the plugin and add it to your esbuild build configuration:

```js
import esbuild from 'esbuild';
import serverPlugin from '@pizca/esbuild-server';

const isWatching = process.argv.includes('--watch');

esbuild.context({
    entryPoints: ['src/index.ts'],
    bundle: true,
    outdir: 'public/dist',
    plugins: [
        // Other plugins...
        serverPlugin({
            enabled: isWatching, // Enables plugin
            port: 3000, // Optional; defaults to 3000
            root: 'public', // Optional; defaults to 'public'
            mime: { // Custom MIME types; HTML, CSS, and JS are handled by default. 'application/octet-stream' is used as fallback.
                '.webp': 'image/webp',
            },
            onRequest(req, res) {
                if (req.url.split('?')[0] === '/') {
                    res.writeHead(200, { 'content-type': 'text/plain' });
                    res.end('Hello, World!');
                }
            },
        })
    ]
}).then(async (ctx) => {
    return isWatching
        ? ctx.watch().then(() => console.log('👀 Watching...\n'))
        : ctx.rebuild().finally(() => ctx.dispose());
});
```

You can optionally insert the reload banner into a single output file, even when using multiple JavaScript entry points. Simply provide a file path or a custom handler via the `setReloadBanner` option.

## What it does

This plugin launches a lightweight HTTP server serving files from your specified root directory and injects a client-side script that listens for rebuild events via Server-Sent Events (SSE). When a rebuild completes successfully, the browser reloads automatically.

It supports:

* Serving static files (HTML, JS, CSS, and custom MIME types)
* Live reload on rebuild success
* SSE connection management for multiple clients
npm package: @pizca/esbuild-webgl
Description: An esbuild plugin to import WebGL shader files as strings, with optional comment stripping for cleaner bundles.
Author: pizca
Latest version: 1.1.2

# @pizca/esbuild-webgl

An esbuild plugin that imports shader files (`.vert`, `.frag`, `.glsl`) as strings, ready to use with WebGL.

## Installation

```bash
npm i -D @pizca/esbuild-webgl
```

## Usage

Import the plugin and add it to your esbuild build configuration:

```js
import esbuild from 'esbuild';
import webglPlugin from '@pizca/esbuild-webgl';

esbuild.build({
  entryPoints: ['src/index.ts'],
  bundle: true,
  outdir: 'dist',
  plugins: [
    webglPlugin({
      stripComments: true // Removes comments
    })
  ],
}).catch(() => process.exit(1));
```

Here's an example of importing and using shaders in a TypeScript file:

```ts
import vertexShader from './shaders/basic.vert';
import fragmentShader from './shaders/basic.frag';

const program = createProgram(gl, vertexShader, fragmentShader);
```

To avoid TypeScript type errors, create a `*.d.ts` file in your project. You can name it `env.d.ts` or something similar, and include the following line to ensure TypeScript can find the plugin's type declarations:

```ts
/// <reference types="@pizca/esbuild-webgl/types" />
```

## What it does

* Read `.vert`, `.frag`, and `.glsl` files as plain text and export them as strings at build time.
* Allow importing shaders directly in your code without manual loading or fetching.
* Simplify development with WebGL by keeping shaders separate and clean.

This plugin lets you integrate shaders easily and directly into your esbuild workflow.
npm package: @pizswap/sdk-core
Description: ⚒️ An SDK for building applications on top of Uniswap V3
Latest version: 1.0.1

# Uniswap SDK Core

[![Unit Tests](https://github.com/Uniswap/uniswap-sdk-core/workflows/Unit%20Tests/badge.svg)](https://github.com/Uniswap/uniswap-sdk-core/actions?query=workflow%3A%22Unit+Tests%22)
[![Lint](https://github.com/Uniswap/uniswap-sdk-core/workflows/Lint/badge.svg)](https://github.com/Uniswap/uniswap-sdk-core/actions?query=workflow%3ALint)
[![npm version](https://img.shields.io/npm/v/@uniswap/sdk-core/latest.svg)](https://www.npmjs.com/package/@uniswap/sdk-core/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/sdk-core/latest.svg)](https://bundlephobia.com/result?p=@uniswap/sdk-core@latest)

This code is shared across Uniswap TypeScript SDKs.
npm package: @pizswap/v2-sdk
Description: 🛠 An SDK for building applications on top of Uniswap V2
Latest version: 1.0.3

# Uniswap V2 SDK

[![Unit Tests](https://github.com/Uniswap/uniswap-v2-sdk/workflows/Unit%20Tests/badge.svg)](https://github.com/Uniswap/uniswap-v2-sdk/actions?query=workflow%3A%22Unit+Tests%22)
[![Lint](https://github.com/Uniswap/uniswap-v2-sdk/workflows/Lint/badge.svg)](https://github.com/Uniswap/uniswap-v2-sdk/actions?query=workflow%3ALint)
[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
[![npm version](https://img.shields.io/npm/v/@uniswap/v2-sdk/latest.svg)](https://www.npmjs.com/package/@uniswap/v2-sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/v2-sdk/latest.svg)](https://bundlephobia.com/result?p=@uniswap/v2-sdk@latest)

In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).
npm package: @pizzafactory/vscode-ws-jsonrpc
Description: VSCode JSON RPC over WebSocket
Author: TypeFox GmbH
Latest version: 0.2.0

# VSCode WebSocket JSON RPC
NPM module to implement communication between a jsonrpc client and server over WebSocket.

### Client side connection handling
```ts
import * as rpc from 'vscode-ws-jsonrpc';

const webSocket = new WebSocket('ws://www.example.com/socketserver');
rpc.listen({
    webSocket,
    onConnection: (connection: rpc.MessageConnection) => {
        const notification = new rpc.NotificationType<string, void>('testNotification');
        connection.listen();
        connection.sendNotification(notification, 'Hello World');
    }
});
```

### Server side connection handling
```ts
import * as rpc from 'vscode-ws-jsonrpc';

const socket: rpc.IWebSocket; // open the web socket
const reader = new rpc.WebSocketMessageReader(socket);
const writer = new rpc.WebSocketMessageWriter(socket);
const logger = new rpc.ConsoleLogger();
const connection = rpc.createMessageConnection(reader, writer, logger);
const notification = new rpc.NotificationType<string, void>('testNotification');
connection.onNotification(notification, (param: string) => {
	console.log(param); // This prints Hello World
});

connection.listen();
```

### Server side connection forwarding
```ts
import * as rpc from 'vscode-ws-jsonrpc';
import * as server from 'vscode-ws-jsonrpc/lib/server';

const socket: rpc.IWebSocket; // open the web socket
const reader = new rpc.WebSocketMessageReader(socket);
const writer = new rpc.WebSocketMessageWriter(socket);
const socketConnection = server.createConnection(reader, writer, () => socket.dispose())
const serverConnection = server.createServerProcess('Example', 'node', ['example.js']);
server.forward(socketConnection, serverConnection, message => {
    if (rpc.isNotificationMessage(message)) {
        if (message.method === 'testNotification') {
            // handle the test notification
        }
    }
    return message;
});
```

## License
[MIT](https://github.com/TypeFox/vscode-ws-jsonrpc/blob/master/License.txt)
npm package: @pizzajsdev/cache
Description: A framework-agnostic cache library that works with IndexedDB, Redis, in-memory, and more
Author: Javier Aguilar
Latest version: 0.1.1

# cache

A framework-agnostic key-value cache library that works with IndexedDB, Redis, in-memory, and more

## Features

Supports these cache types:

- In-memory (via `lru-cache`)
- IndexedDB (via `window.indexedDB` - client-side only)
- Redis (via `@upstash/redis` + `superjson` - server-side only)
- Null (no-op)

## Installation

```bash
pnpm add @pizzajsdev/cache
```

## Usage

```ts
import { InMemoryKvCacheService } from '@pizzajsdev/cache/memory'
const cache = new InMemoryKvCacheService()
cache.set('key', 'value', 60)
const value = await cache.get('key')
console.log(value)
```
npm package: @pizzajsdev/route-collector
Description: A framework-agnostic file-based route collector inspired by Next.js's App Router
Author: Javier Aguilar
Latest version: 0.9.0

# route-collector

A framework-agnostic file-based route collector inspired by Next.js's App Router

## Features

Supports all route types of [the official docs](https://reactrouter.com/start/framework/routing):

- Root and index routes: Either `index.tsx` or `page.tsx`, but a segment folder is not required, e.g. `posts.tsx` is the
  same as `posts/index.tsx`
- Dynamic Segments: `posts/[id].tsx` or `posts/[id]/index.tsx`
- Optional Segments: `[[lang]]/news.tsx`
- Splat/Wildcard routes: `api/auth/[...].tsx`
- Layout routes: `layout.tsx` at any level, inheritable.
- Extras inspired by Next:
  - Route grouping (via parentheses): `(auth)/news.tsx` will be `/news`. Has no effect more than code organisation
    purposes or for sharing the same layout without requiring a nested level.

Supports both `.ts` and `.tsx` files, depends if you use JSX inside or not.

Also supports `.mdx` and `.md` files for markdown pages, with an optional `mdxRendererFile` option to specify the route
file to use as the renderer.

## Installation

```bash
pnpm add @pizzajsdev/route-collector
```

## Usage

### Generic usage

You can use the `collectRoutes` function to collect the routes from the file system, and build your own route
configuration with any framework that supports programmatically-generated routes.

```ts
import { collectRoutes } from '@pizzajsdev/route-collector/fs'

const routeDefinitions = collectRoutes({
  projectRoot: process.cwd() + '/src',
  routesDir: 'api',
  fileExtensions: ['.ts'],
  ignoredPaths: [],
  ignoredPathPrefix: '_',
})

for (const route of routeDefinitions) {
  // define routes e.g. with Hono, Elysia, etc.
}
```

### Using with React Router

Edit the `app/routes.ts` file to use the generated routes.

```ts
// app/routes.ts
import { collectRoutes } from '@pizzajsdev/route-collector/react-router'

const routes = collectRoutes({
  projectRoot: process.cwd() + '/app',
  routesDir: 'routes',
  fileExtensions: ['.tsx', '.ts', '.mdx', '.md'],
  ignoredPaths: [],
  ignoredPathPrefix: '_',
})

export default routes
```
npm package: @pizzamcp/server
Description: Simple Domino's Pizza MCP Server
Author: Graham McBain
Latest version: 1.5.0

# MCPizza - Domino's Pizza MCP Server

Simple MCP server for ordering Domino's pizza through AI assistants.

## Installation

```bash
npm install -g @pizzamcp/server
```

## Usage with Claude Desktop

Add to your MCP configuration:

```json
{
  "mcpServers": {
    "pizzamcp": {
      "command": "npx",
      "args": ["@pizzamcp/server@latest"]
    }
  }
}
```

## Available Tools

- **find_dominos_store** - Find nearest Domino's by address/zip
- **search_menu** - Search menu items  
- **add_to_order** - Add items to order
- **view_order** - View current order

## License

MIT
npm package: @pizzanfruit/react-scripts
Description: Configuration and scripts for Create React App.
Latest version: 3.4.0-fix3

# react-scripts

This package includes scripts and configuration used by [Create React App](https://github.com/facebook/create-react-app).<br>
Please refer to its documentation:

- [Getting Started](https://facebook.github.io/create-react-app/docs/getting-started) – How to create a new app.
- [User Guide](https://facebook.github.io/create-react-app/) – How to develop apps bootstrapped with Create React App.
npm package: @pizzapopcorn/unijs
Description: A seamless interop layer to control Unity WebGL builds from the browser's JavaScript context.
Author: Andres Urrutia
Latest version: 0.0.8

# UniJS - WebGL Interop (Library)

## Prerequisites
- Your Unity WebGL build must have the [Unity plugin package](https://github.com/PizzaPopcorn/unijs) installed and implemented (instructions provided in the README of that repo).
- If you want to customize the library you need to have [Node.js](https://nodejs.org) installed.

## Installation
IMPORTANT: You don't have to clone/fork this repository if you just want to use the library without modifying it. Use CDN in that case.

For getting the latest version in your project just paste this line in the html page that will load the Unity instance:
```javascript
<script src="https://cdn.jsdelivr.net/npm/@pizzapopcorn/unijs/dist/unity.min.js"></script>
```
Now if you want to customize the library you can clone/fork this repository and follow the build steps.

## Build
Building is pretty straightforward, just do the modifications you need and then run the following command:
```bash
npm run build
```
That will create `unity.js` and `unity.min.js` files that you can manually import to your web page project.

## Additional Notes
Notice that this library is designed to be only compatible with browser since that's where Unity runs. That being said, there is no need to import the npm package in any scenario, it just exists for the sake of the CDN download.
npm package: @pizzeria-ui/placeholder
Description: Placeholder package - Pizzeria UI component library coming soon
Author: Pizzeria UI Team
Latest version: 0.0.1

# @pizzeria-ui

This namespace is reserved for the **Pizzeria UI** component library.

## Coming Soon

Main packages:
- `@pizzeria-ui/core` - Shared types, utilities and constants
- `@pizzeria-ui/svelte` - Svelte 5 components
- `@pizzeria-ui/react` - React components
- `@pizzeria-ui/vue` - Vue components
- `@pizzeria-ui/cli` - CLI tools

## Links

- GitHub: https://github.com/pizzeria-ui/pizzeria
- Issues: https://github.com/pizzeria-ui/pizzeria/issues

## License

MIT
npm package: @pjaromin/fast-xml2js
Description: Fork of cmrigney/fast-xml2js. In-place replacement for xml2js parseString. This is about 20x-30x faster and makes use of the rapidxml C++ library.
Author: Cody Rigney
Latest version: 1.4.1

# fast-xml2js

***This is fork of: https://github.com/cmrigney/fast-xml2js***

In-place replacement for xml2js parseString. This is about 20x-30x faster and makes use of the rapidxml C++ library.

### Install

Run ```npm install @pjaromin/fast-xml2js```

### Using

#### parseString

```js
const { parseString } = require('@pjaromin/fast-xml2js');
parseString('<some_xml>', function(err, result) {
    console.log(result);
});
```

#### parseXmlString

```js
const { parseXmlString } = require('@pjaromin/fast-xml2js');
parseXmlString('<some_xml>').then(result => console.log(obj));
```

Errors returned by this function are `Error` instances.

### Changelog

Change log can be found [here](CHANGELOG.md)
Errors returned by this function are `string` instances.
npm package: @pjblog/blog
Description: PJBlog 2004-present 博客主程序工程
Latest version: 2.3.46

# PJBlog

2004-present blog which base `injection` logic.

## Install

```bash
$ npm i @pjblog/blog
$ pnpm i @pjblog/blog
```

## Usage

```ts
import createBlog, { BlogProps, Newable, Plugin } from '@pjblog/blog';
createBlog(options: BlogProps, plugins?: Newable<Plugin<any>>[]): void;
```
npm package: @pjblog/cli
Description: PJBlog博客命令行工具工程
Latest version: 2.3.8

# PJBlog

2004-present blog which base `injection` logic.

## Install

```bash
$ npm i @pjblog/blog
$ pnpm i @pjblog/blog
```

## Usage

```ts
import createBlog, { BlogProps, Newable, Plugin } from '@pjblog/blog';
createBlog(options: BlogProps, plugins?: Newable<Plugin<any>>[]): void;
```