open-index/open-npm huggingface dataset:
npm package: @rbxts/djecs
Description: Stupidly fast Entity Component System
Author: Ukendio
Latest version: 0.1.0


<p align="center">
  <img src="jecs_darkmode.svg#gh-dark-mode-only" width=50%/>
  <img src="jecs_lightmode.svg#gh-light-mode-only" width=50%/>
</p>

[![License: Apache 2.0](https://img.shields.io/badge/License-Apache-blue.svg?style=for-the-badge)](LICENSE-APACHE)
[![Wally](https://img.shields.io/github/v/tag/ukendio/jecs?&style=for-the-badge)](https://wally.run/package/ukendio/jecs)

Just an ECS

jecs is a stupidly fast Entity Component System (ECS).

- Entity Relationships as first class citizens
- Iterate 350,000 entities at 60 frames per second
- Type-safe [Luau](https://luau-lang.org/) API
- Zero-dependency package
- Optimized for column-major operations
- Cache friendly archetype/SoA storage
- Unit tested for stability

### Example

```lua
local world = jecs.World.new()
local pair = jecs.pair

local ChildOf = world:component()
local Name = world:component()

local function parent(entity) 
    return world:target(entity, ChildOf)
end
local function getName(entity) 
    return world:get(entity, Name)
end

local alice = world:entity()
world:set(alice, Name, "alice")

local bob = world:entity()
world:add(bob, pair(ChildOf, alice))
world:set(bob, Name, "bob")

local sara = world:entity()
world:add(sara, pair(ChildOf, alice))
world:set(sara, Name, "sara")

print(getName(parent(sara)))

for e in world:query(pair(ChildOf, alice)) do 
    print(getName(e), "is the child of alice")
end

-- Output
-- "alice"
-- bob is the child of alice
-- sara is the child of alice
```

125 archetypes, 4 random components queried.
![Queries](image-3.png)
Can be found under /benches/query.lua

Inserting 8 components to an entity and updating them over 50 times.
![Insertions](image-4.png)
Can be found under /benches/insertions.lua
npm package: @rbxts/easy-path
Description: This package will help you build paths with smooth turns
Author: tesmi
Latest version: 1.0.7

# 📈 EasyPath
EasyPath will give you the ability to create smooth paths, this package is ideal for TD games where you want the most optimized enemy system possible.

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

```ts
const cframes = [
	new CFrame(11.39, 0.5, -14.8),
	new CFrame(11.39, 0.5, -30.03),
	new CFrame(13.7, 0.5, -32.44).mul(CFrame.fromOrientation(0, math.rad(90), 0))
]

const path = new EasyPath(cframes);
path.Visualize();

const part = new Instance("Part", Workspace);
part.Size = Vector3.one;
part.Anchored = true;
part.CanCollide = false;

let dist = 0;
while (dist <= path.GetLength()) {
	dist += 1;
	part.CFrame = path.CalculateCFrameByLength(dist);
	task.wait(0.1);
}
```

## API

* new EasyPath(cframes: CFrame[])

Takes an array of cframes to be used as waypoints and returns a path object.

* Path.CalculateCFrame(t: number)
  
Takes in a t value from 0-1 and returns a uniform cframe across the path object.

* Path.CalculateCFrameByLength(lenght: number)
  
Takes the path length and returns a uniform frame over the entire path object.

* Path:GetPathLength()

Returns the path objects length.
npm package: @rbxts/ebba
Description: jabby is a debugger for [jecs](https://github.com/ukendio/jecs) based off [gorp](https://github.com/aloroid/gorp)
Latest version: 0.2.5

# 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/)
npm package: @rbxts/ecr
Description: A sparse-set based ECS library for Luau, now with TS types.
Latest version: 0.9.0-ts.0

<div align="center">
	<img src="https://github.com/ReturnedTrue/ecr-ts/blob/master/images/logo.svg" width="600" alt="ecr-ts logo">
</div>

___

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

# Differences to Luau version
- TS has no length operator, instead use `.size()`. Queues and Pools have it as a property, `.size`
- Components don't need to be casted, instead supply the generic
- This package is versioned with `<ecr version>-ts.<x>` where x is incremented for any changes to the TS version in particular 

# Code Sample

```ts
import ecr, { Registry } from "@rbxts/ecr";

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

// define a system
function update_physics(world: Registry, dt: number) {
	for (const [id, pos, vel] of world.view(Position, Velocity)) {
		world.set(id, Position, pos.add(vel.mul(dt)));
	}
}

// instantiate the world
const world = ecr.registry();

// create entities and assign components
for (const i of $range(1, 10)) {
	const id = world.create();
	world.set(id, Position, new Vector3(i, 1, 1));
	world.set(id, Velocity, new Vector3(10, 0, 0));
}

// run system
update_physics(world, 1/60);
```
npm package: @rbxts/emittery
Description: Emittery v0.11.0 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/experimental-reflect
Description: An experimental and incomplete Roblox-TS implementation of the Reflect Metadata API.
Author: typechecked
Latest version: 1.0.0

# Experimental Reflect
An experimental and incomplete Roblox-TS implementation of the Reflect Metadata API.

Declarative Syntax:

```ts
import { Reflect } from "@rbxts/experimental-reflect"

class MyClass {
    @Reflect.metadata("custom:MyMetadata", "This is the metadata for MyProperty.")
    public MyProperty = "Hello, world!"
}

const MyClassInstance = new MyClass()

print(Reflect.getMetadata("custom:MyMetadata", MyClassInstance, "MyProperty")) // Expected output: "This is the metadata for MyProperty."
```

Imperative Syntax:

```ts
import { Reflect } from "@rbxts/experimental-reflect"

class MyClass {
    public MyProperty = "Hello, world!"

    public constructor() {
        Reflect.defineMetadata("custom:MyMetadata", "This is the metadata for MyProperty.", this, "MyProperty")
    }
}

const MyClassInstance = new MyClass()

print(Reflect.getMetadata("custom:MyMetadata", MyClassInstance, "MyProperty")) // Expected output: "This is the metadata for MyProperty."
```
npm package: @rbxts/fable
Description: An easy to use story (game) creator for Roblox. Made in roblox-ts.
Author: strawberrys
Latest version: 0.9.7

# Fable
An easy to use story (game) creator for Roblox. Made in roblox-ts.

## Installation
#### npm:
`npm install @rbxts/fable`
#### .tgz:
`npm install ../path/to/file/rbxts-fable-1.0.0.tgz`

## Building
1. First, be sure to install all necessary dependencies: `npm i`.
2. Next, compile the project: `rbxtsc build`.
3. You can then build the package for external use: `npm pack`. Or you can build the example project for testing: `npm run build`.

## Documentation
Documentation is currently incomplete. It can be built via `npx typedoc ./src/index.ts`.
npm package: @rbxts/faker
Description: A library that mocks Roblox user data, inspired by faker-js.
Author: synpixel
Latest version: 0.2.8

<div align="center">
    <h1>Faker</h1>
    <p>A library that mocks Roblox user data, inspired by faker-js.</p>
    <a href="https://synpixel.github.io/rbx-faker/">View docs →</a>
</div>

## Installation

You can install Faker as a wally dependency by adding this to your `wally.toml` file:

```toml
Faker = "synpixel/faker@0.2.1"
```

## Why?

While at first sight this library might seem useless, it has various use cases, such as mocking Player instances for your interface.
Mocking user data can get very tiring if done manually, this library is here to help with that.
npm package: @rbxts/fenwick-tree
Description: A 1-based Fenwick Tree implementation.
Author: quamatic
Latest version: 1.0.0

# Fenwick Tree

A 1-based Fenwick Tree implementation for Roblox, for efficient computation of dynamic prefix sums.

# Installation

## Wally

```sh
FenwickTree = "quamatic/fenwick-tree@0.1.0"
```

## Roblox TypeScript

```sh
npm i @rbxts/fenwick-tree
pnpm add @rbxts/fenwick-tree
yarn add @rbxts/fenwick-tree
```