open-index/open-npm huggingface dataset:
npm package: @getlaunchpad/components
Description: The launchpad component library
Latest version: 0.0.3

<p align="center">
  <h3 align="center">Launchpad</h3>
  <p align="center">Components for the launchpad frontend</p>
  <p align="center">
    <a href="https://www.npmjs.com/package/@getlaunchpad/components?activeTab=versions"><img src="https://badge.fury.io/js/%40getlaunchpad%2Fcomponents.svg"></a>
  </p>
</p>

## Table of Contents

- [About](#about)
- [Installing](#installing)
- [Usage](#usage)

### Installing <a name = "installing"></a>

Start by installing the package itself

```
npm install @getlaunchpad/components@latest
```

or

```
yarn add @getlaunchpad/components
```

## Usage

```javascript
import React from "react";
import { Text } from "@getlaunchpad/components";

export default function App() {
  return <Text type="h3">Hello world</Text>;
}
```
npm package: @getlazy/common
Description: Common utility classes and functions for lazy
Latest version: 1.1.0

# lazy-common
Common libraries and utilities for lazy

## `LazyLoggingLevels`

Using this object ensures consistent logging levels across all lazy processes running in Node.

Use:

```js
const common = require('@getlazy/common');
const winston = require('winston');

winston.addColors(common.LazyLoggingLevels.colors);
const logger = new winston.Logger({
    // ...
    levels: common.LazyLoggingLevels.levels
});
```

## `PackageLogger`

External packages cannot know if `logger` exists on the global level nor what are its levels. This replaces such logging efforts with emitting `log` events and leaving it to the package's user to listen to these events.

Use:

```js
const common = require('@getlazy/common');
const logger = common.createLogger('my-package'); // We never assign this `logger` to `global` as that would overwrite application's `global.logger`.

// ...

logger.info('Succeeded marvelously.'); // This will emit `log` event. For users to listen to it logger needs to be exported from the package (see next example)
```

Forwarding log events:

```js
const myPackage = require('my-package');
// This now forwards log events from my-package to Winston.
myPackage.logger.on('log', (level, packageName, ...args) => {
    // In this example we put the package name into meta, if such exists.
    const argsWithoutMeta = [...args];
    const meta = argsWithoutMeta.pop();
    if (typeof(meta) === 'object') { // Nah, not really, use lodash!
        if (!meta._packageName) {
            meta._packageName = packageName;
        }
    }
    logger.log(level, ...messages, meta);
})
```
npm package: @getlazy/engine-pipeline
Description: Runs tasks through lazy engine pipeline
Latest version: 2.2.6

# lazy-engine-pipeline-runner
Runs tasks through engine pipelines

### Metrics

On each run pipeline objects may emit multiple `metrics` events. Each such event emits an array of metric objects.

Each metric object consists of:

| Property | Type | Required | Description |
|----------|------|----------|-------------|
| `timestamp` | number | yes | Timestamp of the moment the metric was measured. |
| `category` | string | yes | The category of the metric, for example `file-analysis`. |
| `action` | string | yes | The action of the metric, for example `warning-ignored`. |
| `value` | number | no | Value of the metric. Unless specified it's assumed to be `1` as in single occurrence. |

There can be any number of other properties and all of them will be included in the stored metric as they are. Notice however that lazy **will** overwrite them if their property names match built-in properties (see below)

lazy will add the following built-in properties to each metric before storing it:

| Property | Type | Always | Description |
|----------|------|----------|-------------|
| `engineId` | string | yes | Name of the engine as specified in the lazy.yaml. |
| `language` | string | yes | The language for which the analysis was performed. |
| `hostPath` | string | yes | The path on the host of the file which was analyzed. |
| `client` | string | yes | The client (e.g. `atom`) which requested the analysis. |
| `hostname` | string | yes | The name of the host from which the analysis was invoked. |
| `repository` | string | no | The `origin` repository, if available, otherwise `upstream`, otherwise first remote repository. |
| `branch` | string | no | The current repository branch, if available. |

Other properties may be added in the future but `custom` property name is reserved for exclusive engine use and will never be overwritten by lazy. In it you can thus store deeper structures that need to be tracked.
npm package: @getlazy/faas-pipeline
Description: OpenFaaS function composition
Latest version: 1.0.0

# faas-pipeline
Complex OpenFaaS function composition

faas-pipeline offers executing of complex pipelines on top of [OpenFaaS](https://github.com/ierceg/faas). It does this by:

* Defining its own pipeline definition language
* Defining its own protocol for data exchange between functions
* Accepting pipeline definitions together with initial payload

faas-pipeline can:

* Process payloads concurrently. This is called `~split`. The result of `~split` operation is an array of results of all functions that were executed concurrently.
* Process payloads sequentially. This is called `~pipe`. `~pipe` operation results in a new payload based on its received payload.
* Include optional parameters, beside payload, when invoking each function.
* Send custom metrics for each invoked function to FaaS' built-in Prometheus.

These can be combined in any number of ways. For example:

```
pipeline:
	~pipe:
		- ~split: # sends the received payload into fn1, fn2 and fn3
			fn1:
			fn2:
			fn3:
		- some-merging-fn: # this function acts on array of results from fn1, fn2 and fn3 with parameters of whatever1 and whatever2
			some-param: whatever1
			another-param: whatever2
```

Each compatible function must:

* Expect to receive JSON with optional `payload` and `params` properties.
* Return JSON with either `error` or `result` property and optional `metrics` property.

Execution stops on first error or when the entire pipeline has ran. Pipeline run thus either results in a free-form result or in a free-form error.
npm package: @getlea/lea
Description: Command-line tool for the Lea blockchain
Latest version: 1.0.2

# Lea CLI

Command-line tool for interacting with the Lea blockchain using the Web3 SDK.

Requirements
- Node.js >= 19

Install
- npx: `npx @getlea/lea --help` (or `npx lea` if your npx resolves the single-bin automatically)
- Global: `npm i -g @getlea/lea` then `lea --help`

When publishing
- Package name: `@getlea/lea`
- Ensure the binary is executable (handled by prepublish script)

Usage
- Global options:
- `--cluster <devnet|testnet|mainnet-beta|local|URL>` (default: mainnet-beta)
  - `-o, --outfile <path>` write decoded JSON result to a file (also printed)
  - `--quiet` suppress stderr status line
- Address and keyfiles:
  - Any argument ending with `.json` is treated as a keyfile from `lea-keygen`; its `address` is used.
  - Otherwise the value is interpreted as a Bech32m Lea address.

Commands
- `keygen [new|verify]` — proxy to `@getlea/keygen` to generate and verify keysets
- `publish-keyset --key ./example.json`
- `mint --key ./minter.json --to <address|./recipient.json> --amount <uLEA>`
- `transfer --key ./sender.json --to <address|./recipient.json> --amount <uLEA>`
- `burn --key ./account.json --amount <uLEA>`
- `get-balance --address <address|./account.json>`
- `get-last-tx-hash --address <address|./account.json>`
- `get-allowed-mint --address <address|./account.json>`
- `get-current-supply`
- `mint-whitelist --key ./authority.json --to <address|./recipient.json> --amount <uLEA>`

Keygen
- Overview: `lea keygen` runs the `@getlea/keygen` tool.
- New keyset:
  - `lea keygen new --outfile my-wallet.json`
  - Options: `--no-outfile` to print JSON to stdout, `--force` to overwrite, `--seed <64-hex>` to derive from a master seed.
- Verify keyset address:
  - `lea keygen verify ./my-wallet.json`

Examples
- Publish: `npx @getlea/lea publish-keyset --key ./example.json --cluster devnet`
- Transfer: `npx @getlea/lea transfer --key ./sender.json --to ./recipient.json --amount 1 -o tx.json`
- Balance: `npx @getlea/lea get-balance --address lea1xyz... --quiet`