open-index/open-npm huggingface dataset:
npm package: @hamoonist/apiclient-nodejs
Description: Custom edit of Voximplant's apiclient-nodejs
Author: Hamoon Jamshidi Meydandar
Latest version: 1.0.6

# Voximplant API client library

Version 2.0

## Prerequisites

In order to use Voximplant Node.js SDK, you need the following:

1. A developer account. If you don't have one, [sign up here](https://voximplant.com/sign-up/).
1. A private API key. There are 2 options to obtain it:
    1. Generate it in the [Voximplant Control panel](https://manage.voximplant.com/settings/service_accounts)
    1. Call the [CreateKey](https://voximplant.com/docs/references/httpapi/managing_role_system#createkey) HTTP API
       method with the
       specified [authentication parameters](https://voximplant.com/docs/references/httpapi/auth_parameters). You'll
       receive a response with the **result** field in it. Save the **result** value in a file (since we don't store the
       keys, save it securely on your side).
1. Node.js >= 11

## How to use

Go to your project folder and install the SDK using `npm`:

```bash
npm i --save @voximplant/apiclient-nodejs
```

Then import the SDK in your script

```js
const VoximplantApiClient = require('@voximplant/apiclient-nodejs').default;
```

Next, specify the path to the file with the **result** value either in the constructor or using the environment.

**constructor**:

```js
const client = new VoximplantApiClient('/path/to/credentials.json');
```

**env**:

```bash
export VOXIMPLANT_CREDENTIALS=/path/to/credentials.json
```

## Examples

### Start a scenario

```js
const VoximplantApiClient = require('@voximplant/apiclient-nodejs').default;
const client = new VoximplantApiClient();
client.onReady = function () {
  // Start the scripts from the account.
  client.Scenarios.startScenarios({ ruleId: '1', scriptCustomData: 'mystr' })
    .then((ev) => console.log(ev))
    .catch((err) => console.error(err));
};
```

### Send an SMS

```js
const VoximplantApiClient = require('@voximplant/apiclient-nodejs').default;
const client = new VoximplantApiClient();
client.onReady = function () {
  // Send the SMS message with text "Test message" from the phone number 447443332211 to the phone number 447443332212.
  client.SMS.sendSmsMessage({
    source: '447443332211',
    destination: '447443332212',
    smsBody: 'Test message',
  })
    .then((ev) => console.log(ev))
    .catch((err) => console.error(err));
};
```

### Get a call history item

```js
const VoximplantApiClient = require('@voximplant/apiclient-nodejs').default;
const client = new VoximplantApiClient();
client.onReady = function () {
  // Get the first call session history record from the 2012-01-01 00:00:00 UTC to the 2014-01-01 00:00:00 UTC
  client.History.getCallHistory({
    fromDate: new Date('2012-01-01 00:00:00 GMT'),
    toDate: new Date('2014-01-01 00:00:00 GMT'),
    count: '1',
    timezone: 'Etc/GMT',
  })
    .then((ev) => console.log(ev))
    .catch((err) => console.error(err));
};
```
npm package: @hamq/client
Description: A High level type-safe AMQP client with auto-reconnect and auto-declare
Author: TY
Latest version: 0.1.9

# @hamq/client

> A simple and elegant AMQP client written by TypeScript
>
> Inspired by [amqp-ts](https://www.npmjs.com/package/amqp-ts)

## Usage

### An example

```ts
import * as amqp from '@hamq/client';
// const amqp = require("@hamq/client"); // js require

async function run() {
  const connection = new amqp.Connection('amqp://localhost');
  const exchange = connection.declareExchange('ExchangeName');
  const queue = connection.declareQueue('QueueName');
  await queue.bind(exchange);
  await queue.consume(message => {
    console.log('Message received: ' + message.getContent());
  });

  // it is possible that the following message is not received because
  // it can be sent before the queue, binding or consumer exist
  const msg = new amqp.Message('Test');
  exchange.send(msg);

  await connection.ready();

  // the following message will be received because
  // everything you defined earlier for this connection now exists
  const msg2 = new amqp.Message('Test2');
  exchange.send(msg2);
}

run().catch(console.error);
```

More examples can be found in the
[tutorials directory](https://github.com/taoyuan/hamq/tree/master/packages/client/tutorials).

### Connection Status

- `connection.connected`: Returns true if the connection exists and false, otherwise.
- `connection.online()`: Resolved when connected.
- `connection.ready()`: Resolved when connected and all resources(actors) has been ready.

### Events

All
[events from connback](https://github.com/taoyuan/connback/tree/master/packages/core#connbacktconstructorconnector-connectort-options-connbackoptions)

### Automatic Reconnection

When the library detects that the connection with the AMQP server is lost, it tries to automatically reconnect to the
server.

It is powered by [connback](https://github.com/taoyuan/connback).

## Roadmap

- Better documentation
npm package: @hamradio/aprs
Description: APRS (Automatic Packet Reporting System) protocol support for Typescript
Author: Wijnand Modderman-Lenstra
Latest version: 1.4.2

# @hamradio/aprs

APRS (Automatic Packet Reporting System) utilities and parsers for TypeScript/JavaScript.

> For AX.25 frame parsing, see [@hamradio/ax25](https://www.npmjs.com/package/@hamradio/ax25).

This package provides lightweight parsing and helpers for APRS frames (APRS-IS style payloads). It exposes a small API for parsing frames, decoding payloads, working with APRS timestamps and addresses, and a few utility conversions.

## Install

Using npm:

```bash
npm install @hamradio/aprs
```

Or with yarn:

```bash
yarn add @hamradio/aprs
```

## Quick examples

Examples below show ESM / TypeScript usage. For CommonJS require() the same symbols are available from the package entrypoint.

### Import

```ts
import {
	Frame,
	Address,
	Timestamp,
	base91ToNumber,
	knotsToKmh,
} from '@hamradio/aprs';
```

### Parse a raw APRS frame and decode payload

```ts
const raw = 'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';

// Parse into a Frame instance
const frame = Frame.fromString(raw);

// Inspect routing and payload
console.log(frame.source.toString()); // e.g. NOCALL-1
console.log(frame.destination.toString()); // APRS
console.log(frame.path.map(p => p.toString()));

// Decode payload (returns a structured payload object or null)
const payload = frame.decode();
console.log(payload?.type); // e.g. 'position' | 'message' | 'status' | ...

// Or ask for sections (dissection) along with decoded payload
const res = frame.decode(true) as { payload: any | null; structure: any };
console.log(res.payload, res.structure);
```

### Message decoding

```ts
const msg = 'W1AW>APRS::KB1ABC-5 :Hello World';
const f = Frame.fromString(msg);
const decoded = f.decode();
if (decoded && decoded.type === 'message') {
	console.log(decoded.addressee); // KB1ABC-5
	console.log(decoded.text); // Hello World
}
```

### Work with addresses and timestamps

```ts
const a = Address.parse('WA1PLE-4*');
console.log(a.call, a.ssid, a.isRepeated);

const ts = new Timestamp(12, 45, 'HMS', { seconds: 30, zulu: true });
console.log(ts.toDate()); // JavaScript Date representing the timestamp
```

### Utility conversions

```ts
console.log(base91ToNumber('!!!!')); // decode base91 values used in some APRS payloads
console.log(knotsToKmh(10)); // convert speed
```

## API summary

- `Frame` — parse frames with `Frame.fromString()` / `Frame.parse()` and decode payloads with `frame.decode()`.
- `Address` — helpers to parse and format APRS addresses: `Address.parse()` / `Address.fromString()`.
- `Timestamp` — APRS timestamp wrapper with `toDate()` conversion.
- Utility functions: `base91ToNumber`, `knotsToKmh`, `kmhToKnots`, `feetToMeters`, `metersToFeet`, `celsiusToFahrenheit`, `fahrenheitToCelsius`.

## Development

Run tests with:

```bash
npm install
npm test
```

Build the distribution with:

```bash
npm run build
```

## Contributing

See the project repository for contribution guidelines and tests.

---

Project: @hamradio/aprs — APRS parsing utilities for TypeScript
npm package: @hamradio/meshcore
Description: MeshCore protocol support for Typescript
Author: Wijnand Modderman-Lenstra
Latest version: 1.3.2

# meshcore

TypeScript library for MeshCore protocol utilities.

## Packet parsing

Using the library to decode MeshCore packets:

```ts
import { Packet } from '@hamradio/meshcore';

const raw = new Uint8Array(Buffer.from("050AA50E2CB0336DB67BBF78928A3BB9BF7A8B677C83B6EC0716F9DD10002A06", "hex"));
const packet = Packet.fromBytes(raw);
console.log(packet);

/*
_Packet {
  header: 5,
  transport: undefined,
  pathLength: 10,
  path: Uint8Array(10) [
    165,  14,  44, 176,
     51, 109, 182, 123,
    191, 120
  ],
  payload: Uint8Array(20) [
    146, 138,  59, 185, 191, 122,
    139, 103, 124, 131, 182, 236,
      7,  22, 249, 221,  16,   0,
     42,   6
  ],
  routeType: 1,
  payloadVersion: 0,
  payloadType: 1,
  pathHashCount: 10,
  pathHashSize: 1,
  pathHashBytes: 10,
  pathHashes: [
    'a5', '0e', '2c',
    'b0', '33', '6d',
    'b6', '7b', 'bf',
    '78'
  ]
}
*/
```

## Packet structure parsing

The parser can also be instructed to generate a packet structure, useful for debugging or
printing packet details:

```ts
import { Packet } from '@hamradio/meshcore';

const raw = new Uint8Array(Buffer.from("050AA50E2CB0336DB67BBF78928A3BB9BF7A8B677C83B6EC0716F9DD10002A06", "hex"));
const packet = Packet.fromBytes(raw);
const { structure } = packet.decode(true);
console.log(structure);

/*
[
  {
    name: 'header',
    data: Uint8Array(12) [
        5,  10, 165,  14,  44,
      176,  51, 109, 182, 123,
      191, 120
    ],
    fields: [
      { name: 'flags', type: 0, size: 1, bits: [Array] },
      { name: 'path length', type: 1, size: 1, bits: [Array] },
      { name: 'path hashes', type: 6, size: 10 }
    ]
  },
  {
    name: 'response payload',
    data: Uint8Array(20) [
      146, 138,  59, 185, 191, 122,
      139, 103, 124, 131, 182, 236,
        7,  22, 249, 221,  16,   0,
       42,   6
    ],
    fields: [
      { name: 'destination hash', type: 1, size: 1, value: 146 },
      { name: 'source hash', type: 1, size: 1, value: 138 },
      { name: 'cipher MAC', type: 6, size: 2, value: [Uint8Array] },
      { name: 'cipher text', type: 6, size: 16, value: [Uint8Array] }
    ]
  }
]
*/
```

## Identities

The package supports:
- `Identity` for public key management.
- `LocalIdentity` for private key management.
- `Contact` for managing named identities.
- `Group` for managing groups.
- `KeyManager` for managing all of the above and handling decryption.
npm package: @hamravesh/create-mfe-app
Description: Let's create another micro-frontend application.
Author: hamravesh
Latest version: 1.0.0

# @hamravesh/create-mfe-app

Let's create another micro-frontend application.

## How to use:

NPM:

```bash
npx @hamravesh/create-mfe-app
```

Yarn:

```bash
yarn create @hamravesh/create-mfe-app
```
npm package: @hams-ai/cli
Description: hams.ai — Official CLI for the hams.ai coding agent
Author: hams.ai
Latest version: 1.0.3

# @hams-ai/cli

Official CLI for [hams.ai](https://hams.ai) — AI Coding Agent.

## Install

```powershell
npm install -g @hams-ai/cli
```

## Prerequisites

- **Node.js** 16+ — [nodejs.org](https://nodejs.org)
- **Python** 3.8+ — [python.org](https://python.org)
- **hams.ai** project folder (the Python agent)

## Setup

After install, tell the CLI where your hams.ai project lives:

**PowerShell:**
```powershell
$env:HAMS_PATH = "C:\Users\kamu\hams.ai"
```

**Linux / Mac:**
```bash
export HAMS_PATH="/home/kamu/hams.ai"
```

To make it permanent, add the line above to your shell profile (`$PROFILE` on PowerShell, `~/.bashrc` or `~/.zshrc` on Linux/Mac).

## Usage

```powershell
# Interactive chat (default)
hams

# Run a single task
hams run "buatkan REST API dengan FastAPI untuk CRUD user"

# List available tools
hams tools

# Check if backend is running
hams status

# Show Python backend output (debug)
hams --verbose

# Use custom port
hams --port 9000
```

## How it works

```
hams (CLI)
  └── finds Python on your system
  └── auto-installs requirements.txt (first time)
  └── spawns agent/api.py --port 8000
  └── waits for /health to respond
  └── sends your tasks via POST /run/stream
  └── streams response back to terminal
  └── shuts down Python when you exit
```

## Development (local install)

```powershell
# Di dalam folder cli/
npm install
npm link

# Sekarang "hams" tersedia di terminal
hams
```

## Publishing

```powershell
npm login
npm publish --access public
```
npm package: @hamset/maidenhead-locator
Description: Maidenhead grid locator and WGS84 coordinate calculation and transformation
Author: HoshinoSuzumi
Latest version: 0.2.1

# @hamset/maidenhead-locator

![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/HoshinoSuzumi/lib-maidenhead-locator/ci.yml)
![NPM Downloads](https://img.shields.io/npm/dm/%40hamset%2Fmaidenhead-locator)
![NPM Version (with dist tag)](https://img.shields.io/npm/v/%40hamset%2Fmaidenhead-locator/latest)
![npm bundle size](https://img.shields.io/bundlephobia/min/%40hamset%2Fmaidenhead-locator)
![GitHub License](https://img.shields.io/github/license/HoshinoSuzumi/lib-maidenhead-locator)

Maidenhead grid locator and WGS84 coordinate calculation and transformation

## Usage

```bash
npm i @hamset/maidenhead-locator
```

```typescript
import {
  validateGridLocator,
  WGS84ToMaidenhead,
  maidenheadToWGS84,
  maidenheadToBoundingBox,
  GridLocator,
  WGS84,
  LatLng
} from '@hamset/maidenhead-locator';

// convert maidenhead grid locator to WGS84 coordinate
const grid_locator = 'DM06gs'
const coordinate: WGS84 = maidenheadToWGS84(grid_locator);
// output: { lat: 36.75, lng: -119.5 }

// convert WGS84 coordinate to maidenhead grid locator
const coordinate: LatLng = { lat: 36.75, lng: -119.5 }
const grid_locator: GridLocator = WGS84ToMaidenhead(coordinate);
// output: 'DM06gs'

// get bounding box coordinates from maidenhead grid locator
const grid_locator = 'DM06gs'
const bounds: [LatLng, LatLng] = maidenheadToBoundingBox(grid_locator); 
// output: [ [ 36.75, -119.5 ], [ 36.791666666666664, -119.41666666666667 ] ]
```

## APIs

```typescript
import { CoordinateLike, GridLocator, WGS84 } from "./types";
/**
 * Validate grid locator
 * @param gridLocator grid locator
 * @returns true if the grid locator is valid
 */
declare const validateGridLocator: (gridLocator: GridLocator) => boolean;
/**
 * Convert WGS84 to Maidenhead
 * @param coord coordinate
 * @returns grid locator
 */
declare const WGS84ToMaidenhead: (coord: CoordinateLike) => GridLocator;
/**
 * Convert Maidenhead to WGS84
 * @param gridLocator grid locator
 * @returns coordinate
 */
declare const maidenheadToWGS84: (gridLocator: GridLocator) => WGS84;
/**
 * Convert Maidenhead to bounding box coordinates
 * @param gridLocator grid locator
 * @returns A two-dimensional array containing two diagonal coordinates of bounds
 */
declare const maidenheadToBoundingBox: (gridLocator: GridLocator) => [LatLng, LatLng];

//
// types
//
export type LatLng = [number, number];
export interface WGS84 {
    lat: number;
    lng: number;
}
export type CoordinateLike = LatLng | WGS84;
export type LatLngBounds = [LatLng, LatLng];
export type GridLocator = string;
```
npm package: @hamshad/pie-chart
Description: A beautiful, animated pie chart component with rounded corners for React
Author: Hamshad
Latest version: 1.0.4

# @hamshad/pie-chart

A beautiful, animated pie chart component with rounded corners for React.

## Demo

Below are two short demos showing the chart animation and interaction.

<p>
  <img src="./pie-chart%281%29.gif" alt="Pie chart demo 1" width="360" />
  <img src="./pie-chart%282%29.gif" alt="Pie chart demo 2" width="360" />
</p>

## Installation

```bash
npm install @hamshad/pie-chart
# or
yarn add @hamshad/pie-chart
```

## Usage

```tsx
import { RoundedPieChart } from '@hamshad/pie-chart';

const data = [
  { value: 2.5, label: '+2.5%', color: '#E8D89C' },
  { value: 0.5, label: '-0.5%', color: '#9B6BA8' },
  { value: 0.4, label: '+0.4%', color: '#E89B8C' }
];

function App() {
  return (
    <RoundedPieChart 
      data={data}
      size={300}
    />
  );
}
```

## Props

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `data` | `PieChartSegment[]` | Required | Array of segments with value, label, and color |
| `size` | `number` | `300` | Size of the chart in pixels |
| `innerRadiusRatio` | `number` | `0.6875` | Ratio of inner radius to outer radius (0-1) |
| `cornerRadius` | `number` | `8` | Radius of rounded corners |
| `gap` | `number` | `3` | Gap between segments in degrees |
| `hoverOffset` | `number` | `5` | Distance segments move out on hover |
| `animationDuration` | `number` | `600` | Animation duration in milliseconds |
| `showLabelsOnHover` | `boolean` | `true` | Show labels only on hover |
| `labelDistance` | `number` | `30` | Distance of labels from chart |
| `className` | `string` | `''` | Additional CSS classes |

## Data Format

```typescript
interface PieChartSegment {
  value: number;    // Numeric value
  label: string;    // Display label
  color: string;    // Hex color code
}
```

## Features

- ✨ Smooth animations on load and hover
- 🎨 Customizable colors and sizes
- 📱 Responsive and accessible
- 🎯 TypeScript support
- 🪶 Lightweight with no dependencies
- 🔄 Rounded corners for modern design

## Contributing

Contributions are welcome! Please read the [Contributing Guide](./CONTRIBUTING.md) for setup, branch naming, commit style, and pull request guidelines.

By participating you agree to follow the [Code of Conduct](./CODE_OF_CONDUCT.md). Security issues? Please see [SECURITY.md](./SECURITY.md) for private disclosure instructions.

## License

MIT

## Development

Development instructions (running the example, builds, etc.) were moved to `DEV_README.md`.
See [DEV_README.md](./DEV_README.md) for details and exact npm scripts.