open-index/open-npm huggingface dataset:
npm package: @haptik/interakt-connect-button
Description: ## With yarn
Latest version: 1.0.0

Interakt Connect Button

# Installation

## With yarn

```
yarn add @haptik/interakt-connect-button
```

## With pnpm

```
pnpm add @haptik/interakt-connect-button
```

## With NPM

```
npm install @haptik/interakt-connect-button
```

<br/>
<br/>

# Getting started

Add the Interakt Connect Button to your app:

```jsx
import InteraktConnectButton from "@haptik/interakt-connect-button";
import "@haptik/interakt-connect-button/dist/style.css";

const App = () => {
  const handleCallback = (callbackObject) => {
    console.log("Api Key: " + callbackObject.publicApiSecretKey);
    console.log("Channel Id: " + callbackObject.phoneNumberId);
    console.log("WhatsApp Api Number: " + callbackObject.waApiNumber);
    console.log("Waba Id: " + callbackObject.wabaId);
  };

  return (
    <InteraktConnectButton
      partnerId={"your-partner-id"}
      callback={handleCallback}
    />
  );
};
```

<br/>
<br/>

# Properties

Following properties are supported by the button component:

| Property name | Type | Description | Required |
| ------------- | ---- | ----------- | -------- |
| partnerId     | string   | Your Interakt Partner ID   | ✅       |
| callback        | (callbackObject: { phoneNumberId: string, waApiNumber: string, wabaId: string, publicApiSecretKey: string }) => void | Callback function, that receives the returned phone number id, whatsapp api number, whatsapp business id, public api secret key | ✅       | label           | string                                                                                                               | Optional parameter to provide a custom button label                                                                             |          |
| className       | string                                                                                                               | Optional string for adding custom class name                                                                                    |          |
| style           | React.CSSProperties                                                                                                  | Optional style property to override styles                                                                                      |          |
| queryParameters | { phone?: string, country_code?: string; }                                                                           | Optional query parameters that get passed to the sign up form for pre-filling                                                   |          |     |

<br/>
npm package: @haptix/core
Description: **haptix:** MacOS touchpad haptics
Latest version: 0.2.4

# haptix

**haptix:** MacOS touchpad haptics

## Installing haptix

`haptix` is only supported on MacOS.

You can install the project with npm/pnpm/yarn.

```sh
$ npm install haptix
$ pnpm install haptix
$ yarn install haptix
```

## How do I use it?

There's only one method!

```js
const { perform, PerformanceTime, FeedbackPattern } = require("@haptix/core");
// or
import { perform, PerformanceTime, FeedbackPattern } from "@haptix/core";

perform(FeedbackPattern.Generic, PerformanceTime.Now);
```

Note that nothing will happen unless you're touching the touchpad.

## Internal API? :D

There's an internal reverse-engineered API that's undocumented and may cause your app to be rejected from the Mac App Store.
It's WAY stronger vibration, and it will work without the user touching the trackpad.

```js
import { Actuation, internalApiPerform } from "./index.js";

internalApiPerform(Actuation.Strong);
```

### Internal-er API? :D

Sure ok here is an unsafe Rust function that calls an undocumented FFI API with unknown parameters.
This is likely to segfault :)

```js
import { internalApiPerform } from "./index.js";

// unsafeInternalApiPerform(actuation: integer number, unknown1: integer number, unknown2: floating point number, unknown3: floating point number): void
unsafeInternalApiPerform(6, 0, 0.0, 0.0);
```

## Building haptix from source locally

After cloning this repo, simply run

```sh
$ yarn build
```

# Other Links

This project was built using Node, Rust, and napi-rs.

To learn more about napi, see the [napi documentation](https://napi.rs/docs/introduction/simple-package).

To learn more about Rust, see the [Rust documentation](https://www.rust-lang.org).

To learn more about Node, see the [Node documentation](https://nodejs.org).
npm package: @haqex/claude
Description: Drop-in Claude Code bundles — install production-grade AI skills into any project in one command
Author: haqex
Latest version: 1.0.5

# @haqex/claude

Drop-in Claude Code bundles. Install production-grade AI skills into any project in one command — no config, no setup, no `.claude/` copying required.

## Usage

```bash
npx @haqex/claude
```

Interactive menu — pick which bundle(s) to install.

```bash
npx @haqex/claude frontend
npx @haqex/claude learn
npx @haqex/claude frontend learn
```

Install specific bundles directly.

## What happens

1. Selected bundle(s) are copied into `./haqex/<bundle-name>/` in your project
2. The activation prompt is printed — paste it to Claude and you're done

## Bundles

| Bundle | Skills | What It Does |
|--------|--------|-------------|
| `frontend` | impeccable-design, audit, polish, normalize, critique | Production frontend design — distinctive UI, accessibility, anti-AI-slop |
| `learn` | youtube-to-skill, build-scroll-animation, generate-scroll-frames, generate-transition-video | YouTube knowledge capture + 3D scroll animation pipeline |
| `core` | run-pipeline, approve-proposal | Pipeline orchestration |

> Every bundle includes `run-pipeline` — no separate core install needed.

## Activation

After install, Claude prints a prompt like:

```
I've added the frontend bundle to this project at `./haqex/frontend`.
Read `./haqex/frontend/BUNDLE.md` to load all skills and rules.
Use `./haqex/frontend` as the bundle root for all skill and pipeline lookups.
```

Paste that to Claude. It reads the bundle and all skills are immediately available.

## Example session

```bash
$ npx @haqex/claude frontend

  ✓ Installed frontend → ./haqex/frontend

  Activate with Claude:
  ────────────────────────────────────────────────────────────
  I've added the frontend bundle to this project at `./haqex/frontend`.
  Read `./haqex/frontend/BUNDLE.md` to load all skills and rules.
  Use `./haqex/frontend` as the bundle root for all skill and pipeline lookups.
  ────────────────────────────────────────────────────────────
```

Then in Claude:
```
run-pipeline frontend-build target="a pricing page"
```
npm package: @haqq/format-number-with-subscript-zeros
Description: A library to format numbers using scientific notation with subscript zeros. This method is particularly useful for representing very small numbers in a compact and readable format.
Author: iGroza
Latest version: 1.0.1

# Format Number with Subscript Zeros

A library to format numbers by hiding leading zeros using subscript digits. This method is particularly useful for representing very small numbers in a compact and readable format. The subscript digits indicate the number of hidden zeros.

[Documentation](https://github.com/haqq-network/format-number-with-subscript-zeros/blob/master/docs/globals.md)

## Installation

```bash
yarn add @haqq/format-number-with-subscript-zeros
```

## Usage

```ts
import { formatNumberWithSubscriptZeros } from '@haqq/format-number-with-subscript-zeros';

console.log(formatNumberWithSubscriptZeros("0.42"));               // "0.42"
console.log(formatNumberWithSubscriptZeros("0.042"));              // "0.042"
console.log(formatNumberWithSubscriptZeros("0.0042"));             // "0.0042"
console.log(formatNumberWithSubscriptZeros("0.00042"));            // "0.00042"
console.log(formatNumberWithSubscriptZeros("0.000042"));           // "0.000042"
console.log(formatNumberWithSubscriptZeros("0.0000042"));          // "0.0₅42"
console.log(formatNumberWithSubscriptZeros("0.00000042"));         // "0.0₆42"
console.log(formatNumberWithSubscriptZeros("0.000000042"));        // "0.0₇42"
console.log(formatNumberWithSubscriptZeros("0.0000000042"));       // "0.0₈42"
console.log(formatNumberWithSubscriptZeros("0.00000000042"));      // "0.0₉42"
console.log(formatNumberWithSubscriptZeros("0.000000000042"));     // "0.0₁₀42"
console.log(formatNumberWithSubscriptZeros("0.0000000000042"));    // "0.0₁₁42"
console.log(formatNumberWithSubscriptZeros("0.00000000000042"));   // "0.0₁₂42"
```

### Additional Parameters

The formatNumberWithSubscriptZeros function accepts the following parameters:

 - numberStr (string): The number string to format.
 - presiction (number, optional): The number of decimal places to include in the formatted string. Default is 3.
 - min (number, optional): The minimum value for which the formatting should be applied. Default is 0.00001.

## Running Tests

```sh
yarn test
```

## Building the Project

```sh
yarn build
```

## Linting the Code

```sh
yarn lint
```

## Benefits and Convenience

This method of formatting numbers is particularly useful for:

	• Readability: It makes very small numbers easier to read and understand by representing leading zeros as subscript digits.
	• Compact Representation: It reduces the length of the number string by using subscript digits for leading zeros.
	• Scientific Applications: It is useful in scientific and engineering contexts where numbers can be extremely small and a clear representation is needed.

## How It Works

The function converts the number string to a floating-point number and checks if it is less than 0.01. If the number is larger, it returns the original string. For smaller numbers, it calculates the number of leading zeros and formats them as subscript digits.

## License

MIT
npm package: @haqq/provider-mnemonic-react-native
Description: Provider for mnemonic phrase
Author: vivalaakam
Latest version: 0.0.14

# Provider for mnemonic on react-native platform

provider for working with mnemonic phrase

[docs](https://github.com/haqq-network/haqq-wallet-provider-mnemonic-react-native/blob/main/docs/modules.md)
npm package: @haqq/provider-sss-react-native
Description: Provider for react-native ledger
Author: vivalaakam
Latest version: 0.0.14

# Provider for multi party connection on react-native platform

provider for working with multi party connection

[docs](https://github.com/haqq-network/haqq-wallet-provider-sss-react-native/blob/main/docs/modules.md)
npm package: @haqq/provider-web3-utils
Description: Web3 utils for react-native
Author: vivalaakam
Latest version: 0.0.14

# Encryption service in RN


libs for work with private key/mnemonic such as generate mnemonic, derive hd path and sign transaction (shared between all providers)

[docs](https://github.com/haqq-network/haqq-wallet-provider-web3-utils/blob/main/docs/modules.md)
npm package: @haqq/rn-wallet-providers
Description: React Native providers for Haqq wallet
Latest version: 0.0.12

# HAQQ RN Wallet Providers

![NPM publish](https://github.com/haqq-network/haqq-rn-wallet-providers/actions/workflows/npm-publish.yml/badge.svg)

[![NPM](https://nodei.co/npm/@haqq/rn-wallet-providers.png?downloads=true)](https://www.npmjs.com/package/@haqq/rn-wallet-providers)
npm package: @haquesomrat/react-useful-hooks
Description: Production-ready React + TypeScript hooks: debounced state, async memo, storage, hotkeys, observers, and more.
Latest version: 0.0.1

# @haquesomrat/react-useful-hook

A carefully curated set of **production‑ready hooks** for React + TypeScript. SSR‑aware, strongly typed, zero external deps.

## Hooks

- **State & timing**: `useDebouncedState`, `useThrottleFn`, `useTimeout`, `useInterval`
- **Async**: `useAsyncMemo`
- **Refs & callbacks**: `useLatest`, `useStableCallback`, `usePrevious`, `useMounted`
- **Events & hotkeys**: `useEventListener`, `useHotkeys`
- **Storage**: `useLocalStorage<T>`, `useSessionStorage<T>`
- **Media & observers**: `useMediaQuery`, `useIntersectionObserver`, `useMutationObserver`, `useMeasure`
- **UX utilities**: `useClickOutside`, `useCopyToClipboard`, `useNetworkStatus`

## Install

```bash
npm i @haquesomrat/react-use
```

## Quickstart

```tsx
import {
  useDebouncedState,
  useLocalStorage,
  useHotkeys,
} from "@haquesomrat/react-use";

function Demo() {
  const [raw, setRaw, debounced] = useDebouncedState("", 300);
  const [name, setName] = useLocalStorage<string>("name", "");
  useHotkeys({ "ctrl+k": () => alert("Palette!") });
  return (
    <div>
      <input
        value={raw}
        onChange={(e) => setRaw(e.target.value)}
        placeholder="Search"
      />
      <p>Debounced: {debounced}</p>
      <input
        value={name}
        onChange={(e) => setName(e.target.value)}
        placeholder="Name"
      />
    </div>
  );
}
```

## Patterns & Guarantees

- All callbacks wrapped by `useStableCallback` to avoid stale closures.
- SSR‑safe: guards for `window`, `document`, and observers.
- Strong TS types, generic friendly.

## Testing ideas (Vitest)

- `useDebouncedState` updates after delay.
- `useAsyncMemo` resolves value, cancels on unmount.
- `useLocalStorage` reads/writes JSON.
- `useHotkeys` triggers only on exact combos.

## Roadmap

- `useUndoRedo` state helper
- `useList` and `useSet` typed collections
- `useFetch` tiny fetch wrapper (abortable)
- `useUrlQueryState` (for Next.js app router)
npm package: @har-sdk/capture
Description: Fetch requests in HAR format
Author: Artem Derevnjuk
Latest version: 1.2.2

# @har-sdk/capture

Fetch requests in HAR format

This module makes a request and captures it as a [HAR](http://www.softwareishard.com/blog/har-12-spec/) object.
Under the covers it uses [request](https://www.npmjs.com/package/request) and just passes through all options.
Currently only GET requests are supported although other methods will probably work. The request body might not be properly captured though.

It can now be also used in stream mode. This means that it will stream data events containing the body of the response and then at the end event, the HAR object will be accessible.

## Setup

```bash
npm i --save @har-sdk/capture
```

## API

```ts
import { captureHar } from '@har-sdk/capture';

captureHar(
  {
    url: 'http://www.google.com'
  },
  { withContent: false }
).then((har) => {
  console.log(JSON.stringify(har, null, 2));
});
```

#### `requestOptions`

The [options](https://www.npmjs.com/package/request#requestoptions-callback) for making the request, is just passed through to request package.
This can accept the url directly.

#### `harOptions`

Optional configuration for the resulting HAR object.

##### `withContent`

Defaults to `true`. Specifies whether the response content object should contain the full body of the response.

##### `maxContentLength`

Defaults to `Infinity`. Limits the response body to a maximum byte size.
If the response body is larger than the specified limit, the content text won't exist and an error will be returned for this entity with the code `MAX_RES_BODY_SIZE`.
npm package: @har-sdk/core
Description: The base package can be used to import specification files (i.e. HAR, OAS and Postman Collection) and detect their type.
Author: Artem Derevnjuk
Latest version: 1.5.0

# @har-sdk/core

The base package can be used to import specification files (i.e. HAR, OAS and Postman Collection) and detect their type.

## Setup

```bash
npm i --save @har-sdk/core
```

## Usage

To import a specification you just need to create an instance of `SpecImporter` and call its `import` method passing the data file. The importer performs syntactic analysis and parses a provided file.

```ts
import { SpecImporter } from '@har-sdk/core';

const result = await new SpecImporter().import(sourceAsString);
console.log(result);
// {
//   type: 'postman',
//   format: 'json',
//   doc: {
//     info: {
//       name: 'Postman Sample',
//       schema: 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json'
//     },
//     item: [
//       // ...
//     ]
//   },
//   name: 'Postman Sample.json'
// }
```

To configure the list of importers, you can pass them as an array to the constructor.

```ts
import { SpecImporter, HarImporter } from '@har-sdk/core';

const explorer = new SpecImporter([new HarImporter()]);
```

To extend an explorer by adding a new custom importer, you can easily implement an `Importer` interface.

```ts
import { Importer, Doc, Spec, Importer } from '@har-sdk/core';

class RamlImporter implements Importer<'raml'> {
  get type(): 'raml' {
    return 'raml';
  }

  async import(content: string): Promise<Spec<'raml'>> {
    // your code

    return {
      // other fields
      type: this.type,
      format: 'yaml'
    };
  }
}
```

The package also contains a set of useful utilities like `normalizeUrl`:

```ts
import { normalizeUrl } from '@har-sdk/core';

normalizeUrl('HTTP://example.COM////foo////dummy/../bar/?'); // http://example.com/foo/bar
```
npm package: @har-sdk/postman
Description: [![Maintainability](https://api.codeclimate.com/v1/badges/4acaec95c82465cb2c3d/maintainability)](https://codeclimate.com/github/NeuraLegion/har-sdk/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/4acaec95c82465cb2c3d/test_coverage
Author: Artem Derevnjuk
Latest version: 2.4.7

# @har-sdk/postman

[![Maintainability](https://api.codeclimate.com/v1/badges/4acaec95c82465cb2c3d/maintainability)](https://codeclimate.com/github/NeuraLegion/har-sdk/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/4acaec95c82465cb2c3d/test_coverage)](https://codeclimate.com/github/NeuraLegion/har-sdk/test_coverage)
[![Build Status](https://github.com/NeuraLegion/har-sdk/actions/workflows/auto-build.yml/badge.svg?branch=master)](https://github.com/NeuraLegion/har-sdk/actions/workflows/auto-build.yml?query=branch%3Amaster+event%3Apush)
[![NPM Downloads](https://img.shields.io/npm/dw/@har-sdk/oas?label=NPM%20Downloads)](https://www.npmjs.com/package/@har-sdk/postman)

Transform your [Postman collection](https://blog.postman.com/postman-essentials-exploring-the-collection-format/) into a series of [HAR request objects](http://www.softwareishard.com/blog/har-12-spec/#request). This can be useful for a variety of purposes, such as analyzing network performance and debugging web applications.

- Reuse values in [Postman variables](https://learning.postman.com/docs/sending-requests/variables/) to resolve data.
- Automatically generates fake data using [the Dynamic variables](https://learning.postman.com/docs/writing-scripts/script-references/variables-list/).
- Compatible with [v2.0.0](https://schema.postman.com/collection/json/v2.0.0/draft-07/docs/index.html) and [v2.1.0](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html) collections.
- Simple and easy-to-use API.

With this library, you can easily generate requests with fake data to test your API using [AutoCannon](https://github.com/mcollina/autocannon#readme) or [DevTools](https://developer.chrome.com/blog/new-in-devtools-62/#har-imports).

## Setup

To install the library, run the following command:

```bash
$ npm i --save @har-sdk/postman
```

## Usage

To convert your collection, use the `postman2har` function as follows:

```js
import collection from './postman-collection.json' assert { type: 'json' };
import { postman2har } from '@har-sdk/postman';

const requests = await postman2har(collection);
console.log(requests);
```

If you want to pass additional data to resolve environment variables, you can do so by passing an options object as the second parameter:

```js
const requests = await postman2har(collection, {
  environment: { baseUrl: 'https://example.com' }
});
console.log(requests);
```

## License

Copyright © 2023 [Bright Security](https://brightsec.com/).

This project is licensed under the MIT License - see the [LICENSE file](https://github.com/NeuraLegion/har-sdk/blob/master/LICENSE) for details.
npm package: @har-sdk/types
Description: **THIS PACKAGE HAS BEEN DEPRECATED. THE DEVELOPMENT HAS MOVED TO A [@HAR-SDK/CORE](https://github.com/NeuraLegion/har-sdk/tree/master/packages/oas#readme) PACKAGE**
Author: Artem Derevnjuk
Latest version: 1.1.10

# @har-sdk/types

**THIS PACKAGE HAS BEEN DEPRECATED. THE DEVELOPMENT HAS MOVED TO A [@HAR-SDK/CORE](https://github.com/NeuraLegion/har-sdk/tree/master/packages/oas#readme) PACKAGE**

Types for OpenAPI and Postman documents

## Setup

```bash
npm i --save @har-sdk/types
```

## Usage

```ts
import { OpenAPIV2, isOASV2 } from '@har-sdk/types';

const apiDoc = {
  swagger: '2.0',
  host: 'localhost',
  info: {
    title: 'Some valid API document'
  },
  paths: {}
} as OpenAPIV2.Document;

isOASV2(apiDoc); // returns true
```
npm package: @har-sdk/validator
Description: A validator for HAR v1.2 Spec, OpenAPI and Postman documents.
Author: Artem Derevnjuk
Latest version: 2.6.1

# @har-sdk/validator

A validator for HAR v1.2 Spec, OpenAPI and Postman documents.

## Setup

```bash
npm i --save @har-sdk/validator
```

## Usage

```ts
import { OpenAPIV2 } from '@har-sdk/types';
import { OASValidator, ErrorHumanizer } from '@har-sdk/validator';

const apiDoc = {
  swagger: '2.0',
  host: 'localhost',
  info: {
    title: 'Some valid API document'
  },
  paths: {}
} as OpenAPIV2.Document;

const errors = await new OASValidator().verify(apiDoc as any);
console.log(errors);
// [
//   {
//     "instancePath": "/info",
//     "schemaPath": "#/required",
//     "keyword": "required",
//     "params": {
//       "missingProperty": "version"
//     },
//     "message": "must have required property 'version'"
//   }
// ]

const humanizedErrors = await new ErrorHumanizer().humanizeErrors(errors);
console.log(humanizedErrors);
// [
//   {
//     "originalError": {
//       "instancePath": "/info",
//       "schemaPath": "#/required",
//       "keyword": "required",
//       "params": {
//         "missingProperty": "version"
//       },
//       "message": "must have required property 'version'"
//     },
//     "message": "the value at /info is missing the required field `version`",
//     "messageParts": [
//       {
//         "text": "the value at /info",
//         "jsonPointer": "/info"
//       },
//       {
//         "text": "is missing the required field `version`"
//       }
//     ]
//   }
// ]
```

See [Error Object](https://ajv.js.org/api.html#error-objects)
npm package: @har-tools/http-message
Description: JavaScript API to create an HTTP message from Fetch API requests/responses.
Author: Artem Zakharchenko
Latest version: 0.1.2

# `@har-tools/http-message`

JavaScript API to create an HTTP message from Fetch API requests/responses.

## Installation

```sh
npm install @har-tools/http-message
```

## API

### `new HttpMessage(startLine, headers, body)`

Creates a new HTTP message from the given start line, heades, and optional body.

### `HttpMessage.fromRequest(request)`

- `request: Request`

Creates a new HTTP message from the given request instance.

```js
const request = new Request('https://example.com', {
  method: 'POST',
  body: 'Hello world!',
})
const message = HttpMessage.from(request)

console.log(message)
// POST https://example.com HTTP/1.0
// content-type: text/plain;charset=UTF-8
//
// Hello world!
```

### `HttpMessage.fromResponse(response)`

- `response: Response | http.IncomingMessage`

Creates a new HTTP message from the given response instane.

```js
const response = new Response(
  JSON.stringify({
    id: 1,
    name: 'John',
  }),
  {
    status: 201,
    headers: {
      'Content-Type': 'application/json',
      'X-Custom-Header': 'Value',
    },
  }
)
const message = HttpMessage.from(response)

console.log(message)
// HTTP/1.0 201 Created
// content-type: application/json
// x-custom-header: Value
//
// {"id":1,"name":"John"}
```

> Make sure to _clone the response_ before passing it to the `.fromResponse()` method. This method reads the response body.
npm package: @har-tools/stream
Description: Create a stream of HAR entries from the Fetch API Request/Response instances
Author: Artem Zakharchenko
Latest version: 0.1.2

# `@har-tools/stream`

Create a stream of HAR entries from the Fetch API Request/Response instances.

## Installation

```sh
npm install @har-tools/stream
```

## Usage

```js
import { HarStream, NetworkEntry } from '@har-tools/stream'

// Create an HAR stream.
const stream = new HarStream()

// Create a new network entry.
const entry = new NetworkEntry(new Request('https://example.com'))

// Write the network entry early.
// As soon as you ".end()" the entry with a Response,
// the stream will emit the complete HAR entry.
stream.write(entry)

// Call the ".end()" method once you receive the response.
entry.end(new Response('Hello world'))
```

Listening to HAR entries:

```js
stream.on('data', (entry) => {
  // Observe generated HAR entries as they come in.
  console.log(entry.request, entry.response)
})
```

Stop the stream:

```js
stream.destroy()
```

## Timings

You can control the network entry timings using the `entry.timings` API. It provides you with the methods you have to call _sequentially_ to indicate various staged of the request.

**The order of the timing metrics:**

1. `socketOpened`, socket opened but not connected yet.
1. `dnsLookupEnd`, socket has resolved the DNS name.
1. `connected`, socket has connected.
1. `connectedSecure` (_Optional_)
1. `requestEnd`, request is finished (request headers and body sent).
1. `responseStart`, first byte of the response received.
1. `responseEnd`, last byte of the response received.

Entry timings are _dependent_, so if the previous timing is missing, the next one will not be calculated. For example, if `entry.timings.dnsLookupEnd()` was never called, the network entry will have both `dns` and `connected` timings as `-1`.
npm package: @har4s/use-local-storage
Description: A React Hook for using Browser Local/Session Storage
Author: Hares Khalvati
Latest version: 0.3.4

# Use Local Storage

A React Hook for using Browser Local/Session Storage

## Installation

```shell
npm install @har4s/use-local-storage
```

or

```shell
yarn add @har4s/use-local-storage
```

## Usage

```js
import { useLocalStorage } from '@har4s/use-local-storage';
// or import { useSessionStorage } from '@har4s/use-local-storage';

export const Example = () => {
  // ...
  const [something, setSomething] = useLocalStorage('key', 'fallback');
  // or const [something, setSomething] = useSessionStorage('key', {...});
  // or const [something, setSomething] = useLocalStorage('key', 'fallback',{ persistent:false });
  // ...
};
```