open-index/open-npm huggingface dataset:
npm package: @rbxts/greenwichdb
Description: Bindings from GreenwichDB to be compatible with roblox-ts
Latest version: 1.0.9

# rbxts-greenwich
Bindings from GreenwichDB to be compatible with roblox-ts

See [GreenwichDB](https://github.com/GreenwichDB/GreenwichDB) for more information on this project.
npm package: @rbxts/hashlib
Description: Roblox-TS port of HashLib by Egor Skriptunoff, boatbomber, and howmanysmall.
Author: Konstantine Papakonstantinou
Latest version: 1.0.1

# HashLib

HashLib is a simple module providing you plenty of hashing functions and a couple utility functions. This module was originally written by Egor Skriptunoff and distributed under an MIT license (which can be found here [Test](https://github.com/Egor-Skriptunoff/pure_lua_SHA/blob/master/sha2.lua)).

Further edits to this module were made by boatbomber and howmanysmall to port this to Roblox for Lua 5.1. My further edits include typings for those who use Roblox-TS. For all inquiries into my port, visit my [repository](https://github.com/konstantinepapakonstantinou/HashLib).
npm package: @rbxts/heatup
Description: Why cool down when you can heat up? A Roblox Datastore wrapper that avoids the cooldown limit.
Author: boatbomber
Latest version: 0.1.2

# HeatUp

Why cool down when you can heat up? A Roblox Datastore wrapper that avoids the cooldown limit.

Roblox imposes a 6 second cooldown per key (across all your servers) in Datastores, preventing you from updating any key faster than ten times per minute. I wanted to go a little faster than that, and avoid risk of throttling causing dropped requests.

## How does this do that?

The secret sauce is that under the hood it's not actually writing to the same key. It doesn't really store your value at the key you chose, it stores your value at its own hash. It records that hash in a MemoryStore at your real key, so it knows where the most recent data is being held. (Periodically saving the hash to Datastore as well so it doesn't expire.) Now when you update your data, it'll be a new hash and therefore a new Datastore key- so no cooldown!

The limit is now the bounds of a MemoryStore, but that's [very high](https://developer.roblox.com/en-us/articles/memory-store#limits).

## Example

```Lua
local HttpService = game:GetService("HttpService")

local HeatUp = require(script.HeatUp)
local Store = HeatUp.new("testingHeatUp")

while true do
	Store:Update("hotKey", function(old)
		local new = (old or {})
		new[HttpService:GenerateGUID(false)] = DateTime.now().UnixTimestampMillis
		print(string.format("Updated value: %.2fkb", #HttpService:JSONEncode(new)/1024))
		return new
	end)
	task.wait(1) -- Much less than 6!
end
```
npm package: @rbxts/highlighter
Description: Types for boatbomber/Highlighter
Latest version: 0.8.2-ts.1

# Highlighter

RichText highlighting Lua code with a pure Lua lexer

## Installation

Wally:

```toml
[dependencies]
Highlighter = "boatbomber/highlighter@0.8.2"
```

Roblox Model:

Download from [Releases](https://github.com/boatbomber/Highlighter/releases)


## API

**Functions:**

```Lua
function Highlighter.highlight(props: types.HighlightProps): () -> ()
```

Highlights the given textObject with the given props and returns a cleanup function.
Highlighting will automatically update when needed, so the cleanup function will disconnect
those connections and remove all labels.

```Lua
function Highlighter.refresh(): ()
```

Refreshes all highlighted textObjects. Automatically runs when the theme changes.

```Lua
function Highlighter.setTokenColors(colors: types.TokenColors): ()
```

Sets the token colors to the given colors and refreshes all highlighted textObjects.

```Lua
function Highlighter.getTokenColor(tokenName: types.TokenName): Color3
```

Gets a token color by name.
Mainly useful for setting "background" token color on other UI objects behind your text.

```Lua
function Highlighter.matchStudioSettings(): ()
```

Matches the token colors to the Studio theme settings and refreshes all highlighted textObjects.
Does nothing when not run in a Studio plugin.

**Types:**

```Lua
type TextObject = TextLabel | TextBox

type TokenName =
    "background"
    | "iden"
    | "keyword"
    | "builtin"
    | "string"
    | "number"
    | "comment"
    | "operator"
    | "custom"

type TokenColors = {
    ["background"]: Color3?,
    ["iden"]: Color3?,
    ["keyword"]: Color3?,
    ["builtin"]: Color3?,
    ["string"]: Color3?,
    ["number"]: Color3?,
    ["comment"]: Color3?,
    ["operator"]: Color3?,
    ["custom"]: Color3?,
}

type HighlightProps = {
    textObject: TextObject,
    src: string?,
    forceUpdate: boolean?,
    lexer: Lexer?,
    customLang: { [string]: string }?,
}

type Lexer = {
    scan: (src: string) -> () -> (string, string),
    navigator: () -> any,
    finished: boolean?,
}
```

## Simple Example

```Lua
local Highlighter = require(script.Highlighter)

-- When using in a Studio Plugin, this will automatically match the Studio theme
Highlighter.matchStudioSettings()

-- Add syntax highlighting to myTextLabel
Highlighter.highlight({
    textObject: myTextLabel,
})
```
npm package: @rbxts/hot-reloader
Description: Modules hot reload solution for Roblox.
Author: Ivan Leontev
Latest version: 0.5.0

# rbx-hot-reloader

## Basic Usage

```ts
const container = ReplicatedStorage;

const hotReloader = new HotReloader();

hotReloader.scan(container, (context) => {}, (context) => {});

const module = ReplicatedStorage.SomeModule

hotReloader.listen(module, (context) => {}, (context) => {})
```

### Advanced usage

```ts
// assume that this is some module

defineCleanupCallback(() => {
    // do some stuff;
})
```
npm package: @rbxts/htn-shop
Description: a simple HTN SHOP-like planner
Author: shrjrd
Latest version: 1.0.3

# @rbxts/htn-shop

 a simple HTN, SHOP-like planner written in js, based on [Pyhop](https://bitbucket.org/dananau/pyhop)

 jshop was easy to implement (less than 50 lines of code), and if you understand the basic ideas of HTN planning ([this presentation](http://www.cs.umd.edu/~nau/papers/nau2013game.pdf) contains a quick summary), jshop should be easy to understand.

 jshop's planning algorithm is like the one in SHOP, but with several differences that should make it easier to integrate it with ordinary computer programs:

 jshop represents states of the world using ordinary variable bindings, not logical propositions. A state is just a js object. For example, you might write s.loc['v'] = 'd' to say that vehicle v is at location d in state s.

 To write HTN operators and methods for jshop, you don't need to learn a specialized planning language. Instead, you write them as ordinary js functions. The current state (e.g., s in the above example) is passed to them as an argument.

## Module Usage

```
npm install @rbxts/htn-shop
```

see the unit.test.ts file for an example usage. more to follow.

## Further reading

 - Designing games mechanics with a HTN Planner - [PDF](http://www.gameaipro.com/GameAIPro/GameAIPro_Chapter12_Exploring_HTN_Planners_through_Example.pdf)

 - Use in video games - [Youtube](https://youtu.be/kXm467TFTcY)

## License

MIT
npm package: @rbxts/immut
Description: A draft-based immutable data library based on Immer
Author: SolarHorizon
Latest version: 0.4.4-ts.0

# Immut

A draft-based immutable data library based on [Immer](https://github.com/immerjs/immer)

[View the docs](https://solarhorizon.github.io/immut)

# TypeScript Usage

```ts
import Immut, { nothing, produce } from "@rbxts/immut";

let oldState: Array<string> | undefined;
const newState = produce(oldState, (draft) => {
    if (!draft) return [];

    // draft.includes(), draft.indexOf() NOT allowed as they compile to table.find, which is not draft-safe
    // index starts at 1 for draft-safe table functions!
    if (Immut.table.find(draft, "abc") !== undefined) return nothing;
    if (Immut.table.find(draft, "abc") === 1) return nothing;

    // draft.push(), draft.insert(), draft.unshift() NOT allowed as they compile to table.insert, which is not draft-safe
    // index starts at 1 for draft-safe table functions!
    Immut.table.insert(draft, 1, "draft-safe");

    // draft.remove(), draft.shift() NOT allowed as they compile to table.remove, which is not draft-safe
    Immut.table.remove(draft);
    // index starts at 1 for draft-safe table functions!
    Immut.table.remove(draft, 1);

    draft.pop(); // allowed as it does not compile to table.remove: draft[#draft] = nil

    // draft.sort() NOT allowed as it compiles to table.sort, which is not draft-safe
    Immut.table.sort(draft, (a, b) => a > b);

    // draft.clear() NOT allowed as it compiles to table.clear, which is not draft-safe
    Immut.table.clear(draft);

    // draft.join() NOT allowed as it compiles to table.concat, which is not draft-safe
    Immut.table.concat(draft, ",");

    // draft.move() NOT allowed as it compiles to table.concat, which is not draft-safe
    // there are no draft-safe alternatives for draft.move(). consider using original() or current(), or manually move values over
});

const oldMapState = new Map<string, number>();
const newMapState = produce(oldMapState, (draft) => {
    // draft.clear() NOT allowed as it compiles to table.clear, which is not draft-safe
    Immut.table.clear(draft);

    if (draft.get("foo") === undefined) draft.set("foo", 1);
});

const oldSetState = new Set<string>();
const newSetState = produce(oldSetState, (draft) => {
    // draft.clear() NOT allowed as it compiles to table.clear, which is not draft-safe
    Immut.table.clear(draft);

    if (!draft.has("foo")) draft.add("foo");
});
```
npm package: @rbxts/jabby
Description: jabby is a debugger for [jecs](https://github.com/ukendio/jecs) based off [gorp](https://github.com/aloroid/gorp)
Latest version: 0.5.1

# jabby

jabby is a debugger for [jecs](https://github.com/ukendio/jecs) based off [gorp](https://github.com/aloroid/gorp)

It's still in the early stages of development and is very experimental.

Visit the [documentation!](https://alicesaidhi.github.io/jabby/)