open-index/open-npm huggingface dataset:
npm package: @gn8/alien-signals-react
Description: The alien-signals for React.
Author: junpei-8
Latest version: 0.1.1

# `alien-signals` for React

[![npm](https://img.shields.io/npm/v/@gn8/alien-signals-react)](https://www.npmjs.com/package/@gn8/alien-signals-react)
[![license](https://img.shields.io/github/license/gn8-ai/universe-alien-signals)](https://github.com/gn8-ai/universe-alien-signals/blob/main/LICENSE.md)
[![japanese documents](https://img.shields.io/badge/documents-Japanese-blue)](README.ja.md)

A library that enables the use of the [alien-signals](https://github.com/stackblitz/alien-signals) state management system in React.

<br />

## 🛸 Features

- **Simple**: Easy to implement with minimal code
- **Flexible**: Reuse a single signal across multiple frameworks
- **Type Safe**: Full TypeScript support
- **Best Reactivity**: Leverages alien-signals efficient signal management
- **Tree Shakable**: Bundle only the code you need

<br />

## 🔌 Status

| Framework | Status | SSR Support | Repo                          |
| --------- | ------ | ----------- | ----------------------------- |
| React     | ✅     | 🔼          | [🔗](../alien-signals-react)  |
| Solid     | ✅     | 🔼          | [🔗](../alien-signals-solid)  |
| Vue       | ✅     | 🔼          | [🔗](../alien-signals-vue)    |
| Svelte    | ✅     | 🔼          | [🔗](../alien-signals-svelte) |

- ✅: Implemented
- 🔼: Avoidable
- ⚠️: Unverified
- ⌛️: Coming Soon

<br />

## 💻 Guide

### Installation

```sh
npm install alien-signals @gn8/alien-signals-react
```

### Sample Code

<!-- prettier-ignore -->
```tsx
import { useSignal } from '@gn8/alien-signals-react';
import { signal } from 'alien-signals';

const countSignal = signal(0);

export default function Counter() {
  const [count, setCount] = useSignal(countSignal);

  return (
    <button onClick={() => setCount(count + 1)}>
      count is {count}
    </button>
  );
}
```

### Examples

- [React](../../@examples/react-with-alien-signals)

<br />

## 📚 Roadmap

The following features and support will be added sequentially:

- [ ] Documentation and solutions for handling SSR hydration errors
- [ ] Enhancement of test coverage
- [x] Creation of Astro framework usage examples

<br />

## 💡 Inspiration

This project is inspired by the following amazing library:

### [Nanostores](https://github.com/nanostores/nanostores)

I have been a long-time user of Nanostores with Astro and was impressed by its ease of use. When I learned about alien-signals, I wanted to utilize its reactivity with the same user experience as Nanostores, which led to the development of this library.

Thanks to Nanostores' excellent implementation approach, we were able to quickly progress with support for various frameworks. Much of our code structure and design patterns are based on insights learned from Nanostores.

We deeply thank the Nanostores team for providing the inspiration and knowledge to start this project.

<br />

## 🎉 Acknowledgments

### [alien-signals](https://github.com/stackblitz/alien-signals)

Most of this library's power comes from alien-signals.
We thank the developers of alien-signals.
npm package: @gn8/alien-signals-solid
Description: The alien-signals for Solid.
Author: junpei-8
Latest version: 0.1.1

# `alien-signals` for Solid

[![npm](https://img.shields.io/npm/v/@gn8/alien-signals-solid)](https://www.npmjs.com/package/@gn8/alien-signals-solid)
[![license](https://img.shields.io/github/license/gn8-ai/universe-alien-signals)](https://github.com/gn8-ai/universe-alien-signals/blob/main/LICENSE.md)
[![japanese documents](https://img.shields.io/badge/documents-Japanese-blue)](README.ja.md)

A library that enables the use of the [alien-signals](https://github.com/stackblitz/alien-signals) state management system in Solid.

<br />

## 🛸 Features

- **Simple**: Easy to implement with minimal code
- **Flexible**: Reuse a single signal across multiple frameworks
- **Type Safe**: Full TypeScript support
- **Best Reactivity**: Leverages alien-signals efficient signal management
- **Tree Shakable**: Bundle only the code you need

<br />

## 🔌 Status

| Framework | Status | SSR Support | Repo                          |
| --------- | ------ | ----------- | ----------------------------- |
| React     | ✅     | 🔼          | [🔗](../alien-signals-react)  |
| Solid     | ✅     | 🔼          | [🔗](../alien-signals-solid)  |
| Vue       | ✅     | 🔼          | [🔗](../alien-signals-vue)    |
| Svelte    | ✅     | 🔼          | [🔗](../alien-signals-svelte) |

- ✅: Implemented
- 🔼: Avoidable
- ⚠️: Unverified
- ⌛️: Coming Soon

<br />

## 💻 Guide

### Installation

```sh
npm install alien-signals @gn8/alien-signals-solid
```

### Sample Code

<!-- prettier-ignore -->
```tsx
import { useSignal } from '@gn8/alien-signals-solid';
import { signal } from 'alien-signals';

const countSignal = signal(0);

export default function Counter() {
  const [count, setCount] = useSignal(countSignal);

  return (
    <button onClick={() => setCount(count() + 1)}>
      count is {count()}
    </button>
  );
}
```

### Examples

- [Solid](../../@examples/solid-with-alien-signals)

<br />

## 📚 Roadmap

The following features and support will be added sequentially:

- [ ] Documentation and solutions for handling SSR hydration errors
- [ ] Enhancement of test coverage
- [x] Creation of Astro framework usage examples

<br />

## 💡 Inspiration

This project is inspired by the following amazing library:

### [Nanostores](https://github.com/nanostores/nanostores)

I have been a long-time user of Nanostores with Astro and was impressed by its ease of use. When I learned about alien-signals, I wanted to utilize its reactivity with the same user experience as Nanostores, which led to the development of this library.

Thanks to Nanostores' excellent implementation approach, we were able to quickly progress with support for various frameworks. Much of our code structure and design patterns are based on insights learned from Nanostores.

We deeply thank the Nanostores team for providing the inspiration and knowledge to start this project.

<br />

## 🎉 Acknowledgments

### [alien-signals](https://github.com/stackblitz/alien-signals)

Most of this library's power comes from alien-signals.
We thank the developers of alien-signals.
npm package: @gn8/alien-signals-svelte
Description: The alien-signals for Svelte.
Author: junpei-8
Latest version: 0.1.1

# `alien-signals` for Svelte

[![npm](https://img.shields.io/npm/v/@gn8/alien-signals-svelte)](https://www.npmjs.com/package/@gn8/alien-signals-svelte)
[![license](https://img.shields.io/github/license/gn8-ai/universe-alien-signals)](https://github.com/gn8-ai/universe-alien-signals/blob/main/LICENSE.md)
[![japanese documents](https://img.shields.io/badge/documents-Japanese-blue)](README.ja.md)

A library that enables the use of the [alien-signals](https://github.com/stackblitz/alien-signals) state management system in Svelte 5+ with runes.

<br />

## 🛸 Features

- **Simple**: Easy to implement with minimal code
- **Flexible**: Reuse a single signal across multiple frameworks
- **Type Safe**: Full TypeScript support
- **Best Reactivity**: Leverages alien-signals efficient signal management
- **Tree Shakable**: Bundle only the code you need
- **Runes Support**: Native integration with Svelte 5's runes system

<br />

## 🔌 Status

| Framework | Status | SSR Support | Repo                          |
| --------- | ------ | ----------- | ----------------------------- |
| React     | ✅     | 🔼          | [🔗](../alien-signals-react)  |
| Solid     | ✅     | 🔼          | [🔗](../alien-signals-solid)  |
| Vue       | ✅     | 🔼          | [🔗](../alien-signals-vue)    |
| Svelte    | ✅     | 🔼          | [🔗](../alien-signals-svelte) |

- ✅: Implemented
- 🔼: Avoidable
- ⚠️: Unverified
- ⌛️: Coming Soon

<br />

## 💻 Guide

### Installation

```sh
npm install alien-signals @gn8/alien-signals-svelte
```

### Sample Code

<!-- prettier-ignore -->
```svelte
<script>
  import { useSignal } from '@gn8/alien-signals-svelte';
  import { signal } from 'alien-signals';

  const countSignal = signal(0);

  const count = useSignal(countSignal);
</script>

<button on:click={() => $count++}>
  count is {$count}
</button>
```

### Examples

- [Svelte](../../@examples/svelte-with-alien-signals) (Coming Soon)

<br />

## 📚 Roadmap

The following features and support will be added sequentially:

- [ ] Documentation and solutions for handling SSR hydration errors
- [ ] Enhancement of test coverage
- [ ] Creation of Svelte 5 usage examples
- [ ] Integration with SvelteKit

<br />

## 🙏 Acknowledgments

The development of this library was influenced by:

- [alien-signals](https://github.com/stackblitz/alien-signals) - The core signal library
- [Svelte](https://svelte.dev/) - The progressive JavaScript framework
npm package: @gn8/alien-signals-vue
Description: The alien-signals for Vue.
Author: junpei-8
Latest version: 0.1.1

# `alien-signals` for Vue

[![npm](https://img.shields.io/npm/v/@gn8/alien-signals-vue)](https://www.npmjs.com/package/@gn8/alien-signals-vue)
[![license](https://img.shields.io/github/license/gn8-ai/universe-alien-signals)](https://github.com/gn8-ai/universe-alien-signals/blob/main/LICENSE.md)
[![japanese documents](https://img.shields.io/badge/documents-Japanese-blue)](README.ja.md)

A library that enables the use of the [alien-signals](https://github.com/stackblitz/alien-signals) state management system in Vue.

<br />

## 🛸 Features

- **Simple**: Easy to implement with minimal code
- **Flexible**: Reuse a single signal across multiple frameworks
- **Type Safe**: Full TypeScript support
- **Best Reactivity**: Leverages alien-signals efficient signal management
- **Tree Shakable**: Bundle only the code you need

<br />

## 🔌 Status

| Framework | Status | SSR Support | Repo                          |
| --------- | ------ | ----------- | ----------------------------- |
| React     | ✅     | 🔼          | [🔗](../alien-signals-react)  |
| Solid     | ✅     | 🔼          | [🔗](../alien-signals-solid)  |
| Vue       | ✅     | 🔼          | [🔗](../alien-signals-vue)    |
| Svelte    | ✅     | 🔼          | [🔗](../alien-signals-svelte) |

- ✅: Implemented
- 🔼: Avoidable
- ⚠️: Unverified
- ⌛️: Coming Soon

<br />

## 💻 Guide

### Installation

```sh
npm install alien-signals @gn8/alien-signals-vue
```

### Sample Code

<!-- prettier-ignore -->
```vue
<script setup>
import { useSignal } from '@gn8/alien-signals-vue';
import { signal } from 'alien-signals';

const countSignal = signal(0);

const count = useSignal(countSignal);
</script>

<template>
  <button @click="count++">
    count is {{ count }}
  </button>
</template>
```

### Examples

- [Vue](../../@examples/vue-with-alien-signals)

<br />

## 📚 Roadmap

The following features and support will be added sequentially:

- [ ] Documentation and solutions for handling SSR hydration errors
- [ ] Enhancement of test coverage
- [x] Creation of Astro framework usage examples

<br />

## 💡 Inspiration

This project is inspired by the following amazing library:

### [Nanostores](https://github.com/nanostores/nanostores)

I have been a long-time user of Nanostores with Astro and was impressed by its ease of use. When I learned about alien-signals, I wanted to utilize its reactivity with the same user experience as Nanostores, which led to the development of this library.

Thanks to Nanostores' excellent implementation approach, we were able to quickly progress with support for various frameworks. Much of our code structure and design patterns are based on insights learned from Nanostores.

We deeply thank the Nanostores team for providing the inspiration and knowledge to start this project.

<br />

## 🎉 Acknowledgments

### [alien-signals](https://github.com/stackblitz/alien-signals)

Most of this library's power comes from alien-signals.
We thank the developers of alien-signals.
npm package: @gnai/web-vue
Description: Gnai Web Vue (Arco Vue 2.0 distributions repack)
Author: Gnai Team
Latest version: 0.0.8

# @gnlab/web-vue

基于 Arco Design Vue 构建产物的再发布包（仅包含已构建的 es/lib/dist/json）。

## 安装

```bash
npm i @gnlab/web-vue
# 或
pnpm add @gnlab/web-vue
```

## 使用

```ts
import { createApp } from 'vue';
import ArcoVue, { Button } from '@gnlab/web-vue';
import '@gnlab/web-vue/dist/arco.css';

const app = createApp(App);
app.use(ArcoVue);
app.mount('#app');
```

## 发布流程（仓库内部）

1. 在源包构建产物：
   ```bash
   pnpm -F @arco-design/web-vue run build
   ```
2. 同步构建目录到本包：
   ```bash
   pnpm -F @gnlab/web-vue run sync
   ```
3. 发布：
   ```bash
   cd packages/gnlab-web-vue
   npm publish --access public
   ```

> 注意：本包不包含源码，仅再分发构建产物，依赖 `vue@>=3.1.0`。
npm package: @gnandretta/atom
Description: Atom like reference type to manage and observe state changes
Author: Gabriel Andretta
Latest version: 0.0.1

# Atom

Manage and observe state changes in JavaScript, based on
Clojure(Script) [atoms](http://clojuredocs.org/clojure.core/atom).

# Usage

```js
var atom = require('atom');

var gabriel = atom({likes: "ice cream"});

gabriel.addWatch("logger", function(state) {
  console.log(state);
});

gabriel.state // => {likes: "ice cream"}

gabriel.swap(function(state) {
  return {likes: "cookies"};
});

// {likes: "cookies"} will be logged in the console

gabriel.state // => {likes: "cookies"}
```

# Rationale

I want a clear distinction between state and identity.

# Creating an atom

## atom(state)

Creates a new atom with initial `state`.

# Getting the atom state

## a.state

Returns the current state for the atom `a`.

# Updates

## a.reset(state)

Sets the state of atom `a` to `state`.

## a.swap(f, ...args)

Sets the state of atom `a` to the result of applying the function `f`
to the current state, `a.state`, and the provided `args`.

```js
function setLike(state, food) {
  return Object.assign({}, state, {likes: food});
}

a.swap(setLike, "hamburguers");
a.state.likes // => "hamburguers"
```

## a.mreset(meta, state)

Like `reset` but it will pass the metadata `meta` to the watches.

## a.mswap(meta, f, ...args)

Like `swap` but it will pass the metadata `meta` to the watches.

# Observation

## a.addWatch(key, f)

Invoke the function `f` every time the state of the atom `a` is
updated. The `key` parameter is a ~String~ that is used to identify
the watch and remove it later.

Every time the function `f` is invoked, it will recieve the following
params:

- `state`: current state of the atom, after the update.
- `oldState`: the previous state of the atom, before the update. It is
  possible that `state === oldState` if you don't update the atom's
  state or if you update the state in place. The function `f` is
  called every time one of the update methods are called, there is no
  guarantee that the `state` has actually changed and that the changes
  are preserved in `oldState`. That is up to you.
- `key`: the key provided when adding the watch.
- `meta`: the metadata provided when performing the update with
  `mreset` or `mswap`. If the update was done through `reset` or
  `swap` this parameter will be `undefined`.

## a.removeWatch(key)

Stop invoking the function for the watch with the `key` key.
npm package: @gnanesh/java-object-serialization
Description: Ergonomic java.io.Serializable parsing
Latest version: 0.1.1

# Java Object Serialization

Ergonomic `java.io.Serializable` parsing for JavaScript and TypeScript projects.

## Example

```typescript
import { ObjectInputStream } from "java-object-serialization";

class List {
    value: number = 0;
    next: List | null = null;
}

ObjectInputStream.RegisterObjectClass(List, "List", "7622494193198739048");

const data = "rO0ABXNyAARMaXN0aciKFUAWrmgCAAJJAAV2YWx1ZUwABG5leHR0AAZMTGlzdDt4cAAAABFzcQB+AAAAAAATcHEAfgAD";
const serialized = Buffer.from(data, "base64");

const stream = new ObjectInputStream(serialized);
const list1 = stream.readObject();
const list2 = stream.readObject();
```

The above code deserializes the example given in the Java Object Serialization specification:

```java
class List implements java.io.Serializable {
    int value;
    List next;
    
    public static void main(String[] args) {
        List list1 = new List();
        List list2 = new List();
        list1.value = 17;
        list1.next = list2;
        list2.value = 19;
        list2.next = null;

        ByteArrayOutputStream o = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(o);
        out.writeObject(list1);
        out.writeObject(list2);
        out.flush();
        ...
    }
}
```

There is a `JavaSerializable` interface that can be implemented to customize the deserialization behaviour for classes:

```typescript
interface JavaSerializable {
    readObject?(stream: ObjectInputStream): void
    readResolve?(): any
}
```

`readObject` needs to be implemented for classes that were serialized with a `writeObject` implementation. As with the Java interface the methods on the passed in `ObjectInputStream` can be used to read data related to the class, including the `defaultReadObject` method to read and populate the standard serialized fields.

`readResolve` can be implemented to return an alternative value when deserializing, this can be useful to e.g. return a JavaScript array for `java.util.ArrayList`:

```typescript
class ArrayList implements JavaSerializable {
    size: number = 0;
    elements: any[] = [];
    
    readObject(stream: ObjectInputStream): void {
        // Read in size, and any hidden stuff
        stream.defaultReadObject();
        
        // Read in capacity
        stream.readInt(); // ignored
        
        for (let i = 0; i < this.size; ++i) {
            this.elements.push(stream.readObject());
        }
    }
    
    readResolve(): any {
        return this.elements;
    }
}

JavaObjectStream.RegisterObjectClass(ArrayList, "java.util.ArrayList", "8683452581122892189");
```

## Status
The full Java Object Serialization specification isn't covered, and the API surface isn't stable, but it is usable for parsing real data.

## License
[MIT](https://choosealicense.com/licenses/mit/)
npm package: @gnar-engine/cli
Description: Gnar Engine Development Framework CLI: Project bootstrap, scaffolder & control plane.
Author: Gnar Software Ltd.
Latest version: 1.0.10

# Gnar Engine

Gnar Engine is a micro-service, NodeJS, web-application development framework. Build modern, scalable & deeply AI integrated applications.

### Why Gnar Engine?

Ship microservices faster: Project bootstrap, prebuilt service templates with CLI scaffolding, database connections, logging, and migrations—so you spend less time wiring and more time building.

Built-in distributed power: Command bus, async RabbitMQ calls, and a real-time websocket mesh make multi-service communication effortless.

Inspectable & introspectable architecture: Our custom MCP protocol lets your agents see every command and schema, through service manifests at runtime—perfect for complex applications.

Modern container-first workflow: Local dev containers with ephemeral orchestration mean zero setup headaches. Works seamlessly with Docker, CI/CD, and cloud deployments.

AI-enabled for your users: Let end-users interact with your backend in natural language—no AI expertise required.

Opinionated, but flexible: Prescribed Node.js runtime, Fastify HTTP, MySQL/Mongo support, and command patterns mean conventions you can trust, with freedom where you need it.

### Get Started

Firstly install the Gnar Engine CLI globally using npm:
``` bash
npm install -g @gnar-engine/cli
```

Create your first Gnar Engine project:
``` bash
gnar create project my-first-gnar-project
```

Start your Gnar Engine project:
``` bash
gnar dev up --build
npm package: @gnar-engine/core
Description: Gnar Engine - Service Core
Author: Gnar Software Ltd.
Latest version: 1.0.17

![Gnar Engine Logo](cli/assets/gnar-engine-logo-white.svg)

### Gnar Engine - Service Core

This is the Gnar Engine service core package. This should be used as a dependency for all Gnar Engine back-end services.

To get started please do not download this package directly, but instead use the [Gnar CLI](@gnar-engine/cli) to create a new project.
npm package: @gnarwall19/nymeria
Description: **This framework was put together in order to help me better understand how testing wokrs in JavaScript. I Do NOT recommend ANYBODY use Nymeria for testing prodcution code!!**
Latest version: 1.0.2

## :wolf: Nymeria
#### A small but functional JavaScript testing framework

###### Built with lots of help from Alcides Queiroz's guide on Medium

**This framework was put together in order to help me better understand how testing wokrs in JavaScript. I Do NOT recommend ANYBODY use Nymeria for testing prodcution code!!**

Now since that's out of the way, *how do you use Nymeria to test your code??*
Well as of now it's a long and complicated process, BUT... Like this:

`npm i @gnarwall19/nymeria`

1. Create your own `tests` folder in your applications source folder
2. In your `tests` folder, create an `index.js` file that:
    - has a variable called nymeria that requires '@gnarwall19/nymeria'
    - Requires your `whatever.test.js` files
    - Finishes with `nymeria.end()` to run the exit code
3. Write all the tests you want in your .test.js files just make sure you require them in `index.js`!
4. Run `node tests` from your projects source in the terminal/command prompt

## CONSIDER THIS: ##

- Make sure your tests folder has an `index.js` file that:
    1. Requires nymeria as a const
    2. Requires your `whatever.test.js` files
    3. Finishes with `nymeria.end()` to run the exit code
- `Whatever.test.js` files need to require `{ guarantee, check, xcheck, group }` as a const from nymeria
- Check out the playground folder on [github](https://github.com/Gnarwall19/nymeria) for some examples!

## Example tests/index.js file ##

```
const nymeria = require('@gnarwall19/nymeria');

require('./cool-stuff.test');
require('./check-it-out.test');
require('./bad-naming-conventions.test');
require('./and-so-on.test');

nymeria.end();
```

**Again, credit for this project must be given to Alcides Queiroz for putting together an awesome tutorial! read the medium article [here](https://medium.freecodecamp.org/learnbydiy-how-to-create-a-javascript-unit-testing-framework-from-scratch-c94e0ba1c57a)**
npm package: @gnaudio/jabra-browser-integration
Description: Control Jabra Devices from within a browser app using JavaScript
Author: GN Audio
Latest version: 3.0.1

# Overview

This software project from [Jabra](https://www.jabra.com/) helps developers to make solutions, 
where basic headset call control can be used from within a browser app 
using JavaScript. Since it is not possible to access USB devices directly
from JavaScript, this library provides a solution of getting a route from 
the JavaScript to the Jabra USB device. The API is a JavaScript library 
with a facade that hides implementation details. Basic call control is 
defined by off-hook/on-hook, ringer, mute/unmute and hold/resume. With 
these features, it is possible to implement a browser based softphone app.
Combined with the [WebRTC](https://en.wikipedia.org/wiki/WebRTC) technology 
it is possible to create a softphone that only requires small software 
components installed locally on the computer, while the business logic 
is implemented in JavaScript.

# Documentation

For comprehensive documentation (including important additional software requirements, API usage, changelog, license) and API examples etc. please refer to [our github site](https://github.com/gnaudio/jabra-browser-integration)
npm package: @gnaudio/twilio-flex-call-control-plugin
Description: Call-control in Twilio Flex using a Jabra headset
Author: GN Audio
Latest version: 1.0.0-beta.4

# Twilio Flex Jabra Call Control Plugin

This plugin allows you the control Twilio Flex using a Jabra headset.

**Warning: This software is in BETA. The software can be considered unstable, possibly untested and might be updated at any time. Use at your own risk. If you want to use something stable, please await completion of our development and Q/A process.**

## Installation

Download [plugin-jabra-call-control.js](https://github.com/gnaudio/jabra-twilio-call-control-plugin/releases/download/1.0.0-beta.3/plugin-jabra-call-control.js), take this file and upload it into the Assets part of your Twilio Runtime.

You can also use in your own plugin, start by installing it via NPM og similar

```
npm install @gnaudio/twilio-flex-call-control-plugin
```

In your plugin's `index.js` file import the plugin

```
import { loadPlugin } from "flex-plugin";
import { Plugin } from "@gnaudio/twilio-flex-call-control-plugin";

loadPlugin(Plugin);
```

## Development

Make sure you have [Node.js](https://nodejs.org) as well as [`npm`](https://npmjs.com) installed.

Make a copy of `appConfig.example.js` rename it `appConfig.js`, in the file, fill in the `accountSid`, with your Twilio Flex `accountSid`.

Afterwards, install the dependencies by running:

```
npm install
```

When you make changes to the plugin code, make sure to run:

```
npm run build
```

Or run

```
npm run start
```

To start the build process in watch mode

Then change directory to example, and run:

```
cd example
npm install
```

In order to develop locally, you can use the Webpack Dev Server by running:

```bash
npm run start
```

This will automatically start up the Webpack Dev Server and open the browser for you. Your app will run on `http://localhost:8080`. If you want to change that you can do this by setting the `PORT` environment variable:

```bash
PORT=3000 npm run start
```

When you make changes to your code, the browser window will be automatically refreshed.

## Deploy

Once you are happy with your plugin, you have to bundle it in order to deploy it to Twilio Flex. You do that from the example folder.
Run the following command to start the bundling:

```bash
cd example
npm run build
```

Afterwards, you'll find a `build/` folder that contains a file with the name of `jabra-twilio-call-control-plugin.js`. Take this file and upload it into the Assets part of your Twilio Runtime.
And make a release on GitHub with said file.

To deploy to npm run:

```
npx np
```

And follow the onscreen instructions
npm package: @gnbly/spell-out
Description: spells out numbers and acronyms in a string for TTS to read
Author: Ruyi Ren
Latest version: 1.0.7

# Spell-out

## Overview

This library is used to spell out numbers and acronyms into words that can be pronounced by Text-to-Speech (TTS) systems. It provides the flexibility to convert phone numbers, times, numbers, and acronyms into a spelled out form.

## Installation

You can install this package using npm:

```bash
npm install @gnbly/spell-out
```

Or via yarn

```bash
yarn add @gnbly/spell-out
```

## Usage

```javascript
const { Spell } = require('@gnbly/spell-out');

const spell = new Spell();

const text = 'Call me at 555-1234 at 10:30. The number is 123 and the acronym is NASA.';

const spelledOutText = spell.process(text);

console.log(spelledOutText);
```

## API

### Spell 
The main class for this library.

### Constructor
The constructor accepts an optional options object.
```javascript
const spell = new Spell({
  shouldConvertNumbers: true, // default: true
  shouldConvertMonth: true, // default: true
  shouldConvertPhoneNumbers: true, // default: true
  shouldConvertAcronyms: true, // default: true
});
```

### Methods
- `convertPhoneNumbers(str)`
Converts all phone numbers in the provided string to a spelled out form.

- `convertTime(str)`
Converts all time expressions in the provided string to a spelled out form.

- `convertNumbers(str)`
Converts all numeric values in the provided string to a spelled out form.

- `convertAcronyms(str)`
Converts all acronyms in the provided string to a spelled out form.

- `process(str)`
Processes the provided string and applies all conversion options based on the settings of the Spell instance. If a conversion option is set to false, the corresponding conversion will not be performed.

## Regular Expressions
This library uses the following regular expressions to identify phone numbers, time expressions, numeric values, and acronyms:

- `phoneRegex` for phone numbers
- `timeRegex` for time expressions
- `numberRegex` for numeric values
- `acronymRegex` for acronyms

These regular expressions are not exported by the library and cannot be modified by the user.

## Notes
The `Spell` class uses an instance of the `ToWords` class for converting numbers to words. The `ToWords` class is not exposed by this library. If you want to customize the behavior of the `ToWords` class, you can pass options to the Spell constructor. These options will be passed through to the `ToWords` constructor. For more information on the available options, refer to the `ToWords` documentation.
npm package: @gnchain/chain.js
Description: The JavaScript SDK
Latest version: 0.1.8

The JavaScript SDK 

chain.js is a JavaScript SDK for writing applications that interact with the blockchain from either Node.js, browser, or React Native environments and provides simple abstractions over core data structures, serialization, key management, and API request generation.

## Features

- **Written in TypeScript**, with type definitions
- Versatile support for key management solutions
- Works in Node.js, in the browser, and React Native
- Exposes the API through `LCDClient`
- Parses responses into native JavaScript types

We highly suggest using chain.js with TypeScript, or JavaScript in a code editor that has support for type declarations, so you can take advantage of the helpful type hints that are included with the package.

## Installation

```sh
npm install @gnchain/chain.js
```

## Usage

chain.js can be used in Node.js, as well as inside the browser. Please check the docs for notes on how to get up and running.
npm package: @gnchain/ledger
Description: API for Wallet App (Ledger Nano S/X)
Latest version: 0.1.2

# ledger-terra-js

This package provides a basic client library to communicate with a App running in a Ledger Nano S/X

We recommend using the npmjs package in order to receive updates/fixes.

This repo also includes a simple Vue example for U2F and WebUSB.

![Example](docs/example.png)
npm package: @gnchain/react-base-components
Description: ## How to build react-base-components
Latest version: 0.1.0

# react-base-components

## How to build react-base-components

```sh
npm i
npm run build
```

## How to run react-base-components storybook

```sh
npm i
npm run storybook
```

## How to run react-base-components example

```sh
npm i
npm run build
cd example/
npm i
npm run start
```

## How to publish react-base-components to npm

```sh
npm i
npm run build
npm login
npm publish
```