open-index/open-npm huggingface dataset:
npm package: @rbxts/formati
Description: **formati** is a simple formatting library for creating valid Roblox [RichText Markup](https://create.roblox.com/docs/ui/rich-text) strings, getting rid of the need to memorize RichText tags.
Author: raine
Latest version: 1.0.2

# formati
**formati** is a simple formatting library for creating valid Roblox [RichText Markup](https://create.roblox.com/docs/ui/rich-text) strings, getting rid of the need to memorize RichText tags.

## 📦 Installation
**formati** can be installed on [NPM](https://www.npmjs.com/package/@rbxts/formati) (for rbxts), or with [Wally]().

```bash
# w/ npm
$ npm install @rbxts/formati

# w/ yarn
$ yarn add @rbxts/formati

# w/ pnpm
$ pnpm add @rbxts/formati
```
```toml
# wally.toml
[dependencies]
formati = "_/formati@version"
```

Alternatively, a `rbxm` file is provided in the GitHub Releases menu.

## Documentation
This is primarily for Luau, as TypeScript documentation is provided in code comments.
### `string` formati.newline
The newline string used by the library.\
Defaults to `<br/>`

### `class` formati.Format
A formatter object. The `__tostring` metamethod is set, so it can be safely used in string interpolation without needing to call the `stringify()` method.

#### `constructor` new (raw: string)
Returns a new Format object

```luau
local formatter = Format.new("some text")

formatter:stringify() --> "some text"
tostring(formatter) --> "some text"
```
```typescript
const formatter = new Format("some text")
formatter.stringify() // -> "some text"
tostring(formatter) // -> "some text"
```

**TODO** add documentation for formatter methods

### `function` formati.f (raw: string)
A helper function that just creates a [`Format`](#class-formatiformat) object. The `raw` argument is passed to the [Format.new()](#constructor-new-raw-string) constructor.

> [!TIP]
> You should always use f() when formatting strings. It reduces the amount of typing needed in both TypeScript and Luau, while providing the exact same behavior.
>
> Declare `f` as a variable at the top of your script in Luau to further reduce typing.
> ```luau
> -- Luau
> local _formati = require(path.to.formati)
> local f = _formati.f
>
> print(`This is {f("formatted"):bold()} text!`)
> ```
> ```typescript
> // TypeScript
> import { f } from "@rbxts/formati"
> 
> print(`This is ${f("formatted").bold()} text!`)

## 📝 License
**formati** is provided under the MIT license.
npm package: @rbxts/fsm
Description: Generic finite state machine implementation for roblox-ts.
Latest version: 1.0.0

# FSM (Finite State Machine)

A super simple finite state machine pattern implementation. If you are not sure what this is, a finite state machine is a state manager that ensures a system is only in a single state out of a predefined, finite number of states at one time, and has a set of predefined paths that it can take.

## Example

In this example, this traffic light loops between each state forever. Because we defined the possible transitions in the `transitions` variable, we know that the machine can ONLY go
in the sequence we defined.

If the `ORANGE_OFF` event is fired when the light is `GREEN`, the event is just ignored since there is no transition defined for such a scenario, this way we can ensure our system always follows a predictable and predefined pattern.

```ts
enum State {
	GREEN,
	ORANGE,
    RED,
}

enum Event {
	GREEN_OFF,
	ORANGE_OFF,
	RED_OFF,
}

const transitions: Transition<State, Event>[] = [
    // When the GREEN_OFF event fires, and we're in the GREEN state, switch to ORANGE
	{ event: Event.GREEN_OFF, from: State.GREEN, to: State.ORANGE },

    // When the ORANGE_OFF event fires, and we're in the ORANGE state, switch to RED
	{ event: Event.ORANGE_OFF, from: State.ORANGE, to: State.RED },

    // When the RED_OFF event fires, and we're in the RED state, switch back to GREEN
	{ event: Event.RED_OFF, from: State.RED, to: State.GREEN },

    // Create more states, events, transitions... get as complex as you want
];

const trafficLight = new FiniteStateMachine(State.GREEN, ...transitions);

trafficLight.onState(State.GREEN, () => {
	print('THE LIGHT IS GREEN');
	task.delay(2.5, () => trafficLight.processEvent(Event.GREEN_OFF));
});

trafficLight.onState(State.ORANGE, () => {
	print('THE LIGHT IS ORANGE');
	task.delay(1, () => trafficLight.processEvent(Event.ORANGE_OFF));
});

trafficLight.onState(State.RED, () => {
	print('THE LIGHT IS RED');
	task.delay(2.5, () => trafficLight.processEvent(Event.RED_OFF));
});

// Since the initial state was defined GREEN, the system is currently
// in the GREEN state, so the only event that will do anything is GREEN_OFF
trafficLight.processEvent(Event.GREEN_OFF);
```
npm package: @rbxts/fusion
Description: TypeScript support for Fusion
Author: Elttob
Latest version: 0.2.0

<img align="left" src="https://raw.githubusercontent.com/Elttob/Fusion/main/gh-assets/logo-dark-theme.svg#gh-dark-mode-only" alt="Fusion"><img align="left" src="https://raw.githubusercontent.com/Elttob/Fusion/main/gh-assets/logo-light-theme.svg#gh-light-mode-only" alt="Fusion"><a href="https://elttob.uk/Fusion/"><img align="right" src="https://raw.githubusercontent.com/Elttob/Fusion/main/gh-assets/link-docs.svg" alt="Docs"></a><a href="https://github.com/Elttob/Fusion/releases"><img align="right" src="https://raw.githubusercontent.com/Elttob/Fusion/main/gh-assets/link-download.svg" alt="Download"></a><img src="https://raw.githubusercontent.com/Elttob/Fusion/main/gh-assets/clearfloat.svg">

Fusion is a modern reactive UI library, built specifically for [Roblox](https://developer.roblox.com/) and [Luau](https://luau-lang.org/).

Build your UI with a declarative syntax that's easy to read and write.<br>
Plug in live data with simple, flexible, truly reactive state management.<br>
Deliver a fast, smooth experience to everyone - on mobile, console, PC or in VR.<br>

<a href="https://elttob.uk/Fusion/">
Visit the Fusion documentation to learn more <img valign="middle" src="https://raw.githubusercontent.com/Elttob/Fusion/main/gh-assets/icon-link-extern.svg" alt="(external link)" title="(external link)">
</a>

-----

## Contributing

Please read [our contribution policies](/CONTRIBUTING.md) before opening an issue or pull request.
npm package: @rbxts/ghostevents
Description: Prevent hackers from calling events
Author: efekos
Latest version: 1.0.1

# @rbxts/ghostevents

This module creates an event system that is really easy to use. The main point of this event system is that none of the events have to stay in ReplicatedStorage. All the events automatically get created when fired, and gets deleted after the job is done with that event.

# Profits

Most of the hackers on Roblox follow these steps to hack a game:

* Step 1 - Download an exploit that lets you see the 'Explorer' tab ingame.
* Step 2 - Find where the events are stored in ReplicatedStorage.
* Step 3 - Fire any event you want to manipulate the game.
* Step 4 - You just hacked the game!

When you use this module to make your event system, most of the hackers will fail Step 2 and 3. This makes the hackers' job a lot harder when it's about your game.
npm package: @rbxts/gizmo
Description: gizmo is a visual debug library designed for the Roblox game engine.
Author: Brad Sharp
Latest version: 3.0.3

# About

_gizmo_ is a visual debug library designed for the Roblox game engine.

# Usage

## API Reference

### Types

The following types are supported:
- point: Position
- box: Orientation, Size
- wirebox: Orientation, Size
- sphere: Position, Radius
- wiresphere: Position, Radius
- line: Position, Position
- arrow: Position, Position
- ray: Position, Direction

### gizmo.\<type\>.draw(...) -> void

Renders the gizmo for a single frame

### gizmo.\<type\>.create(...) -> object

Creates a new object which can be rendered over multiple frames

### gizmo.\<type\>.createWithStyle(optional_style, ...) -> object

Creates a new object and applies the style
```ts
const arrow = Gizmo.arrow.createWithStyle({
  color: new Color3(1, 0, 0),
  scale: 2
}, Vector3.zero, Vector3.one.mul(15));
```

#### object.enable() => void

Starts rendering the gizmo

#### object.disable() => void

Stops rendering the gizmo

#### object.update(...) => void

Updates the gizmos appearance

#### object.style

Controls the 'style' of the gizmo

#### object.setStyle(optional_style) => void
Controls the 'style' of the gizmo
```ts
arrow.setStyle({
  alwaysOnTop: true
})
```

### gizmo.style

The global style used by default when creating or drawing a gizmo

## Examples

### Drawing an arrow frame-by-frame

```ts
RunService.PostSimulation.Connect(() => {
  Gizmo.arrow.draw(start, finish);
})
```

### Drawing a ray frame-by-frame with style

```ts
RunService.PostSimulation.Connect(() => {
  //allows to apply the style to the temporary object
  Gizmo.arrow.drawWithStyle({
    alwaysOnTop: true,
    color: new Color3(1, 0, 0),
    scale: 2,
  }, start, finish);
})
```

### Drawing an arrow with an object


```ts
const arrow = Gizmo.arrow.create(start, finish);
arrow.enable();

RunService.PostSimulation.Connect(() => {
  arrow.update(start, finish);
})
```
npm package: @rbxts/goap
Description: A direct port of [crashkonijn/GOAP](https://github.com/crashkonijn/GOAP) to Roblox. Should work functionally the same: albeit a few differences. Eventually, this will support parallel Luau.
Latest version: 3.2.0

# @rbxts/goap

A direct port of [crashkonijn/GOAP](https://github.com/crashkonijn/GOAP) to Roblox. Should work functionally the same: albeit a few differences. Eventually, this will support parallel Luau.
npm package: @rbxts/goap-solver
Description: A lightweight, pure functional GOAP solver in TypeScript for creating complex AI agent behavior in games and simulations
Author: Alexey Ozerov
Latest version: 0.4.0

# GOAP Solver

A lightweight, pure functional GOAP solver in TypeScript for creating complex AI agent behavior in games and simulations.


### Features

- ✨ Pure functional
- 🔢 Boolean and Numeric facts
- 📜 Declarative
- ✅ Written in TypeScript
- 🗜️ Zero dependencies


### References

- [Building a Game Bot with GOAP](https://tezee.art/articles/building-game-bot-goap?lang=en)


## Installation

```zsh
npm i @rbxts/goap-solver
```


## Usage

```ts
import { planner, Action, GoalFacts } from '@rbxts/goap-solver'


// define world state
const state = {
  hasDocument: false,
  money: 0,
  beer: 2,
} satisfies GoalFacts

// define what we want to achieve
const goal = { beer: state.beer + 1 } satisfies GoalFacts

// define available actions
const a: Action = {
  name: 'GetDocument',
  preconditions: { hasDocument: false },
  effects: { hasDocument: true },
  priority: 1,
}
const b: Action = {
  name: 'GetMoney',
  preconditions: { money: 0 },
  effects: { money: 10 },
  priority: 2,
}
const c: Action = {
  name: 'BuyBeer',
  preconditions: { hasDocument: true, money: 10 },
  effects: { beer: 1, money: -10 },
}

const actions = [c, b, a]
const plan = planner(state, goal, actions)
const result = plan?.map(({ name }) => name)

expect(result).toEqual(['GetMoney', 'GetDocument', 'BuyBeer'])
```


### License

[MIT](https://opensource.org/licenses/MIT) © 2025-present, [@13luck](https://github.com/13luck)
npm package: @rbxts/gorp
Description: A hacky ECS debugger
Latest version: 0.2.0-ts.3

<div align="center">
	<h1>gorp-ts</h1>
</div>

Fork of [gorp](https://github.com/Aloroid/gorp) for Roblox-ts.

# Notice
It is preferred that you use jabby / ebba for new work.

# Differences to Luau version
- This package is versioned with `<gorp version>-ts.<x>` where x is incremented for any changes to the TS version in particular.

# Code sample with ecr

The following requires the [gorp-ecr](https://github.com/ReturnedTrue/gorp-ecr-ts) package

Server

```ts
import ecr from "@rbxts/ecr";
import gorp from "@rbxts/gorp";
import gorp_ecr from "@rbxts/gorp-ecr";

// Required, sets up the ecs layer for ecr
gorp_ecr.init({ ecr, gorp });
```

Client
```ts
import ecr from "@rbxts/ecr";
import gorp from "@rbxts/gorp";
import gorp_ecr from "@rbxts/gorp-ecr";

// Required, sets up the ecs layer for ecr
gorp_ecr.init({ ecr, gorp });

// Create components
const Position = ecr.component(() => Vector3.zero);
const Velocity = ecr.component<Vector3>();

// Assign names to components
gorp.names({ pos: Position, vel: Velocity });

// Create world and assign name
const world = ecr.registry();
gorp.hook_world(world, "main_world");

// Get the client and mount the selector interface
const client = gorp.get_client();
client.gorp_selector();

// Create entity, assign components
const ent = world.create();
world.add(ent, Position);
world.set(ent, Velocity, Vector3.xAxis);

// Create scheduler
const scheduler = gorp.scheduler("main_scheduler");

function position_system(dt: number) {
	for (const [id, pos, vel] of world.view(Position, Velocity)) {
		world.set(id, Position, pos.add(vel.mul(dt)));
	}
}

// Run the system every frame in the scheduler
game.GetService("RunService").RenderStepped.Connect((dt) => {
	scheduler.system("position_system", position_system, dt);
	scheduler.finish();
});

// Connect F keybind to toggle the interface
game.GetService("UserInputService").InputBegan.Connect((input) => {
	if (input.KeyCode === Enum.KeyCode.F) {
		client.enabled(!client.enabled());
	}
});

```