open-index/open-npm huggingface dataset:
npm package: @hellhiem/quick-fetch
Description: HTTP client built at the top of [axios](https://github.com/axios/axios) library to reduce your boilerplate in friendly way.
Author: Milosz Szczepanek
Latest version: 0.1.6

# quick-fetch

HTTP client built at the top of [axios](https://github.com/axios/axios) library to reduce your boilerplate in friendly way.

`quickFetch` already return `data` from response or throws error.

When using `TypeScript` you can get use of `Generics` to pass down your own `ResponseType` and `ErrorType` that are returned by API.

# Installation

Using npm:

```bash
npm install @hellhiem/quick-fetch
```

Using yarn:

```bash
yarn add @hellhiem/quick-fetch
```

# Example

## **JavaScript**

```js
quickFetch(Method, Endpoint, Config)
```

**`Params:`**
| Param | Type | Description |
| :--- | :---: | ----------: |
| Method | [Method](https://github.com/axios/axios#request-method-aliases) | Axios method type (POST,GET, etc...) |
| Endpoint | `string` | ... |
| Config (**Optional**) | [AxiosRequestConfig](https://github.com/axios/axios#request-config) | Axios request configs |

```js
/// Simple fetch without configs
quickFetch('GET', 'https://api.example/v1/movies')

// Simple fetch with optional configs
quickFetch('GET', 'https://api.example/v1/movies', 
    { 
        headers: {...yourHeaders },
        ...otherConfigs
    }
)
```

## **TypeScript**

```ts
quickFetch<ResponseType, ErrorType>(Method, Endpoint, Config)
```

**`Params:`**
| Param | Type | Description |
| :--- | :---: | ----------: |
| Method | [Method](https://github.com/axios/axios#request-method-aliases) | Axios method type (POST,GET, etc...) |
| Endpoint | `string` | ... |
| Config (**Optional**) | [AxiosRequestConfig](https://github.com/axios/axios#request-config) | Axios request configs |

**`Generics:`**
| Generics | DefaultType | Description |
| :------- | :---------: | ----------: |
| ResponseType | [AxiosResponse](https://github.com/axios/axios/blob/v1.x/index.d.ts#L267) | Response type returned by `response.data`. When type is not provided is falls back to `AxiosResponse` type. |
| ResponseErrorType | [AxiosError](https://github.com/axios/axios/blob/v1.x/index.d.ts#L276) | Response error type threw by `error`. When type is not provided is falls back to `AxiosError` type. |

```ts
// Example types
type Movie = {
    id: number;
    name: string;
}

type MoviesResponseType = {
    page: number;
    perPage: number;
    maxPage: number;
    data: Movie[];
}

type ResponseErrorType = {
    code: number;
    text: string;
}

/// Simple fetch without configs
quickFetch<MoviesResponseType, ResponseErrorType>('GET', 'https://api.example/v1/movies')

// Simple fetch with optional configs
quickFetch<MoviesResponseType, ResponseErrorType>('GET', 'https://api.example/v1/movies', 
    { 
        headers: {...yourHeaders },
        ...otherConfigs
    }
)
```
npm package: @hellhub-collective/cli
Description: A CLI for Helldivers 2: View the war progress without leaving your terminal! Powered by the HellHub API.
Author: Fabio Nettis
Latest version: 1.4.0

<p align="center">
  <a href="https://github.com/hellhub-collective/cli">
    <img src="https://raw.githubusercontent.com/hellhub-collective/cli/main/assets/logo.png" width="150px" alt="HellHub CLI Logo" />
  </a>
</p>

<h3 align="center">The Official CLI For The Community Driven HellHub API.</h3>
<p align="center">Written 100% in <a href="https://github.com/microsoft/TypeScript">TypeScript</a> on top of the <a href="https://github.com/hellhub-collective/sdk">HellHub SDK</a>, Filter and collect data without ever leaving your terminal! Perfect for mid-work sneak peaks.</p>

<br />

<p align="center">
  <a href="https://github.com/hellhub-collective/cli/actions/workflows/github-code-scanning/codeql">
    <img src="https://github.com/hellhub-collective/cli/actions/workflows/github-code-scanning/codeql/badge.svg?branch=main" alt="CodeQL" />
  </a>
  <a href="https://github.com/hellhub-collective/cli/actions/workflows/test.yml">
    <img src="https://github.com/hellhub-collective/cli/actions/workflows/test.yml/badge.svg" alt="Tests" />
  </a>
  <a href="https://bundlejs.com/?q=%40hellhub-collective%2Fcli%40latest&treeshake=%5B*%5D">
    <img src="https://deno.bundlejs.com/badge?q=@hellhub-collective/cli@latest&treeshake=[*]&config={%2Acompression%2A:%2Agzip%2A,%2Aesbuild%2A:{%2Aplatform%2A:%2Anode%2A}}" alt="Bundle Size (Minified & Zipped)" />
  </a>
</p>

## What is the HellHub CLI?

The HellHub CLI is a command line utility that allows you to interact with the HellHub API directly from your terminal. You can use the CLI to retrieve data from the HellHub API, filter the data, and display it in a raw or human-readable format.

## Installation

To install the HellHub CLI, you can use npm, yarn or bun. For simplicity, we will use bun in this example:

```bash
bun -g add @hellhub-collective/cli
```

## Usage

To use the HellHub CLI, you can simply type the `hellhub` keyword into your terminal. Let's look at a example command:

```bash
hellhub statistics --limit 10 --filters="planet:name:@contains:a"
```

This command will output the statistics for the first 10 planets that do contain the letter "a" in their name:

<p align="center">
    <img src="https://raw.githubusercontent.com/hellhub-collective/cli/main/assets/example-response.png" width="100%" alt="Example Response" />
</p>

Each command outputs a human readable table with the data you requested. You can also use the `--raw` flag to output the data in a raw JSON format.

## Bring your own API

If you are using a self-hosted version of the HellHub API, you can specify the `HELLHUB_API_URL` environment variable to point to your API endpoint. Note that the value will need to include the `/api` path.

```bash
export HELLHUB_API_URL="https://my-hellhub-api.com/api"
```

## License

This project is licensed under the MIT License. See the [LICENSE](https://github.com/hellhub-collective/cli/blob/main/LICENSE) file for details.
npm package: @hellixit/common
Description: Hellixitboard common functions, constants, etc.
Latest version: 0.1.1

# @hellixit/common

## Install

```bash
npm install @hellixit/common
```

If you prefer Yarn over npm, use this command to install the Hellixitboard common package:

```bash
yarn add @hellixit/common
```

With PNPM, similarly install the package with this command:

```bash
pnpm add @hellixit/common
```
npm package: @hellixit/element
Description: Hellixitboard elements-related logic
Latest version: 0.1.1

# @hellixit/element

## Install

```bash
npm install @hellixit/element
```

If you prefer Yarn over npm, use this command to install the Hellixitboard element package:

```bash
yarn add @hellixit/element
```

With PNPM, similarly install the package with this command:

```bash
pnpm add @hellixit/element
```
npm package: @hellixit/hellixitboard
Description: Hellixitboard as a React component
Latest version: 0.1.3

# Hellixitboard

**Hellixitboard** is exported as a React component that you can embed directly in your app.

## Installation

Install the package together with its React peer dependencies.

```bash
npm install react react-dom @hellixit/hellixitboard
# or
yarn add react react-dom @hellixit/hellixitboard
```

## Quick start

The minimum working setup has two easy-to-miss requirements:

1. Import the package CSS:

```ts
import "@hellixit/hellixitboard/index.css";
```

2. Render Hellixitboard inside a container with a non-zero height.

```tsx
import { Hellixitboard } from "@hellixit/hellixitboard";
import "@hellixit/hellixitboard/index.css";

export default function App() {
  return (
    <div style={{ height: "100vh" }}>
      <Hellixitboard />
    </div>
  );
}
```

Hellixitboard fills `100%` of the width and height of its parent. If the parent has no height, the canvas will not be visible.

## Next.js / SSR frameworks

Hellixitboard should be rendered on the client. In SSR frameworks such as Next.js, use a client component and load it dynamically with SSR disabled.

```tsx
// app/components/HellixitboardClient.tsx
"use client";

import { Hellixitboard } from "@hellixit/hellixitboard";
import "@hellixit/hellixitboard/index.css";

export default function HellixitboardClient() {
  return (
    <div style={{ height: "100vh" }}>
      <Hellixitboard />
    </div>
  );
}
```

```tsx
// app/page.tsx
import dynamic from "next/dynamic";

const HellixitboardClient = dynamic(
  () => import("./components/HellixitboardClient"),
  { ssr: false },
);

export default function Page() {
  return <HellixitboardClient />;
}
```

## LLM / agent tips

If an LLM or coding agent is setting up Hellixitboard, these shortcuts usually save more time than re-prompting:

- Start with a plain `<Hellixitboard />` in a `100vh` container. Add refs, `initialData`, persistence, or custom UI only after the base embed works.
- If the canvas is blank, check the CSS import and parent height first. Those are the two most common integration failures.
- In Next.js or other SSR frameworks, assume client-only rendering first. Use `"use client"` and `dynamic(..., { ssr: false })` before debugging hydration or `window is not defined` errors.
- If imports or entrypoints are unclear, inspect `node_modules/@hellixit/hellixitboard/package.json`. The installed package exports are the source of truth.
- Do not set `window.HELLIXITBOARD_ASSET_PATH` unless you are intentionally self-hosting fonts/assets.

## Self-hosting fonts

By default, Hellixitboard downloads the fonts it needs from the CDN.

For self-hosting, copy the contents of `node_modules/@hellixit/hellixitboard/dist/prod/fonts` into the path where your app serves static assets, for example `public/`. Then set `window.HELLIXITBOARD_ASSET_PATH` to that same path:

```html
<script>
  window.HELLIXITBOARD_ASSET_PATH = "/";
</script>
```

## Demo

Try the live demo at [board.hellixit.cloud](https://board.hellixit.cloud).
npm package: @hellixit/laser-pointer
Description: Generate outline for laser pointer tool
Latest version: 0.1.1

# Laser Pointer

## Usage

    import { LaserPointer } from '@hellixit/laser-pointer'

    const stroke = new LaserPointer(options)

    stroke.addPoint([100, 200, 1])
    stroke.close()

    const outline = stroke.getStrokeOutline()

## Options

| Property        | Type                                      | Default    | Description                                                   |
| --------------- | ----------------------------------------- | ---------- | ------------------------------------------------------------- |
| `size`          | `number`                                  | `2`        | Radius of the stroke.                                         |
| `streamline`    | `number`                                  | `0.42`     | Interpolate input points to reduce jitter.                    |
| `simplify`      | `number`                                  | `0.1`      | Reduce stroke size by sacrificing precision.                  |
| `simplifyPhase` | `"input" \| "output" \| "tail" `          | `"output"` | Decides when the simplification algorithm should be applied.  |
| `sizeMapping`   | `(details: SizeMappingDetails) => number` | `() => 1`  | Maps each point to a value between `0.0` and `1.0`.           |
| `keepHead`      | `boolean`                                 | `false`    | Whether size mapping should influence the head of the stroke. |
npm package: @hellixit/math
Description: Hellixitboard math functions
Latest version: 0.1.1

# @hellixit/math

## Install

```bash
npm install @hellixit/math
```

If you prefer Yarn over npm, use this command to install the Hellixitboard math package:

```bash
yarn add @hellixit/math
```

With PNPM, similarly install the package with this command:

```bash
pnpm add @hellixit/math
```