open-index/open-npm huggingface dataset:
npm package: @fsd24229/shuffle-array
Description: A small library that takes an array as input and returns a new array that is shuffled.
Author: your name
Latest version: 0.1.0

# @fsd24229/shuffle-array (Class 2 Example)

> A small library that takes an array as input and returns a new array that is shuffled.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
   - [Examples](#examples)
- [Contribution](#contribution)
- [Security](#security)
- [License](#license)

## Installation

Install via npm:

```bash
npm install @fsd24229/shuffle-array
```
Install via yarn:

```bash
yarn add @fsd24229/shuffle-array
```

## Usage

Basic Usage

```js
import shuffleArray from '@fsd24229/shuffle-array';

const startArray = [1, 2, 3, 4, 5];
const newShuffledArray = shuffleArray(startArray);

console.log(startArray);       // e.g., [1, 2, 3, 4, 5]
console.log(newShuffledArray); // e.g., [3, 1, 5, 2, 4]
```

### Examples

Shuffle a list of user IDs:

```js
import shuffleArray from '@fsd24229/shuffle-array';

const userIds = ['u1', 'u2', 'u3', 'u4'];
const randomizedOrderOfUserIds = shuffleArray(userIds);

console.log(randomizedOrderOfUserIds); // e.g., ['u1', 'u3', 'u4', 'u2']
```

Use in a game for randomizing cards:

```js
import shuffleArray from '@fsd24229/shuffle-array';

const deck = ['Ace of Spades', 'Two of Hearts']; // some card deck
const shuffledDeck = shuffleArray(deck);

console.log(shuffledDeck); // e.g., ['Two of Hearts', 'Ace of Spades', ...]
```

## Contribution

Contributions are welcome! Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more details.

## Security

Please refer to our [SECURITY.md](./SECURITY.md) for information about our security policies, how to report vulnerabilities, and our approach to handling security concerns.

**Important Note**: This library uses non-cryptographic randomness (`Math.random()`). Do not rely on it for security-critical functionality.

## License

This project is licensed under the [MIT License](./LICENSE.md).
npm package: @fsd24229/string-toolkit
Description: a small little library providing useful string manipulation functions
Author: Felix Dilly
Latest version: 1.1.1

# @fsd24229/string-toolkit

## Table of Contents

- [@fsd24229/string-toolkit](#fsd24229string-toolkit)
  - [Table of Contents](#table-of-contents)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Examples](#examples)
  - [Contribution](#contribution)
  - [Security](#security)
  - [License](#license)

## Installation

Install via npm:

```bash
npm install @fsd24229/string-toolkit
```

Install via yarn:

```bash
yarn add @fsd24229/string-toolkit
```

## Usage

Basic Usage

```js
import {toSnakeCase, toKebabCase} from '@fsd24229/string-toolkit';

const testString = 'Hello World';
let snakeCase = toSnakeCase(testString);
let kebabCase = toKebabCase(testString);

console.log(snakeCase);
console.log(kebabCase);
```

## Examples

## Contribution

Contribution are welcome! Please refer to [CONTRIBUTING.md](./CONTRIBUTING.md) for more details.

## Security

Please refer to our [SECURITY.md](./SECURITY.md) for information about security policies, how to report vulnerabilities and our approach to handling concerns.

## License

This project is licensed under the [MIT License](./LICENSE.md).
npm package: @fsdevninja/ninja-bridge
Description: Bridge your AI agents to Ninja Agents dashboard
Author: FsDevNinja
Latest version: 0.4.0

# @ninjaagents/bridge

Bridge your AI agents to the Ninja Agents dashboard for real-time monitoring.

## Installation

```bash
npm install -g @ninjaagents/bridge
```

## Quick Start

1. **Configure the bridge:**
   ```bash
   ninja-bridge config
   ```
   
2. **Start the bridge:**
   ```bash
   ninja-bridge start
   ```

## Commands

### `ninja-bridge start`

Start the bridge to forward events from Clawdbot to Ninja Agents.

```bash
# Use saved config
ninja-bridge start

# Override with CLI options
ninja-bridge start --api-key sk_xxx --ninja ws://localhost:8787/agent

# Use environment variables
API_KEY=sk_xxx ninja-bridge start
```

Options:
- `-c, --clawdbot <url>` - Clawdbot gateway URL (default: `ws://127.0.0.1:18789`)
- `-n, --ninja <url>` - Ninja Agents gateway URL (default: `ws://localhost:8787/agent`)
- `-k, --api-key <key>` - Ninja Agents API key
- `-a, --agent-id <id>` - Agent ID

### `ninja-bridge config`

Interactive configuration wizard. Saves to `~/.ninja-agents/bridge.json`.

```bash
ninja-bridge config
```

### `ninja-bridge status`

Show current configuration and environment variables.

```bash
ninja-bridge status
```

## Environment Variables

| Variable | Description |
|----------|-------------|
| `CLAWDBOT_GATEWAY` | Clawdbot gateway WebSocket URL |
| `CLAWDBOT_GATEWAY_TOKEN` | Clawdbot authentication token |
| `NINJAAGENTS_GATEWAY` | Ninja Agents gateway WebSocket URL |
| `API_KEY` | Ninja Agents API key |
| `AGENT_ID` | Agent identifier |

## Programmatic Usage

```typescript
import { NinjaAgentsBridge } from "@ninjaagents/bridge";

const bridge = new NinjaAgentsBridge({
  clawdbotGateway: "ws://127.0.0.1:18789",
  ninjaAgentsGateway: "ws://localhost:8787/agent",
  apiKey: "sk_xxx",
  agentId: "my_agent",
}, {
  onConnect: () => console.log("Connected!"),
  onEvent: (event) => console.log("Event:", event.type),
});

await bridge.start();
```

## License

MIT
npm package: @fsdk/element-angular
Description: element ui for angular
Latest version: 0.9.1


<div align="center">
  <img src="https://camo.githubusercontent.com/462f24153b8e8739c8ea71f7102585c4cb0e1575/68747470733a2f2f63646e2e7261776769742e636f6d2f456c656d6546452f656c656d656e742f6465762f656c656d656e745f6c6f676f2e737667" width="250" height="100" align="center">
  <img src="https://angular.io/assets/images/logos/angular/angular.svg" width="90" height="90" align="center">
</div>

<h2 align="center">Element for Angular</h2>

This project is intended to bring Element UI Kit (https://element.eleme.io/#/en-US) to the angular world.

The project was initally forked from https://github.com/ElemeFE/element-angular in order to update dependencies so that it can be used along with Angular 9+.

It is now built and packaged with angular cli (v9) toolset and will hopefully be further updated to the current Angular version.

## Getting Started

1. Install:
```bash
# install
npm i --save @fsdk/element-angular
```
2. Usage:
```typescript
// import module
import { ElModule } from '@fsdk/element-angular'
```

```scss
// import styles directly (/src/styles.css)
@import "~@fsdk/element-angular/theme/index.css"
```

```json
// or via anglar-cli configuration (/angular.json):
{
  "app": [{
    "styles": [
      "../node_modules/element-angular/theme/index.css"
    ],
    // other configurations...
  }]
}

```

## Customization

Since components utilize Element-UI styling which reside in the global scope the other option might be to configure styles via https://element.eleme.io/#/en-US/theme/preview, download custom theme and set it up. 
This approach is straightforward and should work, however not tested yet. 

Default theme which @fsdk/element-angular package is build around comes from element-ui@2.0.7 package
npm package: @fsdk/face-api-node
Description: JavaScript API for face detection and face recognition with tensorflow.js
Author: Dmitry Kashinsky
Latest version: 0.22.3

# face-api-node

Face Detection and Recognition API for Node

## Note

This is a fork of the **face-api.js** (**0.22.2**) intended to only work in Node.js environment without monkey patching and any other dependencies but **@tensorflow/tfjs-node**. Tensorflow itself is a peer dependency and should be installed separately.

For documentation please refer to the [original project](https://www.npmjs.com/package/face-api.js/v/0.22.2). Also, bear in mind that drawing capabilities present in the original project are not included.

## Credits

- Original project: [face-api.js](https://github.com/justadudewhohacks/face-api.js)
- TensorflowJS: [Tensorflow/JS](https://js.tensorflow.org/api/latest/)
npm package: @fsdk/tree-utils
Description: Utilities for tree-like structures
Author: Dmitry Kashinsky
Latest version: 0.0.1

# Tree Utilities
A set of utility functions frequently used while working with tree-like structures

# API

## Tree Generator

Thare are 2 tree generation utility functions here:

 - `generateTree` - Helper function. Provided with options, it returns flat array of tree items. Works on top of the generator.
 - `treeGenerator` - Generator function. Provided with options, allows to generate random tree, yielding each tree item.

Usage Example:

`itemCreator` - Both `generateTree` and `treeGenerator` rely on creator function used to generate particular tree item.
```ts
import { defaultItemCreatorFactory, TreeItemMeta } from '@fsdk/tree-utils';
import { nanoid } from 'nanoid'

type FlatTreeItem = {
  id: string;
  parentId?: string;
  name: string;
  depth: number;
}

const flatItemCreator = (parent: FlatTreeItem | undefined, meta: TreeItemMeta) => ({
  id: nanoid(),
  parentId: parent?.id,
  name: `Item ${id}`,
  depth: meta.level,
});

type NestedTreeItem = {
  id: string;
  children: NestedTreeItem[];
}

const nestedItemCreator = (parent: NestedTreeItem | undefined, meta: TreeItemMeta) => {
  const item: NestedTreeItem = {
    id: nanoid(),
    children: [],
  };

  parent?.children.push(item);

  return item;
};

// alternatively you can use built-in item creator factory to produce `flatItemCreator` above
const itemCreator = defaultItemCreatorFactory();
```

`generateTree`:
```ts
import { generateTree } from '@fsdk/tree-utils';

const treeItems = generateTree({
  itemCreator,     // Required. Provides function used to create tree item object
  maxDepth: 5,     // Optional. Provides maximum depth of the randomly generated tree. Defults to 10
  minSiblings: 2,  // Optional. Provides minimum nested items count used by randomzier. Defaults to 3
  maxSiblings: 15, // Optional. Provides maximum nested items count used by randomizer. Defaults to 7
  maxItems: 1000,  // Optional. Limits total items generated in case generation exceeds specified distribution. Defaults to 1000
});

// if you use nested tree object structure it is handy to get `root` as all other items are accessible via children property
const [root] = generateTree({
  itemCreator: nestedItemCreator,
});
```

`treeGenerator`:
```ts
import { treeGenerator } from '@fsdk/tree-utils';

const generator = treeGenerator({
  itemCreator,    // Required. Provides function used to create tree item object
  maxDepth: 10,   // Required. Provides maximum depth of the randomly generated tree.
  minSiblings: 3, // Required. Provides minimum nested items count used by randomzier.
  maxSiblings: 7, // Required. Provides maximum nested items count used by randomizer.
});

// Start generate items by calling `next`
const treeItem = generator.next().value;
```
npm package: @fsdkjs/fsdk-js
Description: Client for fsdk Commerce Rest API
Author: flipshop
Latest version: 1.0.3

# fsdk JS Client

[![Version](https://img.shields.io/npm/v/stripe.svg)](https://www.npmjs.org/package/@fsdkjs/fsdk-js)

The fsdk JS Client provides easy access to the fsdk API from a client written in Typescript.

## Documentation

You can learn more about this client and how to use it [our documentation](https://docs.fsdkjs.com/js-client/overview).

To learn more about the API endpoints that this client allows you to access check out our [API reference](https://docs.fsdkjs.com/api/store).

## Installation

Install the package with:

```sh
npm install @fsdkjs/fsdk-js
# or
yarn add @fsdkjs/fsdk-js
```

## Usage

Import fsdk as a default import and initiate it:

```js
import fsdk from "@fsdkjs/fsdk-js"

const fsdk = new fsdk()

const { cart } = await fsdk.carts.create({})
```

### Authentication

Authentication can be achieved in two ways using the `fsdk-js` client, either by utilizing API keys or by using cookie based authentication, each with their own unique use case.

#### **Using API keys**

API keys can only be used for admin functionality in fsdk because only users of the admin system have api keys. To use API keys for authentication the key should be used when `fsdk-js` is initialized with a config object as described below.

#### **Using cookies**

Authentication using cookies is done automatically by Axios when authenticating using the `auth` endpoints. After authentication all subsequent calls will be authenticated.

_note: Cookie based authentication cannot be used in plain `node.js` applications due to the limitations of axios and `useCredentials` not setting the `Cookie` request header when `set-cookie` is present in the response headers. For pure `node.js` applications use authentication with api keys(see above)_

## Configuration

### Initialize with config object

The package can be initialized with several options:

```js
const fsdk = new fsdk({
  maxRetries: 3,
  baseUrl: "https://api.example.com",
})
```

| Option       | Default                   | Description                                               |
| ------------ | ------------------------- | --------------------------------------------------------- |
| `maxRetries` | `0`                       | The amount of times a request is retried.                 |
| `baseUrl`    | `'http://localhost:9000'` | The url to which requests are made to.                    |
| `apiKey`     | `''`                      | Optional api key used for authenticating admin requests . |
npm package: @fseehawer/requestidlecallback
Description: This requestIdleCallback polyfill doesn't use the window object to detect if the feature is supported in the browser and falls back to a simple timeout if the feature isn't supported.
Author: Fidel Seehawer
Latest version: 1.1.0

# requestIdleCallback polyfill

![](https://img.shields.io/badge/version-1.1.0-green.svg) ![](https://img.shields.io/badge/license-MIT-blue.svg)

This requestIdleCallback polyfill doesn't use the window object to detect if the feature is supported in the browser and falls back to a simple timeout if the feature isn't supported.

## install

```
npm install @fseehawer/requestidlecallback
```

## example

```javascript
import requestIdleCallback from '@fseehawer/requestidlecallback'

requestIdleCallback(() => {
  // your non-splittable task
})
```

for splittable task you can use the yielding technique:

```javascript
requestIdleCallback((deadline) => {
  while ((deadline.timeRemaining() > 0) || deadline.didTimeout) {
    // your splittable tasks
  }
})
```

## Using the Promise-based API

```javascript
import requestIdleCallback from '@fseehawer/requestidlecallback';

requestIdleCallback.promise({ timeout: 100 }).then((deadline) => {
// Use the idle deadline to perform tasks
});
```

## for cancelling?

```javascript
import requestIdleCallback, { cancelIdleCallback } from '@fseehawer/requestidlecallback'

// your code
const id = requestIdleCallback(doSomething)

// then if you need to cancel
cancelIdleCallback(id)
```

## license

[MIT License](https://opensource.org/licenses/MIT)