open-index/open-npm huggingface dataset:
npm package: @jean-michelet/workflow
Description: Manage the life cycle of an entity.
Author: Michelet Jean
Latest version: 1.0.9

# Workflow

> **Note:** This package is still experimental and may change significantly until the next minor version.

Workflows represent the various **states** and **transitions** that an entity can go through in a system. For example, let's say you're developing a task management application. You'll need to establish some rules:

- When a user creates a task, does it start as `new`?
- Can a task move directly from `in progress` to `completed`, or does it need to be `reviewed` first?
- You might allow deleting `new` tasks, but should `completed` tasks only be `archived`?

These kinds of questions can be tricky, and it's crucial to represent this logic clearly in your code.

## Install

```bash
npm i @jean-michelet/workflow
```

## Workflow

The `Workflow` class lets you define state transitions and apply them to the state property of an entity. You can define transitions from a single state or from multiple states.

In this example, a task can move through several stages in its lifecycle: from `new` to `in progress`, then either to `completed` or `canceled`, and finally be archived from either the `canceled` or `completed` states:

```ts
// Example in typecript, but also works with vanilla JS
import {
  Transition,
  MultiOriginTransition,
  Workflow,
} from "@jean-michelet/workflow";

class Task {
  status = "new";
}

const workflow = new Workflow<Task>({
  stateProperty: "status",
});

workflow.addTransition("start", new Transition("new", "in progress"));
workflow.addTransition("complete", new Transition("in progress", "completed"));
workflow.addTransition("cancel", new Transition("in progress", "canceled"));
workflow.addTransition(
  "archive",
  new MultiOriginTransition(["canceled", "completed"], "archived")
);

const task = new Task();

if (workflow.can("start", task)) {
  workflow.apply("start", task);
}
console.log(task.status); // Output: "in progress"

if (workflow.can("cancel", task)) {
  workflow.apply("cancel", task);
}
console.log(task.status); // Output: "canceled"

if (workflow.can("archive", task)) {
  workflow.apply("archive", task);
}
console.log(task.status); // Output: "archived"
```

### Handling Unexpected States

The `Workflow` class supports a `detectUnexpectedState` option. When enabled, this option throws an error if an entity is in an unexpected state that hasn't been accounted for in the defined transitions:

```ts
// Example in typecript, but also works with vanilla JS
import { Workflow, Transition } from "@jean-michelet/workflow";

class Task {
  status = "unknown";
}

const workflow = new Workflow<Task>({
  stateProperty: "status",
  detectUnexpectedState: true,
});

workflow.addTransition("start", new Transition("new", "in progress"));

const task = new Task();

workflow.can("start", task); // Error: "The instance has an unexpected state 'unknown'"
```
npm package: @jean1011/kakarot
Description: 🛠 An SDK for building applications on top of Pangolin.
Author: 0xkilo
Latest version: 2.0.1

# Pangolin SDK
This repo contains tools for developing with [Pangolin](pangolin.exchange).

## Running
This project uses standard npm and yarn workflows.

Install dependencies

```sh
yarn
```

Compile
```sh
yarn build
```

Yarn is available to install [here](https://classic.yarnpkg.com/en/docs/install/#debian-stable) if you need it.

## Installation
This project is available as an npm package. Add to your project with `npm install @pangolindex/sdk`

## Attribution
This code was adapted from this Uniswap repo: [uniswap-sdk](https://github.com/Uniswap/sdk).
npm package: @jean_b/rc-dialog
Description: Dialog React is a React library created for the OpenClassrooms P14 project. It provides a simple and customizable dialog component.
Author: Jean Baradat
Latest version: 1.1.3

<p align="center">
  <img alt="Dialog React" src="https://github.com/user-attachments/assets/91f50838-cce3-4cb4-bfe0-44f84974f9b2">
</p>

<div align="center">

![License MIT](https://img.shields.io/badge/license-MIT-red.svg)
![React 18](https://img.shields.io/badge/React-18.0.0-orange)
![Node 20](https://img.shields.io/badge/node-20.11.0-yellow)
![Vite 5](https://img.shields.io/badge/vite-5.4.1-green)

[Live demo and full doc](https://jean-baradat.github.io/oc-p14--jean_rc-dialog-10-2024/)

</div>

# Dialog React

Dialog React is a React library created for the OpenClassrooms P14 project. It provides a simple and customizable dialog component.

## Installation

Install the package with `npm`:

```bash
npm i @jean_b/rc-dialog
```

## Usage

Import the necessary components:

```JSX
import { Dialog, DialogTrigger, DialogContent } from "@jean_b/rc-dialog"
```

Manage the open/close state of the dialog:

```JSX
const [isOpen, setIsOpen] = useState(false)
```

Use the `Dialog`, `DialogTrigger` and `DialogContent` components to create your dialog:

```JSX
<Dialog 
    isOpen={isOpen} 
    setIsOpen={setIsOpen}
>
    <DialogTrigger onClick>
        <button>
            Open simple dialog
        </button>
    </DialogTrigger>
    <DialogContent titleId="dialogTitle" descriptionId="dialogDescription">
        <h1 id="dialogTitle">
            Dialog title...
        </h1>
        <p id="dialogDescription">
            Dialog description...
        </p>
    </DialogContent>
</Dialog>
```

## Examples

You can find usage examples in the [interactive demo](https://jean-baradat.github.io/oc-p14--jean_rc-dialog-10-2024/)

## Contribution

If you want to contribute to this project, feel free to open an issue or submit a pull request on the [GitHub repository](https://github.com/Jean-Baradat/oc-p14--jean_rc-dialog-10-2024).

## License
[This project](https://github.com/Jean-Baradat/oc-p14--jean_rc-dialog-10-2024) is under the MIT license.
npm package: @jeanbasualdo/pure-vue-chart
Description: Simple and lightweight vue chart svg component without chart library dependencies
Author: Danny Jackson
Latest version: 0.3.6

<p align="center">
  <h1>Pure Vue Chart</h1>
</p>
<p align="center">
    A simple and lightweight vue component for making charts that do not rely on large chart libraries and will not bloat your dependencies
</p>
<hr/>

<h3>Example</h3>

```
<pure-vue-chart
  :points="[3,5,2,5,4]"
  :width="400"
  :height="200"
/>
```

<img src="src/assets/charts.gif" alt="charts" width="350"/>

<p>When props are updated the graph will automatically animate to the new values.</p>

## Install
```
npm i pure-vue-chart
```
Import it:
```
import PureVueChart from 'pure-vue-chart';
```
Register it in your component:
```
components: {
    PureVueChart,
},
```
## Use it
```
<pure-vue-chart
  :points="[3,5,2,5,4]"
  :width="400"
  :height="200"
/>
```
## Options
<p>To further control the display of data, you can use simple props to manipulate the charts. Here are some examples:</p>

![](src/assets/chart-examples.png)

#### Most of the available props below are self-explanatory:
```
:points=[1,4,5,3,4]
:show-y-axis="false"
:show-x-axis="true"
:width="400"
:height="200"
:show-values="true"
:use-month-labels="true"
:months="['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez']"
```

### Additional Features:
#### Trendline
You can add a simple linear trend line by using the following props:
```
:show-trend-line="true"
:trend-line-width="2"
trend-line-color="lightblue"
```
![](src/assets/trendline.png)

#### X-axis labels:
X-axis labels, by default will be from 1 - length-of-data.
But you can automatically use Months by using the prop `:use-month-labels="true"`.
Or you can provide the data as an array of objects, each with a `value`, `stringValue` and `label` like so:
```
:points=[{label: 'N', value: 41.1, stringValue '41.10N'}, {label: 'NW', value: 1, stringValue '1.00NW'}, {label: 'W', value: 15, stringValue '15.00W'}]
```

<h3>Contributing</h3>
I'm open to any issues or pull requests so long as
they are simple, easy to read, use the eslint settings in package.json, 
and follow commitizen-esque style commit formats. Just open an issue on github and start a discussion.
- pure-vue-chart issues - https://github.com/djaxho/pure-vue-chart/issues

<h3>Authors or Acknowledgments</h3>
<ul>
  <li>Danny Jackson</li>
</ul>

<h3> List of features </h3>
<ul>
  <li>Simple bar charts</li>
  <li>Line charts (planned)</li>
  <li>Pie charts (planned)</li>
  <li>Rose charts (planned)</li>
</ul>

<h3>License</h3>

This project is licensed under the MIT License but please create pull requests to improve this package together rather that copying itto another project.
npm package: @jeanbenitez/logical-expression-parser
Description: Logical expression parser and evaluates result, suitable for permissions management
Author: NimitzDEV
Latest version: 1.0.0

# Logical Expression Parser (Fork)
This is a logical expression parser for JavaScript, it can parse a logical expression into a AST object and evaluates the result using your token checking function.

## Supported logical operators
1. `OR`
1. `AND`
1. `()` Parentheses

## How it works
1. The parser parse and tokenize the expression, for example one of your function requires `REGISTED AND (SPECIAL OR INVITED)`
1. Parser then will pass `REGISTED`, `SPECIAL` and `INVITED` into your token checking function to get a boolean result
1. Finaly the parser will evaluates the final result

## Example
```javascript
const LEP = require('@jeanbenitez/lep');

const requirements = 'REGISTED AND (SPECIAL OR INVITED)';
const listA = ['REGISTED', 'INVITED'];
const listB = ['SPECIAL', 'EXPERT'];

const resultA = LEP.parse(requirements, t => listA.includes(t));
const resultB = LEP.parse(requirements, t => listB.includes(t));
console.log({ resultA, resultB });
// { resultA: true, resultB: false }

// Getting AST only
const ast = LEP.ast(requirements);
console.log({ ast });
/*
  {
    ast: ExpNode {
      op: 'AND',
      left: ExpNode {
        op: 'LITERAL',
        literal: 'REGISTED'
      },
      right: ExpNode {
        op: 'OR',
        left: [ExpNode],
        right: [ExpNode]
      }
    }
  }
*/
```
npm package: @jeanberwanger/bwgx
Description: BWGX — AI-Orchestrated Development Framework. Sets up Claude Code agents, cycles, and quality gates in any project.
Latest version: 1.0.2

# BWGX

> **B**uild · **W**ave · **G**ate · e**X**ecute — AI-Orchestrated Development for Claude Code.

Sets up BWGX agents, cycles, and quality gates in any project — new or existing — in seconds.

## Usage

```bash
npx @jeanberwanger/bwgx
```

Run inside any project directory. That's it.

## What it does

1. **Detects** your project — finds `PRD.md`, infers tech stack from `package.json`
2. **Asks** up to 2 questions if needed (describe the project or point to a PRD file)
3. **Installs** into `.claude/`:
   - `CLAUDE.md` — agent configuration for Claude Code
   - `rules/` — authority, handoff, workflow, and story lifecycle rules
   - `commands/BWGX/` — slash commands for all agents
4. **Preserves** any existing `CLAUDE.md` — appends BWGX config without overwriting

## After installation

Open the project in **Claude Code** and run:

```
/BWGX:start
```

This starts guided execution from your PRD through build cycles.

## Agents

| Command | Agent | Role |
|---------|-------|------|
| `@build` | Builder | Writes code, commits |
| `@check` | Checker | Tests, quality verdicts |
| `@think` | Thinker | Architecture, planning |
| `@own` | Owner | Stories, backlog |
| `@ship` | Shipper | `git push`, PRs, releases |
| `@data` | Data Engineer | Schema, migrations, RLS |

Each agent has exclusive authority over its domain. Use `*help` after activation to see available commands.

## The 6 Cycles

| Cycle | When to use |
|-------|------------|
| `feature.cycle` | Building a new feature |
| `fix.cycle` | Quick bug fix |
| `spec.cycle` | Complex feature that needs planning first |
| `review.cycle` | Iterative QA loop (auto, max 5×) |
| `discover.cycle` | Joining an existing codebase |
| `ship.cycle` | Deploying: push + PR + release |

## Requirements

- Node.js 18+
- [Claude Code](https://claude.ai/code)

## License

MIT
npm package: @jeand/postcss-rem-test
Description: PostCSS plugin to use rem units with optional pixel fallback.
Author: Pierre Burel
Latest version: 2.0.3-beta

# postcss-rem [![Node.js CI](https://github.com/pierreburel/postcss-rem/actions/workflows/node.js.yml/badge.svg)](https://github.com/pierreburel/postcss-rem/actions/workflows/node.js.yml)

[PostCSS] plugin to use rem units with optional pixel fallback. Based on [sass-rem](https://github.com/pierreburel/sass-rem).

See also: [startijenn-rem](https://github.com/pierreburel/startijenn-rem), vanilla JavaScript version.

[postcss]: https://github.com/postcss/postcss

## Example

### Input

```scss
.demo {
  font-size: rem(24px); /* Simple */
  padding: rem(5px 10px); /* Multiple values */
  margin: rem(10px 0.5rem); /* Existing rem */
  border-bottom: rem(1px solid black); /* Multiple mixed values */
  box-shadow: rem(
    0 0 2px #ccc,
    inset 0 0 5px #eee
  ); /* Comma-separated values */
  text-shadow: rem(1px 1px) #eee, rem(-1px) 0 #eee; /* Alternate use */
}
```

### Output

```css
.demo {
  font-size: 1.5rem; /* Simple */
  padding: 0.3125rem 0.625rem; /* Multiple values */
  margin: 0.625rem 0.5rem; /* Existing rem */
  border-bottom: 0.0625rem solid black; /* Multiple mixed values */
  box-shadow: 0 0 0.125rem #ccc, inset 0 0 0.3125rem #eee; /* Comma-separated values */
  text-shadow: 0.0625rem 0.0625rem #eee, -0.0625rem 0 #eee; /* Alternate use */
}
```

## Options

With `baseline` to `10` (`html { font-size: 62.5%; }`) and `fallback` to `true`:

```css
.demo {
  font-size: 24px;
  font-size: 2.4rem; /* Simple */
  padding: 5px 10px;
  padding: 0.5rem 1rem; /* Multiple values */
  margin: 10px 5px;
  margin: 1rem 0.5rem; /* Existing rem */
  border-bottom: 1px solid black;
  border-bottom: 0.1rem solid black; /* Multiple mixed values */
  box-shadow: 0 0 2px #ccc, inset 0 0 5px #eee;
  box-shadow: 0 0 0.2rem #ccc, inset 0 0 0.5rem #eee; /* Comma-separated values */
  text-shadow: 1px 1px #eee, -1px 0 #eee;
  text-shadow: 0.1rem 0.1rem #eee, -0.1rem 0 #eee; /* Alternate use */
}
```

With `convert` to `px` (for a lt-ie9 only stylesheet for example):

```css
.demo {
  font-size: 24px; /* Simple */
  padding: 5px 10px; /* Multiple values */
  margin: 10px 8px; /* Existing rem */
  border-bottom: 1px solid black; /* Multiple mixed values */
  box-shadow: 0 0 2px #ccc, inset 0 0 5px #eee; /* Comma-separated values */
  text-shadow: 1px 1px #eee, -1px 0 #eee; /* Alternate use */
}
```

## Usage

Install with `npm i postcss-rem` and use with [PostCSS]:

```js
postcss([require("postcss-rem")]);
```

Example with custom options:

```js
postcss([
  require("postcss-rem")({
    name: "to-rem", // Default to 'rem'
    baseline: 10, // Default to 16
    // convert: "px", // Default to 'rem'
    fallback: true, // Default to false
    precision: 6, // Default to 5
  }),
]);
```

See [PostCSS] docs for examples for your environment.
npm package: @jeandev_2030/js-ai-core
Description: Core HTTP/TLS client for multiple AI providers (OpenAI, Groq, Grok, etc) with zero dependencies
Author: JsByte
Latest version: 0.1.0

# js-ai-core

Core HTTP/TLS client for AI providers with zero dependencies. Today this package ships:

- HttpClient: a minimal TLS + raw HTTP/1.1 client
- OpenAIProvider: wrapper for the OpenAI Responses API

## Install

```bash
npm install @jeandev_2030/js-ai-core
```

## Quick start (OpenAI)

```js
const { OpenAIProvider } = require('@jeandev_2030/js-ai-core');

const client = new OpenAIProvider({
  apiKey: process.env.OPENAI_API_KEY
});

async function run() {
  const response = await client.createResponse({
    model: 'gpt-4.1-mini',
    input: 'Ola!'
  });

  console.log('status:', response.status);
  console.log('id:', response.id);
  console.log('text:', client.extractText(response));
}

run().catch(console.error);
```

## API

### HttpClient

```js
const { HttpClient } = require('@jeandev_2030/js-ai-core');
const http = new HttpClient({ timeout: 30_000 });
```

Methods:

- `request({ method, url, headers, body })`
- `get(url, options)`
- `post(url, body, options)`

Return value:

```js
{
  status: Number,
  headers: Object, // lowercased header names
  data: Object | String | null
}
```

Notes:

- Uses TLS sockets and raw HTTP/1.1 requests
- No redirects, retries, or streaming
- Default headers: `Content-Type: application/json`, `User-Agent: js-ai-core/1.0`, `Connection: close`

### OpenAIProvider

```js
const { OpenAIProvider } = require('@jeandev_2030/js-ai-core');
const openai = new OpenAIProvider({
  apiKey: process.env.OPENAI_API_KEY,
  baseUrl: 'https://api.openai.com/v1' // optional
});
```

Methods:

- `createResponse({ model, input, headers, options })`
  - `headers` are merged into the request headers
  - `options` is merged into the JSON payload sent to `/responses`
- `extractText(response)` returns concatenated text from `response.raw.output`

Errors:

If the API returns `status >= 400`, the provider throws:

```js
{
  provider: 'openai',
  status: Number,
  message: String,
  code: String | null,
  type: String | null,
  raw: Object
}
```

## Node support

- Node.js >= 18

## License

MIT
npm package: @jeanisahakyan/chirp
Description: Chirp is a simple bridge for communicate between webview, iframe and web app
Author: Jean Isahakyan
Latest version: 0.1.11

# @jeanisahakyan/chirp

Chirp is a simple bridge for communicate between webview, iframe and web app

## Installation

```sh
yarn add @jeanisahakyan/chirp
```

## Usage

```js
// todo
```

## Contributing

See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

## License

MIT

---