open-index/open-npm huggingface dataset:
npm package: @rbxts/tf
Description: Extended version of Studio Elttob's ty
Author: Fire
Latest version: 0.1.1

# tf

Extended version of [Studio Elttob's ty](https://github.com/Elttob/LibOpen/tree/main/LibOpen/ty)

## Installation

Pick your poison:

```sh
pesde add team_fireworks/tf
npm i @rbxts/tf
pnpm i @rbxts/tf
yarn add @rbxts/tf
bun i @rbxts/tf
```
npm package: @rbxts/tic-tac-toe
Description: Modular tic-tac-toe without dependencies, because why not.
Latest version: 0.0.3

# Tic Tac Toe

This is a simple module to run games of tic-tac-toe. You can create your own players and outputs to match what your game needs and then let all the logic be handled by this module, simple as that.

For example, if you want this game to be played by two different Roblox players, you could create a `NetworkPlayer`, which when asked for a move, waits for a `RemoteEvent` from a player specified in the constructor. Alongside that, to update participants of a game, you could create a `NetworkOutput` which sends the game information to each participating player whenever something about the game changes.

## Example

```ts
// The "ManualPlayer" is a built in player type which
// automatically returns a move when addressed.
const playerX = new TicTacToeManualPlayer('X');
const playerO = new TicTacToeManualPlayer('O');

// Create a game with two players
const ttt = new TicTacToeGame(playerX, playerO);

// Keep getting the next move until the game is over
while (!ttt.isOver()) {
	ttt.nextMove();
}

// Usually you would handle the result and playing
// of a game in an `Output` reactively, but here for
// clarity we do it declaratively.

const state = ttt.getState();

switch (state) {
	case TicTacToeState.X_WON:
		print('X WON!');
		break;

	case TicTacToeState.O_WON:
		print('O WON');
		break;

	case TicTacToeState.DRAW:
		print('DRAW');
		break;

	// Players can decide to return nothing
	// from their makeMove function to cancel the game.
	case TicTacToeState.CANCELLED:
		print('A player did not make a move');
		break;
}
```

## Benchmark

I am just including this section because I was curious myself, performance really isn't a concern though. Basically, I transformed the example above into a benchmark which runs 50,000 times, and accumulates each state instead of printing it. Each game took about 130μs.

Here is the output, this uses my benchmark utility from `@rbxts/zycore` by the way.

```
Benchmark(TicTacToe): 128.93 μs (6.45 s for 50000 runs)
X: 16084
O: 16295
Draw: 17621
Total: 50000
```
npm package: @rbxts/timer
Description: A simple package for creating timers to more accurately track time and allow for cancellation. Written using roblox-ts.
Author: Bytebit
Latest version: 0.0.9

# roblox-Timer
A simple package for creating timers to more accurately track time and allow for cancellation. Written using roblox-ts.

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

### Wally
[Wally](https://github.com/UpliftGames/wally/) users can install this package by adding the following line to their `Wally.toml` under `[dependencies]`:
```
Timer = "bytebit/timer@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-Timer/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/7881328146/Timer-Package)

# 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/topbar-plus
Description: This ia a Typescript port of [ForeverHD's Topbar+ module](https://github.com/1ForeverHD/TopbarPlus).
Author: g1mmethemoney / wAD
Latest version: 3.2.5

# @roblox-ts/topbar-plus
This ia a Typescript port of [ForeverHD's Topbar+ module](https://github.com/1ForeverHD/TopbarPlus).
npm package: @rbxts/topo-runtime
Description: Topologically-aware runtime for Roblox
Author: Ivan Leontev
Latest version: 0.8.0

# topo-runtime

This package provides an API for writing systems in function hook-ish style.
The approach allows for seamless hot-reloading and thus better DX.

Check out the `make-jsx` package to use JSX in conjunction with hooks like `useInstance`.

## Setup

Add the following entry inside `compilerOptions.plugins` of the tsconfig:
```json
{
    "transform": "@rbxts/topo-runtime/transform/out/index.js"
}
```

## Basic Usage

```ts

import { customHook } from "customHook";
import { loop } from "core";
// or
const loop = new Loop();

function mySystem() {
    // do something with hooks
}

const [step, evict] = loop.scheduleSystem(mySystem);
const connection = RunService.Heartbeat.Connect(step);
// or
const name = "my_system"
RunService.BindToRenderStep(name, Enum.RenderPriority.Camera.Value - 10, step)

defineCleanupCallback(() => {
    connection.Disconnect();
    // or
    RunService.UnbindFromRenderStep(name);

    // If you want a cold reload (meaning all of the state will be reset)
    // you have to evict the system before scheduling the hot reloaded one;
    if (coldReload) {
        evict();
    }
});
```

## Loop

The `Loop` instance is required to run topologically aware functions.
It also collects debug information that could be used by debugger implementations.

## Hooks

Use `useHookState` function for implementing custom hooks.
There is `topo-hooks` package that provides a set of common hooks.

## Custom hooks example

```ts

function cleanupCallback() {}

export function customHook(discriminator?: unknown) {
    const storage = useHookState(discriminator, cleanupCallback);

    return // some stuff
}
```

## Advanced

When implementing the hot-reload behavior for systems, the following behaviors should be considered.

The unique key for determining the system state is consists of 2 parts:
- source of the script (the same as GetFullName());
- system name;
It means that moving the system declaration around or adding a new ones won't affect it's state when hot-reloaded.
An attempt to schedule the anonymous function will result in an error being thrown.

> The system state is a map where the key is a `base key` and the value is table consisting a `hooks storage` alongside `cleanup callback`.
> The hooks storage is a map where the key is a `discriminator` (if not provided, it defaults to 0) and the value is a `discriminated hook storage`.

The base keys are generated at compile time.
These keys are unique per file and consist of the following parts:
- the line and the character;
- the text of the hook expression;
It means that any line/character/text adjustments of the hook calls will result in their state being lost.
npm package: @rbxts/transact
Description: Transaction will allow you to conduct secure transactions using Transact, Rollback methods.
Author: tesmi
Latest version: 1.0.4

# 🤝 Transaction 🤝
Transaction will allow you to conduct secure transactions using Transact, Rollback methods.

## Example
A code snippet showing how to set up and use Transaction.

```ts
class TestEntity implements ITransactEntity {
	public Init() {
		print("Init");
	}
	
	public async Transact() {
		print("Manipulating the data");
		print("Data saving");
	}

	public async Rollback() {
		print("Here you can roll back the data to its original state");
	}

	public End() {
		print("End");
	}
}

const transaction = new Transaction([new TestEntity(), new TestEntity()]);
const transact = transaction.Transact().expect();
print(transact.StatusCodes);
```
npm package: @rbxts/transform-uuid
Description: Compile time UUID transformer
Author: Ivan Leontev
Latest version: 0.0.3

# transform-uuid

```ts
const some_const = $UUID;
```

will be transpiled to:

```ts
const some_const = "2ed9b3d2-6ac2-4024-bd0e-4c07530cf55b";
```
npm package: @rbxts/trello
Description: A library to communicate with the Trello API endpoints.
Author: davness
Latest version: 2.0.0-dev.11.0
Deprecated: Development halted for >a year, no plans to finish. Please do not use this

<h1><p align=center>@rbxts/trello</p></h1>
<h2><p align=center>⚠️ NONFUNCTIONAL - WIP! ⚠️ </p></h2>
<h2><p align=center>🐉 Here be dragons! 🐉</p></h2>

<a href="https://www.npmjs.com/package/@rbxts/trello">
    <p align=center><img src="https://badge.fury.io/js/%40rbxts%2Ftrello.svg"></p>
</a>

This NPM Package will wrap [HypheX's Trello API Module](https://github.com/HypheX/roblox-trello/tree/v2-dev) in TypeScript for [roblox-ts](https://roblox-ts.github.io), with the purpose of unlocking this type of functionality to developers without having to fiddle with setting up complicated modules.

It is currently based on the on-development v2 of the module. Version of the package will be related to the version of the module this is based on.

The ultimate goal is to allow the edition of remote boards with ease, abstracting network questions away.
npm package: @rbxts/try
Description: No yield and no error callback wrapper
Author: Ivan Leontev
Latest version: 0.0.1

# rbx-try

Exposes a constructor function `createTry` that creates a function that:

Calls the given function and returns the result.
If the function yields or throws an error, the thread is closed and an error is thrown.
Regardless of the outcome, the `finally` function is called to clean up any resources.
npm package: @rbxts/ts-remote
Description: Type safe remotes
Author: Murmanox
Latest version: 1.0.3

# ts-remote
Babby's first package.

A very simple TS wrapper for Remote Events and Remote Functions. Basically a 1 to 1 port from lua to Typescript. Hopefully type safe events between client and server.

Example usage:

In some type folder:
```typescript
interface ShootRemote {
    onClientEvent: (shoot_origin: CFrame, weapon: Gun, shooter: Player) => void;
    onServerEvent: (shoot_origin: CFrame) => void;
}

interface GetLevel {
    onServerInvoke: (skill: string) => number
}
```

Client:
```typescript
// remote event wrapper
const ShootRemote = new NetworkEvent<ShootRemote>("ShootRemote");
ShootRemote.onClientEvent.Connect((shoot_origin, weapon, shooter) => {
    // do client stuff
});

ShootRemote.fireServer(new CFrame());

// remote function wrapper
const GetLevel = new NetworkEvent<GetLevel>("GetLevel");
const level = GetLevel.invokeServer("woodcutting")
```

Server:
```typescript
// remote event wrapper
const ShootRemote = new NetworkEvent<ShootRemote>("ShootRemote");
ShootRemote.onServerEvent.Connect((player, shoot_origin) => {
    // do server stuff
});

//remote function wrapper
const GetLevel = new NetworkEvent<GetLevel>("GetLevel");
GetLevel.onServerInvoke = (player, skill) => {
    // return player's skill level
}
```