open-index/open-npm huggingface dataset:
npm package: @peculia/slim-table
Description: Lightweight mobile table web component
Author: endeesa
Latest version: 0.0.6

# Simple Tabular Data Display For Small Mobile Devices


## 1. Example Usage - Vanilla Js/HTML


* //Inside index.html`

* ............

```html
<script src='https://unpkg.com/@peculia/slim-table@latest/dist/peculia-slim-table/peculia-slim-table.js'></script>

<slim-table title="My awsome title"></slim-table>

<script>
  const testData = {
    rowHeaders: ["language", "description", "age", "rating"],
    dataPoints: [
      {
        language: "JS",
        description: "Client side web scripting language",
        age: 25,
        rating: 3.5
      },
      {
        language: "Java",
        description: "Multi-purpose cross platform language",
        age: 225,
        rating: 4.5
      },
      {
        language: "Py",
        description: "Client side web scripting language",
        age: 15,
        rating: 4.95
      }
    ]
  };
  const customTableElem = document.querySelector('slim-table');
  if(customTableElem){
    customTableElem.data =  testData;
  }
</script>
```

* .......
npm package: @peculiar/attestation-cli
Description: A CLI utility for verifying attestation data in various formats, supporting multiple attestation providers and offering a range of commands to interact with attestation files and certificates.
Author: PeculiarVentures
Latest version: 2.0.0

# Attestation Utility

This utility is designed for verifying attestation data in various formats. It supports multiple attestation providers and offers a range of commands to interact with attestation files and certificates.

## Common Purposes

- **Verify Attestation Data**: Ensure the integrity and authenticity of attestation data using trusted certificates.
- **Detail Attestation Information**: Extract and display detailed information from attestation files.
- **Export Public Keys**: Extract public keys from attestation files and optionally compare them with source keys or save them to a file.
- **Certificate Management**: Detail and manage certificates used in the attestation process.

## Installation

To install the utility, use npm:

```sh
npm install @peculiar/attestation-cli
```

## Usage

To get started, you can use the `--help` flag to see the available commands and options:

```sh
attest --help
```

For detailed information on a specific command, use the `--help` flag with the command:

```sh
attest <command> --help
```

## License

This project is licensed under the MIT License.
npm package: @peculiar/attestation-common
Description: A common module providing tools and interfaces for verifying HSM attestation files.
Author: PeculiarVentures
Latest version: 2.0.0

# @peculiar/attestation-common

A common module providing tools and interfaces for verifying HSM attestation files from various HSMs, including support for certificate chain validation and attestation data extraction.

## Installation

> ⚠️ This package depends on `@peculiar/x509`, which requires Reflect metadata support at runtime.
> Import `@abraham/reflection` (or another compatible polyfill) once at application startup before any attestation-related code.
>
> ```ts
> import '@abraham/reflection';
> ```

To install the library, use npm:

```sh
npm install @peculiar/attestation-common
```

## Usage

This example demonstrates how to use the common attestation interfaces and types:

```typescript
import { X509Certificate, PublicKey } from "@peculiar/x509";
import {
  Attestation,
  AttestationVerificationParams,
  AttestationVerificationResult,
  AttestationProvider,
} from "@peculiar/attestation-common";

// Example implementation of an AttestationProvider
class ExampleAttestationProvider implements AttestationProvider {
  format = "example";

  async read(data: BufferSource): Promise<Attestation> {
    // Implement the logic to read attestation data
    return {
      format: this.format,
      publicKey: new PublicKey(/* public key data */),
      metadata: {
        /* metadata */
      },
    };
  }

  async verify(
    params: AttestationVerificationParams
  ): Promise<AttestationVerificationResult> {
    // Implement the logic to verify attestation data
    return {
      status: true,
      chain: params.intermediateCerts,
      signer: params.intermediateCerts[0],
    };
  }
}

// Example usage
const provider = new ExampleAttestationProvider();

// Example attestation data and certificate chain data
const attestationData = new Uint8Array([
  /* attestation data bytes */
]);
const certChainPem = `-----BEGIN CERTIFICATE-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7V1...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7V1...
-----END CERTIFICATE-----`;

// Read the attestation data
const attestation = await provider.read(attestationData);

// Decode the certificate chain
const certBlobs = x509.PemConverter.decode(certChainPem);
const certs = certBlobs.map((blob) => new x509.X509Certificate(blob));

// Verify the attestation using the provided certificate chain
const result = await provider.verify({
  attestation,
  intermediateCerts: certs,
});

console.log(result);
```

## License

This project is licensed under the MIT License.
npm package: @peculiar/attestation-marvell
Description: A library providing tools to verify HSM attestation files from various HSMs that support Marvell attestation, including support for certificate chain validation and attestation data extraction.
Author: PeculiarVentures
Latest version: 2.0.0

# @peculiar/attestation-marvell

A library providing tools to verify HSM attestation files from various HSMs that support Marvell attestation, including support for certificate chain validation and attestation data extraction.

## Installation

> ⚠️ This package depends on `@peculiar/x509`, which requires Reflect metadata support at runtime.
> Import `@abraham/reflection` (or another compatible polyfill) once at application startup before any attestation-related code.
>
> ```ts
> import '@abraham/reflection';
> ```

To install the library, use npm:

```sh
npm install @peculiar/attestation-marvell
```

## Usage

This example demonstrates how to verify an HSM attestation:

```typescript
import { MarvellAttestationProvider } from "@peculiar/attestation-marvell";
import { x509 } from "@peculiar/x509";

// Initialize the MarvellAttestationProvider
const provider = new MarvellAttestationProvider();

// Example attestation data and certificate chain data
const attestationData = new Uint8Array([
  /* attestation data bytes */
]);
const certChainPem = `-----BEGIN CERTIFICATE-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7V1...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7V1...
-----END CERTIFICATE-----`;

// Read the attestation data
const attestation = await provider.read(attestationData);

// Decode the certificate chain
const certBlobs = x509.PemConverter.decode(certChainPem);
const certs = certBlobs.map((blob) => new x509.X509Certificate(blob));

// Verify the attestation using the provided certificate chain
const result = await provider.verify({
  attestation,
  intermediateCerts: certs,
});

console.log(result);
```

## Links

- [Google Cloud KMS Attestation](https://cloud.google.com/kms/docs/attest-key)
- [Marvell Key attestation](https://www.marvell.com/products/security-solutions/nitrox-hs-adapters/software-key-attestation.html)

## License

This project is licensed under the MIT License.
npm package: @peculiar/attestation-yubico
Description: A library providing tools to verify PIV attestation files from Yubico, including support for certificate chain validation and attestation data extraction.
Author: PeculiarVentures
Latest version: 2.0.0

# @peculiar/attestation-yubico

A library providing tools to verify PIV attestation files from Yubico, including support for certificate chain validation and attestation data extraction.

## Installation

> ⚠️ This package depends on `@peculiar/x509`, which requires Reflect metadata support at runtime.
> Import `@abraham/reflection` (or another compatible polyfill) once at application startup before any attestation-related code.
>
> ```ts
> import '@abraham/reflection';
> ```

To install the library, use npm:

```sh
npm install @peculiar/attestation-yubico
```

## Usage

This example demonstrates how to verify a PIV attestation from a Yubico token:

```typescript
import {
  PivTokenManager,
  PivAttestationProvider,
} from "@peculiar/attestation-yubico";

// Initialize the PivTokenManager
const tokenManager = new PivTokenManager("/path/to/token");

// Retrieve slots information
const slots = tokenManager.getSlots();
console.log(slots);

// Assuming the first slot is used
const slot = slots[0];

// Check if the slot has a CA certificate
if (!slot.caCertificate) {
  console.error("Token doesn't support the attestation.");
  tokenManager.close();
  return;
}

// Use specified attestation
const attestation = slot.attestations[0];

// Initialize the PivAttestationProvider
const provider = new PivAttestationProvider();
const attest = await provider.read(attestation.certificate.rawData);

// Verify the attestation using the CA certificate from the slot
const result = await provider.verify({
  attestation: attest,
  trustedCerts: [provider.getDefaultRootCert()],
  intermediateCerts: [slot.caCertificate],
});

console.log(result);

// Close the token manager
tokenManager.close();
```

## License

This project is licensed under the MIT License.
npm package: @peculiar/color
Description: Library for color manipulation and conversion in JavaScript.
Author: PeculiarVentures Team
Latest version: 0.1.10

# `@peculiar/color`

Library for color manipulation and conversion in JavaScript.

## Getting started

To install `@peculiar/color` in your project, you will need to run the
following command using [npm](https://www.npmjs.com/):

```bash
npm install @peculiar/color
```

If you prefer [Yarn](https://yarnpkg.com/en/), use the following command instead:

```bash
yarn add @peculiar/color
```

## Usage

```js
import { Color } from '@peculiar/color';

const color = new Color('#5EBC54');

color.toHex() // => '5EBC54';
color.toHsb() // => [114, 55, 74];
color.toRgb() // => [94, 188, 84];
```

### `palette`

The palette generator can be used to generate a palette for any color you input.

```js
import { Color } from '@peculiar/color';

const color = new Color('#5EBC54');

color.palette() // => Record<PaletteTypes, Color>;
```

## 📝 License

Licensed under the [MIT](/LICENSE).
npm package: @peculiar/eslint-config-react
Description: React-specific ESLint configuration extending the base configuration
Author: PeculiarVentures Team
Latest version: 0.2.9

# @peculiar/eslint-config-react

A React-specific ESLint configuration for modern JavaScript and TypeScript projects. This package integrates recommended configurations for React, TypeScript, JSX accessibility, stylistic rules, and import handling to ensure a consistent and high-quality codebase.

## Quick Start

> [!IMPORTANT]  
> If you are using [pnpm](https://pnpm.io/), be sure to create a `.npmrc` file with at least the following settings:
> ```
> auto-install-peers=true
> node-linker=hoisted
> ```
> This ensures that pnpm installs dependencies in a way that is more compatible with npm and is less likely to produce errors.


### 1. Setup Base Config

Make sure you have the base ESLint configuration set up. Install `@peculiar/eslint-config-base` by following the [installation instructions here](https://github.com/PeculiarVentures/peculiar-lint/blob/main/packages/eslint-config-base/README.md).

### 2. Install React Config

Once the base config is installed, add the `@peculiar/eslint-config-react` package:

```bash
npm install -D @peculiar/eslint-config-react
```

### 3. Configure ESLint

To use `@peculiar/eslint-config-react` in your project, configure your ESLint to extend this configuration.

1. Create or update your ESLint configuration file (e.g., `eslint.config.mjs`).
2. Extend `@peculiar/eslint-config-react` as shown below:

#### Example: `eslint.config.mjs`

```javascript
import tseslint from 'typescript-eslint';
import baseConfig from '@peculiar/eslint-config-base';
import reactConfig from '@peculiar/eslint-config-react';

export default tseslint.config([
  ...baseConfig,
  ...reactConfig,
]);
```

### Step 4: Run the Linter

After setting up, you can run ESLint using the following command:

```bash
npx eslint
```

## Features

This configuration includes:

- **React Rules:** Recommended settings for React and React Hooks using [`eslint-plugin-react`](https://www.npmjs.com/package/eslint-plugin-react) and [`eslint-plugin-react-hooks`](https://www.npmjs.com/package/eslint-plugin-react-hooks).
- **JSX Accessibility:** Ensures accessibility best practices with [`eslint-plugin-jsx-a11y`](https://www.npmjs.com/package/eslint-plugin-jsx-a11y).
- **Custom Rules:** Tailored rules for statement padding, JSX formatting, object formatting, and more.

## Customizations

Feel free to override or extend the rules in your project-specific ESLint configuration as needed. For example:

### Adding a Custom Rule

To add a custom ESLint rule, include it in your configuration as follows:

```javascript
import tseslint from 'typescript-eslint';
import baseConfig from '@peculiar/eslint-config-base';
import reactConfig from '@peculiar/eslint-config-react';

export default tseslint.config([
  ...baseConfig,
  ...reactConfig,
  {
    rules: {
      'your-custom-rule': 'warn',
    },
  },
]);
```

## License

This project is licensed under the MIT License.
npm package: @peculiar/react-components
Description: A simple and customizable component library to build faster, beautiful, and more accessible React applications.
Author: PeculiarVentures Team
Latest version: 1.8.7

# `@peculiar/react-components`

A simple and customizable component library to build faster, beautiful, and more accessible React applications.

## Getting started

To install `@peculiar/react-components` in your project, you will need to run the
following command using [npm](https://www.npmjs.com/):

```bash
npm install @peculiar/react-components
```

If you prefer [Yarn](https://yarnpkg.com/en/), use the following command instead:

```bash
yarn add @peculiar/react-components
```

## Usage

```tsx
import { Button, ThemeProvider } from '@peculiar/react-components';

function MyComponent() {
  return (
    <ThemeProvider>
      <Button>
        Example usage
      </Button>
    </ThemeProvider>
  );
}
```

## 📚 Documentation

- [Storybook](https://peculiarventures.github.io/peculiar-ui/)

## 📝 License

Licensed under the [MIT](/LICENSE).
npm package: @peculiar/webcrypto-test
Description: Mocha tests of WebCrypto API
Author: PeculiarVentures
Latest version: 1.0.7

# webcrypto-test

[![License](https://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://raw.githubusercontent.com/PeculiarVentures/webcrypto-test/master/LICENSE.md)
[![Node.js CI](https://github.com/PeculiarVentures/webcrypto-test/workflows/Node.js%20CI/badge.svg)](https://github.com/PeculiarVentures/webcrypto-test/actions?query=workflow%3A%22Node.js+CI%22)
[![Coverage Status](https://coveralls.io/repos/github/PeculiarVentures/webcrypto-test/badge.svg?branch=master)](https://coveralls.io/github/PeculiarVentures/webcrypto-test?branch=master)
[![npm version](https://badge.fury.io/js/%40peculiar%2Fwebcrypto-test.svg)](https://badge.fury.io/js/%40peculiar%2Fwebcrypto-test)

This module allows you to test cryptographic modules.

## Table Of Contents

* [Installing](#installing)
* [Using](#using)
  * [Run all tests](#run-all-tests)
  * [Run selected tests](#run-selected-tests)
  * [Disable tests](#disable-tests)
  * [Run custom test](#run-custom-test)

## Installing

```
npm install @peculiar/webcrypto-test
```

## Using

### Run all tests
```js
const { WebcryptoTest } = require("@peculiar/webcrypto-test");
const { Crypto } = require("@peculiar/webcrypto");

WebcryptoTest.check( new Crypto());
```
### Run selected tests
```js
const { WebcryptoTest } = require("@peculiar/webcrypto-test");
const  vectors = require("./vectors");
const { Crypto } = require("@peculiar/webcrypto");

WebcryptoTest.check(new Crypto(), [vectors.ECDSA, vectors.ECDH]);
```
### Disable tests
To exclude vectors, you must set them to true
```js
const { WebcryptoTest } = require("@peculiar/webcrypto-test");
const { Crypto } = require("@peculiar/webcrypto");

WebcryptoTest.check(new Crypto(), {
  ECDSA: true,
  ECDH: true,
});
```
### Run custom test
```js
const { WebcryptoTest } = require("@peculiar/webcrypto-test");
const { Crypto } = require("@peculiar/webcrypto");

const myVector = {
  name: "AES-128-CBC",
  actions: {
    generateKey: [
      {
        algorithm: { name: "AES-CBC", length: 128 },
        extractable: true,
        keyUsages: ["encrypt", "decrypt"],
      },
    ],
    encrypt: [
      {
        algorithm: {
          name: "AES-CBC",
          iv: Buffer.from("1234567890abcdef"),
        },
        data: Buffer.from("test message"),
        encData: Buffer.from("d5df3ea1598defe7446420802baef28e", "hex"),
        key: {
          format: "raw",
          data: Buffer.from("1234567890abcdef"),
          algorithm: { name: "AES-CBC" },
          extractable: true,
          keyUsages: ["encrypt", "decrypt"],
        },
      },
    ]
  }
}

WebcryptoTest.add(new Crypto(), myVector);
```
npm package: @pecureo/anvil-stream
Description: Stream-Based Authorization framework for Anvil Connect
Author: Joris Kraak
Latest version: 0.5.0

# Stream-based Authorization Framework for Anvil Connect

This is a library implementing authorization/anthentication flows for [Anvil
Connect](http://anvil.io/) based on [Rx.js](https://reactivex.io/rxjs).

## Instantiating an `Issuer`

`Issuer` instances form the basis of the authorization flows. They need to be
passed an object with the following interface to be able to operate:
```
OidcConfiguration {
  client_id: string;
  issuer: string;
  redirect_uri: string;
}
```
Optionally a `client_secret` key may be included as well, but this will
typically not be necessary for applications running 'client-side'.

## Authorization

Authorization flows can be instantiated in two different forms, either using
full page navigation or using a pop-up. These methods take at least an array of
'scopes', and optionally an object adhering to the following interface:
```
export interface AuthorizationOptions {
  // Whether to close any popups used in the authorization process (defaults to
  // true). When disabled, requires additional logic in the authorization flow
  // callback handling to close the popup
  close_popup?: boolean;

  // Can be used to force a path on the cookie used to store the secret
  // encrypting the tokens stored in localStorage. This can be useful when
  // running the authorization flow from a sub-path of a domain while
  // authorizing for the entire domain
  force_path?: string;

  // The time in seconds for which the session may stay active
  max_age?: number;

  // By specifying a provider, the authorization process will only use that
  // specific provider instead of showing a selector providing access to all
  // identity providers available to the issuer
  provider?: string;

  // Whether to replace the active 'persisted' (i.e. across page reloads)
  // session
  replace_active_session?: boolean;

  // Setting to true implies replacing the active session
  retrieve_user_info?: boolean;
}
```

### Authorization flow using full-page navigation

Call `authorizeFullPage` on an `Issuer` instance

### Authorization flow in popup

Call `authorizeWithPopup` on the `Issuer`. The page located at `redirect_uri`
must capture its full URI and 'post' it back to the window that initiated the
authorization flow using code such as
```javascript
window.addEventListener('load', function() {
  var opener = window.opener;
  if(opener) {
    opener.postMessage(window.location.href, opener.location.origin);
    window.close();
  }
});
```
npm package: @pedalboard/components
Description: A set of well-crafted components
Author: Matti Bar-Zeev
Latest version: 0.6.25

# @pedalboard/components

A set of well-crafted React components.

## Installation

### pnpm
```bash
pnpm add @pedalboard/components
```

### npm
```bash
npm install @pedalboard/components
```

## Peer Dependencies

This package requires the following peer dependencies:
- `react` ^17.0.2
- `react-dom` ^17.0.2
- `prop-types` ^15.8.0

## Components

### Pagination

A pagination component that provides navigation controls for paginated content.

#### Props

| Prop | Type | Description |
|------|------|-------------|
| `totalPages` | `number` | Total number of pages |
| `initialCursor` | `number` | Initial page index (0-based) |
| `pagesBuffer` | `number` | Number of page indicators to display |
| `onChange` | `() => void` | Callback fired when page changes |

#### Usage

```jsx
import {Pagination} from '@pedalboard/components';

function MyComponent() {
    const handlePageChange = () => {
        console.log('Page changed');
    };

    return (
        <Pagination
            totalPages={10}
            initialCursor={0}
            pagesBuffer={5}
            onChange={handlePageChange}
        />
    );
}
```

## Storybook

This package includes a Storybook for component documentation and visual testing. To run it locally:

```bash
cd packages/components
pnpm run storybook
```

## Resources

- [Creating a React Component Generator](https://dev.to/mbarzeev/creating-a-react-component-generator-3g6)

## License

MIT
npm package: @pedalboard/eslint-plugin-craftsmanlint
Description: A set of ESlint rules for your code craftsmanship
Author: Matti Bar-Zeev
Latest version: 1.2.19

# @pedalboard/eslint-plugin-craftsmanlint

A set of ESLint rules for your code craftsmanship.

## Installation

### yarn
```bash
yarn add @pedalboard/eslint-plugin-craftsmanlint -D
```

### npm
```bash
npm install @pedalboard/eslint-plugin-craftsmanlint -D
```

## Setup

Add the plugin to your ESLint configuration file (`.eslintrc.json`):

```json
{
    "plugins": ["@pedalboard/craftsmanlint"],
    "rules": {
        "@pedalboard/craftsmanlint/no-namespace-imports": "error"
    }
}
```

## Rules

### no-namespace-imports

Disallows namespace imports (e.g., `import * as something from 'module'`).

Namespace imports can make it harder to tree-shake unused code and can obscure which specific exports are being used. This rule encourages the use of named imports for better code clarity and optimization.

#### Configuration

**Basic usage** - Disallow namespace imports from all modules:

```json
{
    "rules": {
        "@pedalboard/craftsmanlint/no-namespace-imports": "error"
    }
}
```

**With specific modules** - Only disallow namespace imports from certain modules:

```json
{
    "rules": {
        "@pedalboard/craftsmanlint/no-namespace-imports": [
            "error",
            {
                "forbiddenModules": ["lodash", "./utils"]
            }
        ]
    }
}
```

#### Examples

**Invalid code:**

```javascript
// When rule is enabled for all modules
import * as utils from './utils';
import * as _ from 'lodash';

// When rule is configured with forbiddenModules: ['lodash']
import * as _ from 'lodash';
```

**Valid code:**

```javascript
// Named imports are always allowed
import {map, filter} from 'lodash';
import {myFunction} from './utils';

// Default imports are allowed
import React from 'react';
```

## License

MIT
npm package: @pedalboard/git-hooks
Description: A set of JS Git hooks
Author: Matti Bar-Zeev
Latest version: 1.1.1

# @pedalboard/git-hooks
A set of JS Git hooks

## Installation
### yarn
```bash
yarn add @pedalboard/git-hooks -D
```
### npm
```bash
npm i @pedalboard/git-hooks -D
```

## Usage
The hooks are meant to be used in a Git hook (e.g. pre-commmit, commit-msg, etc.).  
To use the hooks under this package you need to make sure that your hooks are running in NodeJS env. Here is an example of such a hook:

```bash
#!/usr/bin/env node

const {conventionalCommitsValidationHook} = require('@pedalboard/git-hooks');
conventionalCommitsValidationHook.execute();
```

## Hooks
### Conventional Commits Validation Hook
This hook's purpose is to make sure all commit messages follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) standard.
npm package: @pedalboard/hooks
Description: A set of well-crafted React hooks
Author: Matti Bar-Zeev
Latest version: 0.3.5

# @pedalboard/hooks

A set of well-crafted React hooks.

## Installation

### yarn
```bash
yarn add @pedalboard/hooks
```

### npm
```bash
npm install @pedalboard/hooks
```

## Peer Dependencies

This package requires the following peer dependencies:
- `react` ^17.0.2
- `react-dom` ^17.0.2

## Hooks

### usePagination

A hook for managing pagination state with navigation controls.

#### Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `totalPages` | `number` | Yes | - | Total number of pages |
| `initialCursor` | `number` | No | `0` | Initial page index (0-based) |
| `onChange` | `(value: number) => void` | No | - | Callback fired when cursor changes |

#### Returns

| Property | Type | Description |
|----------|------|-------------|
| `cursor` | `number` | Current page index |
| `totalPages` | `number` | Total number of pages |
| `goNext` | `() => void` | Navigate to next page |
| `goPrev` | `() => void` | Navigate to previous page |
| `setCursor` | `(cursor: number) => void` | Set cursor to specific page |

#### Usage

```tsx
import {usePagination} from '@pedalboard/hooks';

function MyPaginatedList() {
    const {cursor, totalPages, goNext, goPrev, setCursor} = usePagination({
        totalPages: 10,
        initialCursor: 0,
        onChange: (page) => {
            console.log(`Navigated to page ${page}`);
        },
    });

    return (
        <div>
            <p>Page {cursor + 1} of {totalPages}</p>
            <button onClick={goPrev} disabled={cursor === 0}>
                Previous
            </button>
            <button onClick={goNext} disabled={cursor === totalPages - 1}>
                Next
            </button>
            <button onClick={() => setCursor(0)}>
                Go to first page
            </button>
        </div>
    );
}
```

#### Error Handling

The hook will throw an error if `totalPages` is not provided:

```tsx
// This will throw: "The UsePagination hook must receive a totalPages argument for it to work"
const pagination = usePagination({});
```

## Resources

- [Converting Your React Hook To TypeScript](https://dev.to/mbarzeev/converting-your-react-hook-to-typescript-2439)
- [Mocking Data-Fetching React Hooks](https://dev.to/mbarzeev/mocking-data-fetching-react-hooks-2h1c)

## License

MIT
npm package: @pedalboard/scripts
Description: A set of reusable scripts
Author: Matti Bar-Zeev
Latest version: 0.2.6

# @pedalboard/scripts
A set of reusable scripts.

## Installation
```bash
pnpm add @pedalboard/scripts -D
```
## Scripts

*** 
### **collectFiles**
This script allows you to collect files which match a given pattern into a target directory

### Usage
In the following example you collect all the coverage-finals.json files  under the packages directory and place them in `.nyc_output`.
```json
"scripts": {
    "collect": "pedalboard-scripts collectFiles --pattern='packages/**/coverage-final.json' --target='.nyc_output'"
}
```

***

### **aggregatePackagesCoverage**
This scripts allow you to aggregate all the unit test coverage report from all packages directory of your monorepo

#### Usage
You'd typically want to call this script form the root project of your monorepo, e.g.
```json
"scripts": {
    "coverage:combined": "pedalboard-scripts aggregatePackagesCoverage"
}
```
Following this script you can then call [nyc](https://github.com/istanbuljs/nyc) to create a combined report for all packages at once, which can look something like this -
```json
"scripts": {
    "coverage:combined": "pedalboard-scripts aggregatePackagesCoverage && nyc report --reporter lcov"
}
```

***

## Resources

- [Yarn Workspace Scripts Refactor - A Case Study](https://dev.to/mbarzeev/yarn-workspace-scripts-refactor-a-case-study-4ol0)

## License

MIT
npm package: @pedaling/eslint-config-pedaling
Description: ESLint configuration
Author: Pedaling
Latest version: 1.0.6

# eslint-config-pedaling

## deps
- eslint-config-airbnb: ^16.1.0
- eslint-plugin-flowtype: ^2.46.0
- eslint-plugin-import: 2.9.0
- eslint-plugin-jest: ^21.12.2
- eslint-plugin-jsx-a11y: ^6.0.3
- eslint-plugin-react: "^7.7.0
npm package: @pedaling/firebase-entities-manager
Description: - redux-thunk (must be configured with 'createStore(...)')
Latest version: 0.11.17

## prerequisites
- redux-thunk (must be configured with 'createStore(...)')

## installation
`$ yarn add @pedaling/firebase-entities-manager`

## upgrade
`$ yarn upgrade @pedaling/firebase-entities-manager --latest`

## guides

1. [Define EntitiesDefinition](docs/define-entities-definition.md)
2. [Configure EntitiesManager](docs/configure-entities-manager.md)
3. [Usages without react](docs/usages-without-react.md)
4. [Usages with react](docs/usages-with-react.md)