open-index/open-npm huggingface dataset:
npm package: @lechihuy/gennote-react
Description: A free block-style editor based on Tiptap
Author: Lê Chí Huy
Latest version: 0.0.68

Gennote is a free block-style editor based on Tiptap.


## Installation
Gennote is styled editor with [TailwindCSS](https://tailwindcss.com/), so you should install it to sync with the editor.

To install Gennote for React, you can run it:
```
npm i @lechihuy/gennote-react
```

## Usage
This is a demo that use Gennote editor in a Next.js project.

```tsx
import React from 'react'
import '@gennote/react/dist/styles/gennote.css'
import { Gennote, useGennote, Image } from '@lechihuy/gennote-react'

export default function Home() {
  let content = '<p>Hello world</p>'

  const editor = useGennote({
    content,
    extensions: {
      image: Image.configure({
        upload: {
          config: (file: File) => ({
            url: 'https://api.imgbb.com/1/upload',
            method: 'POST',
            params: { key: '********' },
            headers: { 'Content-Type': 'multipart/form-data' },
            data: { image: file }
          }),
          imageUrlResolver: (res) => res.data.data.image.url
        }
      })
    }
  })

  if (!editor) return null

  return (
    <div className="p-5 dark:bg-zinc-900 dark:prose-invert max-w-full min-h-screen">
      <Gennote editor={editor} />
    </div>
  )
}
```

## Demo
You can try the editor [here](https://gennote-demo.vercel.app/).
npm package: @leciseau/react-native-emarsys
Description: A simple bridge between emarsys sdk and react-native
Author: John Langan
Latest version: 2.0.1

# @leciseau/react-native-emarsys

## 1. Install the React Native Emarsys plugin

`$ npm install @leciseau/react-native-emarsys --save`

OR

`$ yarn add @leciseau/react-native-emarsys`

## 2 Install the native SDK

#### iOS (Cocoapods)

1. Go to `/ios`
2. If you don't have a Podfile yet run `pod init`
3. Run `pod install`
4. You should now open your project with the `.xcworkspace` instead of the `.xcodeproj`

#### Android (Gradle)

1. Go to `src/app/build.gradle`
2. In `dependencies` add

```gradle
dependencies {
  ...
  implementation 'com.emarsys:emarsys-sdk:3.1.0'
  ...
}
```

## 3 Init SDK

#### iOS

1. Go to `AppDelegate.m`
2. Add

```objective-c
...
#import "EMSConfig.h"
#import "Emarsys.h"

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    ...
    EMSConfig *config = [EMSConfig makeWithBuilder:^(EMSConfigBuilder *builder) {
        [builder setMobileEngageApplicationCode:<applicationCode: NSString>];
        [builder setMerchantId:<predictMerchantId: NSString>];
        [builder enableConsoleLogLevels:@[<EMSLogLevel.trace, EMSLogLevel.debug, EMSLogLevel.info, EMSLogLevel.warn, EMSLogLevel.error, EMSLogLevel.basic>]];
    }];
    [Emarsys setupWithConfig:config];
    ...
}
```

#### Android

1. You should target api 24 as your min SDK in `android/build.gralde`
2. Update

```gradle
    minSdkVersion = 24 <--- there
    compileSdkVersion = 29
    targetSdkVersion = 29
```

3. Go to `MainApplication.java`
4. Add

```java
...
import com.emarsys.Emarsys;
import com.emarsys.config.EmarsysConfig;

@Override
public void onCreate() {
  super.onCreate();
  ...
  EmarsysConfig config = new EmarsysConfig.Builder()
    .application(this)
    .applicationCode(<applicationCode:String?>)
    .merchantId(<merchantId:String?>)
    .build();

    Emarsys.setup(config);
}
```

## Usage
```javascript
import RNEmarsys from '@leciseau/react-native-emarsys';
// or
import {
    trackCustomEvent,
    trackTag,
    setContact,
    clearContact,
    trackCart,
    trackPurchase,
    trackItemView,
    trackCategoryView,
    trackSearchTerm,
} from '@leciseau/react-native-emarsys';

RNEmarsys.trackCustomEvent('myEvent', { toto: "titi" });
RNEmarsys.trackTag('myTag', { toto: "titi" });
RNEmarsys.setContact(contactFieldId, 'userId');
RNEmarsys.clearContact();
RNEmarsys.trackCart([{
    item: 'myItem',
    quantity: '1',
    price: '12.34',
}]);
RNEmarsys.trackPurchase('idPurchase', [{
    item: 'myItem',
    quantity: '1',
    price: '12.34',
}]);
RNEmarsys.trackItemView('myItemId');
RNEmarsys.trackCategoryView('myCategoryPath');
RNEmarsys.trackSearchTerm('mySearchTerm');
```
npm package: @lecongthanhbaoloclamdong/survey
Description: Short description of your package
Author: ThanhLC
Latest version: 1.0.0

# 📦 Survey Package (`@zma/survey`) - Usage Guide

The `@zma/survey` package provides a reusable **Survey Component** for mini app projects.  
This document explains how to install, configure, and use the package.

---

## 1️⃣ Installation

Install the package into your main project:

```bash
npm install git+ssh://git-codecommit.ap-southeast-1.amazonaws.com/v1/repos/survey-web-package#release/survey
```

Or add it directly to your `package.json`:

```json
"dependencies": {
  "@zma/survey": "git+ssh://git-codecommit.ap-southeast-1.amazonaws.com/v1/repos/survey-web-package#release/survey"
}
```

Then run:

```bash
npm install
```

---

## 2️⃣ Initialization

In your `App.jsx` (or `main.jsx`), import and call `initSurvey` to initialize the configuration.  
The API URL should be provided from your `.env` file.

```jsx
import React from 'react';
import ReactDOM from 'react-dom/client';
import App from './App';
import { initSurvey } from '@zma/survey';

// Initialize Survey configuration (using .env value from main project)
initSurvey({
  apiUrl: String,
  mediaCode: String, // Optional
  sharePhoneNumber: Boolean // Default false
  primaryColor: String // Default #3b82f6
});

ReactDOM.createRoot(document.getElementById('root')).render(
  <React.StrictMode>
    <App />
  </React.StrictMode>
);
```

---

## 3️⃣ Using the Survey Component

You can import and use the `Survey` component inside any page or component:

```jsx
import { Survey } from '@zma/survey';

export default function RegisterPage() {
  const handleSharePhoneNumber = (phone) => {
    localStorage.setItem("userPhoneNumber", phone);
  };

  return (
    <div>
      <h1>Survey</h1>
      <Survey
        code="SURVEY-123"
        onSharePhoneNumber={handleSharePhoneNumber}
      />
    </div>
  );
}
```

---

## 4️⃣ Survey Component Props

| Prop                  | Type              | Description                                                                 |
|-----------------------|-------------------|-----------------------------------------------------------------------------|
| `code`               | `string`          | Survey identifier (e.g. `"SURVEY-123"`)                                      |
| `userCode`           | `string`          | If the survey requires a user code                                           |
| `onSubmitSuccess`    | `string`          | Callback when user submit form successfully                                  |
| `onSharePhoneNumber` | `(phone) => void` | Callback when user shares phone number (can be saved into `localStorage`)    |

---

## 5️⃣ Notes

- `react` and `react-dom` are declared as **peer dependencies**, so they must be installed in the main project.  
- Make sure your `.env` file contains the variable `VITE_APP_SURVEY_API_URL`. Example:
  ```
  VITE_APP_SURVEY_API_URL=https://api.example.com/survey
  ```

---

✅ Now you can use the `Survey` component in any page of your application.
npm package: @lecoqjacob/wglt
Description: WebGL Terminal
Author: Cody Ebberson
Latest version: 0.3.1

# WGLT - WebGL Terminal

* Fast, lightweight, terminal emulator using WebGL
* MIT license
* ~30kb minified JS, ~10kb gzipped
* No external dependencies

## What is it?

WGLT is a JavaScript/TypeScript library for creating ASCII games in the browser.

WGLT is absurdly overoptimized for performance, using WebGL for minimal CPU.

WGLT is modelled after libtcod and rot.js.

## Usage

Add dependency:

```bash
npm i -D wglt
```

Import library:

```typescript
import * as wglt from 'wglt';
```

Or, simply use the prebuilt:

```html
<script src="https://unpkg.com/wglt@0.2.3/dist/wglt.js"></script>
```

Use it:

```typescript
const term = new wglt.Terminal(document.querySelector('canvas'), 80, 50);
term.fillRect(0, 0, 80, 50, 0, wglt.Colors.YELLOW, wglt.Colors.DARK_BLUE);

let x = 10;
let y = 10;

term.update = function () {
    if (term.isKeyDown(wglt.Keys.VK_UP)) {
        y--;
    }
    if (term.isKeyDown(wglt.Keys.VK_LEFT)) {
        x--;
    }
    if (term.isKeyDown(wglt.Keys.VK_RIGHT)) {
        x++;
    }
    if (term.isKeyDown(wglt.Keys.VK_DOWN)) {
        y++;
    }

    term.clear();
    term.drawString(1, 1, 'Hello world!');
    term.drawString(1, 3, 'Use arrow keys to move');
    term.drawString(x, y, '@');
};
```
npm package: @lecoupa/v-hotkey
Description: Vue 2.x directive - binding hotkeys for components.
Author: Dafrok
Latest version: 0.7.3

# v-hotkey

[![bundlephobia minified size](https://badgen.net/bundlephobia/min/v-hotkey)](https://bundlephobia.com/result?p=v-hotkey)
[![npm package version](https://badgen.net/npm/v/v-hotkey)](https://npm.im/v-hotkey)
[![github license](https://badgen.net/github/license/dafrok/v-hotkey)](https://github.com/dafrok/v-hotkey/blob/master/LICENSE)
[![js standard style](https://badgen.net/badge/code%20style/standard/pink)](https://standardjs.com)

Vue 2.x directive for binding hotkeys to components.

## Play with me

[https://dafrok.github.io/v-hotkey](https://dafrok.github.io/v-hotkey)

## Install

```bash
$ npm i --save v-hotkey
```

## Usage

```javascript
import Vue from 'vue'
import VueHotkey from 'v-hotkey'

Vue.use(VueHotkey)
```

```vue
<template>
  <span v-hotkey="keymap" v-show="show"> Press `ctrl + esc` to toggle me! Hold `enter` to hide me! </span>
</template>

<script>
export default {
  data () {
    return {
      show: true
    }
  },
  methods: {
    toggle () {
      this.show = !this.show
    },
    show () {
      this.show = true
    },
    hide () {
      this.show = false
    }
  },
  computed: {
    keymap () {
      return {
        // 'esc+ctrl' is OK.
        'ctrl+esc': this.toggle,
        'enter': {
          keydown: this.hide,
          keyup: this.show
        }
      }
    }
  }
}
</script>
```

## Event Handler

- keydown (as default) 
- keyup

## Key Combination

Use one or more of following keys to fire your hotkeys.

- ctrl
- alt
- shift
- meta (windows / command)

## Modifiers

### prevent

Add the prevent modifier to the directive to prevent default browser behavior.

```vue
<template>
  <span v-hotkey.prevent="keymap" v-show="show"> Press `ctrl + esc` to toggle me! Hold `enter` to hide me! </span>
</template>
```

### stop

Add the stop modifier to the directive to stop event propagation.

```vue
<template>
  <div v-hotkey.stop="keymap">
    <span> Enter characters in editable areas doesn't trigger any hotkeys. </span>
    <input>
  </div>
</template>
```

## Key Code Alias

The default key code map is based on US standard keyboard.
This ability to provide their own key code alias for developers who using keyboards with different layouts. The alias name must be a **single character**.

### Definition

```javascript
import Vue from 'vue'
import VueHotkey from 'v-hotkey'

Vue.use(VueHotkey, {
  '①': 49 // the key code of character '1'
})
```

### Template

```vue
<span v-hotkey="keymap"></span>
<script>
export default {
  foo () {
    console.log('Hooray!')
  },
  computed: {
    keymap () {
      return {
        '①': foo
      }
    }
  }
}
</script>
```
npm package: @lecstor/app-error
Description: Simplify error handling in microservices
Author: jason@lecstor.com
Latest version: 0.0.2

app-error
=========

Simplify error handling in microservices

Install
-------
```sh
$ yarn add @lecstor/app-error
```

Usage
-----
```js
const AppError = require('@lecstor/app-error');

const error = AppError(
  "EmailInvalid",
  {
    status: 400,
    message: "Not a valid email address"
  }
);

console.log(error.stack);
EmailInvalid: Not a valid email address
    at repl:1:15
    ...

const response = error.getResponse();

console.log(response);
{
  name: 'EmailInvalid',
  message: 'Not a valid email address',
  status: 400,
  isAppError: true,
  isExpected: true
}
```

#### In Express
```js
const express = require("express");
const requestP = require("request-promise-native");
const bunyan = require("bunyan");
const {
  RemoteError, bunyanSerializer
} = require("@lecstor/app-error");

const buffer = new bunyan.RingBuffer({ limit: 10 });

const log = bunyan.createLogger({
  serializers: { err: bunyanSerializer }
});

const app = express();

/**
 * our function that creates a user with a call to the user service
 * and throws RemoteErrors
 */
function createUser() {
  return requestP.post({ uri: "http://localhost:4321/new-user" })
    .catch(err => {
      throw RemoteError(err.error);
    });
}

/**
 * our routes all end with a catch which calls `next`
 */
app.post("/create-user", (req, res, next) =>
  createUser().catch(next)
);

/**
 * our app includes an error handler which gets those `next` calls
 */
app.use(function(err, req, res, next) {
  if (err.isAppError) {
    const response = err.getResponse();
    res.status(response.status).send(response);
    if (err.isExpected) {
      log.info({ err });
    } else {
      log.error({ err });
    }
  } else {
    res.send(err);
    log.error({ err });
  }
});

module.exports = app;
```
npm package: @lectorjs/mode-bionic
Description: Bionic reading mode for Lector, providing commands for controlling artificial fixation points, eye movement, guidance, and text progression.
Author: Juan Mesa
Latest version: 0.0.1

# @lectorjs/mode-bionic

[![npm package](https://nodei.co/npm/@lectorjs/mode-bionic.png?downloads=true&downloadRank=true&stars=true&compact=true)](https://www.npmjs.com/package/@lectorjs/mode-bionic)

Bionic reading mode for Lector, providing commands for controlling artificial fixation points, eye movement, guidance, and text progression.

![NPM Version](https://img.shields.io/npm/v/@lectorjs/mode-bionic?style=flat-square&color=yellow)

## Installation

With Bun

```sh
bun add @lectorjs/mode-bionic
```

With npm

```sh
npm install @lectorjs/mode-bionic
```

With Yarn

```sh
yarn add @lectorjs/mode-bionic
```

With pnpm

```sh
pnpm add @lectorjs/mode-bionic
```

## Documentation

[Bionic mode](https://lector.pages.dev/docs/modes/bionic)

## Changelog

[Changelog](CHANGELOG.md)

## License

[MIT](../../LICENSE)
npm package: @lectorjs/mode-rsvp
Description: Rapid serial visual presentation (RSVP) reading mode for Lector, providing commands for controlling text flow, pacing, and navigation.
Author: Juan Mesa
Latest version: 0.0.1

# @lectorjs/mode-rsvp

[![npm package](https://nodei.co/npm/@lectorjs/mode-rsvp.png?downloads=true&downloadRank=true&stars=true&compact=true)](https://www.npmjs.com/package/@lectorjs/mode-rsvp)

Rapid serial visual presentation (RSVP) reading mode for Lector, providing commands for controlling text flow, pacing, and navigation.

![NPM Version](https://img.shields.io/npm/v/@lectorjs/mode-rsvp?style=flat-square&color=yellow)

## Installation

With Bun

```sh
bun add @lectorjs/mode-rsvp
```

With npm

```sh
npm install @lectorjs/mode-rsvp
```

With Yarn

```sh
yarn add @lectorjs/mode-rsvp
```

With pnpm

```sh
pnpm add @lectorjs/mode-rsvp
```

## Documentation

[RSVP mode](https://lector.pages.dev/docs/modes/rsvp)

## Changelog

[Changelog](CHANGELOG.md)

## License

[MIT](../../LICENSE)
npm package: @lectorjs/parser-txt
Description: Plain text parser that allows readers to extract and process words from plain text or `.txt` files.
Author: Juan Mesa
Latest version: 0.0.1

# @lectorjs/parser-txt

[![npm package](https://nodei.co/npm/@lectorjs/parser-txt.png?downloads=true&downloadRank=true&stars=true&compact=true)](https://www.npmjs.com/package/@lectorjs/parser-txt)

Plain text parser that allows readers to extract and process words from plain text or `.txt` files.

![NPM Version](https://img.shields.io/npm/v/@lectorjs/parser-txt?style=flat-square&color=yellow)

## Installation

With Deno

With Bun

```sh
bun add @lectorjs/parser-txt
```

With npm

```sh
npm install @lectorjs/parser-txt
```

With Yarn

```sh
yarn add @lectorjs/parser-txt
```

With pnpm

```sh
pnpm add @lectorjs/parser-txt
```

## Documentation

[`Plain text parser`](https://lector.pages.dev/docs/primitives)

## Changelog

[Changelog](CHANGELOG.md)

## License

[MIT](../../LICENSE)
npm package: @lectorjs/primitives
Description: Primitives for building and extending readers, including definitions for context, parsers, modes, commands, plugins, and more.
Author: Juan Mesa
Latest version: 0.0.1

# @lectorjs/primitives

[![npm package](https://nodei.co/npm/@lectorjs/primitives.png?downloads=true&downloadRank=true&stars=true&compact=true)](https://www.npmjs.com/package/@lectorjs/primitives)

Primitives for building and extending readers, including definitions for context, parsers, modes, commands, plugins, and more.

![NPM Version](https://img.shields.io/npm/v/@lectorjs/primitives?style=flat-square&color=yellow)

## Installation

With Bun

```sh
bun add @lectorjs/primitives
```

With npm

```sh
npm install @lectorjs/primitives
```

With Yarn

```sh
yarn add @lectorjs/primitives
```

With pnpm

```sh
pnpm add @lectorjs/primitives
```

## Documentation

[Primitives](https://lector.pages.dev/docs/primitives)

## Changelog

[Changelog](CHANGELOG.md)

## License

[MIT](../../LICENSE)
npm package: @lectro/core
Description: An Awesome Transformer for your Node and your Browser code
Latest version: 1.1.3-alpha.11

## Lectro Core

<img src="logo.png" height="100px">

#### What is Lectro

Lectro enables Node Application to work with different languages that compiles to JS, very smoothly whether it is Coffeescript, Purescript, Typescript or even OCaml
(BuckleScript)

Lectro uses Webpack and its loaders internally, but it is extremely easier to use and extend.

Lectro Core API provides

- A devserver to run Node Application which restarts whenever any file changes, _powered by nodemon_.

- A Build Command to build your Node Application to one bundle.

- An Extend Command to extend Lectro capabilities, mostly to include a file loader.

#### Example

- To use the devserver

```js
const Lectro = require('@lectro/core');
(new Lectro('web'/* or node*/)).dev();
```

Now save this file as run.js at your project root
and start the server with node run.js

_That's It_

Devserver assumes your entry file at src/index.js

- To build your application

```js
const Lectro = require('@lectro/core');
(new Lectro('web'/* or node*/)).build();
```

Now save this file as build.js at your project root
and start the build with node build.js

### Enter the Enhancers

An Enhancer typically enhances lectro features

```js
const Lectro = require('@lectro/core')
const CommonUtilsEnhancer = require('@lectro/enhancer-commonutils')

const lectro = new Lectro('web'/* Target */).apply(CommonUtilsEnhancer)
```
npm package: @lectro/enhancer-buildutils
Description: Add more methods to Lectro build system
Latest version: 0.1.0-alpha-8

## Lectro Enhancer Buildutils

Adds Extra Methods to Lectro Build system

- `tap`

Allows you Tap into the webpack config and mutate the config, consider it as mutable extend

- `runThenBuild`

Allows you to run a function before build begins and then starts the build. To run a promise use async/await.

```js
lectro
  .use(EnhancerBuildutils)
  .runThenBuild(_ => console.log('Starting build, Hold on tight!'))
  .build();

// OR

lectro
  .use(EnhancerBuildutils)
  .runThenBuild(async _ => await copyfiles())
  .build();
```

- `buildThenRun`

Allows you to run a function after build is completed.

```js
lectro
  .use(EnhancerBuildutils)
  .buildThenRun(_ => console.log('Build Completed!'))
  .build();
```

- `setEntry`

Allows you to override lectro's default entry ie. `src/index.js`, accept webpack compatible entry,

```js
lectro
  .use(EnhancerBuildutils)
  .setEntry('./path/to/my/entry/file.js')
  .build();

// OR

lectro
  .use(EnhancerBuildutils)
  .setEntry({
    main: './path/to/my/entry/file.js',
  })
  .build();

// OR

lectro
  .use(EnhancerBuildutils)
  .setEntry({
    entry: {
      main: ['./path/to/my/entry/file1.js', './path/to/my/entry/file2.js'],
    },
  })
  .build();
```

- `setOutputPath`

Allows you to override lectro's default output path ie. `build`. eg.

```js
lectro.use(EnhancerBuildutils).setOutputPath('dist');
```

- `addProgressBar`

Adds a nice progressbar that shows whenever your build occurs eg.

```js
lectro.use(EnhancerBuildutils).addProgressBar({
  name: 'AwesomePackage',
  color: 'orange' /* or red or yellow or blue or green, green by default*/,
});
```

#### Usage

- Install the module `yarn add @lectro/enhancer-buildutils`

```js
const Lectro = require('@lectro/core');
const EnhancerBuildutils = require('@lectro/enhancer-buildutils');

const lectro = new Lectro('node');

lectro
  .use(EnhancerBuildutils)
  .tap(console.log)
  .runThenBuild(_ => console.log('Now Building'));
```
npm package: @lectro/enhancer-commonutils
Description: Add these Common functions in your global scope of your Node Application
Latest version: 1.1.2-alpha-13

## Lectro Enhancer Commonutils

Add these Common functions in your global scope of your Node Application

- `fetch`

The function will not be added in the scope until it is used anywhere, so you can use any of the above function, only the used function will be added in the code

#### Usage

- Install the module `yarn add @lectro/enhancer-flowruntime`
- Create a devserver file `dev.js` with the following contents

```js
const Lectro = require('@lectro/enhancer-flowruntime');
const lectro = new Lectro
lectro.dev()
```
- Use `node dev.js` to run devserver

- This will run the contents of `src/index.js` file with all the necessary polyfills

- To combine `Enchancer-Commonutils` with other lectro enhancements follow this

```js
const EnchancerFlowruntime = require('@lectro/enhancer-flowruntime')
const EnhancerCommonutils = require('@lectro/enhancer-commonutils')

const lectro = EnchancerFlowruntime.combine(new EnhancerCommonutils)

lectro.dev()
```

- To build your bundle

```js

const EnhancerCommonutils = require('@lectro/enhancer-commonutils')
const lectro = EnchancerFlowruntime.combine(new EnhancerCommonutils)

const lectro = new EnhancerCommonutils

// or this if you want to combine with other enhancer

const EnchancerFlowruntime = require('@lectro/enhancer-flowruntime')
const lectro = EnchancerFlowruntime.combine(new EnhancerCommonutils)

lectro.build()
```

- Use `node build.js` to run build

- This will build the contents of `src/index.js` file with all the necessary polyfills to `build/main.js`.
npm package: @lectro/enhancer-flowruntime
Description: Lectro with Flow Runtime
Author: Ray Bulgarin
Latest version: 1.1.2-alpha-4

## Lectro Enhancer Flowruntime

Add Flowruntime checking to your code.

#### Usage

- Install the module `yarn add @lectro/enhancer-flowruntime`
- Create a devserver file `dev.js` with the following contents

```js
const Lectro = require('@lectro/enhancer-flowruntime');
const lectro = new Lectro
lectro.dev()
```
- Use `node dev.js` to run devserver

- This will run the contents of `src/index.js` file with all the necessary transformations and runtime checks.

- With Flow Runtime you'll get runtime errors for every annotated Function passed with wrong parameters

- To combine `Enchancer-Flowruntime` with other lectro enhancements follow this

```js
const EnchancerFlowruntime = require('@lectro/enhancer-flowruntime')
const EnhancerCommonutils = require('@lectro/enhancer-commonutils')

const lectro = EnchancerFlowruntime.combine(new EnhancerCommonutils)

lectro.dev()
```

- To build your bundle

```js
const EnchancerFlowruntime = require('@lectro/enhancer-flowruntime')
const lectro = new EnchancerFlowruntime

// or this if you want to combine with other enhancer

const EnhancerCommonutils = require('@lectro/enhancer-commonutils')
const lectro = EnchancerFlowruntime.combine(new EnhancerCommonutils)

lectro.build()
```

- Use `node build.js` to run build

- This will build the contents of `src/index.js` file with all the necessary transformations to `build/main.js`.

- Runtime checks are disabled in Production builds.
npm package: @lecxa/shipstation-react-query
Description: React Query hooks for ShipStation API v2 - Type-safe hooks with automatic caching and invalidation
Author: Lecxa
Latest version: 1.0.4

# @lecxa/shipstation-react-query

React Query hooks for ShipStation API v2.

## Installation

```bash
npm install @lecxa/shipstation-react-query @tanstack/react-query
```

Peer dependencies:
- `@tanstack/react-query` ^5.0.0
- `react` >=18

## Usage

### Setup

```tsx
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';

const queryClient = new QueryClient();

function App() {
  return (
    <QueryClientProvider client={queryClient}>
      <YourApp />
    </QueryClientProvider>
  );
}
```

### Query Hooks

```tsx
import { useListShipments, useGetShipmentById } from '@lecxa/shipstation-react-query';

function ShipmentsPage() {
  const { data, isLoading, error } = useListShipments({ page: 1 });

  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <ul>
      {data?.shipments?.map(s => (
        <li key={s.shipment_id}>{s.shipment_id}</li>
      ))}
    </ul>
  );
}
```

### Mutation Hooks

```tsx
import { useCreateLabel } from '@lecxa/shipstation-react-query';

function CreateLabelButton() {
  const createLabel = useCreateLabel();

  const handleClick = async () => {
    const result = await createLabel.mutateAsync({
      shipment: { /* ... */ },
      carrier_code: 'stamps_com',
      service_code: 'usps_priority_mail',
    });
  };

  return (
    <button onClick={handleClick} disabled={createLabel.isPending}>
      Create Label
    </button>
  );
}
```

### Infinite Queries

```tsx
import { useListShipmentsInfinite } from '@lecxa/shipstation-react-query';

function InfiniteList() {
  const { data, fetchNextPage, hasNextPage } = useListShipmentsInfinite({
    page_size: 50,
  });

  return (
    <div>
      {data?.pages.map((page, i) => (
        <div key={i}>
          {page.shipments?.map(s => <div key={s.shipment_id}>{s.shipment_id}</div>)}
        </div>
      ))}
      {hasNextPage && <button onClick={() => fetchNextPage()}>Load More</button>}
    </div>
  );
}
```

## Available Hooks

Query hooks (GET):
- `useListShipments`, `useListShipmentsInfinite`
- `useGetShipmentById`
- `useListLabels`, `useListLabelsInfinite`
- `useGetLabelById`
- `useListCarriers`
- `useCalculateRates`
- And more...

Mutation hooks (POST/PUT/DELETE):
- `useCreateLabel`
- `useCreateShipments`
- `useVoidLabel`
- `useCreateBatch`
- And more...

## License

MIT
npm package: @lecxa/shipstation-sdk
Description: TypeScript SDK for ShipStation API v2 - Type-safe REST client with full API coverage
Author: Lecxa
Latest version: 1.0.4

# @lecxa/shipstation-sdk

TypeScript SDK for ShipStation API v2.

## Installation

```bash
npm install @lecxa/shipstation-sdk
```

## Usage

```typescript
import { ShipStationClient } from '@lecxa/shipstation-sdk';

const client = new ShipStationClient({
  token: 'your-api-token',
});

// List shipments
const shipments = await client.shipments.list({ page: 1 });

// Create a label
const label = await client.labels.create({
  shipment: {
    ship_to: {
      name: 'John Doe',
      address_line1: '123 Main St',
      city: 'Austin',
      state_province: 'TX',
      postal_code: '78701',
      country_code: 'US',
    },
    ship_from: {
      name: 'Your Store',
      address_line1: '456 Warehouse Ave',
      city: 'Austin',
      state_province: 'TX',
      postal_code: '78702',
      country_code: 'US',
    },
    packages: [{
      weight: { value: 1.5, unit: 'pound' },
    }],
  },
  carrier_code: 'stamps_com',
  service_code: 'usps_priority_mail',
});

// Calculate rates
const rates = await client.rates.calculate({
  shipment: { /* ... */ },
});
```

## API Methods

The client organizes methods by resource:

- `client.batches` - Batch operations
- `client.carriers` - Carrier management
- `client.labels` - Label creation and management
- `client.rates` - Rate calculation
- `client.shipments` - Shipment operations
- `client.warehouses` - Warehouse management
- `client.webhooks` - Webhook configuration

Additional resources available via direct module imports.

## Direct Function Imports

You can also import generated functions directly:

```typescript
import { listShipments, createLabel } from '@lecxa/shipstation-sdk';
```

## Types

All types are exported:

```typescript
import type {
  CreateLabelRequestBody,
  ListShipmentsParams,
  Shipment,
} from '@lecxa/shipstation-sdk';
```

## License

MIT
npm package: @lecxa/shipstation-zod
Description: Zod schemas for ShipStation API v2 - Runtime validation and type-safe schema definitions
Author: Lecxa
Latest version: 1.0.4

# @lecxa/shipstation-zod

Zod schemas for ShipStation API v2.

## Installation

```bash
npm install @lecxa/shipstation-zod zod
```

Peer dependencies:
- `zod` ^3.0.0

## Usage

### Schema Validation

```typescript
import { schemas } from '@lecxa/shipstation-zod';

// Parse and validate
const shipment = schemas.shipment.parse(data);

// Safe parse (no throw)
const result = schemas.shipment.safeParse(data);
if (result.success) {
  console.log(result.data);
} else {
  console.error(result.error);
}
```

### Type Inference

```typescript
import { schemas } from '@lecxa/shipstation-zod';
import { z } from 'zod';

type Shipment = z.infer<typeof schemas.shipment>;
type CreateLabelBody = z.infer<typeof schemas.createLabelBody>;
```

### Form Validation

Works with react-hook-form:

```tsx
import { useForm } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { schemas } from '@lecxa/shipstation-zod';

function LabelForm() {
  const { register, handleSubmit } = useForm({
    resolver: zodResolver(schemas.createLabelBody),
  });

  return <form onSubmit={handleSubmit(onSubmit)}>{/* ... */}</form>;
}
```

## License

MIT
npm package: @led-backpack/gl-react-expo
Description: React Native via Expo implementation of gl-react, an universal React library to write and compose WebGL shaders
Author: Gaëtan Renaudeau
Latest version: 5.0.1

# <img width="32" alt="icon" src="https://cloud.githubusercontent.com/assets/211411/9813786/eacfcc24-5888-11e5-8f9b-5a907a2cbb21.png"> gl-react-expo

`gl-react-expo` is the [React Native](https://facebook.github.io/react-native/) via Expo implementation of [gl-react](https://github.com/gre/gl-react), library to write and compose WebGL shaders.

## Camera support

You can enable camera support with this:

```
yarn add expo-camera webgltexture-loader-expo-camera
```

and you just need to load the lib in your entry point:

```
import "webgltexture-loader-expo-camera";
```

## Links

- [Github](https://github.com/gre/gl-react)
- [Cookbook, examples, API](https://gl-react-cookbook.surge.sh)
- [![Join the chat at https://gitter.im/gl-react/Lobby](https://badges.gitter.im/gl-react/Lobby.svg)](https://gitter.im/gl-react/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)