open-index/open-npm huggingface dataset:
npm package: @prismadev/webmarine2d
Description: Core utils for 2D verson of game engine Webmarine
Author: 7y1o
Latest version: 0.0.1-et

# Webmarine 2D 
[![Webmarine 2D](https://img.shields.io/endpoint?url=https://dashboard.cypress.io/badge/simple/6p5fwb/master&style=flat&logo=cypress)](https://dashboard.cypress.io/projects/6p5fwb/runs)
[![Code Quality](https://www.code-inspector.com/project/25962/score/svg)](https://frontend.code-inspector.com/project/25962/dashboard)
[![Code Grade](https://www.code-inspector.com/project/25962/status/svg)](https://frontend.code-inspector.com/project/25962/dashboard)
[![Webmarine 2D](https://img.shields.io/endpoint?url=https://dashboard.cypress.io/badge/count/6p5fwb/master&style=flat&logo=cypress)](https://dashboard.cypress.io/projects/6p5fwb/runs)

### What is Webmarine 2D
Webmarine 2D is a game engine created for developing games in the browser or using technologies like Electron or NW.js.

> #### Attention!
> At the moment Webmarine 2D is under development and, 
> since it does not have release versions, it has an 
> unstable API. That is, the methods and names may 
> change in the future, so use at your own risk.

The game engine is currently under development...
npm package: @prismaext/pagination
Description: This [Prisma Generator](https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#generator) adds polyfills for async-iterable-cursor-based pagination with a simple `.paginate()` method on each prisma delegate. This is a usual opt-in poly
Latest version: 0.1.0

<h1 align="center">
Prisma Pagination
</h1>

## About

This [Prisma Generator](https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#generator) adds polyfills for async-iterable-cursor-based pagination with a simple `.paginate()` method on each prisma delegate. This is a usual opt-in polyfill, so no original/generated prisma files will be touched.

Usage is as easy as:

```ts
const prisma = new PrismaClient();

async function printAllPosts() {
  for await (const posts of prisma.post.paginate({ cursorField: 'id', pageSize: 50, include: { author: true } })) {
    posts.forEach((post) => {
      console.log(post.id, post.author.email);
    });
  }
}
```

## Installation

1. Install `@prismaext/pagination` with either `yarn` or `npm` (or some other package manager)

   e.g. `npm install @prismaext/pagination` or `yarn add @prismaext/pagination`

2. Add a generator block to your `schema.prisma` like:
   ```prisma
   generator pagination {
      provider = "pagination-generator"
   }
   ```
3. Run `prisma generate`
4. Add `import '@prismaext/pagination';` to the top of the file where your `PrismaClient` is being initialized.

After importing the definitions from `@prismaext/pagination`, all prisma delegates will have additional `paginate` methods. To align with the other apis, the method only allows a single argument of the type:

```ts
export type ${Model}PaginateArgs = {
   /**
    * Select specific fields to fetch from the ${Model}
    *
    **/
   select?: ${Model}Select | null
   /**
    * Choose, which related nodes to fetch as well.
    *
    **/
   include?: ${Model}Include | null
   /**
    * Filter, which ${Model}s to fetch.
    *
    **/
   where?: ${Model}WhereInput
   /**
    * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
    *
    * Determine the order of ${Model}s to fetch.
    *
    **/
   orderBy?: Enumerable<${Model}OrderByWithRelationInput>
   /**
   * Items to be fetched per ${Model}
   *
   */
   pageSize: number

   distinct?: Enumerable<${Model}ScalarFieldEnum>

   /**
    * The cursor field to be used to paginate through
    *
    * defaults to 'id' or the first unique field present in the model
    *
    */
   cursorField?: 'id' // or some other unique field
}
```

Similar to `prisma-client-js`, this generator allows specifying the `output` path where the generated definitions will be placed in.
npm package: @prismai/prism-ladle
Description: Enhanced component development environment based on Ladle, with multi-project support
Author: Alex Liu
Latest version: 0.0.1

# Prism UI

Enhanced component development environment based on [Ladle](https://github.com/tajo/ladle), with multi-project support and custom features for enterprise workflows.

## Features

- ✅ **All original Ladle features** - Fast, Vite-powered, Storybook-compatible
- 🚀 **Multi-project support** - Manage multiple component libraries
- 🎨 **Custom theming** - Prism design system integration
- 📊 **Enhanced analytics** - Usage tracking and insights
- 🔧 **Enterprise features** - Team collaboration and deployment tools

## Installation

```bash
npm install @prismai/prism-ladle
# or
yarn add @prismai/prism-ladle
```

## Quick Start

```bash
# Start the development server
npx prism-ladle serve

# Build for production
npx prism-ladle build

# Preview production build
npx prism-ladle preview
```

## Programmatic API

```javascript
import serve from "@prismai/prism-ladle/serve";
import build from "@prismai/prism-ladle/build";
import preview from "@prismai/prism-ladle/preview";

// Start development server
await serve({
  port: 6006,
  stories: "src/**/*.stories.{js,jsx,ts,tsx}",
});

// Build stories
await build({
  outDir: "dist/stories",
});

// Preview built stories
await preview({
  port: 8080,
});
```

## Configuration

Create `.ladle/config.mjs` in your project:

```javascript
/** @type {import('@prismai/prism-ladle').UserConfig} */
export default {
  stories: "src/**/*.stories.{js,jsx,ts,tsx,mdx}",
  addons: {
    control: { enabled: true },
    action: { enabled: true },
    source: { enabled: true },
    a11y: { enabled: true },
  },
};
```

## Attribution

This package is based on the excellent work by [Vojtech Miksu](https://github.com/tajo) and the Ladle team. The core story parsing and rendering engine is from [Ladle v5.0.3](https://github.com/tajo/ladle).

## License

MIT License - Original Ladle is also MIT licensed.
npm package: @prismamedia/retry
Description: ## About
Latest version: 1.0.1

# TS Retry

## About

This module aims to ease the retry of a function, using an exponential time between tries.

## Getting started

## Usage

```javascript
import { retry } from '@prismamedia/retry';

try {
  const myResult = await retry(async () => {
    // Do my processing that may throw an Error

    return 2;
  });
} catch (err) {
  // Handle error after "n" tries
}
```
npm package: @prismamedia/ts-async-event-emitter
Description: **Typescript async event emitter**
Latest version: 3.0.2

**Typescript async event emitter**

[![npm version](https://badge.fury.io/js/%40prismamedia%2Fts-async-event-emitter.svg)](https://badge.fury.io/js/%40prismamedia%2Fts-async-event-emitter) [![github actions status](https://github.com/prismamedia/ts-async-event-emitter/workflows/CI/badge.svg)](https://github.com/prismamedia/ts-async-event-emitter/actions) [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)

Heavily inspired by https://github.com/sindresorhus/emittery#typescript, without the legacy part

# Usage

```js
import EventEmitter from '@prismamedia/ts-async-event-emitter';

// We use an "Enum" to name the events
enum EventKind {
  Pre = 'pre',
  Post = 'post',
}

// We "type" the data carried by the events like this :
const ee = new EventEmitter<{ [EventKind.Pre]: { at: number }; [EventKind.Post]: { took: number } }>();

// We can listen on events like this :
// "offFirstPre" is a convenient method to unregister the listener later, see below
const offFirstPre = ee.on(EventKind.Pre, ({ at }) => console.log({ first: at }));
ee.on(EventKind.Pre, ({ at }) => console.log({ second: at * 2 }));
ee.on(EventKind.Post, async ({ took }) => console.log({ took }));

// [...]

await ee.emit(EventKind.Pre, { at: 2000 });
// -> { any: 2000 }
// -> { first: 2000 }
// -> { second: 4000 }

await ee.emit(EventKind.Post, { took: 100 });
// -> { any: 100 }
// -> { took: 100 }

// Unregister the first listener
offFirstPre();

// Only the second listener remains
await ee.emit(EventKind.Pre, { at: 10000 });
// -> { any: 10000 }
// -> { second: 20000 }
```

## Other convenient methods are available :

### on "config"

```js
// Subscribe to a bunch of events
ee.on({
  // Several listeners for this event
  [EventKind.Pre]: [
    () => console.log({ at }),
    () => console.log({ at: at * 2 }),
  ],
  // Only one here
  [EventKind.Post]: () => console.log({ took }),
});
```

_Be aware that the on "config" method does not support "numeric" event kinds, as javascript transforms the "numeric" keys into "string"_

### once

```js
// Subscribe to an event for only one execution
ee.once(EventKind.Pre, ({ at }) => console.log({ at }));
```

### wait

```js
// Wait for an event to be triggered
const eventData = await ee.wait(EventKind.Pre);

// Wait for an event to be triggered with a 100ms timeout (if the "timeout" is reached before the event has been triggered an Error will be thrown)
const eventData = await ee.wait(EventKind.Pre, 100);
```
npm package: @prismamedia/ts-module-loader
Description: **Typescript module loader**
Latest version: 3.1.4

**Typescript module loader**

[![npm version](https://badge.fury.io/js/%40prismamedia%2Fts-module-loader.svg)](https://badge.fury.io/js/%40prismamedia%2Fts-module-loader) [![github actions status](https://github.com/prismamedia/ts-module-loader/workflows/CI/badge.svg)](https://github.com/prismamedia/ts-module-loader/actions) [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)

How to load every single modules from a directory?

```
src/
├── index.ts
└── modules/
    ├── Article.ts
    ├── Category.ts
    └── Image.ts
```

The basic idea is to import each module one-by-one. Then list the modules one-by-one to create the map. But what appends when a new module is added to the directory? It must be added twice in the code. That is error prone and a potential source of headache.

```js
// Don't do that

import Article from 'modules/Article';
import Category from 'modules/Category';
import Image from 'modules/Image';

const moduleMap = {
  Article: Article,
  Category: Category,
  Image: Image,
};
```

## Async

```js
import loadModuleMap from '@prismamedia/ts-module-loader';
# or import { loadModuleMap } from '@prismamedia/ts-module-loader';

# [...]

# The simplest call, the result will be a "Map<string, any>"
const moduleMap = await loadModuleMap(`${__dirname}/modules`);

# A call with params
const moduleMap = await loadModuleMap({
  directory: `${__dirname}/modules`,
  include: /^[_A-Za-z][_0-9A-Za-z]*$/,
  strict: true
});

# A call with a known module type/interface, the result will be a "Map<string, ModuleInterface>"
interface ModuleInterface {}
const moduleMap = await loadModuleMap<ModuleInterface>(`${__dirname}/modules`);
```

## Sync

```js
import { loadModuleMapSync } from '@prismamedia/ts-module-loader';

# [...]

const moduleMap = loadModuleMapSync(`${__dirname}/modules`);

const moduleMap = loadModuleMapSync({
  directory: `${__dirname}/modules`,
  include: /^[_A-Za-z][_0-9A-Za-z]*$/,
  strict: true
});
```
npm package: @prismane/core
Description: Prismane - Simple React UI library
Author: Martin Petrov
Latest version: 1.6.0

<p align="center">
  <img src="https://www.prismane.io/profile_picture.png" alt="Prismane" width="200">
</p>
<h1 align="center">  
  Prismane
  <br>
</h1>

<h4 align="center">A React UI library built with ease of use in mind.</h4>

<p align="center">
  <a href="#key-features">Key Features</a> •
  <a href="#how-to-use">How To Use</a> •
  <a href="#storybook">Storybook</a> •
  <a href="#credits">Credits</a> •
  <a href="#license">License</a>
</p>

## Key Features

- Custom styling system
- Dynamic theming out of the box
- Built in support for dark and light theme variants
- 111+ React components
- 26+ custom hooks
- 27+ custom form validators

## How To Use

[Read Documentation](https://prismane.io)

```bash
# With yarn
yarn add @prismane/core

# With npm
npm install @prismane/core
```

## Storybook

Our Storybook is uploaded to Chromatic and is automatically updated with every change.

[Storybook on Chromatic](https://master--64c0fd7432b79714c11e2b24.chromatic.com/)

## Credits

This package uses the following packages:

- [React](https://reactjs.org)
- [Phosphor Icons](https://phosphoricons.com/)
- [Stitches](https://stitches.dev/)

## License

MIT

---

> GitHub [@prismaneui](https://github.com/prismaneui) &nbsp;&middot;&nbsp;
> Twitter [@prismaneui](https://twitter.com/prismaneui) &nbsp;&middot;&nbsp;
> Reddit [r/prismane](https://www.reddit.com/r/prismane/)
npm package: @prismatic-io/graphql-utils
Description: Shared GraphQL utilities for Prismatic webapp and CLI tool
Latest version: 0.1.1

# @prismatic-io/graphql-utils

`@prismatic-io/graphql-utils` contains a set of common GraphQL utilities that are used by the main Prismatic webapp and [CLI tool](https://prismatic.io/docs/cli/cli-usage).

## What is Prismatic?

Prismatic is an integration platform built specifically for B2B software companies. It's an easier way to build, deploy, and support integrations for your customers.

Prismatic reduces integration effort and empowers everyone involved in the integration process with the tools they need for their roles, so you can spend less time on integrations and more time on core product innovation.

With Prismatic, you can:

- Build reusable [integrations](https://www.prismatic.io/docs/integrations) in an intuitive integration designer
- Deploy customer-specific integration [instances](https://www.prismatic.io/docs/instances) with unique [configurations](https://www.prismatic.io/docs/configuration-variables) and [credentials](https://www.prismatic.io/docs/credentials)
- Run your integrations in a purpose-built environment
- Provide better support with built-in [logging](https://www.prismatic.io/docs/logging) and [alerting](https://www.prismatic.io/docs/monitoring-and-alerting)
- Embed a white-labeled customer integration portal
- Mold the platform to your product, industry, and the way you build software

## Who uses Prismatic?

Prismatic is for B2B (business-to-business) software companies, meaning software companies that provide applications used by businesses. It's a good fit for products/teams at any stage, including early stage SaaS, established SaaS, and legacy or on-prem systems.

Many B2B software teams serve customers in niche vertical markets, and we designed Prismatic with that in mind. We provide powerful and flexible tools so you can build exactly the integrations your customers need, no matter who your customers are, no matter what systems you need to connect to, no matter how "non-standard" your integration scenario.

## What kind of integrations can you build using Prismatic?

Prismatic supports integrations ranging from simple and standard to complex, bespoke, and vertical-specific.
Teams use it to build integrations between applications of all kinds, SaaS or legacy, with or without a modern API, regardless of protocol or data format.
Here are some example use cases:

- Use job data from your system to create invoices in your customers' ERP.
- Import and process data from third-party forms that vary significantly from customer to customer.
- Email activity summary reports with parameters and intervals defined on a per-customer basis.

For information on the Prismatic platform, check out our [website](https://www.prismatic.io) and [docs](https://www.prismatic.io/docs).

## License

This package is MIT licensed.