open-index/open-npm huggingface dataset:
npm package: @rushstack/stream-collator
Description: Display intelligible realtime output from concurrent processes
Latest version: 4.2.12

## @rushstack/stream-collator

This library enables a tool to display live console output from multiple concurrent processes,
while ensuring that their output does not get jumbled together.

## How does it work?

The **stream-collator** manages the output of these streams, ensuring that no two streams are writing to the console
at the same time. At any given time, one stream registered with the collator is the **active stream**, which means
that particular stream will be live streaming, while the others will wait for that stream to finish before their
output is displayed.

For example, if you have 3 streams (e.g. from using `child_process.spawn()`).

Stream A will write: `AAAAA`

Stream B will write: `BBBBBBBBBBBBBBBBBBBB`

Stream C will write: `CCCCCCCCCC`

If these streams are all being piped directly to stdout (without `@rushstack/stream-collator`), you could end up
with jumbled output:

`ABACCCBCCCCBBABBCBBABBBBBBCCAB`

Something like the following would be much more useful to users of your application:

`AAAAABBBBBBBBBBBBBBBCCCCCCCCCC`

This is where the `@rushstack/stream-collator` comes in!

## The active stream

At any given time, a single stream is designated as the **active stream**. The output of the active stream will always be
live-streamed. This is particularly useful for long-running streams. When the active stream finishes, a new stream
is selected as the active stream and all of its contents up to that point will be emitted. Whenever an active stream finishes,
all background streams which have been completed will be emitted.

## Usage

> 🚨 _This is an early preview release. Please report issues!_ 🚨
>
> WITH VERSION 4.X, THIS PACKAGE HAS BEEN REDESIGNED TO USE THE NEW
> [@rushstack/terminal](https://www.npmjs.com/package/@rushstack/terminal) SYSTEM.
> IN THE NEXT RELEASE, THE `CollatedTerminal` API WILL BE REPLACED WITH
> THE `Terminal` API.
>
> The usage instructions will be updated once that refactoring is complete.

## Links

- [CHANGELOG.md](
  https://github.com/microsoft/rushstack/blob/main/libraries/stream-collator/CHANGELOG.md) - Find
  out what's new in the latest version
- [API Reference](https://api.rushstack.io/pages/stream-collator/)

`@rushstack/stream-collator` is part of the [Rush Stack](https://rushstack.io/) family of projects.
npm package: @rushstack/terminal
Description: User interface primitives for console applications
Latest version: 0.22.5

# @rushstack/terminal

This library implements a system for processing human readable text that
will be output by console applications.

The design is based loosely on the `WritableStream` and `TransformStream` classes from
the system [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Concepts),
except that instead of asynchronous byte streams, the `TerminalWritable` system synchronously transmits
human readable messages intended to be rendered on a text console or log file.

Consider a console application whose output may need to be processed in different ways
before finally being output. The conceptual block diagram might look like this:

```
         [Terminal API]
                |
                V
       [normalize newlines]
                |
                V
      +----[splitter]-------+
      |                     |
      V                     V
  [shell console]     [remove ANSI colors]
                            |
                            V
                      [write to build.log]
```

The application uses the `Terminal` API to print `stdout` and `stderr` messages, for example with standardized
formatting for errors and warnings, and ANSI escapes to make nice colors. Maybe it also includes text
received from external processes, whose newlines may be inconsistent. Ultimately we want to write the
output to the shell console and a `build.log` file, but we don't want to put ANSI colors in the build log.

For the above example, `[shell console]` and `[write to build.log]` would be modeled as subclasses of
`TerminalWritable`. The `[normalize newlines]` and `[remove ANSI colors]` steps are modeled as subclasses
of `TerminalTransform`, because they output to a "destination" object. The `[splitter]` would be
implemented using `SplitterTransform`.

The stream of messages are {@link ITerminalChunk} objects, which can represent both `stdout` and `stderr`
channels. The pipeline operates synchronously on each chunk, but by processing one chunk at a time,
it avoids storing the entire output in memory. This means that operations like `[remove ANSI colors]`
cannot be simple regular expressions -- they must be implemented as state machines (`TextRewriter` subclasses)
capable of matching substrings that span multiple chunks.

## Links

- [CHANGELOG.md](
  https://github.com/microsoft/rushstack/blob/main/libraries/terminal/CHANGELOG.md) - Find
  out what's new in the latest version
- [API Reference](https://api.rushstack.io/pages/terminal/)

`@rushstack/terminal` is part of the [Rush Stack](https://rushstack.io/) family of projects.
npm package: @rushstack/webpack-plugin-utilities
Description: This plugin sets the webpack public path at runtime.
Latest version: 0.6.13

# webpack-plugin-utilities

## Installation

`npm install @rushstack/webpack-plugin-utilities --save`

## Overview

This is a collection of utilities for writing webpack plugins

# Usage

## VersionDetection

```JavaScript
import { VersionDetection } from "@rushstack/webpack-plugin-utilities"

class MyExampleWebpackPlugin {
  constructor() {
    this.pluginName = "MyExampleWebpackPlugin"
  }

  apply(compiler) {
    if (VersionDetection.isWebpack3OrEarlier(compiler)) {
      throw new Error(`This plugin does not support webpack 3 or below.`)
    }

    const isWebpack4 = VersionDetection.isWebpack4(compiler);

    if (isWebpack4) {
      compiler.hooks.compilation.tap(this.pluginName, (compilation) => {
        // ....
      });
    } else {
      compiler.hooks.compilation.tap(this.pluginName, (compilation) => {
        // ...
      });
    }
  }
}
```

## Testing

### `getTestingWebpackCompiler`

```typescript

import { getTestingWebpackCompiler } from "@rushstack/webpack-plugin-utilities"

describe("MyPlugin", () => {
  it("should run", async () => {
    const stats = await getTestingWebpackCompiler("./src/index.ts");

    expect(stats).toBeDefined();
  });
});
```

### `getTestingWebpackCompiler` with additional configuration

If you want to pass in additional configuration to the webpack compiler, you can pass it in as the second parameter to `getTestingWebpackCompiler`.

```typescript
import { getTestingWebpackCompiler } from "@rushstack/webpack-plugin-utilities"

describe("MyPlugin", () => {
  it("should run", async () => {
    const stats = await getTestingWebpackCompiler("./src/index.ts", {
      mode: "production",
    });

    expect(stats).toBeDefined();
  });
});
```

### `getTestingWebpackCompiler` with virtual filesystem

If you want to be able to read, analyze, access the files written to the memory filesystem,
you can pass in a memory filesystem instance to the `memFs` parameter.

```typescript
import { getTestingWebpackCompiler } from "@rushstack/webpack-plugin-utilities"
import { createFsFromVolume, Volume, IFs } from "memfs"
import path from "path"

describe("MyPlugin", () => {
  it("should run", async () => {
    const virtualFileSystem: IFs = createFsFromVolume(new Volume());
    const stats = await getTestingWebpackCompiler(
      `./src/index.ts`,
      {},
      virtualFileSystem
    );

    expect(stats).toBeDefined();
    expect(virtualFileSystem.existsSync(path.join(__dirname, "dist", "index.js"))).toBe(true);
  });
});
```

## Links

- [CHANGELOG.md](
  https://github.com/microsoft/rushstack/blob/main/webpack/webpack-plugin-utilities/CHANGELOG.md) - Find
  out what's new in the latest version

`@rushstack/webpack-plugin-utilities` is part of the [Rush Stack](https://rushstack.io/) family of projects.
npm package: @rushstack/webpack-preserve-dynamic-require-plugin
Description: This plugin tells webpack to leave dynamic calls to "require" as-is instead of trying to bundle them.
Latest version: 0.12.13

# @rushstack/webpack-preserve-dynamic-require-plugin

## Overview

This Webpack plugin instructs webpack to leave dynamic usage of `require` as-is in the bundled code. For example, if your code contains:
```js
function requireSomeUserThing(path) {
  return require(path);
}
```
The emitted bundle will preserve the call to `require(path)` instead of trying to process it.
npm package: @rushstack/webpack-workspace-resolve-plugin
Description: This plugin leverages workspace-level metadata to greatly accelerate module resolution.
Latest version: 0.6.12

# @rushstack/webpack-workspace-resolve-plugin

This package contains a plugin for webpack 5 that leverages a cache file generated from package manager metadata to greatly accelerate module resolution.
Local benchmarks have shown a savings of around 10% of build time for some fairly large closed source projects.

## Installation

`npm install @rushstack/webpack-workspace-resolve-plugin --save-dev`

## Overview

This plugin is intended primarily for use in pnpm monorepos, but any tool that produces a strict package layout can be made compatible by generating the necessary cache file.

The cache file contains information about the locations of every `package.json` file known to the package manager (including those in subdirectories of packages), as well as the list of declared dependencies of each and where they can be found.

When using this plugin, the following options should be configured for your resolver:
- `symlinks: false` - Since the cache knows the symlinks for package dependencies, you can avoid the cost of testing for other symlinks unless you are using additional symlinks.
- `modules: []` - The cache should contain all information necessary to locate available dependencies for any arbitrary folder. If you need to allow resolution in other roots, you can add those, but omit `'node_modules'`.

## Impact

This plugin should eliminate file system calls associated with the following operations of NodeJS module resolution in webpack:
- Find the nearest `package.json` to the calling module
- Locate a named package from a calling module
- Identify a `package.json` in a resolved directory
- Find the nearest `package.json` to a resolved file path

## Limitations

This plugin depends on the presence of a cache file in the workspace to function. Data in this cache file is assumed not to change while the webpack process is running.

**Note:** Generating the cache file is not in the scope of this plugin.

This plugin does not currently support having subdirectory `package.json` files within workspace projects (e.g. for declaring `{ "type": "module" }` in mixed CommonJS/ESM packages).
This plugin does not work (well) with a hoisted node_modules installation layout.

## Links

- [CHANGELOG.md](
  https://github.com/microsoft/rushstack/blob/main/webpack/webpack-workspace-resolve-plugin/CHANGELOG.md) - Find
  out what's new in the latest version

`@rushstack/webpack5-workspace-resolve-plugin` is part of the [Rush Stack](https://rushstack.io/) family of projects.
npm package: @rushstack/webpack4-module-minifier-plugin
Description: This plugin splits minification of webpack compilations into smaller units.
Latest version: 0.15.14

# @rushstack/webpack4-module-minifier-plugin

## Installation

`npm install @rushstack/webpack4-module-minifier-plugin --save-dev`

## Overview

This Webpack plugin performs minification of production assets on a per-module basis, rather than minifying an entire chunk at a time.
It issues async calls to the minifier for each unique module and each unique set of chunk boilerplate (i.e. the webpack runtime and the structure of the module list).
This improves minification time by:
- Avoiding duplicate work for each module that is included in multiple distinct assets/chunks (this is common with async chunks)
- Handing smaller code chunks to the minifier at a time (AST analysis is superlinear in size of the AST)
- Even single asset builds will likely still contain multiple modules in the final output, which can be split across available CPU cores

## Use with `[hash]` and `[contenthash]` tokens
The plugin will do its best to update webpack hashes if changing the direct inputs (`useSourceMap`, `compressAsyncImports` or `usePortableModules`) to the plugin, but if altering the `minifier` property itself, you may need to use the `output.hashSalt` property to force a change to the hashes, especially if leverging the `MessagePortMinifier` or similar, since it has no direct access to the configuration of the minifier.

## Parallel execution
If running on node 10, you will need to ensure that the `--experimental-workers` flag is enabled.

```js
const { ModuleMinifierPlugin, WorkerPoolMinifier } = require('@rushstack/webpack4-module-minifier-plugin');

// In your webpack options:
optimization: {
  minimizer: [
    new ModuleMinifierPlugin({
      minifier: new WorkerPoolMinifier(),
      // If not provided, the plugin will attempt to guess from `mode` and `devtool`.
      // Providing it expressly gives better results
      useSourceMap: true
    })
  ]
}
```

## Single-threaded execution
You can also run the ModuleMinifierPlugin in a single-threaded configuration.

```js
// webpack.config.js
const { ModuleMinifierPlugin, LocalMinifier } = require('@rushstack/webpack4-module-minifier-plugin');

// In your webpack options:
optimization: {
  minimizer: [
    new ModuleMinifierPlugin({
      minifier: new LocalMinifier()
    })
  ]
}
```

## Links

- [CHANGELOG.md](
  https://github.com/microsoft/rushstack/blob/main/webpack/module-minifier-plugin/CHANGELOG.md) - Find
  out what's new in the latest version

`@rushstack/webpack4-module-minifier-plugin` is part of the [Rush Stack](https://rushstack.io/) family of projects.
npm package: @rushstack/webpack5-module-minifier-plugin
Description: This plugin splits minification of webpack compilations into smaller units.
Latest version: 5.8.14

# @rushstack/webpack5-module-minifier-plugin

This package contains a plugin for webpack 5 that performs minification on a per-module basis rather than per-asset to deduplicate and parallelize compression work.

## Installation

`npm install @rushstack/webpack5-module-minifier-plugin --save-dev`

## Overview

This Webpack plugin performs minification of production assets on a per-module basis, rather than minifying an entire chunk at a time.
It issues async calls to the minifier for each unique module and each unique set of chunk boilerplate (i.e. the webpack runtime and the structure of the module list).
This improves minification time by:
- Avoiding duplicate work for each module that is included in multiple distinct assets/chunks (this is common with async chunks)
- Handing smaller code chunks to the minifier at a time (AST analysis is superlinear in size of the AST)
- Even single asset builds will likely still contain multiple modules in the final output, which can be split across available CPU cores

## Use with `[hash]` and `[contenthash]` tokens
The plugin will do its best to update webpack hashes if changing the direct inputs (`useSourceMap`) to the plugin, but if altering the `minifier` property itself, you may need to use the `output.hashSalt` property to force a change to the hashes, especially if leveraging the `MessagePortMinifier` or similar, since it has no direct access to the configuration of the minifier.

## Parallel execution

```js
const { ModuleMinifierPlugin } = require('@rushstack/webpack5-module-minifier-plugin');
const { WorkerPoolMinifier } = require('@rushstack/module-minifier');

// In your webpack options:
optimization: {
  minimizer: [
    new ModuleMinifierPlugin({
      minifier: new WorkerPoolMinifier(),
      // If not provided, the plugin will attempt to guess from `mode` and `devtool`.
      // Providing it expressly gives better results
      useSourceMap: true
    })
  ]
}
```

## Single-threaded execution
You can also run the ModuleMinifierPlugin in a single-threaded configuration.

```js
// webpack.config.js
const { ModuleMinifierPlugin } = require('@rushstack/webpack5-module-minifier-plugin');
const { LocalMinifier } = require('@rushstack/module-minifier');

// In your webpack options:
optimization: {
  minimizer: [
    new ModuleMinifierPlugin({
      minifier: new LocalMinifier()
    })
  ]
}
```

## Links

- [CHANGELOG.md](
  https://github.com/microsoft/rushstack/blob/main/webpack/webpack5-module-minifier-plugin/CHANGELOG.md) - Find
  out what's new in the latest version

`@rushstack/webpack5-module-minifier-plugin` is part of the [Rush Stack](https://rushstack.io/) family of projects.
npm package: @rushstack/worker-pool
Description: Lightweight worker pool using NodeJS worker_threads
Latest version: 0.7.12

# @rushstack/worker-pool

This library contains a lightweight worker pool using the NodeJS worker_threads API.

## Links

- [CHANGELOG.md](
  https://github.com/microsoft/rushstack/blob/main/libraries/worker-pool/CHANGELOG.md) - Find
  out what's new in the latest version
- [API Reference](https://api.rushstack.io/pages/worker-pool/)

`@rushstack/worker-pool` is part of the [Rush Stack](https://rushstack.io/) family of projects.
npm package: @rushstack/zipsync
Description: CLI tool for creating and extracting ZIP archives with intelligent filesystem synchronization
Latest version: 0.3.12

# @rushstack/zipsync

zipsync is a focused tool for packing and unpacking build cache entries using a constrained subset of the ZIP format for high performance. It optimizes the common scenario where most files already exist in the target location and are unchanged.

## Goals & Rationale

- **Optimize partial unpack**: Most builds reuse the majority of previously produced outputs. Skipping rewrites preserves filesystem and page cache state.
- **Only write when needed**: Fewer syscalls.
- **Integrated cleanup**: Removes the need for a separate `rm -rf` pass; extra files and empty directories are pruned automatically.
- **ZIP subset**: Compatibility with malware scanners.
- **Fast inspection**: The central directory can be enumerated without inflating the entire archive (unlike tar+gzip).

## How It Works

### Pack Flow

```
for each file F
  write LocalFileHeader(F)
  stream chunks:
    read -> hash + crc + maybe compress -> write
  finalize compressor
  write DataDescriptor(F)
add metadata entry (same pattern)
write central directory records
```

### Unpack Flow

```
load archive -> parse central dir -> read metadata
scan filesystem & delete extraneous entries
for each entry (except metadata):
  if unchanged (sha1 matches) => skip
  else extract (decompress if needed)
```

## Why ZIP (vs tar + gzip)

Pros for this scenario:

- Central directory enables cheap listing without decompressing entire payload.
- Widely understood / tooling-friendly (system explorers, scanners, CI tooling).
- Per-file compression keeps selective unpack simple (no need to inflate all bytes).

Trade-offs:

- Tar+gzip can exploit cross-file redundancy for better compressed size in datasets with many similar files.
npm package: @rushvora/claudia-local-api
Description: Command line utility to launch Express local API for claudia-api-builder. Test drive your lambda functions before deployment
Author: Rushabh Vora
Latest version: 1.1.1

# claudia-local-api

[![CircleCI](https://img.shields.io/circleci/project/suddi/claudia-local-api/master.svg)](https://circleci.com/gh/suddi/claudia-local-api)
[![codecov](https://codecov.io/gh/suddi/claudia-local-api/branch/master/graph/badge.svg)](https://codecov.io/gh/suddi/claudia-local-api)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/4aaafdcb86574c709f856f2e00d3a809)](https://www.codacy.com/app/Suddi/claudia-local-api)
[![npm](https://img.shields.io/npm/v/claudia-local-api.svg)](https://www.npmjs.com/package/claudia-local-api)
[![npm](https://img.shields.io/npm/dt/claudia-local-api.svg)](https://www.npmjs.com/package/claudia-local-api)
[![Greenkeeper badge](https://badges.greenkeeper.io/suddi/claudia-local-api.svg)](https://greenkeeper.io/)
[![David](https://img.shields.io/david/suddi/claudia-local-api.svg)](https://david-dm.org/suddi/claudia-local-api)
[![David](https://img.shields.io/david/dev/suddi/claudia-local-api.svg)](https://david-dm.org/suddi/claudia-local-api?type=dev)
[![license](https://img.shields.io/github/license/suddi/claudia-local-api.svg)](https://github.com/suddi/claudia-local-api/blob/master/LICENSE)

[![codecov](https://codecov.io/gh/suddi/claudia-local-api/branch/master/graphs/commits.svg)](https://codecov.io/gh/suddi/claudia-local-api)

Command line utility to launch Express local API for claudia-api-builder. Test drive your lambda functions before deployment

````
npm install --save-dev claudia-local-api
````

To install globally:

````
npm install --global claudia-local-api
````

## Usage

If you have a [`claudia`](https://www.npmjs.com/package/claudia) and [`claudia-api-builder`](https://www.npmjs.com/package/claudia-api-builder) app/server named `lib/app.js` ready for deployment and you want to test it locally:

````js
'use strict';

const ApiBuilder = require('claudia-api-builder');

function handleGetRequest(app, req) {
    return new app.ApiResponse('OK', {
        called: 'handleGetRequest'
    }, 200);
}

function handlePostRequest(app, req) {
    return new app.ApiResponse('OK', {
        called: 'handlePostRequest'
    }, 201);
}

function bootstrap() {
    const app = new ApiBuilder();

    app.get('/', handleGetRequest.bind(null, app));
    app.post('/', handlePostRequest.bind(null, app));

    return app;
}

module.exports = bootstrap();
````

You can install `claudia-local-api`  and run the command line Express API to test out the lambda function locally:

````
claudia-local-api --api-module lib/app.js
````

Or add into your `package.json`:

````json
"server": "claudia-local-api --api-module lib/app.js"
````

This will start up a local Express server on port 3000 to proxy requests to your [`claudia-api-builder`](https://www.npmjs.com/package/claudia-api-builder) app.

---

For full list of options:

````
claudia-local-api --help
````
npm package: @rusinov/react-big-calendar
Description: Calendar! with events
Author: Jason Quense
Latest version: 0.22.2

# react-big-calendar

An events calendar component built for React and made for modern browsers (read: IE10+) and uses flexbox over the classic tables-ception approach.

[**DEMO and Docs**](http://intljusticemission.github.io/react-big-calendar/examples/index.html)

Inspired by [Full Calendar](http://fullcalendar.io/).

## Use and Setup

`npm install react-big-calendar --save`

Include `react-big-calendar/lib/css/react-big-calendar.css` for styles, and make sure your calendar's container
element has a height, or the calendar won't be visible.

## Starters

* [react-big-calendar](https://github.com/arecvlohe/rbc-starter)
* [react-big-calendar with drag and drop](https://github.com/arecvlohe/rbc-with-dnd-starter)

## Run examples locally

```
$ git clone git@github.com:intljusticemission/react-big-calendar.git
$ cd react-big-calendar
$ npm install
$ npm run examples
```

* Open [localhost:3000/examples/index.html](http://localhost:3000/examples/index.html).

### Localization and Date Formatting

`react-big-calendar` includes two options for handling the date formatting and culture localization, depending
on your preference of DateTime libraries. You can use either the [Moment.js](http://momentjs.com/) or [Globalize.js](https://github.com/jquery/globalize) localizers.

Regardless of your choice, you **must** choose a localizer to use this library:

#### Moment.js

```js
import BigCalendar from 'react-big-calendar'
import moment from 'moment'

const localizer = BigCalendar.momentLocalizer(moment) 

const MyCalendar = props => (
  <div>
    <BigCalendar
      localizer={localizer}
      events={myEventsList}
      startAccessor="start"
      endAccessor="end"
    />
  </div>
)
```

#### Globalize.js v0.1.1

```js
import BigCalendar from 'react-big-calendar'
import globalize from 'globalize'

const localizer = BigCalendar.globalizeLocalizer(globalize) 

const MyCalendar = props => (
  <div>
    <BigCalendar
      localizer={localizer}
      events={myEventsList}
      startAccessor="start"
      endAccessor="end"
    />
  </div>
)
```

## Join us on Reactiflux Discord

Join us on [Reactiflux Discord](https://discord.gg/uJsgpkC) community under the channel #react-big-calendar if you have any questions.
npm package: @rusinov/react-scripts
Description: Configuration and scripts for Create React App.
Latest version: 2.1.3

# react-scripts

This package includes scripts and configuration used by [Create React App](https://github.com/facebook/create-react-app).<br>
Please refer to its documentation:

- [Getting Started](https://facebook.github.io/create-react-app/docs/getting-started) – How to create a new app.
- [User Guide](https://facebook.github.io/create-react-app/) – How to develop apps bootstrapped with Create React App.
npm package: @rusintez/gss
Description: Sync .env files to GitHub repository secrets
Author: Vladimir Popov
Latest version: 0.1.0

# gss — GitHub Secret Sync

Sync `.env` files to GitHub repository secrets.

## Install

```bash
npm i -g @rusintez/gss
```

## Usage

```bash
# Push secrets from .env to current repo
gss push .env

# Push from .dev.vars to a specific repo
gss push .dev.vars -r owner/repo

# Push from JSON format
gss push .production.env.json

# Push to a GitHub environment
gss push .env -e production

# Push and remove secrets not in the file
gss push .env --prune

# Preview without making changes
gss push .env --dry-run

# List remote secret names
gss pull

# Compare local file vs remote
gss diff .env

# Convert between formats
gss fmt .env --json          # .env → JSON
gss fmt .production.env.json --env  # JSON → .env
```

## File formats

### `.env` / `.dev.vars`

```
DATABASE_URL=postgres://localhost/db
API_KEY=sk-123
# comments and empty lines are stripped
```

### `.production.env.json`

```json
{
  "DATABASE_URL": "postgres://localhost/db",
  "API_KEY": "sk-123"
}
```

## Requirements

- [GitHub CLI (`gh`)](https://cli.github.com/) installed and authenticated
npm package: @rusintez/qp
Description: Filter arrays using SQL like querystring
Author: Vladimir Popov
Latest version: 1.0.0

# qp

Filter arrays using SQL like querystring

### Installation 

    $ npm install @rusintez/qp --save

### Usage

```js

var filter = require('@rusintez/qp');
var assert = require('assert');

var arr = [{
  bool_field: true,
  another_bool_field: false,
  a: 1,
  b: 2,
  c: 'blah',
  d: [1, "2", true, false]
}];

var query = 'bool_field AND NOT another_bool_field AND a = 1 AND (b >= 2 OR c = "blah") AND d INCLUDES [1, "2", true]';
var result = filter(query, arr);

assert.deepEqual(arr, result);
```

### API

#### filter({String} query, {Array} list[, {String} adapter]):Array

```js
var result = filter(query, list);
```

### Adapters

By default adapter is set to 'native' that uses tree-like structure to filter objects in an array.
It's possible to use (included) sift.js filtering mechanism

```js
var siftFilteredList = filter(query, list, 'sift');
```

### Query Syntax

##### AND

`a AND b` — true when both are true

##### OR

`a OR b` - true when either one is true

##### NOT

`NOT c` — true if c is falsy

##### EQUALS

`a EQUALS 5` — true when a is number 5
`a = 5` — shorthand, same as above

##### GT

`a > 4` — true when a is greater than 4

##### GTE

`a >= 4` — true when a is greater than or equals 4

##### LT

`a < 4` — true when a is less than 4

##### LTE

`a <= 4` — true when a is less than or equals 4

##### INCLUDES

`tags INCLUDES ["russia", "china"]` — true when tags include *both* russia and china 
`tags IN ["us", "uk"]` — shorthand, same as above

##### Flags

Flags are shorthand expressions by them selves, eg.

`has_active_license AND no_principal` will become `has_active_license = true AND no_principal = true`

##### Brackets

Brackets are supported to ensure correct order or comparison

```
a = 5 OR (b = 10 AND c > 0) AND NOT tags IN ["blacklisted"]
```

### Supported datatypes

##### String

`"hello world"` — strings must be surrounded by double quotes

##### Number 

`5` - for now only non-negative integers are supported, more coming soon

##### Boolean

`true`, `false`

##### Null

`null`

##### Array

`[1,"2", false, [true, true], null]` — all of the above + nesting

### Advanced

It's possible to get back parsed query tree using excellent PEG generated parser.

```js

var parser = require('@rusintez/qp/parser');
var assert = require('assert');

var tree = parser.parse('license_types INCLUDES 7');

assert.deepEqual(tree, { 
  token: 'INCLUDES',
  key: 'license_types',
  value: { 
    token: 'NUMBER', 
    value: 7
  }
});

```

### Author

Vladimir Popov

### License

MIT
npm package: @rusintez/skt
Description: Use xsalsa20-poly1305 private key encryption and ed25519 signatures to safely read and write encrypted data on public internet.
Author: Vladimir Popov
Latest version: 2.1.0

# Secret Manager

Use xsalsa20-poly1305 private key encryption and ed25519 signatures to safely read and write encrypted data on public internet.

### Installation

```bash
$ pnpm install --global @rusintez/skt
```

### Usage

```bash
$ export SKT_TOKEN=$(skt token) # outputs base58 encoded token
$ skt set GITHUB_TOKEN <some-value-here>
$ skt get GITHUB_TOKEN # outputs "<some-value-here>"
```

### Run your own vault

Setup cli and server to run locally

```bash
$ git clone git@github.com:rusintez/secret-manager.git
$ cd secret-manager
$ pnpm install
$ echo "JWT_SECRET=$(openssl rand -hex 32)" > .dev.vars
$ pnpm dev
$ export SKT_DEV=true
$ pnpm link --global
```
npm package: @rusintez/slack
Description: Agent-friendly Slack CLI and library with local sync and triggers
Author: rusintez
Latest version: 0.2.2

# @rusintez/slack

Agent-friendly Slack CLI with local sync. Markdown I/O by default.

## Install

```bash
npm install -g @rusintez/slack
```

Or run directly with npx:

```bash
npx @rusintez/slack --help
```

## Setup

Add your Slack workspace token (get from [Slack App Settings](https://api.slack.com/apps) > OAuth & Permissions):

```bash
slack config add work xoxb-your-bot-token
slack config default work
```

Required OAuth scopes:

- `channels:read`, `channels:history` — read public channels
- `channels:join` — join channels
- `groups:read`, `groups:history` — read private channels
- `users:read`, `users:read.email` — read user info
- `chat:write` — send/edit/delete messages
- `reactions:write` — add/remove reactions
- `search:read` — search messages

Or use env var for one-off commands:

```bash
SLACK_TOKEN=xoxb-xxx slack me
```

## Usage

### Config Management

```bash
slack config list              # List all workspaces
slack config add <name> <key>  # Add/update workspace
slack config remove <name>     # Remove workspace
slack config default <name>    # Set default workspace
```

### Reading

```bash
slack me                       # Current user
slack team                     # Workspace info
slack channels                 # List channels
slack channel #general         # Channel details
slack users                    # List users
slack user @john               # User details
slack messages #general        # Get messages
slack thread #general 1234.56  # Thread replies
slack search "deploy"          # Search messages
slack inbox                    # DMs, mentions, activity
```

### Writing

```bash
slack send #general "Hello!"                    # Send message
slack reply #general 1234.5678 "Thanks!"        # Reply to thread
slack react #general 1234.5678 thumbsup         # Add reaction
slack unreact #general 1234.5678 thumbsup       # Remove reaction
slack edit #general 1234.5678 "Updated text"    # Edit message
slack delete #general 1234.5678                 # Delete message
```

### Sync (Local Cache)

Data syncs to `~/.local/share/slack/{workspace}/` as flat JSON files (one file per entity).

```bash
slack sync                     # Sync channels, users
slack sync --full              # Full sync (remove deleted items)
slack sync --channels          # Sync only channels
slack status                   # Show sync stats
```

### Output Formats

```bash
slack channels                 # Markdown table (default)
slack channels -f json         # JSON
slack channels -f minimal      # Tab-separated, one per line
```

### Multi-workspace

```bash
slack -w work messages #general
slack -w personal channels
```

## Human-Friendly Inputs

The CLI accepts readable names instead of IDs:

- Channels: `#general`, `general`, or `C1234567890`
- Users: `@john`, `john`, `john@example.com`, or `U1234567890`
- Special: `me` resolves to the current user

## Config Location

`~/.config/slack-cli/config.json`

## License

MIT
npm package: @rusirunethmina/world-currencies-js
Description: ISO 4217 currency codes with names and symbols
Author: rusirunethmina
Latest version: 1.0.0

# 🌍 @rusirunethmina/world-currencies-js

A lightweight and developer-friendly JavaScript library for working with world currency data, including **ISO 4217 currency codes**, **names**, and **symbols**.

---

## 📦 Installation

```bash
npm install @rusirunethmina/world-currencies-js
```

or using Yarn:

```bash
yarn add @rusirunethmina/world-currencies-js
```

---

## 🔧 Usage

```js
const currencies = require('@rusirunethmina/world-currencies-js');

// Get all currencies
console.log(currencies.getAll());

// Get currency by ISO code
console.log(currencies.getByCode('USD'));
// Output: { code: 'USD', name: 'United States Dollar', symbol: '$' }

// Get currency by name
console.log(currencies.getByName('Euro'));
// Output: { code: 'EUR', name: 'Euro', symbol: '€' }
```

---

## 📘 API Reference

### `getAll(): Currency[]`

Returns a list of all currencies in the dataset.

```js
[
  { code: 'USD', name: 'United States Dollar', symbol: '$' },
  { code: 'EUR', name: 'Euro', symbol: '€' },
  ...
]
```

---

### `getByCode(code: string): Currency | null`

Returns the currency object that matches the given ISO 4217 code (case-insensitive).

```js
getByCode('inr');
// { code: 'INR', name: 'Indian Rupee', symbol: '₹' }
```

---

### `getByName(name: string): Currency | null`

Returns the currency object that matches the exact name (case-insensitive).

```js
getByName('British Pound');
// { code: 'GBP', name: 'British Pound', symbol: '£' }
```

---

## 🧾 Currency Object Format

Each currency entry has the following format:

```ts
{
  code: string;   // ISO 4217 currency code (e.g., "USD")
  name: string;   // Full currency name (e.g., "United States Dollar")
  symbol: string; // Currency symbol (e.g., "$")
}
```

---

## 🛠 Use Cases

- Currency pickers in forms
- E-commerce or payment apps
- Data normalization tools
- Localization & formatting

---

## 📁 Project Structure

```
.
├── currencies.json       # Raw data file
├── index.js              # Module exports and API
├── package.json
└── README.md
```

---

## 💡 Roadmap

- ✅ JavaScript version (v1)
- 🔜 TypeScript version (`@rusirunethmina/world-currencies`)
- 🔜 Add more metadata (regions, subregions, decimals, etc.)
- 🔜 ISO currency validation

---

## 👫 Contributing

Contributions are welcome!  
Please open an issue or submit a pull request with improvements or new features.

---

## 📜 License

[MIT](./LICENSE)

---

## 🔗 Related Projects

- 🌍 [`@rusirunethmina/world-countries`](https://www.npmjs.com/package/@rusirunethmina/world-countries) *(Coming Soon)* — ISO 3166 country data.
- 💸 [`currency.js`](https://www.npmjs.com/package/currency.js) — A library for money math (not currency lists).

---
npm package: @ruskydev/better-tree
Description: A fast, customizable directory tree viewer for the terminal.
Latest version: 1.0.4

# @ruskydev/better-tree

A fast, customizable directory tree viewer for the terminal.


## Installation

You can run it directly with `npx` (no install needed):

```bash
npx @ruskydev/better-tree --help
````

Or install globally:

```bash
npm install -g @ruskydev/better-tree
better-tree --help
```

## Usage

```bash
better-tree [directory] [options]
```

### Options

```
--ignore <patterns...>     Ignore matching files/folders (supports *, **)
--depth <n>                Limit recursion depth
--files-only               Show only files
--dirs-only                Show only directories
--help                     Show this help message
```

### Examples

```bash
# Show current directory tree
npx @ruskydev/better-tree .

# Ignore node_modules and dist
npx @ruskydev/better-tree src --ignore node_modules dist

# Limit depth to 2
npx @ruskydev/better-tree --depth 2

# Show only directories
npx @ruskydev/better-tree --dirs-only
```

## License
This project is licensed under the [MIT License](LICENSE).
npm package: @ruslan_kotliarenko/string-toolkit
Description: A small and useful JavaScript library for string manipulation, including common utilities like converting strings to `snake_case` and `kebab-case`.
Latest version: 1.1.0

# @yourname/string-toolkit

A small and useful JavaScript library for string manipulation, including common utilities like converting strings to `snake_case` and `kebab-case`.

## ✨ Features

- ✅ Convert to `snake_case`
- ✅ Convert to `kebab-case`
- ✅ Lightweight and easy to use

## 📦 Installation
```bash
# Using npm
npm install @yourname/string-toolkit

# Using yarn
yarn add @yourname/string-toolkit
```

## 🛠️ Usage
```js
const { toSnakeCase, toKebabCase } = require('@yourname/string-toolkit');

console.log(toSnakeCase("Hello World")); // hello_world
console.log(toKebabCase("Hello World")); // hello-world
```

## 🤝 Contributing
We welcome contributions! Please read the CONTRIBUTING.md for guidelines.

## 📄 License
This project is licensed under the MIT License - see the LICENSE file for details.