open-index/open-npm huggingface dataset:
npm package: @patternsoflife/patterns-cli
Description: Problem-sustaining patterns CLI scripts
Latest version: 1.1.0

# Patterns NodeJS CLI
This package contains command-line NodeJS scripts that invoke functionality
from the [patterns](https://www.npmjs.com/package/@patternsoflife/patterns)
package.

## Installation
### Downloading from npmjs
The easiest way is to install this package globally on your system:
```
npm i -g @patternsoflife/patterns-cli
```
This will make the `patternjs` command available.

### Local development
If you have the `patterntools` git repository checked out on your system for
local development, you can also install this package in development mode:
```
cd patterns-ts-cli
npm install
npm run build
npm link
```
This will make the `patternjs` command globally available by linking it to
the `bin` entrypoint in your `package.json`. After rebuilding the package
with `npm run build`, the global command will reflect the changes.

## Usage
### Running a script
After installation you can run scripts in the following way:
```
patternjs <cmd> [args]
```
Where `<cmd>` specifies the script to run and `[args]` the arguments,
if any, needed to run the script. For example:
```
patternjs svg mypattern.json
```

### Getting help
For more information about the available commands, run:
```
patternjs -h
```
For help on a specific command, run:
```
patternjs <cmd> -h
```

### Definitions for SVG generator
The `patternjs svg` command assumes that there is a `definitions` directory
containing the `context_categories.json`, `role_categories.json`, and
`node_definitions.json` files.
npm package: @patternson/cli
Description: command line interface for patternson
Author: Hannes Diercks
Latest version: 1.3.1

![Patternsoncli Banner](https://raw.githubusercontent.com/patternsonio/cli/master/patternsoncli-logo.png)

<h2 align="center">Create, Run and Publish helper for <a href="https://patternson.io">Patternson</a> Libraries.
</h2>

## Install

`npm i -g @patternson/cli`

## Config

There are multiple ways to configure the patternson cli.

_Sorted by importance (cli args will overwrite env vars etc.)_

### command line arguments

```bash
patternson <command> --[key]=[value]
```

### environment variables

```bash
patternson_[key]=[value] patternson <command>
```

or

```bash
export patternson_[key]=[value]
patternson <command>
```

### `.patternsonrc` file in any parent folder

```ini
[key]=[value]
```

### `package.json` file of the project

```json
{
  "name": "mylib",
  "patternson": {
    "[key]": "[value]"
  }
}
```

## Options

### `accessToken`

authentication token for patternson registry.  
_required_

### `name`

name of the component library.  
_defaults to `name` in `package.json`_

### `version`

version of the library.  
_defaults to `version` in `package.json`_

### `componentsDir`

directory where all components can be found.  
_defaults to `src/components`_

### `rootDir`

root directory of the local library.  
_defaults to dirname of `package.json`_

### `registryUrl`

http endpoint of the patternson registry.  
_defaults to the official patternson registry_

## Contributing

Feel free to send us issues and pull requests.
npm package: @patternson/octopus
Description: An adapting design system
Author: patternson-octopus@lassediercks.de
Latest version: 1.2.0

# Octopus

[![CircleCI](https://circleci.com/gh/patternsonio/Octopus/tree/master.svg?style=shield)](https://circleci.com/gh/patternsonio/Octopus/tree/master)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![Love and Peace](http://love-and-peace.github.io/love-and-peace/badges/base/v1.0-small.svg)](https://github.com/love-and-peace/love-and-peace/blob/master/versions/base/v1.0/en.md)

An adapting pattern library

## Run Locally

```
npm install
npm start
```

## Usage

put the library in your html:

`<script src="https://lib.patternson.io/Octopus/v/latest.js"></script>`

Put up the frame (it serves the global css variables) and start to use components

```
<op-frame>
  <op-headline>This is a Octopus Headline</op-headline>
  <op-button>Checkout the repository</op-button>
</op-frame>
```

### Specific version:

For a specific version use `https://lib.patternson.io/Octopus/v/[tag].js`

Where `[tag]` must be either `latest` or a valid semver specifier.
npm package: @patternson/registry-client
Description: apollo client for patternson registry
Author: Hannes Diercks
Latest version: 1.2.22

# @patternson/registry-client

[![CircleCI](https://circleci.com/gh/patternsonio/patternson-registry-client/tree/master.svg?style=shield)](https://circleci.com/gh/patternsonio/patternson-registry-client/tree/master)
[![codecov](https://codecov.io/gh/patternsonio/patternson-registry-client/branch/master/graph/badge.svg)](https://codecov.io/gh/patternsonio/patternson-registry-client)
[![Greenkeeper badge](https://badges.greenkeeper.io/patternsonio/patternson-registry-client.svg)](https://greenkeeper.io/)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![Love and Peace](http://love-and-peace.github.io/love-and-peace/badges/base/v1.0-small.svg)](https://github.com/love-and-peace/love-and-peace/blob/master/versions/base/v1.0/en.md)

apollo client for [patternson](https://patternson.io/) registry based on [aws-mobile-appsync-sdk-js](https://github.com/awslabs/aws-mobile-appsync-sdk-js).

## Install

`npm install @patternson/registry-client`

## Usage

```js
import PatternsonRegistryClient from '@patternson/registry-client';

const client = new PatternsonRegistryClient({
  // optional. Guest access if not provided
  accessToken: 'myPatternsonAccessToken',
});

client.query({ query: myQuery });
```

## License

* aws-mobile-appsync-sdk-js licensed under [Amazon Software License 1.0](https://github.com/awslabs/aws-mobile-appsync-sdk-js/blob/master/LICENSE)
* aws-sdk-js licensed under [Apache License](https://github.com/aws/aws-sdk-js/blob/master/LICENSE.txt)

All code in this repository is licensed under the MIT licence.

> The MIT License
>
> Copyright (C) 2018 Hannes Diercks
>
> Permission is hereby granted, free of charge, to any person obtaining a copy of
> this software and associated documentation files (the "Software"), to deal in
> the Software without restriction, including without limitation the rights to
> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
> of the Software, and to permit persons to whom the Software is furnished to do
> so, subject to the following conditions:
>
> The above copyright notice and this permission notice shall be included in all
> copies or substantial portions of the Software.
>
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
npm package: @patterujs/cli
Description: Patteru - Small load balancer for developers
Latest version: 1.0.1

# Patteru JS

A [Node.js](https://nodejs.org/en/) CLI Tool for small load balancer

![npm](https://img.shields.io/npm/v/@patterujs/cli)
![NPM](https://img.shields.io/npm/l/@patterujs/cli)
![GitHub last commit](https://img.shields.io/github/last-commit/patterujs/patteru-cli)

## Description

The Patteru CLI is a command line interface tool for helps you to test run your project in load balancer.

## Installing

### Installing for global use

```shell
npm i -g @patterujs/cli
```

### Installing in current project

```shell
npm i --save-dev @patterujs/cli
```

After the installation is complete, add a script to package.json in your project.

```json
{
  "script": {
    "balancer": "patteru start filename.js"
  }
}
```

## Usage

To run your project using PatteruJS, you have to add `process.env.PORT` into your project as in the example below.

### Example of use in Express

```javascript
// index.js
const express = require('express');
const app = express();
const port = process.env.PORT;

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});
```

To run it

```shell
patteru start index.js
```

### Example of use in Fastify

```javascript
// index.js

const fastify = require('fastify')({
  logger: true,
});

fastify.get('/', function (request, reply) {
  reply.send({ hello: 'world' });
});

fastify.listen(process.env.PORT, function (err, address) {
  if (err) {
    fastify.log.error(err);
    process.exit(1);
  }
  fastify.log.info(`server listening on ${address}`);
});
```

To run it

```shell
patteru start index.js
```

### Example of use in Nestjs

```typescript
// main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(process.env.PORT);
}
bootstrap();
```

Before running it, make the project first.

```shell
npm run build
```

To run it

```shell
patteru start dist/main.js
```

## License

PatteruJS is [MIT Licensed](LICENSE)
npm package: @pattofu/openlayers-react
Description: OpenLayer React Components
Latest version: 1.1.3

# openlayers-react

Currently, a minimal [React](https://facebook.github.io/react/) 
wrapper of [OpenLayers 5](https://openlayers.org/)
written in [TypeScript](https://www.typescriptlang.org/).

Goal is to redo the DOM rendering/resolution, and eventing purely in React components.

## Install

    npm install openlayers-react --save

## Usage

There are thin wrapper components to handle the rendering of Map, and Control. They do nothing else.
The CurrentMapContext allows you to do any further processing on the enclosing ol/Map, while the MapContext keeps track of any Map controls within it, and can be used for further manipulation.

See [examples](./examples/) for some basic scenarios.

Give the Map component a ol/Map config, exluding the target/element properties:
    
    const mapOptions = {
        controls: [
            new ScaleLine({ units: 'imperial' }), // You can use ol/Controls as normal
        ],
        layers: [
            new TileLayer({
                source: new TileWMS({
                    ...
                }),
            }),
        ],
        view: new OlView({
            center: [0, 0],
            zoom: 4,
        }),
    };
    export const BasicMapExample = (props) => {
        return (
            <div>
                <OlMap initialMapOptions={mapOptions} mapId={'MyMap'}>
                    {/* or you can render it with a wrapper in the enclosing map */}
                    <Control controlType={ZoomSlider} controlProps={{}} />
                </OlMap>
            </div>
        );
    }
npm package: @pattonwebz/focustrap
Description: A simple, pure vanilla JS, focus trap.
Author: William Patton
Latest version: 1.0.1

# FocusTrap
It's a simple - pure vanilla JS - focus trap. No frills, just straightforward use.

You can start the trap with just a region.

Optionally (and highly recommended) you can pass a triggering element which focus will be returned to on ending. 

Optionally, you can pass an element inside the region that will be the first focused element. Otherwise, the first focusable element will be used (falling back to the region itself if no focusable items are inside).

## Using FocusTrap

```js
// With a region to trap and a trigger element.
const regionElement = document.getElementById( 'aModalElement' );
const triggerElement = document.getElementById( 'aTriggerButton' );

// Create a new FocusTrap with them.
const trap = new FocusTrap( regionElement, triggerElement );

// Start the trap.
trap.activate();
// Pause the trap.
trap.pause();
// Resume the trap.
trap.resume();
// End the trap.
trap.deactivate();
```
npm package: @patuach/oh-my-gauge
Description: Gauge and Benchmark - time Javascript operations
Author: Gaugy McGauge Face
Latest version: 1.0.1

# Oh My Gauge!
## Gauge - time Javascript operations

[![npm package](https://badge.fury.io/js/%40patuach%2Foh-my-gauge.svg)](https://www.npmjs.com/package/@patuach/oh-my-gauge)
[![Codeship Status](https://app.codeship.com/projects/485cd4c0-4223-0135-3490-2a9fd3996dea/status?branch=master)](https://app.codeship.com/projects/230238)

[![pull requests](https://img.shields.io/github/issues-pr/patuach/oh-my-gauge.svg)](https://github.com/patuach/oh-my-gauge/pulls) [![issues](https://img.shields.io/github/issues/patuach/oh-my-gauge.svg)](https://github.com/patuach/oh-my-gauge/issues)

## Install
```sh
npm i @patuach/oh-my-gauge
```

```javascript
const {Gauge, Benchmark} = require('@patuach/oh-my-gauge');
```

## Usage

#### Gauge
```javascript
const Gauge = require('@patuach/oh-my-gauge').Gauge;
const gauge = new Gauge((res, name) => console.log(`${name} took ${res}ms`));
//                        ^     ^         ^
//              Milliseconds  String   report-method

const myObj = {
    name: 'My Obj',
    sayName: function() {
        return this.name;
    }
};

myObj.sayName = gauge(myObj.sayName, 'sayName method');
```

#### Benchmark
```javascript
const Benchmark = require('@patuach/oh-my-gauge').Benchmark;
const benchmark = new Benchmark();

benchmark(
  100000,
  [() => {/* Do thing one   */}, 'Thing 1 description'],
  [() => {/* Do thing two   */}, 'Thing 2 description'],
  [() => {/* Do thing three */}, 'Thing 3 description']
);
```

Or use a map
```javascript
const Benchmark = require('@patuach/oh-my-gauge/lib/benchmark'); // Require to the module directly
const benchmark = new Benchmark(
    console.warn, // override the default console.log callback
    (ms, name) => `Method: ${name}, Time: ${ms}` // override default formatter
);

const things = new Map();
things.set(() => {/* Do thing one   */}, 'Thing 1 description');
things.set(() => {/* Do thing two   */}, 'Thing 2 description');
things.set(() => {/* Do thing three */}, 'Thing 3 description');

benchmark(1e5, things);
```
npm package: @patwoz/prettier-config
Description: My personal Prettier config
Author: Patrick Wozniak
Latest version: 1.1.0

# `@patwoz/prettier-config`

[![npm version](https://badge.fury.io/js/%40patwoz%2Fprettier-config.svg)](https://badge.fury.io/js/%40patwoz%2Fprettier-config) [![Actions Status](https://github.com/patlux/prettier-config/workflows/publish/badge.svg)](https://github.com/patlux/semantic-release-test/actions) [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/) [![Twitter Follow](https://img.shields.io/twitter/follow/de_patwoz?style=social)](https://twitter.com/de_patwoz)

> My personal [Prettier](https://prettier.io) config.

## 🔎 Usage

**Install**:

npm

```bash
$ npm install --save-dev @patwoz/prettier-config
```

yarn

```bash
$ yarn add --dev @patwoz/prettier-config
```

**Edit `package.json`**:

```jsonc
{
  // ...
  "prettier": "@patwoz/prettier-config"
}
```

## 🦸‍♂️

Created with 🔥 by [@de_patwoz](https://twitter.com/de_patwoz)
npm package: @patwoz/semantic-release-test
Description: [![npm version](https://badge.fury.io/js/%40patwoz%2Fsemantic-release-test.svg)](https://www.npmjs.com/package/@patwoz/semantic-release-test 'View this project on npm') [![Actions Status](https://github.com/patlux/semantic-release-test/workflows/nodejs/ba
Author: Patrick Wozniak
Latest version: 1.2.0

# semantic-release-test

[![npm version](https://badge.fury.io/js/%40patwoz%2Fsemantic-release-test.svg)](https://www.npmjs.com/package/@patwoz/semantic-release-test 'View this project on npm')
[![Actions Status](https://github.com/patlux/semantic-release-test/workflows/nodejs/badge.svg)](https://github.com/patlux/semantic-release-test/actions)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
[![Twitter Follow](https://img.shields.io/twitter/follow/de_patwoz?style=social)](https://twitter.com/de_patwoz)

Me just playing with [semantic-release](https://github.com/semantic-release/semantic-release).

## 🔁 Flow

### Local (on your computer)

![Flow local](./docs/flow-local.png)

See [`.huskyrc`](./.huskyrc), [`.lintstagedrc`](./.lintstagedrc), [`package.json`](./package.json), [`commitlint.config.js`](./commitlint.config.js)

### Remote (CI)

![Flow remote](./docs/flow-remote.png)

See [`.github/workflows/nodejs.yml`](./.github/workflows/nodejs.yml)

## 🔖 License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

Created with 🔥 by [@de_patwoz](https://twitter.com/de_patwoz)
npm package: @patxin/cli
Description: CLI for patxin.com — patch in a human from any agent or terminal
Author: Alejandro Gracia García
Latest version: 0.1.2

# @patxin/cli

CLI for [patxin.com](https://patxin.com) — patch in a human from any agent, orchestrator, or terminal.

The universal interface for human-in-the-loop. Works with any AI agent that can execute commands.

## Install

```bash
npm install -g @patxin/cli
# or run directly
npx @patxin/cli
```

## Setup

```bash
export PATXIN_API_KEY=pk_live_...  # Get your key at https://patxin.com/dashboard
```

Optional: `PATXIN_API_URL` to point to a custom endpoint.

## Commands

### Check account

```bash
patxin limits                    # Credits, budget, rate limits
patxin policy                    # Information policy, allowed skills
```

### Estimate pricing

```bash
patxin estimate -s code_review -u 5min -d 15min
```

### Request a human

```bash
# Wait for completion (default — blocks until done)
patxin request -s code_review -u 5min -d 15min \
  -c "Review this function for XSS vulnerabilities: ..." \
  -p 8EUR

# Fire and forget
patxin request -s translation_en_es -u 15min -d 30min \
  -c "Translate this legal clause: ..." \
  -p 12EUR --no-wait

# With policy and category
patxin request -s legal_review_spain -u 5min -d 15min \
  -c "Review this NDA clause..." \
  -p 10EUR --policy sandboxed --category domain_expertise
```

### Track requests

```bash
patxin status req_abc123         # Check status
patxin wait req_abc123           # Wait for completion (WebSocket + polling)
patxin list                      # List all requests
patxin list -s completed -n 5    # Last 5 completed
```

### After completion

```bash
patxin rate req_abc123 --score 5 --comment "Perfect review"
patxin cancel req_abc123         # Cancel pending (refunds credits)
patxin dispute req_abc123 --reason "Incomplete work"
```

## Output modes

```bash
patxin limits                    # Auto-detect: pretty in TTY, JSON in pipes
patxin limits --json             # Force JSON (for agents)
patxin limits --pretty           # Force pretty (colored, human-readable)
```

JSON output is one line per invocation — ideal for parsing:

```bash
patxin estimate -s code_review -u 5min -d 15min --json | jq '.estimated_price'
```

## Agent integration

Any AI agent that can execute shell commands can use patxin:

```bash
# Orchestrator script
ESTIMATE=$(patxin estimate -s code_review -u 5min -d 15min --json)
PRICE=$(echo "$ESTIMATE" | jq -r '.estimated_price')

if [ "$(echo "$PRICE < 10" | bc)" -eq 1 ]; then
  RESULT=$(patxin request -s code_review -u 5min -d 15min \
    -c "Review this code: ..." -p "${PRICE}EUR" --json)
  echo "$RESULT" | jq '.result'
fi
```

## Other integration options

| Channel    | Best for                     | Install                                |
|------------|------------------------------|----------------------------------------|
| **CLI**    | Any agent / orchestrator     | `npm i -g @patxin/cli`                 |
| **MCP**    | Claude Code, Cursor          | `npm i -g @patxin/mcp-server`          |
| **REST**   | Custom frameworks            | `curl api.patxin.com/v1/...`           |

## License

MIT
npm package: @patxin/mcp-server
Description: MCP server for patxin.com — patch in a human for real-time cognitive micro-tasks
Author: Alejandro Gracia García
Latest version: 0.1.1

# @patxin/mcp-server

MCP server for [patxin.com](https://patxin.com) — patch in a human for real-time cognitive micro-tasks.

When your AI agent needs human judgment — legal review, creative feedback, ethical decisions, domain expertise — it calls patxin and gets a matched human in under 60 seconds.

## Setup

### Claude Desktop / Claude Code

```bash
claude mcp add patxin -- npx @patxin/mcp-server
```

### Cursor / other MCP clients

Add to your MCP configuration:

```json
{
  "mcpServers": {
    "patxin": {
      "command": "npx",
      "args": ["@patxin/mcp-server"],
      "env": {
        "PATXIN_API_KEY": "pk_live_your_key_here"
      }
    }
  }
}
```

## Environment Variables

| Variable | Required | Description |
|---|---|---|
| `PATXIN_API_KEY` | Yes | Your patxin API key (`pk_live_*` or `pk_test_*`) |
| `PATXIN_API_URL` | No | Custom API base URL (default: `https://api.patxin.com`) |

Test keys (`pk_test_*`) return simulated responses without real patxers or credit spend.

## Tools

| Tool | Description |
|---|---|
| `patxin_check_limits` | Check remaining credits and request limits |
| `patxin_check_policy` | Check information policy and allowed skills |
| `patxin_estimate` | Get price estimate before committing |
| `patxin_request` | Request a human (blocks until completion) |
| `patxin_status` | Check status of an existing request |
| `patxin_rate` | Rate a completed interaction |

## Example

Once connected, your agent can use natural language:

> "I need a Spanish lawyer to review this NDA clause for compliance with GDPR Article 28."

The agent will call `patxin_estimate` to check pricing, then `patxin_request` to get a qualified human review.

## Real-time

The server uses WebSocket connections for instant task completion notifications, with automatic fallback to HTTP polling if WebSocket is unavailable.

## Links

- Website: https://patxin.com
- API docs: https://patxin.com/docs
- API health: https://api.patxin.com/v1/health

## License

MIT
npm package: @patys/snap-it
Description: Tool to generate jest test cases with snapshots for React Native components.
Author: Patryk Szczygło
Latest version: 0.3.0

# snap-it

[![npm version](https://badge.fury.io/js/%40patys%2Fsnap-it.svg)](https://badge.fury.io/js/%40patys%2Fsnap-it)

This is a tool to create a snapshot for your component. You can use it to simply generate boilerplate file with all cases. Keep in mind that you should verify and add your own test cases.

Works only with TypeScript for now.

## Usage:

Follow instalation guide and then:

```bash
yarn create-snapshot components/Search.tsx
```

Or you can use it directly without installing:

```bash
npx @patys/snap-it g components/Search.tsx
```

To save in the same directory use option: --direct=true

```bash
npx @patys/snap-it g components/Search.tsx --direct=true
```

Effect with direct:
components/Search.tsx
components/Search.test.tsx

Effect without direct:
components/Search.tsx
\_\_tests\_\_/Search.test.tsx

## Installation:

```bash
yarn add --dev @patys/snap-it
```

Add to your package.json

```bash
{
  "scripts": {
    ...
    "create-snapshot": "yarn snap-it g "
    ...
  }
}
```

## Example:

Your component:

```javascript
// example/Search.tsx
import React from 'react';
import { View } from 'react-native';

interface Props {
  numberTest?: number;
  booleanTest?: boolean;
  stringTest?: string;
  anyTest?: any;
  functionTest?: () => void;

  requiredTest: string;
}

export default function Search({}: Props) {
  return <View />;
}
```

Effect:

```javascript
import React from 'react';
import { render } from '@testing-library/react-native';

import { Search } from '../example/Search.tsx';

describe('Search', () => {
  test('Snaphot for required props', () => {
    const props = {
      requiredTest: 'testing string',
    };
    const tree = render(<Search {...props} />).toJSON();
    expect(tree).toMatchSnapshot();
  });

  test('Snaphot for numberTest', () => {
    const props = {
      requiredTest: 'testing string',

      numberTest: 123,
    };
    const tree = render(<Search {...props} />).toJSON();
    expect(tree).toMatchSnapshot();
  });

  test('Snaphot for booleanTest', () => {
    const props = {
      requiredTest: 'testing string',

      booleanTest: true,
    };
    const tree = render(<Search {...props} />).toJSON();
    expect(tree).toMatchSnapshot();
  });

  test('Snaphot for stringTest', () => {
    const props = {
      requiredTest: 'testing string',

      stringTest: 'testing string',
    };
    const tree = render(<Search {...props} />).toJSON();
    expect(tree).toMatchSnapshot();
  });

  test('Snaphot for anyTest', () => {
    const props = {
      requiredTest: 'testing string',

      anyTest: {},
    };
    const tree = render(<Search {...props} />).toJSON();
    expect(tree).toMatchSnapshot();
  });

  test('Snaphot for functionTest', () => {
    const props = {
      requiredTest: 'testing string',

      functionTest: jest.fn(),
    };
    const tree = render(<Search {...props} />).toJSON();
    expect(tree).toMatchSnapshot();
  });
});
```
npm package: @patzj/types-ol-ext
Description: Type definitions for ol-ext
Author: Siedlerchr
Latest version: 0.0.4

# types-ol-ext

[ol-ext](https://github.com/Viglino/ol-ext) TypeScript declaration. If you encounter any missing typings or wrong, please open an issue!

## Installation

Add this package with an alias:

```sh
# NPM
npm i -D @types/ol-ext@npm:@patzj/types-ol-ext

# Yarn
yarn add -D @types/ol-ext@npm:@patzj/types-ol-ext
```

**Note: This is a forked version.**
npm package: @paukol/randomid-generator
Description: USAGE const randomID = require('@paukol/randomid-generator');
Latest version: 1.0.2

USAGE
const randomID = require('@paukol/randomid-generator');

randomID(10); // to generate random id with 10 signs

INSTALLATION
yarn add @paukol/randomid-generator

or npm i @paukol/randomid-generator
npm package: @paul-joy/react-guitar-chords
Description: A React component for rendering SVG guitar chords (based on @tombatossals/react-chords).
Author: paul-joy
Latest version: 2.1.0

## @paul-joy/react-guitar-chords

A lightweight React component to render SVG guitar chord diagrams. Inspired by `@tombatossals/react-chords` and modernized for React 19 with ESM/CJS builds and TypeScript types.

### Install

```bash
npm i @paul-joy/react-guitar-chords
# or
yarn add @paul-joy/react-guitar-chords
# or
pnpm add @paul-joy/react-guitar-chords
# or
bun add @paul-joy/react-guitar-chords
```

Requires React 19 in your app.

### Quick start

```tsx
import React from "react";
import Chord from "@paul-joy/react-guitar-chords";

const instrument = {
  tunings: { standard: ["E", "A", "D", "G", "B", "E"] },
  strings: 6,
  fretsOnChord: 5,
};

// Example: A minor (positions are from low-E to high-e; -1 = muted)
const chord = {
  frets: [0, 0, 2, 2, 1, 0],
  fingers: [0, 0, 3, 2, 1, 0],
  barres: [],
  baseFret: 1,
};

export default function Example() {
  return <Chord chord={chord} instrument={instrument} />;
}
```

### Barre chords

```tsx
const eMajorBarreOn7 = {
  frets: [7, 9, 9, 8, 7, 7],
  fingers: [1, 3, 4, 2, 1, 1],
  barres: [7],
  capo: true,
  baseFret: 1,
};

<Chord chord={eMajorBarreOn7} instrument={instrument} />;
```

### Lite mode and theming

```tsx
// Minimal rendering (hides labels and extras)
<Chord chord={chord} instrument={instrument} lite />;

// Customize colors
const theme = {
  primaryColor: "#222",
  textColor: "#fff",
  fretPositionColor: "#888",
};

<Chord chord={chord} instrument={instrument} theme={theme} />;
```

### API

- **Default export**: `Chord`

- **Props**
  - **chord**: object describing the fingering
    - `frets: number[]` — fret per string, from low‑E to high‑e; `0` = open, `-1` = muted
    - `barres?: number[]` — fret numbers that are barred
    - `capo?: boolean` — show capo style on the first barre (if any)
    - `fingers?: number[]` — finger numbers per string
    - `baseFret: number` — base fret index for display (1 = nut)
  - **instrument**: object describing the instrument layout
    - `tunings.standard: string[]` — e.g. `["E","A","D","G","B","E"]`
    - `strings: number` — number of strings
    - `fretsOnChord: number` — how many frets to render in the viewport
  - **lite?**: boolean — simplified rendering
  - **theme?**: object — colors used for rendering
    - `primaryColor: string`
    - `textColor: string`
    - `fretPositionColor: string`

TypeScript helper types (simplified):

```ts
type ChordType = {
  frets: number[];
  barres?: number[];
  capo?: boolean;
  fingers?: number[];
  baseFret: number;
};

type InstrumentType = {
  tunings: { standard: string[] };
  strings: number;
  fretsOnChord: number;
};

type ThemeType = {
  primaryColor: string;
  textColor: string;
  fretPositionColor: string;
};
```

### Import styles

```js
// ESM
import Chord from "@paul-joy/react-guitar-chords";

// CommonJS
const Chord = require("@paul-joy/react-guitar-chords").default;
```

### License

MIT © paul-joy
npm package: @paul-shuvo/nodejs-stock-info
Description: A nodejs library to fetch stock info that doesn't require subscribing to any API calls.
Author: Shuvo Kumar Paul
Latest version: 0.1.18

<div align="center">
<h1>NodeJS Stock Info</h1>

[![Build Status](https://travis-ci.com/paul-shuvo/nodejs-stock-info.svg?branch=main)](https://travis-ci.com/paul-shuvo/nodejs-stock-info) [![Known Vulnerabilities](https://snyk.io/test/github/paul-shuvo/nodejs-stock-info/badge.svg?targetFile=package.json)](https://snyk.io/test/github/paul-shuvo/nodejs-stock-info?targetFile=package.json) [![codecov](https://codecov.io/gh/paul-shuvo/nodejs-stock-info/branch/main/graph/badge.svg)](https://codecov.io/gh/paul-shuvo/nodejs-stock-info)
 ![license: MIT](https://img.shields.io/npm/l/vue.svg) [![Maintainability](https://api.codeclimate.com/v1/badges/b512e403dfc172ee3b0d/maintainability)](https://codeclimate.com/github/paul-shuvo/nodejs-stock-info/maintainability) ![npm version](https://badge.fury.io/js/nodejs-stock-info.svg)
 <!-- ![npm](https://img.shields.io/npm/dm/nodejs-stock-info) -->

<p>A minimal NodeJS library to fetch stock info.</p>
</div>

__Disclaimer:__ This package fetch the result from finance.yahoo.com using web scrapping. Owner will not be responsible for any misuse of this package. This is solely for the purpose of learning.

## Getting started

### Installation

This package can be installed using `npm`

```bash
npm install stock-info
```

or, `yarn`

```bash
yarn add stock-info
```

### Usage

Import `stock-info`.

```javascript
const SI = require('stock-info')
```

Then instantiate with either the empty constructor

```javascript
let stockInfo = new SI()
```

Or, with a string or list of strings corresponding to the stock e.g. `"amzn"` or `["amzn", "aapl"]`

```javascript
let stockInfo = new SI("amzn")
// or
let stockInfo = new SI(["amzn", "aapl"])
```

The `getStockInfo` method will return the latest stock information and can be used as a promise.

```javascript
stockInfo.getStockInfo().then((response) => {
    console.log(response) //or do something else
})
```

Chaining is also supported.

```javascript
stockInfo.setStocks("tsla").getStockInfo().then((response) => {
    console.log(response) //or do something else
})
```

## Issues

If any issues are found, they can be reported [here](https://github.com/paul-shuvo/nodejs-stock-info/issues).

## License

This project is licensed under the [MIT](LICENSE) license.
npm package: @paul.legan/shiny
Description: Create shiny objects using configurable templates.
Author: Paul Legan
Latest version: 0.0.2

#shiny

## Description

`shiny` lets you create simple Handlebars.js-based templates for common or repetitive tasks. Think of this as a simplified `yeoman` that you can more easily edit yourself via your templates folder.

## Usage

To install shiny from npm, run:

```
$ npm install -g @paul.legan/shiny
```

```shiny --help```

Your templates are located in `~/shiny/templates`. Each template has a `shiny.json` file that has configuration information. It lets you define:

1. Rules: Set of conditions for specific files to be copied from the template.
2. Variables: Set of all variables that can be used in the Handlebars.js templates.

Here is an example:

```json
{
    "variables": [
        { "name": "component", "message": "Please enter your component name.", "type": "input" },
        { "name": "dialog", "message": "Include a dialog?", "type": "confirm" }
    ],
    "rules": [
        {
            "file": "{{component}}/dialog.xml",
            "condition": {
                "variable": "dialog",
                "operation": "equals",
                "value": true
            }
        }
    ]
}
```

To use a template, run the following command:

```
shiny new [object]
```

This will utilize a template stored at `~/shiny/templates/object` and pull in the related files and subfolders. You will be prompted to enter each of the variable values present in the `shiny.json` configuration file. However, you can pass some or all of these variables in as name=value pairs to the command, like so:

```
shiny new [object] component="Hello World"
```

There is no limit to how many files can exist within a template, and both file/folder names and the contents of a file can include placeholders for variable swap. Here is an example where both a file and folder have variables within their names:

```
.
├── shiny.json
└── {{component}}
    ├── dialog.xml
    ├── readme.md
    └── {{component}}.html
```

## Template Library

Many templates are available in a separate repository:
https://github.com/hngrylobster/shiny-templates

You can clone this repository into your `~/shiny/templates` directory to get them all.

```
git clone https://github.com/hngrylobster/shiny-templates.git ~/shiny/templates
```

## License

Copyright (c) 2019 Paul Legan

[MIT License](http://en.wikipedia.org/wiki/MIT_License)
npm package: @paul803/ocpp
Description: OCPP 1.6: Open Charge Point Protocol
Author: Vitalii Savchuk
Latest version: 1.0.7

# Open Charge Point Protocol 1.6

[![Build Status](https://travis-ci.org/elifTech/cpd-ocpp.svg?branch=master)](https://travis-ci.org/elifTech/cpd-ocpp)

This repository contain abstraction layer for easy work with OCPP and validate input and output requests.
Currently implemented only version 1.6 JSON. Whereas OCPP2.0 will support only JSON have no plans to implement SOAP.

## Article

https://www.eliftech.com/blog/48-a-diy-charging-point-for-an-electric-car-perspective-protocol-and-prototype

## Installation
```
npm install --save ocpp-eliftech
```

## Overview

Open Charge Point Protocol (OCPP, <http://www.openchargealliance.org/>) is a communication protocol between multiple charging stations ("charge points") and a single management software ("central system").

## Usage

Server

```js
import { OCPPServer, OCPPCommands } from 'ocpp-eliftech';

const server = new OCPPServer();

server.listen(9220);

server.onRequest = async function(command) {
    // Handle different commands
    if (command instanceof OCPPCommands.BootNotification) {
        return {
            status: 'Accepted',
            currentTime: new Date().toISOString(),
            interval: 60
        };
    }
}
```

Client

```js
import { OCPPClient, OCPPCommands } from 'ocpp-eliftech';

const client = new OCPPClient({
    serverUrl: 'http://localhost:9220/webServices/ocpp/CP1111'
});

await client.connect();

const boot = new OCPPCommands.BootNotification({
    chargePointVendor: 'BrandX',
    chargeBoxSerialNumber: 'AQ1234VB5678',
    chargePointSerialNumber: '123',
    chargePointModel: '12'
});

let answer = await client.send(boot);
console.info(answer);
```

### P.S.

If you need professional support with your IOT projects contact us http://www.eliftech.com/.
npm package: @paul_ayanava/eslint-config-react
Description: Paul (ESLint) configuration
Author: Sapient XT
Latest version: 1.0.2

# XT Page Source Eslint Config Package

### Package to unify ESLint configuration and rules across projects. No need to install those packages anymore in your projects and maintain them all separately.

#### To Install package .

```
npm install @xt-pagesource/eslint-config-react

```

#### Configure

#### Create the file .eslintrc in your app root folder and extend rules. you can also add additional rules as per your desire.

```
{

 "extends":["@xt-pagesource/eslint-config-react"]

}

```

#### Note: You can extend or modify this rules in your project as is described on the documentation of eslint, the same way as you will do when extending eslint recommended rules.

```
{

 "extends":["@xt-pagesource/eslint-config-react"],

 rules:{
     your rules here
 }

}

```

### Usage

#### Like you will do normally with eslint, this package is nothing else just a wrapper. - For just linting and to see the report, run:

```
eslint path/to/folder

```

For linting and autofix the problems, run:

```
eslint --fix path/to/folder

```

Recommended
Add in your package.json at the scripts section the two following scripts:

```

{
    "scripts": {
    "lint:js": "eslint path/to/folder",
    "lint:fix": "eslint  --fix path/to/folder"
    }
}

```