open-index/open-npm huggingface dataset:
npm package: @rbxts/muon
Description: A memory store library
Author: artzified
Latest version: 1.0.7

<h1 align="center">
	<a href="https://www.npmjs.com/package/@rbxts/muon">
		<img src="public/logo.svg" alt="Muon" width="200" />
	</a>
	<br />
	<b>Muon</b>
</h1>

<div align="center">

[![npm version](https://img.shields.io/npm/v/@rbxts/muon.svg?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@rbxts/muon)
[![GitHub license](https://img.shields.io/github/license/artzified/muon?style=for-the-badge)](LICENSE.md)

</div>

## ⚛️ Muon
Muon is a simple memory store library implementation designed with ease of use in mind. It features exponential backoff for every operation in Hash Maps, Queues, and Sorted Maps

## 📦 Installation
To install Muon, use npm:
```bash
npm install @rbxts/muon
```

## 🧪 Usage
```ts
import { Muon } from '@rbxts/muon';

const hashMap = Muon.hashMap('myHashMap', {
	lifetime: 60, // data only exists for 60 seconds
	exponentialBackoff = {
		base: 1.5; // if something fails, it will retry for 1.5 (1.5^1), then 2.25 (1.5^2), ..., and so on till maxTries has been reached
		maxTries: 5; // a maximum of 5 tries before it gives an error
	}
});

(async() => {
	await hashMap.set('count', 1);
	await hashMap.update('count', (oldCount) => ++oldCount); // increments the count. has a side effect of resetting the lifetime of the count

	print(await hashMap.get<number>('count'));
})();
```

Any operation method has an `overrideOptions` parameter, which allows you to specify what options should be used for the operation
```ts
// ...
await hashMap.set('count', 1, { lifetime: 120 }); // use a lifetime of 120 seconds
```

## 🤝 Contributing
Contributions are welcome! Please open an issue or submit a pull request on [GitHub](https://github.com/artzified/Muon).

## 📄 License
Muon is licensed under the MIT License. See the [LICENSE](https://github.com/artzified/Muon/blob/master/LICENSE) file for more details.
npm package: @rbxts/must
Description: Just a simple function that errors out if the argument is nil / undefined.
Author: Bytebit
Latest version: 1.0.5

# Must
<p align="center">
  <a href="https://github.com/Bytebit-Org/roblox-Must/actions">
      <img src="https://github.com/Bytebit-Org/roblox-Must/workflows/CI/badge.svg" alt="CI status" />
  </a>
  <a href="http://makeapullrequest.com">
    <img src="https://img.shields.io/badge/PRs-welcome-blue.svg" alt="PRs Welcome" />
  </a>
  <a href="https://opensource.org/licenses/MIT">
    <img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT" />
  </a>
  <a href="https://discord.gg/QEz3v8y">
    <img src="https://img.shields.io/badge/discord-join-7289DA.svg?logo=discord&longCache=true&style=flat" alt="Discord server" />
  </a>
</p>

Must is just a simple function that errors out if the argument is nil / undefined.

## Installation
### roblox-ts
Simply install to your [roblox-ts](https://roblox-ts.com/) project as follows:
```
npm i @rbxts/must
```

### Wally
[Wally](https://github.com/UpliftGames/wally/) users can install this package by adding the following line to their `Wally.toml` under `[dependencies]`:
```
Must = "bytebit/must@1.0.5"
```

Then just run `wally install`.

### From model file
Model files are uploaded to every release as `.rbxmx` files. You can download the file from the [Releases page](https://github.com/Bytebit-Org/roblox-Must/releases) and load it into your project however you see fit.

### From model asset
New versions of the asset are uploaded with every release. The asset can be added to your Roblox Inventory and then inserted into your Place via Toolbox by getting it [here.](https://www.roblox.com/library/9164403107/Warn-Function)

## Documentation
Documentation can be found [here](https://github.com/Bytebit-Org/roblox-Must/tree/master/docs), is included in the TypeScript files directly, and was generated using [TypeDoc](https://typedoc.org/).

## Example
Here's a simple example of a function that just wants to throw if the value it looks up is `nil` / `undefined`.

<details>
  <summary>roblox-ts example</summary>

  ```ts
  import { must } from "@rbxts/must";

  export class Foo {
    public bar() {
      const fetchedValue = must(fetchSomeValue());
      
      // more logic
    }
  }
  ```
</details>

<details>
  <summary>Luau example</summary>

  ```lua
  local must = require(path.to.modules["must"]).must

  local Foo = {}
  Foo.__index = Foo

  function new()
    local self = {}
    setmetatable(self, Foo)

    return self
  end

  function Foo:bar()
    local fetchedValue = must(fetchSomeValue())

    -- more logic
  end

  return {
    new = new
  }
  ```
</details>
npm package: @rbxts/nanoai
Description: Minimal library for creating neural networks
Author: littensy
Latest version: 0.1.0

<p align="center">
  <p align="center">
	<img width="150" height="150" src="https://raw.githubusercontent.com/littensy/charm/master/images/logo.png" alt="Logo">
  </p>
  <h1 align="center"><b>Nanoai</b></h1>
  <p align="center">
    Minimal library for creating neural networks.
    <br />
    <a href="https://npmjs.com/package/@rbxts/nanoai"><strong>npm package →</strong></a>
  </p>
</p>

<div align="center">

![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/littensy/nanoai/ci.yml?style=for-the-badge&branch=master&logo=github)
[![NPM Version](https://img.shields.io/npm/v/@rbxts/nanoai.svg?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@rbxts/nanoai)
[![GitHub License](https://img.shields.io/github/license/littensy/nanoai?style=for-the-badge)](LICENSE.md)

</div>

**Nanoai** is a fast, lightweight library for handling multi-layer perceptron (MLP) neural networks.

The addition of recurrent and convolutional layers is not planned at this time.

## 📦 Setup

### TypeScript

```sh
npm install @rbxts/nanoai
yarn add @rbxts/nanoai
pnpm add @rbxts/nanoai
```

### Wally

Add `littensy/nanoai` to your `wally.toml` file.

```toml
[dependencies]
Nanoai = "littensy/nanoai@VERSION"
```

## 📚 API Reference

#### `create(shape, activation)`

#### `predict(network, input)`

#### `backpropagate(network, input, expected, learningRate)`

#### `evolution(options)`

#### `init[type](network, ...)`

#### `initialize(network, initializer)`

#### `clone(network)`

## 🚀 Examples

### XOR problem

```lua
local model = Nanoai.create({ 2, 3, 1 }, Nanoai.Activation.TanH)

Nanoai.init.normal(model)

for _ = 1, 500 do
	Nanoai.backpropagate(model, { 0, 1 }, { 1 }, 0.3)
	Nanoai.backpropagate(model, { 1, 0 }, { 1 }, 0.3)
	Nanoai.backpropagate(model, { 0, 0 }, { 0 }, 0.3)
	Nanoai.backpropagate(model, { 1, 1 }, { 0 }, 0.3)
end

Nanoai.predict(model, { 0, 1 }) -- ~1
```

---

<p align="center">
Nanoai is released under the <a href="LICENSE.md">MIT License</a>.
</p>

<div align="center">

[![MIT License](https://img.shields.io/github/license/littensy/nanoai?style=for-the-badge)](LICENSE.md)

</div>
npm package: @rbxts/neomake
Description: My personal alternative to [@rbxts/make](https://www.npmjs.com/package/@rbxts/make).
Author: Neohertz
Latest version: 1.0.2

# Neomake

My personal alternative to [@rbxts/make](https://www.npmjs.com/package/@rbxts/make). 

```ts
import { make, modify } from "@rbxts/neomake";

// basic usage
const root = make("Part", {
	Position: Vector3.zero,
	children: make("Attachment"),
});

// refs
const weldedPart = make("Part", (ref) => ({
	Position: Vector3.zero,
	Parent: Workspace,
	children: make("WeldConstraint", {
		Part0: ref,
		Part1: root,
	}),
}));

// carbon-copy
const light = make(new Instance("PointLight"), {
	Color: new Color3(1, 1, 1),
	Parent: weldedPart,
});

// modify an existing instance
modify(light, {
	Enabled: false,
});
```

## Caveats
- This module does not have event support. If that is something you'd need I'd suggest using `@rbxts/make` or `@rbxts/altmake`.

## Contributing
All PRs are welcome!
npm package: @rbxts/neturl
Description: URL and Query string parser, builder, normalizer
Latest version: 1.1.1-ts.1

<h1 align="center">🌐 NetUrl 🌐</h1>

roblox-ts typings for the NetUrl library, a URL and Query string parser, builder, and normalizer for Lua. Some useful links:

-   [NetUrl's repository](https://github.com/golgote/neturl/tree/master)
-   [This package's repository](https://github.com/tacheometry/rbxts-neturl)

## Installation

[![NPM](https://nodei.co/npm/@rbxts/neturl.png)](https://npmjs.org/package/@rbxts/neturl)

Run `npm i @rbxts/neturl` in your project directory.

## Usage

To import:

```ts
import NetUrl from "@rbxts/neturl";
```

Below are some usage examples adapted from the NetUrl repository:

### URL parser

```ts
const u = NetUrl.parse("http://www.example.com/test/?start=10");

print(u.scheme); // http
print(u.host); // www.example.com
print(u.path); // /test/
```

### Querystring parser

```ts
const query = NetUrl.parseQuery("a=123&b=456");

print(query); // a=123&b=456
print(query.get("a")); // "123"
print(query.get("b")); // "456"
```

```ts
// Note: replace the type if using brackets in the query string:
const query = NetUrl.parseQuery<string | string[]>("first=abc&a[]=123&a[]=false&b[]=str&c[]=3.5&a[]=last");

print(query); // a[1]=123&a[2]=false&a[3]=last&b[1]=str&c[1]=3.5&first=abc
print(query.get("a")); // [ "3.5" ]
```
npm package: @rbxts/networked-signals
Description: A TypeScript wrapper for RemoteEvents that provides a type-safe interface for networked events in a Roblox game.
Author: Bytebit
Latest version: 0.0.10

# Networked Signals
A TypeScript wrapper for `RemoteEvent`s that provides a type-safe interface for networked signals in a Roblox game.

## Installation
### roblox-ts
Simply install to your [roblox-ts](https://roblox-ts.com/) project as follows:
```
npm i @rbxts/networked-signals
```

### Wally
[Wally](https://github.com/UpliftGames/wally/) users can install this package by adding the following line to their `Wally.toml` under `[dependencies]`:
```
NetworkedSignals = "bytebit/networked-signals@0.0.9"
```

Then just run `wally install`.

### From model file
Model files are uploaded to every release as `.rbxmx` files. You can download the file from the [Releases page](https://github.com/Bytebit-Org/roblox-NetworkedSignals/releases) and load it into your project however you see fit.

### From model asset
New versions of the asset are uploaded with every release. The asset can be added to your Roblox Inventory and then inserted into your Place via Toolbox by getting it [here.](https://www.roblox.com/library/7874130414/Networked-Signals-Package)

## Helpful Links
- [Documentation](DOCUMENTATION.md)
- [Tutorial](TUTORIAL.md)

# Why is this still version 0.x?
Because this package does not yet have thorough unit testing, it cannot really be trusted to be a 1.x release. Once thorough unit testing is added, then this package can have a high enough degree of trust to release version 1.0.0!
npm package: @rbxts/object-event
Description: Allows for custom events to be created for custom OOP implementations. Attempts to reproduce Roblox's syntax as closely as possible while adding more features.
Author: davness
Latest version: 1.1.0

<h1><p align="center">@rbxts/object-event</p></h1>

<p align="center"><a href="https://badge.fury.io/js/%40rbxts%2Fobject-event"><img src="https://badge.fury.io/js/%40rbxts%2Fobject-event.svg" alt="npm version" height="18"></a></p>

This NPM Package for Roblox-TS allows developers to implement custom Events for custom classes, without resorting to `BindableEvents`.

This should be particularly useful for projects that heavily rely on the OOP paradigm for libraries and other game components.

The module can be used both in pure Lua(u) scripts (via Rojo or any other way) or with Roblox-TS (includes compile-time type-checking).

## Example

```ts
/////// Module.ts ///////

import ObjectEvent from "@rbxts/object-event"

const event = new ObjectEvent<[number, String, Vector3]>()

event.Connect((id, msg, position) => {
    // We can safely assume that:
    // id is a number
    // msg is a string
    // position is a Vector3
})

export event


/////// Waiter.server.ts ///////

import {event} from "./Module"

event.Fire(10, "oof", new Vector3(1, 2, 3))  // all good
event.Fire(10, "oof")                        // will not compile!

export {}
```

To allow all kinds of arguments, of any number:

```ts
let event = new ObjectEvent<[...unknown]>()
```

## `ObjectEvent` API

- `Connect(f)` - `f` is a function that takes the arguments typed accordingly and returns `void`. Returns an `ObjectEventConnection`
- `Wait()` - yields the thread until the event is fired. Returns the values typed accordingly.
- `Fire(...)` - fires the event. Arguments must be the same number and type of the event.
- `Event` - an `RBXScriptSignal`-like interface supporting the `Connect()` and `Wait()`, just in case you prefer to use it as a BindableEvent.
- `SubscribedConnections` - an array of `ObjectEventConnection`s with all the connections currently listening to the event.

## `ObjectEventConnection` API

- `Disconnect()` - disconnects from the event
- `Reconnect()` - reverts a disconnection
- `IsConnected()` - returns `true` if the connection is listening to the event (this is, not Disconnect()'ed), `false` otherwise.
- `Event` - the `ObjectEvent` associated with this connection
- `Listener` - the function associated with this connection

## Current Features:

- **Standard Roblox Event Feature Set:**
- - Connecting to an event;
- - Disconnecting a connection;
- - Yielding a thread until the event is fired;
- - Passing arguments through the functions;
- **Custom features:**
- - Reconnecting a disconnected connection without having to make a new one (ability to reuse connections).
- - Reading all active connections for a given event.

## Goals:

- Abstraction from internals;
- Roblox-like syntax while keeping a minimum of decency for TypeScript syntax;
- Code readability for OOP implementations.
- Complement Roblox's implementation with extra (useful) features.
npm package: @rbxts/object-pool
Description: <p align="center">   <a href="http://makeapullrequest.com">     <img src="https://img.shields.io/badge/PRs-welcome-blue.svg" alt="PRs Welcome" />   </a>   <a href="https://opensource.org/licenses/MIT">     <img src="https://img.shields.io/badge/Licen
Latest version: 1.1.0

# Object Pool

<p align="center">
  <a href="http://makeapullrequest.com">
    <img src="https://img.shields.io/badge/PRs-welcome-blue.svg" alt="PRs Welcome" />
  </a>
  <a href="https://opensource.org/licenses/MIT">
    <img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT" />
  </a>
</p>

Object Pool is a module that uses a set of initialized object kept ready to use, rather than allocating and destroying them on demand. Provides a generic and an instance pool.

## Installation

### roblox-ts

Simply install to your [roblox-ts](https://roblox-ts.com/) project as follows:

```
npm i @rbxts/object-pool
```
npm package: @rbxts/observers
Description: Collection of observer utility functions
Author: sleitnick
Latest version: 0.5.0

[![CI](https://github.com/Sleitnick/RbxObservers/actions/workflows/ci.yaml/badge.svg)](https://github.com/Sleitnick/RbxObservers/actions/workflows/ci.yaml)
[![Docs](https://github.com/Sleitnick/RbxObservers/actions/workflows/docs.yaml/badge.svg)](https://github.com/Sleitnick/RbxObservers/actions/workflows/docs.yaml)

# RbxObservers

A collection of observer utility functions.

## Installation

### Wally

Add `sleitnick/observers` to dependencies list:
```toml
[package]
name = "your_name/your_project"
version = "0.1.0"
registry = "https://github.com/UpliftGames/wally-index"
realm = "shared"

[dependencies]
Observers = "sleitnick/observers@^0.4.0"
```

### roblox-ts

Add `@rbxts/observers` to your `package.json` dependencies list, or run the npm install command:

```json
{
	"dependencies": {
		"@rbxts/observers": "^0.4.0"
	}
}
```

```sh
npm i --save @rbxts/observers
```
npm package: @rbxts/ohmyprvd
Description: Oh My Prvd is a delightful framework for Roblox games.
Author: znotfireman
Latest version: 0.2.0-dev.5

# Oh My Prvd

<img src="../../assets/logo.svg" width="300px" align="right" alt="Logo"/>

![CI](https://github.com/team-fireworks/ohmyprvd/actions/workflows/ci.yml/badge.svg)

Oh My Prvd is a delightful framework for Roblox games.

Boring. Do it again.

***Oh My Prvd will not make you a front page developer, but you may feel like
one.***

Oh My Prvd accelerates the process with providers, connecting the top-level
design of your game. Choose to mix in networking and components as you need.
Enjoy a development experience that fades into the background, freeing you to
build faster and shout: **Oh, My Prvd!**

## Highlights

- Type-safe APIs for both Luau and TypeScript
- Featherlight, choose to mix in packages as you need
- Uses dependency injection for cleaner code organization
- Made to be extendable
- Non-intrusive lifecycle events for flexibility
- Designed for clarity with syntax inspired by Rust

Sparked your interest? [Get going in minutes with our on-rails
tutorial](https://team-fireworks.github.io/ohmyprvd/latest/get-started/).

> **Warning:** Oh My Prvd is in early development. Portions of the API may
> break, be changed, or outright deleted. There will be dragons.

## Code Sample

```Lua
local prvd = require("@pkg/ohmyprvd")
local CharacterProvider = require("./character-provider")

local CombatProvider = {
  characterProvider = prvd.use(CharacterProvider)
}

function CombatController.performMove(
  self: typeof(CombatController),
  move: CombatMove
)
  local character = self.characterProvider:awaitCharacter()
  -- do something with the character
end

return prvd.Provider("CombatProvider", CombatProvider)
```

```TypeScript
import { Provider, use } from "@rbxts/ohmyprvd"
import { CharacterProvider } from "./character-provider"

export const CombatProvider = Provider("CombatProvider", {
  characterProvider: use(CharacterProvider)

  performMove(move: CombatMove) {
    const character = this.characterProvider.awaitCharacter()
    // do something with the character
  }
})
```

## FAQ

### How do you say Oh My Prvd?

However you want:

- *Oh, my prvd!* for excitement
- *Oh, my providers!* for completeness
- *O-m-p!* for brevity
- *Ommp!* for power

### Who's that handsome gentlemen on the home page?

His name is Womp Womp:

<img src="../../assets/womp.png" alt="Womp Womp" height="256px" />
npm package: @rbxts/ping
Description: Dead simple roblox-ts bindable event wrapper.
Latest version: 2.4.8

# Ping

Yet another super simple bindable event wrapper which uses ✨`camelCase`✨ and allows connection directly or via an encapsulated `connector`, which is useful for replicating the behaviour of regular Roblox signals.

## Example

A simple example, there isn't much to this library.

```ts
class PingExample {
	// Both of these work!
	private ping = new Ping<(player: Player) => void>();
	private ping = new Ping<[player: Player]>();

	// Open up the API to connect to the ping externally
	public readonly onPing = this.ping.connector;

	private foo(player: Player) {
		// Alerts all connections
		this.ping.fire(player);
	}
}

const example = new PingExample();

// To any external users, only .connect, .connectParallel and .wait are available.
example.onPing.connect((player) => {
	print(player);
});
```
npm package: @rbxts/planck-rewire
Description: A hot-reload plugin for @rbxts/planck
Author: YetAnotherClown
Latest version: 0.1.2-rc.0

# @rbxts/planck-rewire

A plugin for the Planck ECS framework in Roblox TypeScript. This plugin enables hot-reloading of systems by dynamically reloading system folders, making development faster and more efficient.

## Installation

Install the package via `npm`:

```sh
npm install @rbxts/planck-rewire
```

Or using `pnpm`:

```sh
pnpm add @rbxts/planck-rewire
```

## Usage

### Setting Up the Scheduler

In your `scheduler.ts` file, configure and initialize the scheduler with the necessary plugins:

```ts
import { Scheduler } from '@rbxts/planck';
import PlanckRewirePlugin from '@rbxts/planck-rewire';

export const scheduler = new Scheduler();

export function hotReload(systemRoots: Array<Folder>) {
  const rewirePlugin = new PlanckRewirePlugin(systemRoots);
  scheduler.addPlugin(rewirePlugin);
}
```

### Hot Reloading Systems

To enable hot reloading of systems, call the `hotReload` function in your client code:

```ts
import { hotReload } from "shared/scheduler";

hotReload([ReplicatedStorage.WaitForChild("TS").WaitForChild("systems") as Folder]);
```

In this example, the systems are located in the `ReplicatedStorage/TS/systems` folder. **Ensure that the systems are not required beforehand**. The plugin will handle loading the systems dynamically at runtime. Requiring them manually before passing them to the plugin may cause unexpected behavior.

## How It Works

- The `PlanckRewirePlugin` hooks into the Planck scheduler, listening for changes in the specified system folders.
- When a change is detected, the affected systems are reloaded dynamically, improving iteration speed during development.

## Why Use Planck Rewire?
- **Faster Iteration** – No need to restart the server after every code change.
- **Modular** – Easily integrates with Planck ECS.
- **Simple Setup** – Minimal configuration required.

## Requirements
- Roblox TypeScript (`rbxts`)
- Planck ECS framework (`@rbxts/planck`)

## License

MIT License. See `LICENSE` for details.

---

If you encounter any issues or have feature requests, feel free to open an issue on the GitHub repository.
npm package: @rbxts/player-module-types
Description: This package provides TypeScript type definitions for the Roblox built-in PlayerModule. It is designed to be used with roblox-ts.
Author: CanineData
Latest version: 0.1.0

# PlayerModule-Types

This package provides TypeScript type definitions for the Roblox built-in PlayerModule. It is designed to be used with roblox-ts.
npm package: @rbxts/players-tracker
Description: Tracker of player's character.
Author: Catargo
Latest version: 1.1.6

package [npm](https://www.npmjs.com/package/@rbxts/players-tracker)

```bash
npm i @rbxts/players-tracker
```

# Players Tracker

Tracker of player's character.

Handle getting humanoid / root_part / character / animator from one place

## Getting the Tracker

### Player Tracker

```ts
const player_tracker: PlayerTracker | undefined =
	PlayersTracker.GetTracker(player);
const player_tracker: Promise<PlayerTracker> =
	PlayersTracker.AwaitTracker(player);
```

### Local Player Tracker

```ts
/**@client*/
const local_player_tracker: PlayerTracker = PlayersTracker.GetLocalTracker();
```

## Getting items

### can_be_dead

```ts
/**
 * if can_be_dead is false and the character is dead, will await respawn and will return the new Humanoid
 * defaults to true
 *
 * [if the character is dead his parts still exist for some time til the character removal]
 */
const can_be_dead: boolean = true;
```

### Humanoid

```ts
const humanoid: Humanoid | undefined = player_tracker.GetHumanoid();
const humanoid: Promise<Humanoid> = player_tracker.AwaitHumanoid(can_be_dead);
```

### RootPart

```ts
const root_part: BasePart | undefined = player_tracker.GetRootPart();
const root_part: Promise<BasePart> = player_tracker.AwaitRootPart(can_be_dead);
```

### Animator

```ts
const animator: Animator | undefined = player_tracker.GetAnimator();
const animator: Promise<Animator> = player_tracker.AwaitAnimator(can_be_dead);
```

### Character

```ts
const character: Model | undefined = player_tracker.GetCharacter();
const character: Promise<Model> = player_tracker.AwaitCharacter(can_be_dead);
```

## Loading Animation

```ts
const animation_track: AnimationTrack | undefined =
	player_tracker.TryLoadAnimation(animation, {
		Priority: Enum.AnimationPriority.Action,
		Looped: true,
	});
const animation_track: Promise<AnimationTrack> =
	player_tracker.AwaitAndLoadAnimation(animation, {
		Looped: true,
	});
```

## Events

### OnDied

```ts
player_tracker.OnDied.Connect(() => {});
```

### OnSpawned

```ts
player_tracker.OnSpawned.Connect(() => {});
```

## Functions

### IsDead

```ts
const is_dead = player_tracker.IsDead();
```
npm package: @rbxts/plugin-components
Description: React plugin components for Roblox
Author: raine
Latest version: 0.1.0

> [!CAUTION]  
> plugin-components is currently in development. Do not use plugin-components
> for real work.

<p align="center">
  <h1 align="center"><b>@rbxts/plugin-components</b></h1>
  <p align="center">
    React Roblox plugin components
    <br />
    <a href="https://npmjs.com/package/@rbxts/plugin-components"><strong>npm package →</strong></a>
  </p>
</p>

## ✨ Features

plugin-components is made to make creating Roblox Studio plugins with React in
Roblox-TS easier. Instead of spending time making components, focus on making
the actual plugin.

- Useful React Hooks for plugins
- Pre-made, Roblox Studio-like components
- Components for Studio plugin behavior (toolbars, buttons, windows)
- Other plugin utilities

## 📦 Get Started

Read over our (in progress) documentation for more information.

### Installation

> [!IMPORTANT]  
> [rbxts-react](https://github.com/littensy/rbxts-react/tree/main) should be
> installed already.

Install plugin-components from
[npm](https://npmjs.com/package/@rbxts/plugin-components):

```sh
npm install @rbxts/plugin-components
pnpm add @rbxts/plugin-components
yarn add @rbxts/plugin-components
```
npm package: @rbxts/poisson-disk-sampling
Description: Poisson disk sampling implemention for roblox-ts
Author: ioltuszyk
Latest version: 0.2.5

# Poisson Disk Sampling for roblox-ts

This module provides an implementation of Bridson's algorithm for Poisson Disk Sampling, a technique for randomly generating points within a given region while ensuring that they are distributed with a minimum and maximum distance from each other.

## Installation

You can install this module using npm:

```
npm install @rbxts/poisson-disk-sampling
```

For navigable documentation,

## Usage

```ts
import { PoissonDiskSampler } from "@rbxts/poisson-disk-sampling";

function example() {
  const sampler = new PoissonDiskSampler(
    { xMin: 0, xMax: 100, yMin: 0, yMax: 100 }, // region
    5, // minDistance
    5, // density (not yet implemented)
    30 // maxAttempts
  );

  sampler.getPoints().forEach((point) => {
    print(point.x, point.y);
  });
}
```

## Todo

- [x] An implementation of Bridson's algorithm
- [x] Enable configuration of the algorithm, such as max attempts to generate a new random point in an annulus around each active point.
- [ ] Various algorithm implementations, such as those that support variable density and parallelization.
- [ ] N-dimensional generation
- [x] Documentation
npm package: @rbxts/pretty-format
Description: PrettyFormat bindings for Roblox
Author: littensy
Latest version: 3.16.0-ts.1

<p align="center">
  <p align="center">
    <img width="150" height="150" src="https://github.com/littensy/rbxts-jest/blob/main/assets/logo.png?raw=true" alt="Logo">
  </p>
  <h1 align="center"><b>@rbxts/jest</b></h1>
  <p align="center">
    TypeScript type definitions for Jest Lua.
    <br />
    <a href="https://npmjs.com/package/@rbxts/jest"><strong>npm package →</strong></a>
  </p>
</p>

TypeScript type definitions for [Jest Lua](https://github.com/jsdotlua/jest-lua) and [roblox-ts](https://roblox-ts.com), sourced from the official Jest types. Currently, `jest` and `jest-globals` are ported, while `jest-benchmark` is not yet available.

See the [Jest Lua documentation](https://jsdotlua.github.io/jest-lua/) for more information on how to use Jest Lua.

## Setup

Install Jest and Jest Globals with your package manager of choice:

```sh
npm install @rbxts/jest @rbxts/jest-globals
yarn add @rbxts/jest @rbxts/jest-globals
pnpm add @rbxts/jest @rbxts/jest-globals # 🛑 See below
```

Then, add the following to your Rojo project file, under the `node_modules` folder:

```json
"node_modules": {
  "$className": "Folder",
  "@rbxts": {
    "$path": "node_modules/@rbxts"
  },
  "@rbxts-js": {
    "$path": "node_modules/@rbxts-js"
  }
}
```

### Usage with pnpm

If you're using pnpm as your package manager, you'll need to create a `.npmrc` file in the root of your project with the following content:

```ini
node-linker=hoisted
```

## License

This project is licensed under the [MIT license](LICENSE).
npm package: @rbxts/pretty-react-hooks
Description: Useful hooks for @rbxts/react
Author: littensy
Latest version: 0.6.4

## 🌺 [pretty-react-hooks](https://npmjs.com/package/@rbxts/pretty-react-hooks)

![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/littensy/pretty-react-hooks/ci.yml?branch=master&style=for-the-badge&logo=github)
[![npm version](https://img.shields.io/npm/v/@rbxts/pretty-react-hooks.svg?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@rbxts/pretty-react-hooks)
[![npm downloads](https://img.shields.io/npm/dt/@rbxts/pretty-react-hooks.svg?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@rbxts/pretty-react-hooks)
[![GitHub license](https://img.shields.io/github/license/littensy/pretty-react-hooks?style=for-the-badge)](LICENSE.md)

An opinionated collection of useful hooks and utilites for [React](https://github.com/littensy/rbxts-react) in [roblox-ts](https://roblox-ts.com).

If you find a bug or have a feature request, please [open an issue](https://github.com/littensy/pretty-react-hooks/issues/new/).

&nbsp;

## ⭐ Featured

Check out some featured hooks:

-   [🦾 `useMotion`](src/use-motion/) - Creates a memoized Motion object set to the given initial value. Returns a binding that updates with the Motion, along with the Motion object.
-   [⏱️ `useAsync`](src/use-async/) - A hook that runs an async function and returns the result and status
-   [⚙️ `useTagged`](src/use-tagged/) - Tracks and returns a list of all instances with the given tag

This package also exports some useful utilities:

-   [📕 `hoarcekat`](src/utils/hoarcekat.tsx) - Create a Hoarcekat story
-   [📦 `binding utils`](src/utils/binding.ts) - Work with values that may or may not be bindings

Or, see the [full list of hooks](src/).

&nbsp;

## 📦 Installation

This package is available for Roblox TypeScript projects on [NPM](https://www.npmjs.com/package/@rbxts/pretty-react-hooks).

```sh
npm install @rbxts/pretty-react-hooks
yarn add @rbxts/pretty-react-hooks
pnpm add @rbxts/pretty-react-hooks
```

&nbsp;

## 🌻 Contributing

Contributions are welcome! Note that if you make a change to a hook, you should also check the tests and documentation.

To get started, clone the repository and run `pnpm install`. Then, you can run the following commands:

-   `pnpm dev` - Enable watch mode with support for TestEZ Companion
-   `pnpm build` - Compile the package's `out` directory

You will likely need the following extensions:

-   [Rojo VSCode extension](https://marketplace.visualstudio.com/items?itemName=evaera.vscode-rojo)
-   [TestEZ Companion](https://marketplace.visualstudio.com/items?itemName=tacheometrist.testez-companion)

&nbsp;

## 📝 License

pretty-react-hooks is licensed under the [MIT License](LICENSE.md).
npm package: @rbxts/pretty-roact-hooks
Description: ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/littensy/pretty-roact-hooks/ci.yml?branch=master&style=for-the-badge&logo=github) [![npm version](https://img.shields.io/npm/v/@rbxts/pretty-roact-hooks.svg?style=for-the-badg
Author: littensy
Latest version: 3.2.1

## 🌺 [pretty-roact-hooks](https://npmjs.com/package/@rbxts/pretty-roact-hooks)

![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/littensy/pretty-roact-hooks/ci.yml?branch=master&style=for-the-badge&logo=github)
[![npm version](https://img.shields.io/npm/v/@rbxts/pretty-roact-hooks.svg?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@rbxts/pretty-roact-hooks)
[![npm downloads](https://img.shields.io/npm/dt/@rbxts/pretty-roact-hooks.svg?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@rbxts/pretty-roact-hooks)
[![GitHub license](https://img.shields.io/github/license/littensy/pretty-roact-hooks?style=for-the-badge)](LICENSE.md)

An opinionated collection of useful hooks and utilites for Roblox-TS and [Roact Hooked](https://github.com/littensy/rbxts-roact-hooked/).

Every hook has documentation and tests. If you find a bug or have a feature request, please [open an issue](https://github.com/littensy/pretty-roact-hooks/issues/new/).

&nbsp;

## ⭐ Featured

Check out some featured hooks:

-   [🦾 `useMotor`](src/use-motor/) - Creates a motor and returns a binding, a function to set the goal, and a motor API
-   [⏱️ `useAsync`](src/use-async/) - A hook that runs an async function and returns the result and status
-   [⚙️ `useProperty`](src/use-property/) - Tracks the state of one or more instance properties without refs

This package also exports some useful utilities:

-   [🧪 `renderHook`](src/utils/testez.tsx) - Render a hook in a test environment
-   [📕 `hoarcekat`](src/utils/hoarcekat.tsx) - Create a Hoarcekat story with hook detection
-   [📦 `binding utils`](src/utils/binding.ts) - Work with values that may or may not be bindings

Or, see the [full list of hooks](src/).

&nbsp;

## 📦 Installation

This package is available for Roblox TypeScript projects on [NPM](https://www.npmjs.com/package/@rbxts/pretty-roact-hooks).

```sh
npm install @rbxts/pretty-roact-hooks @rbxts/flipper @rbxts/roact-hooked
```

or

```sh
pnpm add @rbxts/pretty-roact-hooks @rbxts/flipper @rbxts/roact-hooked
```

&nbsp;

## 🌻 Contributing

Contributions are welcome! Note that if you make a change to a hook, you should also check the tests and documentation.

To get started, clone the repository and run `npm install` or `pnpm install`. Then, you can run the following commands:

-   `pnpm dev` - Enable watch mode with the `game` project type
-   `pnpm build` - Build the package

You will likely need the following extensions:

-   [Rojo VSCode extension](https://marketplace.visualstudio.com/items?itemName=evaera.vscode-rojo)
-   [TestEZ Companion](https://marketplace.visualstudio.com/items?itemName=tacheometrist.testez-companion)

&nbsp;

## 📝 License

pretty-roact-hooks is licensed under the [MIT License](LICENSE.md).
npm package: @rbxts/pretty-vide-utils
Description: Useful utilities for @rbxts/vide
Author: PepeElToro
Latest version: 0.0.5

Useful collection of utilities for [@rbxts/vide](https://www.npmjs.com/package/@rbxts/vide)

This package tries to re-implement some of the hooks of [@rbxts/pretty-react-hooks](https://www.npmjs.com/package/@rbxts/pretty-react-hooks) but for Vide

## Installation

```sh
npm install @rbxts/pretty-vide-utils
yarn add @rbxts/pretty-vide-utils
pnpm add @rbxts/pretty-vide-utils
```