open-index/open-npm huggingface dataset:
npm package: @salayna/shrimp-cli
Description: Yet another Project Builder
Author: @salayna
Latest version: 0.6.2

# Shrimp CLI

_I'm a newbie in Golang, I'm still figuring out things so you'll probably have a lot to say about this, so feel free publish issues_

## Install

### Just building a binary file

To install it locally you can just run the following command `go build -o ./bin/shrimp` after cloning the project sources

[comment]: <> (### global install)

[comment]: <> (You can Install it using the command ``npm install -g @salayna/shrimp_cli``)
## Running the app

With the local installation you can run the cli with this command `./{path/to/your/binary/file}`
[comment]: <> And with the global installation you can just run `shrimp`.

### The arguments
_this part is deprecated, while the arguments are still there I'm not satisfied with them so by the release of V1 these will drastically change_
- **-n || --name**: is the name/directory of the project
- **-l || --language**: is the language of the project to be chosen from a specific set of configuration files, stored in the configs folder
- **-f || --file**: **Not Implement yet**is if you wanna created a project from a configuartion file (like for a one time project)
- **-v || --verbose** **Not Implement yet**
- **-v || --version** **Not Implement yet**

### Adding configuations

The configurations files will be stored in the configs folder at ``$HOME/.shrimp``. All of them must be written in JSON
here is an example of configuration files

```json
{
  "directories": {
    "src": {
      "baseDir": "internal",
      "subDir": [
        "cli"
      ]
    },
    "scripts": {
      "baseDir": "pkg"
    },
    "deployments": {
      "baseDir": "deployments"
    },
    "test": {
      "baseDir": "test"
    },
    "docs": {
      "baseDir": "docs"
    }
  },
  "commands": {
    "git": {
      "base": "git",
      "arguments": ["init"]
    },
    "golang init": {
      "base": "go",
      "arguments": ["mod", "init"]
    }
  },
  "files": {
    "LICENSE": {
      "name": "LICENSE",
      "directory": "./"
    },
    "Main": {
      "name": "main.go",
      "directory": "./"
    },
    "ReadMe": {
      "name": "README.md",
      "directory": "./"
    }
  }
}
```
npm package: @salazkin/easing-functions
Description: Easing Functions.
Author: Oleksii Salazkin
Latest version: 1.1.0

# Easing Functions

### Quadratic

- `quadEaseIn`
- `quadEaseOut`
- `quadEaseInOut`

### Cubic

- `cubicEaseIn`
- `cubicEaseOut`
- `cubicEaseInOut`

### Sine

- `sinEaseIn`
- `sinEaseOut`
- `sinEaseInOut`

### Circular

- `circEaseIn`
- `circEaseOut`
- `circEaseInOut`

### Elastic

- `elasticEaseIn`
- `elasticEaseOut`
- `elasticEaseInOut`

### Back

- `backEaseIn`
- `backEaseOut`
- `backEaseInOut`

### Bounce

- `bounceEaseIn`
- `bounceEaseOut`
- `bounceEaseInOut`

### YoYo

- `yoyo`

---

### Installation

```bash
npm install @salazkin/easing-functions
```

---

## License

MIT
npm package: @salazkin/promise-utils
Description: A minimalistic utility library for managing states and executing asynchronous operations using promises.
Author: Oleksii Salazkin
Latest version: 2.0.1

# Promise Utility Library

A minimalistic utility library for managing states and executing asynchronous operations using promises. Includes functions for running tasks in sequence or parallel, tweening values, and managing a micro state machine.

---

## Sequence and Parallel

Run promises in sequence or parallel.

### Example

```javascript
import { sequence, parallel, delay } from "@salazkin/promise-utils";

const tasks = [
  async () => {
    await delay(1000);
    console.log("Task 1 done");
  },
  async () => {
    await delay(200);
    console.log("Task 2 done");
  },
  async () => {
    await delay(500);
    console.log("Task 3 done");
  },
];

(async () => {
  await sequence(tasks); // Output: Task 1 done, Task 2 done, Task 3 done
  console.log("Sequence complete");

  await parallel(tasks); // Output: Task 2 done, Task 3 done, Task 1 done
  console.log("Parallel complete");
})();
```

---

## Tween

A simple tween that resolves as a promise. Tweens a value from `0` to `1` over a specified duration. Can be canceled using an AbortSignal.

### Example

```javascript
import { tween } from "@salazkin/promise-utils";

const lerp = (start, end, t) => start + (end - start) * t;

(async () => {
  await tween(1000, (progress) => {
    const value = lerp(0, 100, progress); // Interpolate from 0 to 100
    console.log(`Value: ${value}`);
  });
  console.log("Tween 1 complete");

  // Example with cancellation
  await tween(
    1000,
    (progress, aborted) => {
      console.log(`Progress: ${progress}`);
      if (aborted) console.log("Tween aborted");
    },
    AbortSignal.timeout(500) // Skip after 500ms
  );
  console.log("Tween 2 complete");
})();
```

---

## Delay

A simple delay function that resolves after a specified duration.

### Example

```javascript
import { delay } from "@salazkin/promise-utils";

(async () => {
  await delay(1000);
  console.log("1 second delay complete");
})();
```

---

## States

A micro state machine that resolves as a promise. Each state is a handler function that can transition to the next state or exit.

### Example

```javascript
import { states, delay } from "@salazkin/promise-utils";

(async () => {
  await states({
    async start(next) {
      console.log("Starting...");
      next("idle");
    },
    async idle(next) {
      console.log("In the idle...");
      await delay(500);
      next("end");
    },
    async end(next, exit) {
      console.log("Ending...");
      await delay(500);
      exit();
    },
  });
  console.log("State machine exited");
})();
```

---

## Installation

```bash
npm install @salazkin/promise-utils
```

---

## License

MIT
npm package: @salazkin/signals
Description: Simple Signal Class and Reactive Wrapper.
Author: Oleksii Salazkin
Latest version: 1.0.3

# Simple Observer Class and Reactive Wrapper

A lightweight implementation of the Observer pattern using a `Signal` class. Also `reactive` wrapper for creating reactive objects.

---

## Signal

The `Signal` class implements the Observer pattern, allowing you to register listeners that are triggered when the signal is dispatched.

### API

**`add(listener, context?)`**: Registers a listener to be called on dispatch.  
**`addOnce(listener, context?)`**: Registers a one-time listener, auto-removed after dispatch.  
**`remove(listener, context?)`**: Removes a listener.  
**`removeAll()`**: Removes all listeners.  
**`dispatch(data)`**: Triggers the signal, passing `data` to all listeners.  
**`isEmpty()`**: Returns `true` if no listeners are registered, otherwise `false`.

### Example

```javascript
import { Signal } from "@salazkin/signals";

const signal = new Signal();

signal.add(message => {
  console.log(`Received: ${message}`);
});

signal.dispatch("Hello, World!"); // Output: "Received: Hello, World!"
```

---

## Reactive

The `reactive` function wraps an object in a `Proxy` to make it reactive. Any changes to the object's properties trigger a signal, allowing you to watch for changes.

### Example

```javascript
import { reactive } from "@salazkin/signals";

const user = reactive({
  name: "Alice",
  age: 25
});

const subscription = user.watch(({ prop, value }) => {
  console.log(`Property "${prop}" changed to ${value}`);
});

user.name = "Bob"; // Output: `Property "name" changed to Bob`
user.age = 30; // Output: `Property "age" changed to 30`

// Unsubscribe from changes
subscription.unsubscribe();
user.name = "Charlie"; // No output (unsubscribed)
```

---

### Installation

```bash
npm install @salazkin/signals
```

---

## License

MIT
npm package: @salchipapasdemil/adyen-salesforce-pwa
Description: This NPM package enables you to go live fast with payments with Adyen as a payment service provider when building your Salesforce PWA Retail application.
Latest version: 3.0.1

# Adyen Salesforce PWA

This NPM package enables you to go live fast with payments with Adyen as a payment service provider when building your Salesforce PWA
Retail application.

To request a feature, report a bug, or report a security
vulnerability, [create a GitHub issue](https://github.com/Adyen/adyen-salesforce-headless-commerce-pwa/issues/new/choose).

## Dependencies & Requirements

Adyen Payments Composable Storefront Integration for B2C Commerce depends on:

1. PWA 2.7.x - 3.4.x
2. [Adyen Web v5.66.0](https://www.npmjs.com/package/@adyen/adyen-web)
3. [Adyen API Library for Node.js v16.0.1](https://www.npmjs.com/package/@adyen/api-library)
4. Node v18 or later
5. NPM v9 or later
6. Salesforce Managed Runtime

## Installation

For set-up, installation, and Go-Live instructions, refer to [Adyen Docs](https://docs.adyen.com/plugins/salesforce-commerce-cloud/composable-storefront).
Available payment methods and features can be found on [Adyen Docs](https://docs.adyen.com/plugins/salesforce-commerce-cloud).

## Prerequisites

* [Adyen test account](https://www.adyen.com/signup)
* [API key](https://docs.adyen.com/development-resources/how-to-get-the-api-key)
* [Client key](https://docs.adyen.com/development-resources/client-side-authentication#get-your-client-key)

## Support

For other questions, contact our [support team](https://www.adyen.help).

## License

This repository is available under the [MIT license](LICENSE).
npm package: @saleae/dns-deploy
Description: standalone node module for dns deployment
Author: Oz Haven
Latest version: 1.1.0

# dns-deploy

standalone node module for dns deployment


```
dns [command]

Commands:
  dns sync  deploy dns json to cloudflare
  dns dump  dump the current dns json into a
            file

Options:
  --help     Show help               [boolean]
  --version  Show version number     [boolean]

```

```
dns sync

deploy dns json to cloudflare

Options:
  --help         Show help           [boolean]
  --version      Show version number [boolean]
  -f, --file     the json file to sync to the
                 dns server         [required]
  -e, --email    email for the dns management
                 account
  -d, --dry      dry run, no server changes
  -k, --key      global api key for the dns
                 management account
  -z, --zone     zone id for the dns
                 management account
  --verbose, -V               [default: false]

```

```
dns dump

dump the current dns json into a file

Options:
  --help         Show help           [boolean]
  --version      Show version number [boolean]
  -o, --output   location of output file
                                    [required]
  -e, --email    email for the dns management
                 account
  -k, --key      global api key for the dns
                 management account
  -z, --zone     zone id for the dns
                 management account
  --verbose, -V               [default: false]

```
npm package: @saleae/react-contexify
Description: Add contextmenu to your react component with ease
Author: Fadi Khadra
Latest version: 4.1.6

<img width="645" alt="screenshot 2018-10-31 at 13 32 57" src="https://user-images.githubusercontent.com/5574267/47815610-1806fa00-dd51-11e8-981b-2f680244ae29.png">

![Build Status](https://travis-ci.org/fkhadra/react-contexify.svg?branch=master) [![npm](https://img.shields.io/npm/dm/react-contexify.svg)]() [![npm](https://img.shields.io/npm/v/react-contexify.svg)]() [![license](https://img.shields.io/github/license/fkhadra/react-contexify.svg?maxAge=2592000)]() [![Coverage Status](https://coveralls.io/repos/github/fkhadra/react-contexify/badge.svg?branch=master)](https://coveralls.io/github/fkhadra/react-contexify?branch=master)

![readme-ctx](https://user-images.githubusercontent.com/5574267/29753912-43c54008-8b7b-11e7-9627-258fde1ffddd.gif)

## Documentation

Go [here](https://fkhadra.github.io/react-contexify). 

## Installation

Using yarn

```sh
$ yarn add react-contexify
```

Using npm

```sh
$ npm install --save react-contexify
```

## The gist

```js
import React from 'react';
import { Menu, Item, Separator, Submenu, MenuProvider } from 'react-contexify';
import 'react-contexify/dist/ReactContexify.min.css';

const onClick = ({ event, props }) => console.log(event,props);

// create your menu first
const MyAwesomeMenu = () => (
    <Menu id='menu_id'>
       <Item onClick={onClick}>Lorem</Item>
       <Item onClick={onClick}>Ipsum</Item>
       <Separator />
       <Item disabled>Dolor</Item>
       <Separator />
       <Submenu label="Foobar">
        <Item onClick={onClick}>Foo</Item>
        <Item onClick={onClick}>Bar</Item>
       </Submenu>
    </Menu>
);

const App = () => (
    <div>
        <MenuProvider id="menu_id" style={{ border: '1px solid purple', display: 'inline-block' }}>
            Right click me...
        </MenuProvider>
        <MyAwesomeMenu />
    </div>
);
```

## To-Do

- [ ] Allow keyboard navigation
- [ ] Accessibility
- [ ] RTL support
- [ ] Add release notes


## Browser Support

![IE](https://cloud.githubusercontent.com/assets/398893/3528325/20373e76-078e-11e4-8e3a-1cb86cf506f0.png) | ![Chrome](https://cloud.githubusercontent.com/assets/398893/3528328/23bc7bc4-078e-11e4-8752-ba2809bf5cce.png) | ![Firefox](https://cloud.githubusercontent.com/assets/398893/3528329/26283ab0-078e-11e4-84d4-db2cf1009953.png) | ![Opera](https://cloud.githubusercontent.com/assets/398893/3528330/27ec9fa8-078e-11e4-95cb-709fd11dac16.png) | ![Safari](https://cloud.githubusercontent.com/assets/398893/3528331/29df8618-078e-11e4-8e3e-ed8ac738693f.png) | ![Edge](https://raw.githubusercontent.com/alrra/browser-logos/master/src/edge/edge_48x48.png)
--- | --- | --- | --- | --- | --- |
IE 11+ ✔ | Latest ✔ | Latest ✔ | Latest ✔ | Latest ✔ | Latest ✔ |


## Contribute

Any idea and suggestions are welcome. There is a playground to help you start, just run `yarn start`.

## License

React Contexify is licensed under MIT.
npm package: @saleae/ref-array
Description: Create C "array" instances on top of Buffers
Author: Nathan Rajlich
Latest version: 2.0.1

# ref-array

### Create C typed "array" instances on top of Buffers

[![Build Status](https://secure.travis-ci.org/TooTallNate/ref-array.svg)](https://travis-ci.org/TooTallNate/ref-array)
[![Build Status](https://ci.appveyor.com/api/projects/status/auxk791h56hbughd?svg=true)](https://ci.appveyor.com/project/TooTallNate/ref-array)

This module offers an "array" implementation on top of Node.js Buffers using
the ref "type" interface.

Note: Forked from https://github.com/lxe/ref-array#node-12 to support Electron Node 12

## Installation

Install with `npm`:

```bash
$ npm install ref-array
```

## Examples

#### Basic usage

```js
var ref = require("ref");
var ArrayType = require("ref-array");

// typedef
var int = ref.types.int;

// define the "int[]" type
var IntArray = ArrayType(int);

// now we can create array instances; the constructor takes the same arguments
// the native JS Array class

var a = new IntArray(5); // by length
a.length; // 5
a[0] = 0;
a[1] = 1;
a[2] = -1;
a[3] = 2;
a[4] = -2;

var b = new IntArray([1, 2, 3, 4, 5]); // with an existing Array
b.length; // 5
b[0]; // 1
b[1]; // 2
b[2]; // 3
b[3]; // 4
b[4]; // 5
```

#### Reading a `NULL`-terminated Array

```js
// sometimes you get a variable length array that is terminated by a NULL byte.
var buf = new Buffer(int.size * 3);
int.set(buf, int.size * 0, 5);
int.set(buf, int.size * 1, 8);
int.set(buf, int.size * 2, 0); // <- terminate with 0s

// you can create an array instance with the length automatically determined
var array = IntArray.untilZeros(buf);
console.log(array.length);
// 2
console.log(array);
// [ 5, 8 ]
```

#### With `node-ffi`

```js
var ffi = require("ffi");

// the "int[]" type may be used as a "type" in FFI'd functions or callbacks
var func = ffi.ForeignFunction(funcPointer, int, [IntArray, int]);

var arg = new IntArray(3);
arg[0] = 1234;
arg[1] = -9999;
arg[2] = 1;

var rtn = func(arg, arg.length);
```

## License

(The MIT License)

Copyright (c) 2012 Nathan Rajlich &lt;nathan@tootallnate.net&gt;

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: @salecycle/aws-api-gateway-fetch
Description: provides easy authed access to aws apigateway from node
Author: Salecycle Assets Team
Latest version: 1.0.4

# aws-api-gateway-fetch
An npm library wraps the signature generation parts of calling an aws api gateway, allowing us to treat it like any other fetch.

## Usage
```
const gateWayFetch = require('@salecycle/aws-api-gateway-fetch');
const result = await gateWayFetch.apiGatewayFetch(
  'http://targeturl,
    {
      accessKeyId: 'AWS_ACCESS_KEY_ID,
      region: 'AWS_REGION',
      secretAccessKey: 'AWS_SECRET_ACCESS_KEY',
      sessionToken: 'OPTIONAL_SECURITY_TOKEN_NEEDED_IF_A_TEMPORARY_KEY'
    }
);
```

apart from the call to the inital method everything else will work like a normal fetch

## Development

### built with
* nodejs
* typescript

### non local requirements
* yarn - `brew install yarn`

### running locally
* `yarn` - install packages
* `yarn build` build the js outputs from the typescript inputs
* `yarn link` It's a library so you will need to link it to something that uses it, but you need to link the js version, not the typescript version
npm package: @salecycle/fastify-typescript-request-schema
Description: Automatically generated typescript types from json response/request schemas written for [fastify](https://www.fastify.io/)
Author: Salecycle Assets Team
Latest version: 3.2.2

# fastify-typescript-request-schema

Automatically generated typescript types from json response/request schemas written for [fastify](https://www.fastify.io/)

## Installation

```
npm install --save @salecycle/fastify-typescript-request-schema
```

## Usage

The package currently takes one command, which is a glob that locates the schema files to be transformed.

This package acts as a command, as such it's easiest just to add the call to the `scripts` section of your package json.

So, given that all my fastify json schema files are called `schema.json` I can add the following to the `scripts` section of my `package.json` to allow me to generate the typescript files:

`"generateTypes": "fastify-typescript-request-schema \"src/**/schema.json\""`

then running `npm run generateTypes` will result in `schema.ts` files being created in the same directory as the associated `schema.json` file.
npm package: @salecycle/koa2-joi-validator
Description: koa2 joi validation middleware
Author: Salecycle assets team
Latest version: 1.0.2

# koa2-joi-validator
joi validation middleware for koa2

Owned by the the [assets team](https://salecycle.slack.com/messages/G870U5JBV)

[Koa](koajs.com) middlevare for request validation using [Joi](https://github.com/hapijs/joi).

Contains full typescript definitions

## Installation

```
npm install --save @salecycle/koa2-joi-validator
```

## Usage
```javascript
const validate = require('@salecycle/koa2-joi-validator');

const schema = {
  headers: joi.object().keys({
    'my-custom-header': joi.string().required(),
  }),
  body: joi.object().keys({
    email: joi
      .string()
      .email()
      .required(),
    password: joi
      .string()
      .required(),
  }),
};

route.post('/login', validate(schema), async ctx => {...})
```