open-index/open-npm huggingface dataset:
npm package: @robertakarobin/eslint-config
Description: This package is named `@robertakarobin/eslint-config` instead of just `@robertakarobin/eslint` [because ESLint says so](https://eslint.org/docs/latest/extend/shareable-configs#creating-a-shareable-config).
Latest version: 0.0.29

# Robin's ESLint

This package is named `@robertakarobin/eslint-config` instead of just `@robertakarobin/eslint` [because ESLint says so](https://eslint.org/docs/latest/extend/shareable-configs#creating-a-shareable-config).

## Why not Prettier?

We're not using Prettier because it's too much of a PITA, especially when supporting custom templates like `.astro`.

## Styleguide

The philosophy is that a "rule" is only a rule if it can be caught by an automated linter.

Rules that we haven't found lint rules for yet:

-	When you have to use quotes when declaring an object property name, use single quotes.

-	Use `data-` attributes to select elements, not CSS classes.

-	Use the global namespace when calling global variables. This makes it clearer where the variable is coming from.

	Yes:
	```js
	window.location
	```

	No:
	```js
	location
	```
npm package: @robertakarobin/path-data-polyfill
Description: path-data-polyfill with types
Author: robertakarobin
Latest version: 0.0.3
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# @robertakarobin/path-data-polyfill

A wrapper around [path-data-polyfill](https://www.npmjs.com/package/path-data-polyfill) that just declares its types so it's Typescript-compatible.

## Usage

```ts
import '@robertakarobin/path-data-polyfill';

const path = document.querySelector(`path`)!;
path.getPathData({ normalize: true }); // By importing this package, `getPathData` and `setPathData` have been added to the SVGPathElement prototype
```
npm package: @robertaron/hono-typed-sse
Description: ```shell npm install @robertaron/hono-typed-sse ```
Latest version: 0.2.0

# Hono Typed SSE

## Getting Started

```shell
npm install @robertaron/hono-typed-sse
```

### Server

```ts
import { Hono } from "hono";
import { streamSSETyped } from "@robertaron/hono-typed-sse/typedSSE";

const app = new Hono().get("/sse", (c) =>
  streamSSETyped<{ myType: number }>(c, async (s) => {
    for (let i = 0; i < 5; i++) {
      s.writeSSE({
        data: { myType: i },
      });
      await s.stream.sleep(1000);
    }
    // done sends a custom event. This can be used to close the stream, and let the EventSource know it shouldn't try to re-connect.
    await s.done();
  })
);

export type AppType = typeof app;
```

### Client

```ts
import { hc } from "hono/client";
import { connectToSSE } from "@robertaron/hono-typed-sse/connectToSse";
import type { AppType } from "./server";

const client = hc<AppType>("http://localhost:3000");

connectToSSE(client.sse, {
  onOpen: () => console.log("opened!"),
  onMessage: (_, data) => console.log(`Got data: ${data.myType}`),
  onDone: () => console.log("stream complete"),
  onError: () => console.log("connection error"),
});
```

The client uses `EventSource` which is only available in browser environments. Testing the client from Node/Bun is not supported.

## Motivation

This package aims to unlock the power of SSE and Hono with minimal overhead.

Hono has a great RPC system, but it doesn't work for server-sent events. It's unlikely there will be first-party support in the near future due to [package size concerns](https://github.com/honojs/hono/pull/3957#issuecomment-2693310852).
npm package: @robertaron/spacial-partitioning
Description: Efficient spatial partitioning and neighbor graph generation for 3D simulations, powered by Rust and WebAssembly. This package provides a fast way to compute nearby relationships between points in 3D space, useful for flocking, boids, crowd simulation, an
Latest version: 1.0.0

# @robertaron/spacial-partitioning

Efficient spatial partitioning and neighbor graph generation for 3D simulations, powered by Rust and WebAssembly. This package provides a fast way to compute nearby relationships between points in 3D space, useful for flocking, boids, crowd simulation, and other spatial algorithms.

---

## Features

- **High performance**: Core logic implemented in Rust and compiled to WebAssembly.
- **Works in Node.js and browsers**: Supports both ESM and CommonJS.
- **Typed API**: TypeScript types included.

---
## Installation

```sh
npm install @robertaron/spacial-partitioning
```

---

## Usage

```js
import { init, createNearByGraph } from "@robertaron/spacial-partitioning";

// Initialize the WASM module (required before using createNearByGraph)
await init();
const positions = new Float32Array([
  0, 0, 0,
  1, 0, 0,
  0, 10, 0,
  0, 10, 1,
  // ... more points
]);
const neighborGraph = createNearByGraph(positions, 2);
// neighborGraph is an array of arrays: neighborGraph[i] = [indices of neighbors of i]
```

---

## API

### `async init(): Promise<void>`

Initializes the WASM module. **Must be called before using `createNearByGraph`.**

### `createNearByGraph(positions: Float32Array, distance: number): number[][]`

- `positions`: Flat array of 3D coordinates (x, y, z, x, y, z, ...).
- `distance`: Maximum distance to consider two points as neighbors.
- Returns: An array of arrays, where each sub-array contains the indices of neighboring points.

---

## Use Cases

- Flocking/boids simulations
- Crowd and agent-based modeling
- Efficient spatial queries in 3D environments

---

## License

MIT

---

## Credits

- Rust WASM core by [@robertaron](https://github.com/robertaron)
- Inspired by spatial partitioning techniques in game development and simulation

---

For more details,