open-index/open-npm huggingface dataset:
npm package: @hidev/udp-rcon
Description: This node module lets you communicate with a server through the UDP RCON protocol.
Author: Baptiste Miquel
Latest version: 3.0.1

# UDP RCON

This node module lets you communicate with a server through the UDP RCON protocol.

## Install module

```
npm install @hidev/udp-rcon
```


## Import module

```js
import { UDP_RCON } from "@hidev/udp-rcon";
```


## Full example

```js
import { UDP_RCON } from "@hidev/udp-rcon";

// RCON configuration
const server_ip = "ENTER_RCON_IP_HERE";
const rcon_port = "ENTER_RCON_PORT_HERE";
const rcon_password = "ENTER_RCON_PASSWORD_HERE";
let my_rcon = new UDP_RCON(server_ip, rcon_port, rcon_password);

const rcon_success = (msg) => {
  console.log("Message received:", msg);
};

const rcon_error = (err) => {
  console.log(`Error: \n${err.stack}`);
};

// Commands
let rcon_instance = my_rcon.send("say Hello!", rcon_success, rcon_error);
```


## Build module

```
npm run build
```


## Structure

* lib : Built code
* src : Source code


## Functionalities

### Define a new RCON connection

```js
let my_rcon = new UDP_RCON(ip, port, password);
```

### Send a command

```js
my_rcon.send("say Test");
```

### Send a command with callbacks

```js
// Called on success => When a message is received
const success = (msg) => {
  console.log("Message received:", msg);
};

// Called on error with the connection
const error = (err) => {
  console.log(`Error: \n${err.stack}`);
};

my_rcon.send("say Test", success, error);
```

### Custom events

UDP RCON lets you use custom events:

```js
let rcon_instance = my_rcon.send("say Test");
rcon_instance.sender.setEvent("connect", () => {
  console.log(`Connection established with ${my_rcon.ip}:${my_rcon.port}`);
});
```

All events possible:

```js
// When connected to the RCON server
rcon_instance.sender.setEvent("connect", () => {});

// When message sended
rcon_instance.sender.setEvent("sended", (buffer) => {});

// When error occured while connecting to RCON
rcon_instance.sender.setEvent("error", (err) => {});

// When client is listening for response
rcon_instance.client.setEvent("listening", (address) => {});

// Overwrite rcon_success => When a message is received
rcon_instance.client.setEvent("message", (msg) => {});

// Overwrite rcon_error => When an error occured with the message received
rcon_instance.client.setEvent("error", (err) => {});
```


## Author

Made by Baptiste Miquel for HiDEV under the MIT license.
npm package: @hideyuki-hori/filch
Description: Get dependencies from package.json in other environment
Author: hideyuki-hori
Latest version: 0.0.6

# [filch](https://www.npmjs.com/package/@hideyuki-hori/filch)

[![Build Status](https://travis-ci.org/hideyuki-hori/filch.svg?branch=master)](https://travis-ci.org/hideyuki-hori/filch)

see -> https://hideyuki-hori.github.io/filch/

# Installation

```
npm install -g @hideyuki-hori/filch
```

# Usage

```
Usage
  # from locally
  $ filth ./package.json
  # from url
  $ filth https://raw.githubusercontent.com/hideyuki-hori/filch/master/package.json

Options
  --devDependencies, -d
    When installing to devDependencies.
    if not specified is install to dependencies.
  --defaultChoosePackages, -c
    Select all packages from the first
    if not specified no select.
  --yarn, -y
    Use yarn.
    using npm if not specified.
  --help, -h
    Show help
  --version, -v
    Show version
```
npm package: @hidie0644/utils
Description: utils for hidie
Author: yellowsea
Latest version: 3.0.0

<!-- TODO logo -->
<h1 align="center">@hidie/utils</h1>

<p align="center">
Collection of common and useful JavaScript / TypeScript utilities by <a href="https://github.com/yellowsae">@yellowsae</a>.
</p>


## Features
- 🚀 Tree-shakable ESM
- 😊 Fully typed - with TSDocs

## LICENSE
[MIT](./LICENSE) License © 2022 [yellowsae](https://github.com/yellowsae)
npm package: @hidoo/data-from
Description: Utility to get data from JSON, JSON5, and YAML.
Author: hidoo
Latest version: 1.0.0

# @hidoo/data-from

[![Test](https://github.com/hidoo/data-from/actions/workflows/test.yml/badge.svg)](https://github.com/hidoo/data-from/actions/workflows/test.yml)

> Utility to get data from JSON, JSON5, and YAML.

## Installation

```sh
npm install @hidoo/data-from
```

## Usage

Get data from a string:

```js
import { fromString } from '@hidoo/data-from';

const data = fromString('{"test": {"hoge": "hoge", "fuga": "{{test.hoge}}');
// {test: {hoge: 'hoge', fuga: 'hoge'}}
```

Get data from Front Matter (wrapper of [front-matter](https://www.npmjs.com/package/front-matter)):

```js
import { fromFrontMatter } from '@hidoo/data-from';

const data = fromFrontMatter(
  `---
test:
  hoge: hoge
  fuga: "{{test.hoge}}"
---
`
);
// {body: '', attributes: {test: {hoge: 'hoge', fuga: 'hoge'}}, frontmatter: 'test:\n  hoge: hoge\n  fuga: "{{test.hoge}}"'}
```

Get data from files matched specified glob pattern:

```json5
// data.json5
{
  data: {
    hoge: 'hoge',
    fuga: '{{validJSON5.hoge}}'
  }
}
```

```js
import { fromFiles, fromFilesSync } from '@hidoo/data-from';

const data = await fromFiles('/path/to/*.json5');
// {data: {hoge: 'hoge', fuga: 'hoge'}}

// By synchronously
const data = fromFilesSync('/path/to/*.json5');
```

## Test

```sh
pnpm test
```

## License

MIT
npm package: @hidoo/eslint-config
Description: Shareable config for ESlint.
Author: hidoo
Latest version: 2.0.0

# @hidoo/eslint-config

[![Test](https://github.com/hidoo/eslint-config/actions/workflows/test.yml/badge.svg)](https://github.com/hidoo/eslint-config/actions/workflows/test.yml)

Shareable config for ESlint.

## Installation

```sh
npm install --save-dev eslint @hidoo/eslint-config
```

## Usage

### basic

```js
import configs from '@hidoo/eslint-config';

/** @type {import('eslint').Linter.Config[]} */
export default [...configs];
```

### with @babel/eslint-parser

```js
import configs from '@hidoo/eslint-config';
import babelConfig from '@hidoo/eslint-config/+babel';

/** @type {import('eslint').Linter.Config[]} */
export default [...configs, babelConfig];
```

### with ESLint Stylistic

```js
import configs from '@hidoo/eslint-config';
import stylisticConfig from '@hidoo/eslint-config/+stylistic';

/** @type {import('eslint').Linter.Config[]} */
export default [...configs, stylisticConfig];
```

### with Prettier

```js
import configs from '@hidoo/eslint-config';
import prettierConfig from '@hidoo/eslint-config/+prettier';

/** @type {import('eslint').Linter.Config[]} */
export default [...configs, prettierConfig];
```

### with compatibility check

```js
import configs from '@hidoo/eslint-config';
import compatibilityConfig from '@hidoo/eslint-config/+compatibility';

/** @type {import('eslint').Linter.Config[]} */
export default [...configs, compatibilityConfig];
```

### for Mocha

```js
import configs from '@hidoo/eslint-config';
import mochaConfig from '@hidoo/eslint-config/+mocha';

/** @type {import('eslint').Linter.Config[]} */
export default [
  ...configs,
  {
    files: ['**/*.test.js'],
    ...mochaConfig
  }
];
```

### for Node

```js
import configs from '@hidoo/eslint-config';
import nodeConfig from '@hidoo/eslint-config/+node';

/** @type {import('eslint').Linter.Config[]} */
export default [
  ...configs,
  {
    files: ['**/*.test.js'],
    ...nodeConfig
  }
];
```

## Test

```sh
pnpm test
```

## License

MIT
npm package: @hidoo/kss-builder
Description: Provides a custom builder for kss-node.
Author: hidoo
Latest version: 1.1.0

<p align="center">
  <a href="https://github.com/hidoo/kss-builder" target="_blank" rel="noopener">
    <img alt="@hidoo/kss-builder" src="https://raw.githubusercontent.com/hidoo/kss-builder/HEAD/.github/assets/logo.svg" width="150" height="150" style="max-width: 100%;">
  </a>
</p>

<h1 align="center">@hidoo/kss-builder</h1>

<p align="center">
  <a href="https://github.com/hidoo/kss-builder/actions/workflows/test.yml" target="_blank" rel="noopener">
    <img alt="Test" src="https://github.com/hidoo/kss-builder/actions/workflows/test.yml/badge.svg"/ >
  </a>
</p>

<p align="center">Provides a custom builder for <a href="https://github.com/kss-node/kss-node" target="_blank" rel="noopener">kss-node</a>.</p>

## Demo

See [the example style guide](https://hidoo.github.io/kss-builder/) built with this builder.

## Installation

```sh
npm install --save-dev kss @hidoo/kss-builder
```

## Usage

```bash
kss path/to/css path/to/dest --builder @hidoo/kss-builder
```

## License

MIT
npm package: @hidoo/sass-importer
Description: Custom Sass importer.
Author: hidoo
Latest version: 1.0.0

# @hidoo/sass-importer

[![Test](https://github.com/hidoo/sass-importer/actions/workflows/test.yml/badge.svg)](https://github.com/hidoo/sass-importer/actions/workflows/test.yml)

> Custom sass importer.

## Installation

```sh
npm install @hidoo/sass-importer
```

## Usage

```js
import * as sass from 'sass';
import { createFileImporter } from '@hidoo/sass-importer';

const options = {
  importers: [
    createFileImporter({
      extensions: ['.scss'],
      mainFields: ['sass'],
      packagePrefix: '^'
    })
  ]
};
const { css } = await sass.compileAsync('path/to/entry.scss', options);
```

### Use with legacy API

```js
import * as sass from 'sass';
import { createImporter } from '@hidoo/sass-importer';

const options = {
  file: 'path/to/entry.scss',
  importer: [
    createImporter({
      extensions: ['.scss'],
      mainFields: ['sass'],
      packagePrefix: '^'
    })
  ]
};
const { css } = await new Promise((resolve, reject) => {
  sass.render(options, (error, result) => {
    if (error) {
      reject(error);
    } else {
      resolve(result);
    }
  });
});
```

## Test

```sh
pnpm test
```

## License

MIT
npm package: @hidoo/sassdoc-to-markdown
Description: Generate markdown documentation from SassDoc comments.
Author: hidoo
Latest version: 1.0.0

# @hidoo/sassdoc-to-markdown

[![Test](https://github.com/hidoo/sassdoc-to-markdown/actions/workflows/test.yml/badge.svg)](https://github.com/hidoo/sassdoc-to-markdown/actions/workflows/test.yml)

> Generate markdown documentation from SassDoc comments.

## Installation

```sh
npm install @hidoo/sassdoc-to-markdown
```

## Usage

```sh
Usage
  $ sassdoc2md <src> [dest]

Options
  --markdown, -m  markdown that inject document
  --section, -s   section that inject to markdown (default: API)

Customize Options
  --type-order    order of context type (default: variable,placeholder,function,mixin)
  --template      file path of custom handlebars template
  --partials      glob pattern of handlebars partials (ex. path/to/partial/*.hbs)
  --helpers       glob pattern of handlebars helpers (ex. path/to/helpers/*.js)

Supported SassDoc Options
  --exclude
  --autofill
  --verbose, -v
  --strict
  --debug

Examples
  $ sassdoc2md ./src/scss/*.scss
  $ sassdoc2md ./src/scss/*.scss -m ./src/README.md -s API
  $ sassdoc2md ./src/scss/*.scss ./dest/README.md
  $ sassdoc2md ./src/scss/*.scss ./dest/README.md -m ./src/README.md -s API
```

### via Node API

```js
import sassdoc2md from '@hidoo/sassdoc-to-markdown';

const markdown = await sassdoc2md('./src/scss/*.scss');

console.log(markdown);
```

## Test

```sh
pnpm test
```

## License

MIT
npm package: @hidoo/stylelint-config
Description: Shareable stylelint config for my projects.
Author: hidoo
Latest version: 1.1.0

# @hidoo/stylelint-config

[![Test](https://github.com/hidoo/stylelint-config/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/hidoo/stylelint-config/actions/workflows/test.yml)

> Shareable stylelint config for my projects.

## Installation

```sh
npm install --save-dev stylelint @hidoo/stylelint-config
```

## Usage

### Basic rules for CSS syntax

```json
{
  "extends": ["@hidoo/stylelint-config"]
}
```

### Basic rules with the order of properties

```json
{
  "extends": ["@hidoo/stylelint-config", "@hidoo/stylelint-config/+order"]
}
```

### Basic rules with the browser compatibility check

```json
{
  "extends": [
    "@hidoo/stylelint-config",
    "@hidoo/stylelint-config/+compatibility"
  ]
}
```

### Basic rules with the performance check

```json
{
  "extends": ["@hidoo/stylelint-config", "@hidoo/stylelint-config/+performance"]
}
```

### Basic rules with SCSS syntax

```json
{
  "extends": ["@hidoo/stylelint-config", "@hidoo/stylelint-config/+scss"]
}
```

## Test

```sh
$ pnpm test
```

## License

MIT
npm package: @hidoo/util-fancy-print
Description: Utility that print styled values to console
Author: hidoo
Latest version: 0.19.0

# @hidoo/util-fancy-print

> Utility that print styled values to console.

## Installation

```sh
$ npm install @hidoo/util-fancy-print
```

## Usage

```js
import fancyPrint from '@hidoo/util-fancy-print';

fancyPrint('project name', [
  {label: 'Host', value: '0.0.0.0'},
  {label: 'Port', value: 8000}
]);
// ++++++++++++++++++++++++++++++
//          project name
// ++++++++++++++++++++++++++++++
//
// Host: 0.0.0.0
// Port: 8000
//
// ++++++++++++++++++++++++++++++
```

## Test

```sh
$ yarn test
```

## License

MIT
npm package: @hidoo/util-local-ip
Description: Utility that get current ip address in local network.
Author: hidoo
Latest version: 0.19.0

# @hidoo/util-local-ip

> Utility that get current ip address in local network.

## Installation

```sh
$ npm install @hidoo/util-local-ip
```

## Usage

```js
import getLocalIps from '@hidoo/util-local-ip';

const ips = getLocalIps({ipv6: false, internal: true, external: false});
// ['127.0.0.1']
```

## Test

```sh
$ yarn test
```

## License

MIT
npm package: @hidoo/util-merge-babelrc
Description: Utility that merge .babelrc.
Author: hidoo
Latest version: 0.19.0

# @hidoo/util-merge-babelrc

> Utility that merging .babelrc.

## Installation

```sh
$ npm install --save-dev @hidoo/util-merge-babelrc
```

## Usage

```js
import mergeBabelrc from '@hidoo/util-merge-babelrc';

const babelOptions = mergeBabelrc('/path/to/.babelrc.js', {
  presets: [...],
  plugins: [...],
  useBuiltIns: 'usege'
});
```

## Test

```sh
$ yarn test
```

## License

MIT
npm package: @hidori/playwright-crawler-core
Description: Playwright crawler core
Author: hidori
Latest version: 0.0.5

# @hidori/playwright-crawler-core

Playwright crawler core

## INSTALL

```sh
npm i --save @hidori/playwright-crawler-core
```

## USAGE

```js
import { Crawler } from "@hidori/playwright-crawler-core";

class GoogleCaptureJob {
  async run({ crawler, page }) {
    await page.goto("https://www.google.com");
    crawler.infoSync("google/capture: navigated");

    await page.screenshot({ path: "screenshot.png", fullPage: true });
    crawler.infoSync("google/capture: captured");

    await page.waitForTimeout(5000);
  }
}

const config = {
  playwright: {
    channel: "chrome",
    headless: false,
  },
};

const jobs = {
  "google/capture": new GoogleCaptureJob(),
};

new Crawler(config, jobs).run(["google/capture"]);
```
npm package: @hidrasoft-meta-sdk/core
Description: The **Core Module** is the foundational part of the project. It contains essential logic, fundamental services, and reusable tools that support the rest of the system.
Author: Hidrasoft S.A.S
Latest version: 1.0.0

# @hidrasoft-meta-sdk/core

The **Core Module** is the foundational part of the project. It contains essential logic, fundamental services, and reusable tools that support the rest of the system.

## Features of the Core Module

- **Modularity**: Designed to integrate seamlessly with other modules.
- **Scalability**: Implements design patterns to support growth without compromising structure.
- **Centralized Configuration**: All essential configurations are unified in one place.
- **Written in TypeScript**: Leverages static typing and robust development practices.

## Project Setup

### `tsconfig.json` Highlights

The project is configured with the following key options:

- **Target**: `es2016` to ensure compatibility with modern JavaScript environments.
- **Module**: `commonjs` for compatibility with Node.js modules.
- **Strict Mode**: Enabled to enforce stricter type checking.
- **ES Module Interoperability**: `esModuleInterop` is enabled for better compatibility with CommonJS modules.
- **Skip Library Check**: `skipLibCheck` is set to avoid unnecessary type checking of `.d.ts` files.

## Installation

To install the module, use the following command:

```bash
npm install @hidrasoft-meta-sdk/core
```
## Usage
### Importing the Module
You can import and use the module as follows:

```typescript
import { MetaApiClient } from '@hidrasoft-meta-sdk/core';

// Example usage
const client = new MetaApiClient({ apiKey: 'your-api-key' });
const data = await client.fetchData('endpoint');
console.log(data);
```

### Authentication Modules
The Core Module includes various authentication classes for handling different types of tokens:

* **App Token:** `AppAuthentication`
* **Client Token:** `ClientAuthentication`
* **Page Access Token:** `PageAuthentication`
* **System User Token:** `SystemUserAuthentication`
* **User Token:** `UserAuthentication`

Example:

```typescript
import { PageAuthentication } from '@hidrasoft-meta-sdk/core';

const pageAuth = new PageAuthentication('your-page-token');
const pageInfo = await pageAuth.getPageInfo();
console.log(pageInfo);
```

## Folder Structure
The Core Module has the following folder structure:

```lua
core/
├── src/
│   ├── auth/
│   │   ├── AppAuthentication.ts
│   │   ├── ClientAuthentication.ts
│   │   ├── PageAuthentication.ts
│   │   ├── SystemUserAuthentication.ts
│   │   └── UserAuthentication.ts
│   ├── clients/
│   │   └── MetaApiClient.ts
│   ├── config/
│   │   └── index.ts
│   ├── utils/
│   │   └── helpers.ts
│   └── index.ts
├── tests/
│   └── core.test.ts
├── package.json
└── tsconfig.json
```

## Running Tests
To run tests for the module, use the following command:

```bash
npm test
```

## Contributing
We welcome contributions! Please follow the guidelines in the [CONTRIBUTING.md]() file.

## License
This project is licensed under the MIT License. See the LICENSE file for details.
npm package: @hieco/mirror-cli
Description: CLI tool for Hedera Mirror Node REST API - query accounts, tokens, transactions, blocks, contracts, schedules, topics, and network state
Author: pow
Latest version: 1.0.0

# @hieco/mirror-cli

`@hieco/mirror-cli` is the command-line companion to Hieco’s Mirror client.

It lets you inspect Hedera data from a terminal as quickly as you can think of the question.

## Why This Package Exists

Sometimes the fastest way to understand chain data is not a script or an app. It is a terminal command you can run right now.

`@hieco/mirror-cli` exists for that moment. It gives you:

- one `hieco` binary
- read-only commands across the main Mirror domains
- human-friendly output for exploration
- JSON output for shell scripts and automation

## When To Use It

Choose `@hieco/mirror-cli` when you want to:

- inspect accounts, tokens, transactions, contracts, or topics
- verify Mirror responses without writing code
- script read-only blockchain checks in CI or local tooling
- move quickly between “what does the data look like?” and “now automate it”

If you need a programmatic client, use [`@hieco/mirror`](../mirror/README.md).

## Run Without Installing

```bash
bunx @hieco/mirror-cli --help
```

```bash
npx -y @hieco/mirror-cli --help
```

```bash
pnpm dlx @hieco/mirror-cli --help
```

```bash
yarn dlx @hieco/mirror-cli --help
```

## Global Installation

```bash
npm install --global @hieco/mirror-cli
```

```bash
pnpm add --global @hieco/mirror-cli
```

```bash
yarn global add @hieco/mirror-cli
```

```bash
bun add --global @hieco/mirror-cli
```

The installed binary name is `hieco`.

## Quick Start

```bash
bunx @hieco/mirror-cli account 0.0.1001
bunx @hieco/mirror-cli balance 0.0.1001
bunx @hieco/mirror-cli token 0.0.2001
bunx @hieco/mirror-cli transactions:list --account 0.0.1001 --limit 10
bunx @hieco/mirror-cli network:exchange-rate
```

## Command Model

The CLI follows a consistent pattern:

- single-resource lookups such as `account`, `token`, and `transaction`
- filtered collection commands such as `balances`, `blocks`, and `contract:results`
- broad list commands such as `accounts:list`, `tokens:list`, and `topics:list`

Global flags available on every command:

- `-n, --network <network>`
- `-u, --mirror-url <url>`

Most commands also accept `-j, --json`.

## Common Workflows

### Explore data interactively

```bash
bunx @hieco/mirror-cli contract 0.0.3001
bunx @hieco/mirror-cli topic:messages 0.0.5005 --limit 20
```

### Use JSON in a shell pipeline

```bash
bunx @hieco/mirror-cli transactions:list --account 0.0.1001 --limit 25 --json > transactions.json
```

### Point at a different network

```bash
bunx @hieco/mirror-cli accounts:list --network testnet --limit 5
```

## Related Packages

- [`@hieco/mirror`](../mirror/README.md)
- [`@hieco/mirror-mcp`](../mirror-mcp/README.md)
npm package: @hieco/mirror-mcp
Description: MCP server for Hedera Mirror Node REST API
Author: pow
Latest version: 1.0.0

# @hieco/mirror-mcp

`@hieco/mirror-mcp` turns Hieco’s Mirror client into a local MCP server so agents can explore Hedera data through a clean, validated, read-only tool surface.

If `@hieco/mirror-cli` is for humans in a terminal, this package is for agents in an MCP-compatible host.

## Why This Package Exists

AI agents should not need custom wrappers every time they need blockchain reads. This package gives them:

- a ready-to-run stdio MCP server
- read-only tools across the main Mirror domains
- validated input schemas
- environment-driven startup config
- optional session-level network switching

## When To Use It

Choose `@hieco/mirror-mcp` when you want to:

- expose Hedera data to a local MCP client
- give an agent safe, structured Mirror access
- avoid hand-building tool definitions around the Mirror REST API
- keep agent tooling aligned with the same package family used elsewhere in the repo

## Run Without Installing

```bash
bunx @hieco/mirror-mcp
```

```bash
npx -y @hieco/mirror-mcp
```

```bash
pnpm dlx @hieco/mirror-mcp
```

```bash
yarn dlx @hieco/mirror-mcp
```

## Global Installation

```bash
npm install --global @hieco/mirror-mcp
```

```bash
pnpm add --global @hieco/mirror-mcp
```

```bash
yarn global add @hieco/mirror-mcp
```

```bash
bun add --global @hieco/mirror-mcp
```

The installed binary name is `mirror-mcp`.

## Quick Start

Example MCP client configuration with `npx`:

```json
{
  "mcpServers": {
    "hedera-mirror": {
      "command": "npx",
      "args": ["-y", "@hieco/mirror-mcp"],
      "env": {
        "MIRROR_NETWORK": "mainnet",
        "MIRROR_ALLOW_NETWORK_SWITCH": "true"
      }
    }
  }
}
```

Example MCP client configuration with `bunx`:

```json
{
  "mcpServers": {
    "hedera-mirror": {
      "command": "bunx",
      "args": ["@hieco/mirror-mcp"],
      "env": {
        "MIRROR_NETWORK": "mainnet",
        "MIRROR_ALLOW_NETWORK_SWITCH": "true"
      }
    }
  }
}
```

## Runtime Model

The server starts over stdio and keeps one in-memory `MirrorNodeClient` for the current process.

Environment variables shape startup behavior:

- `MIRROR_NETWORK`
- `MIRROR_NODE_URL`
- `MIRROR_ALLOW_NETWORK_SWITCH`

When network switching is enabled, the process can move to a different built-in network or custom Mirror endpoint for later tool calls.

## Notes

- This package is read-only.
- Tool inputs are validated before a Mirror call is made.
- Restarting the server resets the session to its startup defaults.
- The server is built on the same `@hieco/mirror` client used by the CLI and framework wrappers.

## Related Packages

- [`@hieco/mirror`](../mirror/README.md)
- [`@hieco/mirror-cli`](../mirror-cli/README.md)
npm package: @hieco/mirror-preact
Description: Type-safe Preact hooks for Hedera Mirror Node with TanStack Query
Author: pow
Latest version: 1.0.0

# @hieco/mirror-preact

`@hieco/mirror-preact` gives Preact apps the same read-only Mirror Node experience that `@hieco/mirror-react` gives React apps.

It is the Preact-native way to bring Hieco Mirror reads into a component tree without giving up the underlying `@hieco/mirror` mental model.

## Why This Package Exists

Preact apps still need typed blockchain reads, shared client state, and predictable query flows. This package adds:

- a `MirrorNodeProvider` for Preact
- query hooks over the core Mirror client
- shared network switching
- the same domain model used by the rest of the Mirror package family

## When To Use It

Choose `@hieco/mirror-preact` when you are building a Preact app that needs:

- accounts, balances, and transactions
- token or NFT views
- contract or topic inspection
- read-only network data in a reactive UI

## Installation

```bash
npm install @hieco/mirror @hieco/mirror-preact @tanstack/preact-query
```

```bash
pnpm add @hieco/mirror @hieco/mirror-preact @tanstack/preact-query
```

```bash
yarn add @hieco/mirror @hieco/mirror-preact @tanstack/preact-query
```

```bash
bun add @hieco/mirror @hieco/mirror-preact @tanstack/preact-query
```

Peer dependencies expected from the host app:

- `preact >= 10`
- `@tanstack/preact-query ^5`

## Quick Start

```tsx
import { QueryClient, QueryClientProvider } from "@tanstack/preact-query";
import { MirrorNodeProvider, useAccountInfo, useTransactionsByAccount } from "@hieco/mirror-preact";

const queryClient = new QueryClient();

function AccountPanel() {
  const account = useAccountInfo({ accountId: "0.0.1001" });
  const transactions = useTransactionsByAccount({
    accountId: "0.0.1001",
    params: {
      limit: 10,
      order: "desc",
    },
  });

  if (account.isPending || transactions.isPending) {
    return <div>Loading...</div>;
  }

  return (
    <pre>{JSON.stringify({ account: account.data, transactions: transactions.data }, null, 2)}</pre>
  );
}

export function App() {
  return (
    <QueryClientProvider client={queryClient}>
      <MirrorNodeProvider config={{ defaultNetwork: "testnet" }}>
        <AccountPanel />
      </MirrorNodeProvider>
    </QueryClientProvider>
  );
}
```

## Notes

- This package is the Preact wrapper over `@hieco/mirror`.
- The provider owns the current network and active `MirrorNodeClient`.
- The public flow intentionally matches the React wrapper so teams can move between the two with less friction.

## Related Packages

- [`@hieco/mirror`](../mirror/README.md)
- [`@hieco/mirror-react`](../mirror-react/README.md)
- [`@hieco/mirror-solid`](../mirror-solid/README.md)
npm package: @hieco/mirror-solid
Description: Type-safe SolidJS hooks for Hedera Mirror Node with TanStack Query
Author: pow
Latest version: 1.0.0

# @hieco/mirror-solid

`@hieco/mirror-solid` gives Solid apps a provider and query helpers for read-only Hedera data from Mirror Node.

It keeps the same Hieco Mirror story intact while fitting Solid’s reactive model.

## Why This Package Exists

Solid apps need the same building blocks as other frontend apps:

- a shared client
- framework-native data APIs
- network switching
- predictable data access across Hedera entities

This package delivers that on top of `@hieco/mirror`.

## When To Use It

Choose `@hieco/mirror-solid` when you are building a Solid app that needs:

- read-only account or token views
- transaction feeds
- topic or contract inspection
- network and block data in a reactive UI

## Installation

```bash
npm install @hieco/mirror @hieco/mirror-solid @tanstack/solid-query
```

```bash
pnpm add @hieco/mirror @hieco/mirror-solid @tanstack/solid-query
```

```bash
yarn add @hieco/mirror @hieco/mirror-solid @tanstack/solid-query
```

```bash
bun add @hieco/mirror @hieco/mirror-solid @tanstack/solid-query
```

Peer dependencies expected from the host app:

- `solid-js >= 1.8`
- `@tanstack/solid-query ^5`

## Quick Start

```tsx
import { QueryClient, QueryClientProvider } from "@tanstack/solid-query";
import { MirrorNodeProvider, createAccountInfo } from "@hieco/mirror-solid";

const queryClient = new QueryClient();

function AccountPanel() {
  const account = createAccountInfo(() => ({ accountId: "0.0.1001" }));

  return <pre>{JSON.stringify(account.data, null, 2)}</pre>;
}

export function App() {
  return (
    <QueryClientProvider client={queryClient}>
      <MirrorNodeProvider config={{ defaultNetwork: "testnet" }}>
        <AccountPanel />
      </MirrorNodeProvider>
    </QueryClientProvider>
  );
}
```

## Solid-Specific Shape

Unlike the React and Preact wrappers, the Solid package exposes `create*` query helpers such as:

- `createAccountInfo`
- `createTransactionsByAccount`
- `createContractLogs`

That keeps the API aligned with Solid’s reactive style instead of pretending every framework should look like React.

## Notes

- This package is read-only and built on `@hieco/mirror`.
- The provider exposes the active client and network-switching behavior.
- Its structure intentionally matches the rest of the Mirror family even though the query API style is Solid-native.

## Related Packages

- [`@hieco/mirror`](../mirror/README.md)
- [`@hieco/mirror-react`](../mirror-react/README.md)
- [`@hieco/mirror-preact`](../mirror-preact/README.md)
npm package: @hieco/realtime
Description: Real-time streaming client for Hedera Mirror Node via HIP-694 JSON-RPC Relay
Author: pow
Latest version: 1.0.0

# @hieco/realtime

`@hieco/realtime` is the Hieco client for live Hedera relay streams over the realtime JSON-RPC layer.

Use it when your app needs to move from “what happened?” to “what is happening right now?”

## Why This Package Exists

Mirror reads are great for current state, but some apps need to stay subscribed to new events as they arrive. This package gives you:

- a realtime relay client
- connection lifecycle management
- subscription primitives for live chain updates
- a reusable foundation for framework bindings

## When To Use It

Choose `@hieco/realtime` when you are building:

- live dashboards
- transaction or block feeds
- event-driven backend services
- apps that need websocket-style subscriptions without React

If you want the React wrapper, use [`@hieco/realtime-react`](../realtime-react/README.md).

## Installation

```bash
npm install @hieco/realtime
```

```bash
pnpm add @hieco/realtime
```

```bash
yarn add @hieco/realtime
```

```bash
bun add @hieco/realtime
```

## Quick Start

```ts
import { RelayWebSocketClient } from "@hieco/realtime";

const client = new RelayWebSocketClient({
  network: "testnet",
  endpoint: "wss://testnet.mirrornode.hedera.com/relay/ws",
});

const connected = await client.connect();

if (!connected.success) {
  throw new Error(connected.error.message);
}

const subscription = await client.subscribe({ type: "newHeads" }, (message) => {
  console.log(message.result);
});

if (subscription.success) {
  await client.unsubscribe(subscription.data);
}

await client.disconnect();
```

## The Realtime Model

The package is centered around connection and subscription primitives:

- connect
- subscribe
- react to stream state
- unsubscribe
- disconnect cleanly

That keeps it useful in scripts, services, and custom UI integrations where you want low-level control.

## Client Choices

Inside the package there are two main connection models:

- `RelayWebSocketClient` for one connection
- `ConnectionPool` for multiple coordinated connections

Start with `RelayWebSocketClient`. Reach for `ConnectionPool` only when the app genuinely needs pooled subscriptions or load distribution.

## Packaging And Runtime Support

The package ships browser-friendly ESM output with conditional exports for `browser`, `worker`, `workerd`, `node`, and `default`.

That does not change the runtime model of the websocket client itself, but it does make the package easier to consume in modern browser, edge, and server toolchains.

## Related Packages

- [`@hieco/realtime-react`](../realtime-react/README.md)
- [`@hieco/mirror`](../mirror/README.md) when you want initial state plus live updates
npm package: @hieco/realtime-react
Description: React hooks for @hieco/realtime with automatic subscription management
Author: pow
Latest version: 1.0.0

# @hieco/realtime-react

`@hieco/realtime-react` brings Hieco’s realtime relay client into React with a provider, hooks, and managed connection state.

It is the easiest way to add live Hedera updates to a React app without hand-rolling websocket orchestration.

## Why This Package Exists

Realtime React code gets messy fast when connection state, subscriptions, and cleanup all live in components. This package gives you:

- a `RealtimeProvider`
- shared client and connection state
- hooks for relay subscriptions
- an easier bridge between static reads and live updates

## When To Use It

Choose `@hieco/realtime-react` when you are building:

- live transaction feeds
- streaming dashboards
- React apps that combine initial Mirror reads with realtime updates
- components that should subscribe and unsubscribe cleanly with the tree

## Installation

```bash
npm install @hieco/realtime @hieco/realtime-react
```

```bash
pnpm add @hieco/realtime @hieco/realtime-react
```

```bash
yarn add @hieco/realtime @hieco/realtime-react
```

```bash
bun add @hieco/realtime @hieco/realtime-react
```

Peer dependencies expected from the host app:

- `react >= 18`
- `react-dom >= 18`

## Quick Start

```tsx
import { useEffect } from "react";
import {
  RealtimeProvider,
  useContractLogs,
  useRealtimeContext,
  useStreamState,
} from "@hieco/realtime-react";

function ContractLogFeed() {
  const { connect } = useRealtimeContext();
  const streamState = useStreamState();
  const { logs, isConnected, error } = useContractLogs({
    address: "0x0000000000000000000000000000000000001389",
    enabled: true,
  });

  useEffect(() => {
    void connect();
  }, [connect]);

  if (!isConnected) return <div>{streamState._tag}</div>;
  if (error) return <div>{error.message}</div>;

  return <pre>{JSON.stringify(logs, null, 2)}</pre>;
}

export function App() {
  return (
    <RealtimeProvider
      config={{
        network: "testnet",
        relayEndpoint: "wss://testnet.mirrornode.hedera.com/relay/ws",
      }}
    >
      <ContractLogFeed />
    </RealtimeProvider>
  );
}
```

## The Provider Model

`RealtimeProvider` owns:

- the active relay client
- the current stream state
- `connect()`
- `disconnect()`

That makes realtime connectivity feel like shared app infrastructure instead of one more local component concern.

The provider does not auto-connect by itself. Call `connect()` from `useRealtimeContext()` when the app is ready to open the relay connection.

## Useful Hooks

Common exports include:

- `useRealtimeClient()`
- `useStreamState()`
- `useChainId()`
- `useContractLogs()`

Use the provider and hooks first. Drop to the raw client only when you need manual subscription logic.

## Related Packages

- [`@hieco/realtime`](../realtime/README.md)
- [`@hieco/mirror-react`](../mirror-react/README.md) for “load current state, then stay live” flows
npm package: @hieco/runtime
Description: Runtime-aware Hiero SDK adapter for browser, workers, and Node.js
Author: pow
Latest version: 1.0.0

# @hieco/runtime

`@hieco/runtime` is the runtime-aware adapter around the Hiero JavaScript SDK used by the Hieco package family.

It exists so Hieco packages can depend on one stable import path while package resolution still does the right thing in browsers, workers, workerd, and Node-style runtimes.

## Why This Package Exists

Hieco packages use this package as the shared boundary around the underlying Hiero SDK:

- `@hieco/sdk` re-exports core SDK types from `@hieco/runtime`
- `@hieco/wallet` uses it for signer and transaction interop
- the package manifest can declare different entrypoints for browser and node consumers without every sibling package having to solve that problem on its own

Most Hieco users will touch this package indirectly through `@hieco/sdk` or `@hieco/wallet`. Reach for it directly when you need raw Hiero SDK exports but want to stay aligned with Hieco’s runtime packaging.

## When To Use It

Use `@hieco/runtime` when you need:

- raw SDK classes such as `Client`, `PrivateKey`, or `Transaction`
- SDK types like `Signer` in shared code that already depends on Hieco packages
- one import path that can resolve correctly in browser, worker, and node environments

If you want Hieco’s fluent application client, use [`@hieco/sdk`](../sdk/README.md) instead.

## Installation

```bash
npm install @hieco/runtime
```

```bash
pnpm add @hieco/runtime
```

```bash
yarn add @hieco/runtime
```

```bash
bun add @hieco/runtime
```

## Quick Start

```ts
import { Client, PrivateKey, type Signer } from "@hieco/runtime";

const client = Client.forTestnet();
const key = PrivateKey.generateED25519();

export function useSigner(signer: Signer) {
  return { client, signer, key };
}
```

## Runtime Resolution

The package publishes explicit runtime-aware entrypoints:

- `@hieco/runtime` resolves to the browser build by default
- `@hieco/runtime/node` gives you the node entry explicitly
- `@hieco/runtime/browser` gives you the browser entry explicitly

The root export also declares `browser`, `worker`, `workerd`, `node`, and `default` conditions, so supported bundlers can pick the right file automatically.

## What It Exports

The package re-exports the underlying Hiero SDK surface. That means the familiar SDK classes and types are available here, including:

- `Client`
- `Signer`
- `PrivateKey`
- `PublicKey`
- `Mnemonic`
- transaction, query, and receipt types

## Build And Publish Behavior

`@hieco/runtime` is the public package in the workspace that ships separate browser and node build outputs:

- `dist/browser.js`
- `dist/node.js`

Everything else in the workspace can stay on a single browser-friendly ESM build and rely on conditional exports plus externalized dependencies.

## Related Packages

- [`@hieco/sdk`](../sdk/README.md) for the higher-level fluent Hieco client
- [`@hieco/wallet`](../wallet/README.md) for wallet-derived signers built on this runtime boundary
npm package: @hieco/utils
Description: Shared utilities and types for Hieco packages
Author: pow
Latest version: 1.0.0

# @hieco/utils

`@hieco/utils` is the shared toolbox behind the Hieco package family.

It is the low-level package where shared types, network helpers, validation utilities, query keys, and error helpers live so the rest of the package family stays aligned.

## Why This Package Exists

Good ecosystems feel consistent because the small rules are shared. This package centralizes those rules for:

- API and pagination types
- Hedera entity validation
- built-in network configuration
- Mirror query key factories
- invalidation helpers used by framework wrappers
- shared error and result utilities

## Who Should Use It

Most Hieco consumers will want one of the higher-level packages instead.

This package exists mainly for maintainers, framework wrappers, and advanced consumers that want the low-level shared primitives directly.

## What Lives Here

Shared exports include:

- API result and error types
- entity and network helpers
- Mirror query key factories
- invalidation helpers used by the framework packages

## Packaging Notes

This package follows the same packaging rules as the rest of the public package family:

- build output lives in `dist`
- the package exports browser-friendly ESM
- package manifests declare explicit runtime conditions

That keeps behavior consistent across SDK, wallet, Mirror, and realtime packages.

## Related Packages

- [`@hieco/mirror`](../mirror/README.md)
- [`@hieco/sdk`](../sdk/README.md)
- [`@hieco/realtime`](../realtime/README.md)
npm package: @hiendv/bem-sass
Description: BEM mixins for Sass
Author: Hien Dao
Latest version: 0.1.0

# BEM mixins for Sass
- [BEM by Example](https://seesparkbox.com/foundry/bem_by_example) - NATHAN RAMBECK
- [BEM Mixins](https://css-tricks.com/snippets/sass/bem-mixins/) - HUGO GIRAUDEL
npm package: @hiendv/react-tabs
Description: Tabs component for React.js
Author: Theodore Kluge
Latest version: 0.12.5

# @hiendv/react-tabs
Lightweight and flexible tabs component for the web :zap:

## Features
- [x] Tab definition using template & programmatically
- [x] Octicons support in tab items
- [x] Beautiful modulized themes included
- [x] Easily accessible navigation with URL
- [x] Easy tab positioning
- [x] *Ghost* tabs support

## Demo
See [https://hiendv.github.io/tabs](https://hiendv.github.io/tabs)

## Installation & Usage
### CDN
```html
<script src="https://cdn.jsdelivr.net/npm/@hiendv/react-tabs@latest/dist/iife.js" crossorigin="anonymous"></script>
```
**Note: We recommend linking to a specific version number that you can update manually**
```js
const { Tab, Tabs, themeDefault, themeDark } = reacttabs
```

### NPM
```bash
npm install --save @hiendv/react-tabs
# yarn add @hiendv/react-tabs
```

```jsx
import React, { Component } from 'react'
import { Tabs, Tab } from '@hiendv/react-tabs'
export default class App extends Component {
  render () {
    return (
      <Tabs>
        <Tab title='First'>
          Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
          tempor incididunt ut labore et dolore magna aliqua.
        </Tab>

        <Tab title='Second'>
          Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
          aliquip ex ea commodo consequat.
        </Tab>

        <Tab title='Third'>
          Duis aute irure dolor in reprehenderit in voluptate velit esse cillum
          dolore eu fugiat nulla pariatur.
        </Tab>
      </Tabs>
    )
  }
}
```
Please see **[react-tabs-example](/packages/react-tabs-example)** for a complete demonstration.

## Documentation
### Tabs
| Property | Type | Required | Default | Description
|-------|-------|-------|-------|-------|
| theme | Object | No | themeDefault - *[@hiendv/tabs](https://github.com/hiendv/tabs/tree/master/packages/tabs)* | Modulized style
| show | Number | No | 0 | Initial active tab
---

| Event | Arguments | Description
|-------|-------|-------|
| onUpdate | (index) | Current active tab


### Tab
#### Props
| Property | Type | Required | Default | Description
|-------|-------|-------|-------|-------|
| title | String | No | 'Title' | Tab title
| icon | Object | No | Empty | Tab octicon - *[octicons-react](https://github.com/hiendv/octicons-modular/tree/master/packages/octicons-react)*
| hash | String | No | null | Unique hash fragment for easy bookmark and navigation
| end | Boolean | No | false | Push the tab and its following friends to the right
| ghost | Boolean | No | false | Mark tab as a pure button


## Development & Testing
Please check the [Contributing Guidelines](https://github.com/hiendv/tabs/blob/master/CONTRIBUTING.md).

## Contribution
Issues and PRs are welcome !
npm package: @hiendv/stylelint-config-primer
Description: Sharable stylelint config used by GitHub's CSS
Author: GitHub, Inc.
Latest version: 3.0.0
Deprecated: this package has been deprecated

# Primer Stylelint Config

[![NPM version](https://img.shields.io/npm/v/stylelint-config-primer.svg)](https://www.npmjs.org/package/stylelint-config-primer)
[![Build Status](https://travis-ci.org/primer/primer.svg?branch=master)](https://travis-ci.org/primer/primer)

This is a fork from [stylelint-config-primer](https://github.com/primer/primer/tree/master/tools/stylelint-config-primer).

## Install

```
$ npm install --save @hiendv/stylelint-config-primer
```

## Usage

Within your [stylelint config object](http://stylelint.io/user-guide/configuration/#extends) You can extend this configuration. This will serve as a base for your config, then you can make overrides in your own config object.

```json
{
  "extends": "@hiendv/stylelint-config-primer"
}
```

## License

[MIT](./LICENSE) &copy; [GitHub](https://github.com/)
npm package: @hiendv/tabs
Description: Utilities & themes for @hiendv/vue-tabs & @hiendv/react-tabs
Author: Hien Dao
Latest version: 0.12.5

# @hiendv/tabs
Utilities & themes for @hiendv/vue-tabs & @hiendv/react-tabs

## Installation & Usage
### NPM
The package is mostly consumed by internal Vue & React components. Everything is re-exported.
```js
// Vue
import { themeDefault, themeDark, setHash } from '@hiendv/vue-tabs'

// React
import { themeDefault, themeDark, setHash } from '@hiendv/react-tabs'
```

Please see **[vue-tabs-example](/packages/vue-tabs-example)** for a complete demonstration.

## Development & Testing
Please check the [Contributing Guidelines](https://github.com/hiendv/tabs/blob/master/CONTRIBUTING.md).

## Contribution
Issues and PRs are welcome !
npm package: @hienhoceo/n8n-nodes-blogger
Description: n8n community nodes for the Blogger API - manage blogs, posts, pages, and comments
Author: hienhoceo
Latest version: 1.1.5

# n8n-nodes-blogger

Community node pack for n8n to work with the Blogger API.

## Documentation

For complete documentation and setup guide, visit:
- English: https://dps.media/en/guide-to-integrating-blogger-api-into-n8n-with-hienhoceo-n8n-nodes-blogger/
- Vietnamese: https://dps.media/huong-dan-tich-hop-blogger-api-vao-n8n-voi-hienhoceo-n8n-nodes-blogger/

## Features

- Blogs: get by ID, get by URL, list by user
- Posts: list, get, search, get by path, create, update, patch, delete
- Comments: list, get
- Pages: list, get
- Users: get (self or by ID)

## Installation

```bash
npm install @hienhoceo/n8n-nodes-blogger
```

## Credentials

- **Blogger OAuth2 API**: supports private data and write operations. Use the OAuth Redirect URL shown by n8n in your Google OAuth client.

OAuth scope required: `https://www.googleapis.com/auth/blogger`

## Notes

- All operations require OAuth2 credentials.
- List operations support pagination with `Return All` and `Limit`.
npm package: @hienhoceo/n8n-nodes-larksuite-document
Description: n8n node for Lark Suite Document API with HTML conversion and advanced automation
Latest version: 0.9.0

# n8n-nodes-larksuite-document

## Description
n8n community node for Lark Suite Document API with advanced automation capabilities including HTML conversion, multiple block types, and enterprise-grade features.

## Key Features
- ✅ 16+ block types (Headings, Text, Lists, Code, Quotes, Todos, Callouts, Images, etc.)
- 🔥 HTML to Lark conversion
- ⚡ Automatic chunking for large documents
- 🛡️ Enterprise-grade error handling
- 🎨 Smart App ID/Secret authentication

## Quick Start
```bash
npm install @hienhoceo/n8n-nodes-larksuite-document
```

## 📖 Full Documentation & Examples
**Complete setup guide, detailed examples, and use cases:**
👉 **[dps.media/tu-dong-dang-bai-len-lark-suite-document](https://dps.media/tu-dong-dang-bai-len-lark-suite-document-voi-node-hienhoceo-n8n-nodes-larksuite-document/)**

## Quick Setup
1. Install node: `npm install @hienhoceo/n8n-nodes-larksuite-document`
2. Get App ID & Secret from [Lark Developer Console](https://open.larksuite.com/app)
3. Configure permissions: `docx:document`, `docx:document:readonly`
4. Start automating your Lark documents!

## Operations
- **Create**: New documents with title & folder
- **Create Block**: Multiple content types including HTML conversion
- **Get**: Document details and content
- **Get Blocks**: List all document blocks

## NPM
[@hienhoceo/n8n-nodes-larksuite-document](https://www.npmjs.com/package/@hienhoceo/n8n-nodes-larksuite-document)

## License
MIT