open-index/open-npm huggingface dataset:
npm package: @probolabs/probo-browser
Description: Probo Labs Browser Automation Tool
Author: Probo Labs
Latest version: 1.0.20

# @probolabs/probo-browser

A command-line tool for launching browsers with Probo extensions pre-installed.

## Installation

```bash
npm install -g @probolabs/probo-browser
```

Or run directly with npx:

```bash
npx @probolabs/probo-browser
```

## Usage

### Launch a browser

```bash
probo-browser launch
```

### Launch a browser and navigate to a URL

```bash
probo-browser launch --url https://example.com
```

## Programmatic Usage

You can also use the package programmatically in your Node.js applications:

```typescript
import { initBrowser, getPage } from "@probolabs/probo-browser";

async function main() {
  const context = await initBrowser();
  const page = getPage();
  await page.goto("https://example.com");
}

main().catch(console.error);
```

## Features

- Launches a browser with Probo extensions pre-installed
- Cross-platform support (Windows, macOS, Linux)
- Simple command-line interface
- Programmatic API for automation
- Automatic extension management

## License

MIT
npm package: @probot/pino
Description: formats pino logs and sends errors to Sentry
Author: Gregor Martynus
Latest version: 5.0.1

# `@probot/pino`

> formats [pino](https://github.com/pinojs/pino) logs and sends errors to [Sentry](https://sentry.io)

## About

`@probot/pino` is currently built into `probot`, you don't need to manually pipe probot's logs into it. It will be easy to move it out of `probot` in future though, and give people a simple way to recover the logging behavior if they wish, or to replace it with another [pino transport](https://getpino.io/#/docs/transports)

## CLI Usage

```
node my-script.js | pino-probot
```

You can test the environment variables by setting them inline

```
node my-script.js | LOG_FORMAT=json pino-probot
```

## Programmatic usage

`@probot/pino` exports a `getTransformStream()` async function which can be passed as 2nd argument to `pino()`

```js
import pino from "pino";
import { getTransformStream } from "@probot/pino";

const log = pino(
  {
    name: "probot",
  },
  await getTransformStream(),
);
```

This won't log anything to stdout though. In order to pass the formatted logs back to stdout, do the following

```js
import pino from "pino";
import { getTransformStream } from "@probot/pino";

const transform = await getTransformStream();
transform.pipe(pino.destination(1));
const log = pino(
  {
    name: "probot",
  },
  transform,
);
```

With custom options:

```js
const transform = await getTransformStream({
  logFormat: "json",
  logLevelInString: true,
  sentryDsn: "http://username@example.com/1234",
});
```

### Options

The `pino-probot` binary can be configured using environment variables, while the `getTransformStream()` accepts an object with according keys

| Environment Varibale  | Option             | Description                                                                                                                                                                                              |
| --------------------- | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `LOG_FORMAT`          | `logFormat`        | Set to `pretty` or `json`. When set to `pretty`, logs are formatted for human readability. Setting to `json` logs using JSON objects. Defaults to `pretty`                                               |
| `LOG_LEVEL_IN_STRING` | `logLevelInString` | By default, when using the `json` format, the level printed in the log records is an int (`10`, `20`, ..). This option tells the logger to print level as a string: `{"level": "info"}`. Default `false` |
| `SENTRY_DSN`          | `sentryDsn`        | Set to a [Sentry](https://sentry.io/) DSN to report all errors thrown by your app. <p>_(Example: `https://1234abcd@sentry.io/12345`)_</p>                                                                |

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md)

## License

[ISC](LICENSE)
npm package: @proc/configuration
Description: Configuration object.
Author: Chris Walker
Latest version: 0.2.0

# typed configuration object

A Configuration Object. It uses a simple `{[key:string]: string}` source object
(like `process.env`, encouraging 12-factor style configuration) and exposes
methods for fetching strings, booleans, integers and floats, with fallbacks.

Works well with `dotenv/register`.

## Usage

```typescript
import { createConfig } from "@proc/configuration";

const config = createConfig(process.env);

console.log(config.getString("NODE_ENV", "development"));
console.log(config.getInteger("SOME_INTEGER", 123));
```
npm package: @proc/context
Description: A Hierachical Application Context
Author: Chris Walker
Latest version: 0.2.0

# An application context.

A hierachical application context object. Create a parent context
for the application and spawn child contexts for each request/process.
Each gets a unique id and lifecycle.

Properties can be weakly attached to the context and the lifecycle events
ensure they can be destroyed after a request, hopefully avoiding memory
leaks by held resources.

The `enhancer` allows wrapping properties to the context without specifying
the implementations. This means you can create the interface (in Typescript)
and code against it, but leave the real implementation up the main library.

## Simple Usage

```typescript
import createContext from "@proc/context";

const ctx = createContext();
const child = ctx.child();

ctx.waitForChildren().finally(() => {
  console.log("child context finished");
});

someLongProcess(child).finally(() => {
  child.done(); // causes console.log: child context finished
});

ctx.done(); // free all resources
```
npm package: @proc/context-auth
Description: Authentication and authorization module for @proc/context
Author: Chris Walker
Latest version: 0.2.0

# Authentication/Authorization module adapter for `@proc/context`

The Authn module provides a framework for authentication and authorization within
your application.

It provides a middleware for attaching authn information to HTTP requests, or
(de)serializing that information. It also provides a basis for authorization which
includes decision making and reporting of decisions (audit).

Teminology:

There's a bunch of domain specific terms here and I may or may not be using standardised
wording, so I'll define some things.

- **`authn`**: Authentication, proving you are who you say you are
- **`authz`**: Authorization, deciding what you can and cannot do
- **`entity`**: A person, system or thing that can act within the application. The `authn`
  specifies and identifies the authenticated `entity`.
- **`subject`**: this is the authenticated `entity`, i.e. the entity that the authn
  object is referencing. In an authorization decision like "Can `X` do `Y` with `Z`"
  the `subject` is `X`.
- **`owner`**: this is the `entity` which owns this authentication. This is not
  often different to the `subject`, however sometimes we create _delegated_ authentication
  object. That is a _privileged_ entity may be allowed to act as a different entity, for
  example a admin user logged into a regular user's account. We distinguish this case from
  the direct authn as sometimes it is useful to be able to discern the difference, even
  if the decisions are based solely on the `subject` and `scopes`.
- **`scopes`**: which are simply string values that identify the capabilities this authn
  has been granted. They will be application specific and carry little meaning externally.
  They are used to determine the outcome of authorization decisions.

There are 3 types of Authn Entity defined:

- `User` this represents a human user, has an identifier to represent the stored ID for the user.
- `System` this represents a non-human user, i.e. system to system communication, scheduled tasks.
- `Anonymous` this represents a non-authenticated state. It is useful to have this seperately for
  a number of reasons, foremost it means you can make your authn object non-null (simplifying code)
  and also anonymous access is often allowed in many systems and defining it up front makes it easier
  to reason about. This also represents a failed Authn, which is often best handled the same as none, but
  we still want to know if there was _no_ authn attempt versus an _invalid_ authentication attempt.
npm package: @proc/context-db
Description: The main interface for Database connections using context
Author: Chris Walker
Latest version: 0.2.0

# database adapter for `@proc/context`

Provides a high level interface for creating database sepcific adapters for use with `@proc/context`.

Each _context_ will get a wrapper which allows you track queries made within a specifc context and get statistics for them.

This package is not intended to be consumed directly, but rather as a dependency of another adapter:

- [`@proc/context-sqlite`](../context-sqlite)
- [`@proc/context-postgres`](../context-postgres)
npm package: @proc/context-koa
Description: Adds a @proc/context to koa via a middleware
Author: Chris Walker
Latest version: 0.2.0

# Koa Middleware to provide context.

Get a `@proc/context` object for every request. While this package works standalone, a more complete web server implementation exists as [`@proc/runtime`](../runtime).

## Usage

```typescript
import Koa from "koa";
import { createContext } from "@proc/context";
import { middleware, getRequestContext } from "@proc/context-koa";

const app = new Koa();
const parentContext = createContext();
app.use(middleware(parentContext));

app.use((ktx, next) => {
  const childContext = getRequestContext(ktx);
  ktx.body = `Child context had id: ${childContext.id}`;
});

app.listen(8080);
```
npm package: @proc/context-metrics
Description: The main interface for Metrics using context
Author: Chris Walker
Latest version: 0.2.0

# metrics adapter for `@proc/context`

Provides a high level interface for creating sepcific metrics adapters for use with `@proc/context`.

This package is not intended to be consumed directly, but rather as a dependency of another adapter:

- [`@proc/context-metrics-statsd`](../context-metrics-statsd)
- [`@proc/context-metrics-influxdb2`](../context-metrics-influxdb2)
npm package: @proc/context-metrics-influxdb2
Description: The InfluxDB 2 plugin for Metrics using context
Author: Chris Walker
Latest version: 0.2.0

# metrics adapter for `@proc/context`

Provides a high level interface for creating sepcific metrics adapters for use with `@proc/context`.

This package is not intended to be consumed directly, but rather as a dependency of another adapter:

- [`@proc/context-metrics-statsd`](../context-metrics-statsd)
- [`@proc/context-metrics-influxdb2`](../context-metrics-influxdb2)
npm package: @proc/context-metrics-statsd
Description: The StatsD plugin for Metrics using context
Author: Chris Walker
Latest version: 0.2.0

# metrics adapter for `@proc/context`

Provides a high level interface for creating sepcific metrics adapters for use with `@proc/context`.

This package is not intended to be consumed directly, but rather as a dependency of another adapter:

- [`@proc/context-metrics-statsd`](../context-metrics-statsd)
- [`@proc/context-metrics-influxdb2`](../context-metrics-influxdb2)
npm package: @proc/context-pino
Description: A Logger property for contexts
Author: Chris Walker
Latest version: 0.2.0

# Logging with context

A context aware logger using `pino` as a backend. Provides structured
logging with little overhead.

```typescript
import { createContext } from "@proc/context";
import { createLogger } from "@proc/context-pino";

const parent = createContext();
const getLogger = createLogger({
  base: {
    some: "fixed",
    values: true
  },
  ...otherPinoOptions
});

const child = parent.child();

const childLog = getLogger(child);

// will have the ctx id in the meta.
childLog.info("this is the child");

// bind some contextual values to this child
childLog.bind({ foo: "bar" });

// will have foo:bar in the meta
childLog.info("with added foo");

const parentLog = getLogger(parent);

parentLog.debug(
  "this will have the parent `ctx.id`, and not the added foo=bar"
);

// good practice, to release resources.
child.done();
parent.done();
```
npm package: @proc/context-postgres
Description: Postgres Connection for contexts
Author: Chris Walker
Latest version: 0.2.0

# Contextual Database handle.

A database connection wrapped to use `@proc/context`.
Not much added value here from using a global, except that you can get
context-level statistics (i.e. per-request query count/timing info) easily.

## Usage

```typescript
import { createContext } from "@proc/context";
import { createDatabase } from "@proc/context-postgres";

const ctx = createContext();
const getDatabase = createDatabase("postgres://user:pass@127.0.0.1:5432/mydb");

const child = ctx.child();

const db = getDatabase(child);

db.selectOne<{ n: number; s: string }>("SELECT 1 as n, 'foo' as s;").then(v => {
  console.log(v.n, v.s); // 1 foo
});

db.getStatistics().forEach(s => {
  // s has the query, time, result count, parameters, etc...
  // here it will be empty (the query above won't have finished yet...)
  // but after that resolves we will have 1 entry here.
});
```
npm package: @proc/context-redis
Description: Redis Connection for contexts
Author: Chris Walker
Latest version: 0.2.0

# Redis with Context

A Redis connection for your context. Not much value added except that we manage
the connection lifecycle. so after your parent context has `.done()` called, the
connection is released and the application can shutdown sanely.

## Usage

```typescript
import { createContext } from "@proc/context";
import { createRedis } from "@proc/context-redis";

const getRedis = createRedis();

const ctx = createContext();

const r = getRedis(ctx);

r.set("foo", "bar").finally(() => {
  ctx.done(); //application will not be held open by the redis connection
});
```
npm package: @proc/context-sqlite
Description: SQLite Connection for contexts
Author: Chris Walker
Latest version: 0.2.0

# SQLite connection for contexts

A database connection wrapped to use `@proc/context`.
Not much added value here from using a global, except that you can get
context-level statistics (i.e. per-request query count/timing info) easily.

```typescript
import { createContext } from "@proc/context";
import { createDatabase } from "@proc/context-sqlite";

const ctx = createContext();
const getDatabase = createDatabase("sqlite://path/to/file");

const child = ctx.child();

const db = getDatabase(child);

db.selectOne<{ n: number; s: string }>("SELECT 1 as n, 'foo' as s;").then(v => {
  console.log(v.n, v.s); // 1 foo
});

db.getStatistics().forEach(s => {
  // s has the query, time, result count, parameters, etc...
  // here it will be empty (the query above won't have finished yet...)
  // but after that resolves we will have 1 entry here.
});
```
npm package: @proc/errors
Description: Generic errors, specific codes
Author: Chris Walker
Latest version: 0.2.0

# Error objects for the web.

These error object can be used throughout your application and should cover most needs out-of-the-box.

If used consistently, the distinction between _unexpected_ errors (i.e. not `@proc/error`s) and expected/handled errors becomes clear. This allows you to identify problems that need highlighting as bugs and errors that need reporting to the client/user.

We only specific a few "_variants_" which do not cover the HTTP Status Codes, but provide
most that are useful in more than just plain HTTP/RESTful contexts.

```typescript
export enum ErrorVariant {
  NOT_IMPLEMENTED, // not implemented
  INTERNAL, // any non-explicit error
  BAD_REQUEST, // any input error that's not validation (e.g. unsupported media type, bad request)
  USER_INPUT, // validation error (e.g. unprocessable entity)
  CONFLICT, // non-user error, but the thing cannot be done due to business rules.
  NOT_FOUND, // not found,
  UNAUTHENTICATED, // authentication required but not present (e.g. http unauthorized)
  UNAUTHORIZED // authentication present but insufficient (e.g. http forbidden)
}
```

## Usage

```typescript
import { badData, isProcError } from "@proc/error";
// create an error
if (it_is_the_users_fault) {
  throw badData("user did something wrong");
}

// identify errors.
try {
  doSomething();
} catch (e) {
  if (isProcError(e)) {
    // it's a proc error
  } else {
    // an unexpected error!
  }
}
```
npm package: @proc/graphql
Description: GraphQL Server, Tools and Scalars
Author: Chris Walker
Latest version: 0.2.0

# `@proc/graphql` adds GraphQL server scalars and Koa middleware.

This package provides some utilities to make your GraphQL server life easier.

It allows you to create a pure Koa Middleware, without having to pass a Koa App up front (my biggest issue with `apollo-server-koa`).

It also provides some useful scalar type definitions.

## usage

```typescript
import {
  ApolloServer,
  makeExecutableSchema,
  gql,
  createGraphQLMiddleware,
  Duration
} from "@proc/graphql";

const start = Date.now();

const schema = makeExecutableSchema({
  typeDefs: gql`
    scalar Duration
    type Query {
      uptime Duration!
    }
  `,
  resolvers: {
    Duration: Duration,
    Query: {
      uptime: () => Date.now() - start
    }
  }
});

const server = new ApolloServer({ schema });

// middleware can be used in any Koa App. and will server the requests at `/graphql`
const middleware = createGraphQLMiddleware(server, { path: "/graphql" });
```
npm package: @proc/html
Description: HTML rendering asynchronously
Author: Chris Walker
Latest version: 0.2.0

# async html tagged template for rendering on the server.

Basically a tiny wrapper around `hyperx` and `virtual-dom` to allow attributes and
children to be promises.

## Usage

```typescript
import { html, render } from "@proc/html";

const title = "<Example>";

const someAsyncTask = () => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve("delayed");
    }, Math.random() * 1000);
  });
};

const template = html`
  <html>
    <body>
      <h1>${title}</h1>
      <p>
        ${someAsyncTask().then(
          text =>
            html`
              it's <strong>${text}</strong>!
            `
        )}
      </p>
    </body>
  </html>
`;

render(template).then(rawHTML => {
  console.log(rawHTML);
});
```
npm package: @proc/runtime
Description: An koa web-app runtime for @proc/context
Author: Chris Walker
Latest version: 0.2.0

# Koa web app runtime for `@proc/context`

Simplies starting a web app server.
Uses `dotenv` for configuration bootstrapping.

## Usage

```typescript
import { bootstrap, getRequestContext } from "@proc/runtime";

// create middlewares in order, like you would call `app.use()` in koa
const middlewares = [
  (ktx, next) => {
    const ctx = getRequestContext(ktx);
    ctx.log.info("log something?");
    ktx.body = `<h1>Served with context id: ${ctx.id}</h1>`;
  }
];

const app = bootstrap();
app.use(...middlewares);
app.run().catch(err => {
  app.ctx.log.error(err, "unexpected error!");
});
```
npm package: @proc/sql
Description: SQL tagged template string
Author: Chris Walker
Latest version: 0.2.0

# ES6 tagged template strings for SQL

I _love_ [`sql-template-strings`](https://github.com/felixfbecker/node-sql-template-strings),
except for one thing. Immutablility. There were a number of discussions about adding it,
either via a `.concat` method, or by allowing nesting templates.

Personally I like both approaches. so used both

- nested querys: the inner queries are copied, not mutated.
- `.append` will copy the arguments, not mutate, but will mutate the original query.
- `.concat` will copy the arguments, not mutate and will not mutate the original query returning a new object.

Otherwise the API is similar, the `sql`, `raw` method both produce an `SQLStatement`, which has
(apart from the properties and methods required for actually making the queries) the following
properties:

- `.concat(...next: Array<SQLStatement|string>): SQLStatement` concatenates all the queries together in order, producing a _new_ statement.
- `.concat(s: TemplateStringArray, v: any[]): SQLStatement` the tagged template string version of `concatenate`, but of course can only work on a single input.
- `.append(...next: Array<SQLStatement|string>): SQLStatement` like concatenate, but mutates the query it is called on.
- `.append(s: TemplateStringArray, v: any[]): SQLStatement` the tagged template string version of the `append`.
- `.clone()` explicit copy of the statement - note that the values array is shallow copied.

**NB** I have not implemented the bind syntax yet. I plan to at some point but have no need for it yet.

There are also some useful helper functions:

- `join(separator: string, arr: Array<Statement | string | number>): Statement`: joins the statements together in order, using the given seprator (note that spaces between statements will be added as needed).
- `mapJoin<T>(separator: string, arr: Array<T>, fn: (v: T, i: number, a: Array<T>) => Statement | string | number): Statement`: the same as join but allows you to pass an array of anything, and a mapping function to produce a Statement or primitive.
- `like(str: string): string`: escapes a string for a SQL LIKE clause. It wraps `_`,`%`,`[`,`]` in square brackets. _This may or may not be enough in your SQL server._

This allows you to do things like:

```typescript
import { sql, mapJoin, like } from "@proc/sql";

// like a database response...
const bigArrayOfThings = [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }];

// find articles with all the names in (simplistic search)
const query = sql`
  SELECT title, body
  FROM articles
  WHERE ${mapJoin("AND", bigArrayOfThings, ({ id }) => {
    // create a LIKE clause
    const matcher = `%${like(id)}%`;
    sql`body LIKE ${matcher}`;
  })};
`;
```
npm package: @proc7ts/async
Description: Asynchronous utilities
Author: Ruslan Lopatin
Latest version: 2.1.0

# Asynchronous Utilities

[![NPM][npm-image]][npm-url]
[![Build Status][build-status-img]][build-status-link]
[![Code Quality][quality-img]][quality-link]
[![Coverage][coverage-img]][coverage-link]
[![GitHub Project][github-image]][github-url]
[![API Documentation][api-docs-image]][api documentation]

See the [API documentation].

[npm-image]: https://img.shields.io/npm/v/@proc7ts/async.svg?logo=npm
[npm-url]: https://www.npmjs.com/package/@proc7ts/async
[build-status-img]: https://github.com/proc7ts/async/workflows/Build/badge.svg
[build-status-link]: https://github.com/proc7ts/async/actions?query=workflow:Build
[quality-img]: https://app.codacy.com/project/badge/Grade/6dd694badd554ca39c6a85f0ec2c55b4
[quality-link]: https://www.codacy.com/gh/proc7ts/async/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/async&utm_campaign=Badge_Grade
[coverage-img]: https://app.codacy.com/project/badge/Coverage/6dd694badd554ca39c6a85f0ec2c55b4
[coverage-link]: https://www.codacy.com/gh/proc7ts/async/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/async&utm_campaign=Badge_Coverage
[github-image]: https://img.shields.io/static/v1?logo=github&label=GitHub&message=project&color=informational
[github-url]: https://github.com/proc7ts/async
[api-docs-image]: https://img.shields.io/static/v1?logo=typescript&label=API&message=docs&color=informational
[api documentation]: https://proc7ts.github.io/async/
npm package: @proc7ts/delta-set
Description: JavaScript Set keeping delta of changes made to it
Author: Ruslan Lopatin
Latest version: 2.0.1

# DeltaSet

[![NPM][npm-image]][npm-url]
[![Build Status][build-status-img]][build-status-link]
[![Code Quality][quality-img]][quality-link]
[![Coverage][coverage-img]][coverage-link]
[![GitHub Project][github-image]][github-url]
[![API Documentation][api-docs-image]][api-docs-url]

JavaScript Set keeping delta of changes made to it

[npm-image]: https://img.shields.io/npm/v/@proc7ts/delta-set.svg?logo=npm
[npm-url]: https://www.npmjs.com/package/@proc7ts/delta-set
[build-status-img]: https://github.com/proc7ts/delta-set/workflows/Build/badge.svg
[build-status-link]: https://github.com/proc7ts/delta-set/actions?query=workflow:Build
[quality-img]: https://app.codacy.com/project/badge/Grade/067cc45d12134dfaa78daeb3fb45a7d1
[quality-link]: https://www.codacy.com/gh/proc7ts/delta-set/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/delta-set&utm_campaign=Badge_Grade
[coverage-img]: https://app.codacy.com/project/badge/Coverage/067cc45d12134dfaa78daeb3fb45a7d1
[coverage-link]: https://www.codacy.com/gh/proc7ts/delta-set/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/delta-set&utm_campaign=Badge_Coverage
[github-image]: https://img.shields.io/static/v1?logo=github&label=GitHub&message=project&color=informational
[github-url]: https://github.com/proc7ts/delta-set
[api-docs-image]: https://img.shields.io/static/v1?logo=typescript&label=API&message=docs&color=informational
[api-docs-url]: https://proc7ts.github.io/delta-set/index.html

A `DeltaSet` class inherits ES2015 `Set`. In addition, it keeps changes made to it and has methods
to deal with these changes' delta.

```typescript
import { DeltaSet } from '@proc7ts/delta-set';

// Construct a delta set containing specified elements
// and record their addition.
const deltaSet = new DeltaSet([1, 2, 3]); // [1, 2, 3]

// Remove element and record its removal
deltaSet.delete(2); // [1, 3]

// Add element and record its addition
deltaSet.add(4); // [1, 3, 4]

const otherSet = new Set<number>();

// Replay changes in another set
deltaSet.redelta(otherSet); // otherSet: [1, 3, 4]

// Changes may be reported to receiver function
deltaSet.redelta((add, remove) => console.log('added:', ...add, '; removed:', ...remove));
// Logs: added: 1 3 4 ; removed: 2

// Forget about changes made to delta set
deltaSet.undelta();

// Apply more changes
deltaSet.delta(/* add */ [11, 12], /* remove */ [4]); // [1, 3, 11, 12]

// Replay last changes in another set
deltaSet.redelta(otherSet); // otherSet: [1, 3, 11, 12]

// Remove all elements and record their removal
deltaSet.clear();

deltaSet.redelta((add, remove) => console.log('added:', ...add, '; removed:', ...remove));
// Logs: added: ; removed: 4 1 3 11 12
```
npm package: @proc7ts/fs-events
Description: Functional file system events processor
Author: Ruslan Lopatin
Latest version: 1.0.0-dev.1

# File System Events Processor

[![NPM][npm-image]][npm-url]
[![Build Status][build-status-img]][build-status-link]
[![Code Quality][quality-img]][quality-link]
[![Coverage][coverage-img]][coverage-link]
[![GitHub Project][github-image]][github-url]
[![API Documentation][api-docs-image]][api documentation]

[npm-image]: https://img.shields.io/npm/v/@proc7ts/fs-events.svg?logo=npm
[npm-url]: https://www.npmjs.com/package/@proc7ts/fs-events
[build-status-img]: https://github.com/proc7ts/fs-events/workflows/Build/badge.svg
[build-status-link]: https://github.com/proc7ts/fs-events/actions?query=workflow:Build
[quality-img]: https://app.codacy.com/project/badge/Grade/94bb1dd58e124da788c46a04ea55c96a
[quality-link]: https://www.codacy.com/gh/proc7ts/fs-events/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/fs-events&utm_campaign=Badge_Grade
[coverage-img]: https://app.codacy.com/project/badge/Coverage/94bb1dd58e124da788c46a04ea55c96a
[coverage-link]: https://www.codacy.com/gh/proc7ts/fs-events/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/fs-events&utm_campaign=Badge_Coverage
[github-image]: https://img.shields.io/static/v1?logo=github&label=GitHub&message=project&color=informational
[github-url]: https://github.com/proc7ts/fs-events
[api-docs-image]: https://img.shields.io/static/v1?logo=typescript&label=API&message=docs&color=informational
[api documentation]: https://proc7ts.github.io/fs-events/
npm package: @proc7ts/primitives
Description: Type and function primitives
Author: Ruslan Lopatin
Latest version: 4.0.1

# Type And Function Primitives

[![NPM][npm-image]][npm-url]
[![Build Status][build-status-img]][build-status-link]
[![Code Quality][quality-img]][quality-link]
[![Coverage][coverage-img]][coverage-link]
[![GitHub Project][github-image]][github-url]
[![API Documentation][api-docs-image]][api documentation]

An assorted set of very basic types and utilities. See the [API documentation].

[npm-image]: https://img.shields.io/npm/v/@proc7ts/primitives.svg?logo=npm
[npm-url]: https://www.npmjs.com/package/@proc7ts/primitives
[build-status-img]: https://github.com/proc7ts/primitives/workflows/Build/badge.svg
[build-status-link]: https://github.com/proc7ts/primitives/actions?query=workflow:Build
[quality-img]: https://app.codacy.com/project/badge/Grade/ddfc9695d4d64d08ae53a1d14c0a2b3b
[quality-link]: https://www.codacy.com/gh/proc7ts/primitives/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/primitives&utm_campaign=Badge_Grade
[coverage-img]: https://app.codacy.com/project/badge/Coverage/ddfc9695d4d64d08ae53a1d14c0a2b3b
[coverage-link]: https://www.codacy.com/gh/proc7ts/primitives/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/primitives&utm_campaign=Badge_Coverage
[github-image]: https://img.shields.io/static/v1?logo=github&label=GitHub&message=project&color=informational
[github-url]: https://github.com/proc7ts/primitives
[api-docs-image]: https://img.shields.io/static/v1?logo=typescript&label=API&message=docs&color=informational
[api documentation]: https://proc7ts.github.io/primitives/
npm package: @proc7ts/workbench
Description: A workbench for coordinated workloads
Author: Ruslan Lopatin
Latest version: 1.2.1

# Workbench

[![NPM][npm-image]][npm-url]
[![Build Status][build-status-img]][build-status-link]
[![Code Quality][quality-img]][quality-link]
[![Coverage][coverage-img]][coverage-link]
[![GitHub Project][github-image]][github-url]
[![API Documentation][api-docs-image]][api documentation]

A workbench for coordinated workloads. See the [API documentation].

[npm-image]: https://img.shields.io/npm/v/@proc7ts/workbench.svg?logo=npm
[npm-url]: https://www.npmjs.com/package/@proc7ts/workbench
[build-status-img]: https://github.com/proc7ts/workbench/workflows/Build/badge.svg
[build-status-link]: https://github.com/proc7ts/workbench/actions?query=workflow:Build
[quality-img]: https://app.codacy.com/project/badge/Grade/adca2de926424571bab9dfe9fc04b4c6
[quality-link]: https://www.codacy.com/gh/proc7ts/workbench/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/workbench&utm_campaign=Badge_Grade
[coverage-img]: https://app.codacy.com/project/badge/Coverage/adca2de926424571bab9dfe9fc04b4c6
[coverage-link]: https://www.codacy.com/gh/proc7ts/workbench/dashboard?utm_source=github.com&utm_medium=referral&utm_content=proc7ts/workbench&utm_campaign=Badge_Coverage
[github-image]: https://img.shields.io/static/v1?logo=github&label=GitHub&message=project&color=informational
[github-url]: https://github.com/proc7ts/workbench
[api-docs-image]: https://img.shields.io/static/v1?logo=typescript&label=API&message=docs&color=informational
[api documentation]: https://proc7ts.github.io/workbench/