open-index/open-npm huggingface dataset:
npm package: @rbxts/volume3
Description: An RBXTS TypeScript library for defining 3D convex hull volumes in Roblox with efficient collision detection and object tracking. Track Models, BaseParts, and Attachments entering/leaving dynamic volumes using precise spatial queries with customizable que
Author: irishfix
Latest version: 1.0.3

# @rbxts/volume3

[![Documentation](https://img.shields.io/badge/docs-online-blue)](https://irishfix.github.io/rbxts-volume3/)

Roblox-ts library for convex-hull volumes with evented enter/leave detection and object tracking. Define arbitrary 3D shapes from vertices or boxes, hook signals for parts/models entering or leaving, and keep volumes up to date with live object trackers.

## Features
- Create volumes from vertices, boxes (`FromBox`, `FromAABB`, `FromRegion3`), extruded planes (`FromPlaneXY/XZ/YZ`), or object trackers.
- Track arbitrary models, parts, or attachments with `ObjectTracker` (point or full box vertices; low/high precision).
- Signals: `AnyEntered`, `AnyLeft`, `PartEntered`, `PartLeft`, `ModelEntered`, `ModelLeft`.
- Awareness helpers: `TryMakeAware`, `TryForget`, `IsAwareOf`, `AwareInside`, `GetAwareInside`.
- Configurable query modes: `ModelQueryMode` (Any/All/Primary) and `PartQueryMode` (Point/Box).
- Optional debug drawing for hull faces/edges (see TSDoc on debug helpers).

## Documentation
Full API documentation: **[https://irishfix.github.io/rbxts-volume3/](https://irishfix.github.io/rbxts-volume3/)**

## Installation
```sh
npm install @rbxts/volume3
```

## Quick start
```ts
import { Volume3, ObjectTracker } from "@rbxts/volume3";

// Build a box volume at a CFrame with size
const volume = Volume3.FromBox(new CFrame(0, 10, 0), new Vector3(20, 10, 20));
volume.SetPartQueryMode(Volume3.PartQueryMode.Box);
volume.SetModelQueryMode(Volume3.ModelQueryMode.Any);

// Subscribe to enter/leave signals
volume.AnyEntered.Connect((thing) => print(`${thing.Name} entered`));
volume.AnyLeft.Connect((thing) => print(`${thing.Name} left`));

// Register things to track (Models/BaseParts) and start listening
for (const part of Workspace.GetDescendants().filter(isBasePart)) {
	volume.TryMakeAware(part);
}
volume.BeginListening(); // hooks RunService.PostSimulation

// Track a moving object and feed its vertices into the hull
const tracker = new ObjectTracker(somePart, Volume3.ObjectTrackerMode.Box, Volume3.ObjectTrackerPrecision.High, true);
const trackerVolume = Volume3.FromObjectTrackers([tracker]);
trackerVolume.BeginListening();
```

## API hints
- Creation: `FromVertices`, `FromBox`, `FromAABB`, `FromRegion3`, `FromPlaneXY/XZ/YZ`, `FromObjectTrackers`.
- Control queries: `SetModelQueryMode` / `GetModelQueryMode`, `SetPartQueryMode` / `GetPartQueryMode`.
- Awareness lifecycle: `TryMakeAware(thing, automaticallyForget?)`, `TryForget(thing)`, `IsAwareOf`, `AwareInside`, `GetAwareInside`.
- Looping: `BeginListening()` / `StopListening()` to hook/unhook the per-frame query.
- Debug: enable/disable/debug draw helpers via the `Debug` methods (see TSDoc for details).
npm package: @rbxts/weave
Description: TypeScript support for Weave
Author: andrewtdiz
Latest version: 0.1.3

<img align="left" src="./gh-assets/logo.svg" height="100px" width="100px" alt="Fusion"><a href="https://andrewtdiz.github.io/Weave/"><img align="right" src="./gh-assets/link-docs.svg" alt="Docs"></a><a href="https://github.com/andrewtdiz/Weave/releases/latest"><img align="right" src="./gh-assets/link-download.svg" alt="Download"></a><img src="./gh-assets/clearfloat.svg">

Weave is a modern state libarary, built specifically for [Roblox](https://developer.roblox.com/) and [Luau](https://luau-lang.org/).

Plug in live data with simple, flexible, truly reactive state management.<br>
Build your UI with a declarative syntax that's easy to read and write.<br>
Send data from Server to Client and replicate data with simple syntax.<br>
Deliver a fast, smooth experience to everyone - on mobile, console, PC or in VR.<br>

Visit the Weave documentation to learn more <img valign="middle" src="./gh-assets/icon-link-extern.svg" alt="(external link)" title="(external link)">

---

## Contributing

Please read [our contribution policies](/CONTRIBUTING.md) before opening an issue or pull request.

---

## Building
To build the file from scratch, use:

```bash
rojo build -o "Weave.rbxm"
```

Next, open `Weave.rbxm` in Roblox Studio and start the Rojo server:

```bash
rojo serve
```
npm package: @rbxts/yaruil
Description: Yet Another Roblox UI Library
Author: greenbobux
Latest version: 0.1.2-alpha

# Yaruil
*Yet Another Roblox UI Library*
Yaruil is fairly simple, it's similar to reactjs and solidjs. <br/>
If you want JSX, then you will have to install the [transformer](https://github.com/greenbobux/rbxts-transformer-yaruil). <br/>
With JSX, you'll always want to have the Yauril module imported, `import * as Yaruil from "@rbxts/yaruil"`
## Props and children

Creating an element looks like this: `Yaruil.createElement("ScreenGui, {/* props */}, [/* children */])`. 
## Prop values
The value of a prop can be a function or a literal. <br/>
```() => (`count: ${count()}`)``` or just simply  `` `count: ${count()}` ``
## Examples
Here is an example of a basic component.
```ts
import { Players } from "@rbxts/services";
import * as Yaruil from "@rbxts/yaruil";
import { createSignal, render } from "@rbxts/yaruil";
import { childrenLike } from "@rbxts/yaruil/out/util/types";

function Button({ children }: { children?: childrenLike }) {
	const [count, setCount] = createSignal(0);

	return (
		<screengui>
			<textbutton
				on:MouseButton1Click={() => {
					setCount(count() + 1);
				}}
				Size={new UDim2(0, 100, 0, 100)}
				Text={`count: ${count()}`}
			>
                // we dont know if children is defined
				{...children || []}
			</textbutton>
		</screengui>
	);
}
render(
	<Button>
		<uicorner />
	</Button>,
	Players.LocalPlayer.WaitForChild("PlayerGui"),
);
```
It's relatively easy to communicate state. 

```ts
import { Players } from "@rbxts/services";
import * as Yaruil from "@rbxts/yaruil";
import { createDependency, render } from "@rbxts/yaruil";
import { externalSignal } from "@rbxts/yaruil/out/hooks/externalSignal";
import { childrenLike } from "@rbxts/yaruil/out/util/types";

export const countSignal = externalSignal(1);
// some event happens...
Event.connect((newValue) => countSignal.set(999))
function Button({ children }: { children?: childrenLike }) {
	const [count, setCount] = createDependency(countSignal);

	return (
		<screengui>
			<textbutton
				on:MouseButton1Click={() => {
					setCount(count() + 1);
				}}
				Size={new UDim2(0, 100, 0, 100)}
				Text={() => `count: ${count()}`}
			>
				{...children || []}
			</textbutton>
		</screengui>
	);
}
```
npm package: @rbxts/zenui-core
Description: Core user interface code for the Zenerith Engine - open sourced for other games using TypeScript to use.
Author: Vorlias
Latest version: 0.8.1

# ZenUI Core
Core user interface code for the Zenerith Engine - open sourced for other games using TypeScript to use.


## Controllers
Contains behaviour-oriented components that when built together, will give a behaviour. Currently houses core pieces for pagination/tabs.
- `PageController` - Controller that handles pages
- `TabController` - Handles tab rendering, when used with `PageController` can be used to create tab widgets.

## Views
View objects - currently contains the simplest unit 
- `View` (which is just a frame that defaults to transparent & `UDim2.fromScale(1, 1)` size)

## Layouts
Contains objects which handle layout
- `ColumnView` which will create columns that automatically size, each column can also have a specified size, in which other columns will automatically size to.
npm package: @rbxts/zirconium-ast
Description: Parser for Zirconium
Author: Vorlias
Latest version: 1.0.0-beta.14


<center>
    <img src="https://assets.vorlias.com/i1/zirconium-ast.png"/>
</center>

# Zirconium AST
Lexer and Parser for the Zirconium DSL (Domain-specific Language) for use in Roblox.
More information in the [Zirconium project](https://github.com/roblox-aurora/zirconium).

### _Note: Documentation is WIP as the new parser is written_

## Features
### Using commands
```bash
command hello 10 true "Hello there $playerName!" # simple call
command("hello", 10, true, "Hello there $playerName!") # explicit call
```
A simple call is for quick & easy commands (and more like a command), explicit calls allow passing other commands as arguments and is more explicit and akin to regular programming.

- I'm possibly planning with Zircon that certain commands require 'explicit'

### Using Variables
```bash
$aNumber = 10
$aString = "Hello there!"
$aBoolean = true
```

### Using arrays
```bash
$arrayVariable = [ "string", true, 10, 5.5, "combined $variable string" ] #variable use
kill [ vorlias, augmin ]
kill([ "vorlias", "augmin" ])
```

Indexing
```bash
$array = [ "Hello, World!" ]
$helloWorld = $array.0 # will retrieve the first value
echo $helloWorld
```

### Using Pipes and Synchronous calls
```bash
command | command2 # Passes values from command to command2
command && command2 # Meant to only execute command2 if command succeeds
command || command2 # Meant to only execute command2 if command fails
```
Explicit calls can also be used with these.

### If Statement
```bash
$value = true

if $value { 
    echo "True!"
}

if $value: echo "True!" # Short form if, same as above

if $value {
    echo "True!"
} else {
    echo "False!"
}
```
The above would print `True!` three times.


## Block Scope
```bash
{
    $x = 10
    echo $x # x is 10
}

echo $x # x is out of scope, would be nil
```

## Functions
```ts
// No arguments
function functionName() {

}

// Implicit any
function functionName($argument) {

}

// With multiple arguments and types
function functionName($argument: string, $anotherArgument: number) {
    echo $argument $anotherArgument
}
```
npm package: @rbxts/zycore
Description: Utilities I have considered useful for my projects.
Latest version: 2.8.1

> **Big Disclaimer Time** <br>
> I made this package with my project/future project needs in mind. This means that I will go into this package and change things whenever I need something changed for my project. To be short, expect breaking changes, changes that may affect your project and the way it behaves, so if you need something in this package, either install it and then don't update unless you know what has changed, or go grab only the utilities you need from the repo.

# Zycore

Just a bunch of utilities thrown together since I don't like copying the files between my projects manually.
Feel free to contribute any new utilities or corrections.
This package exports quite a few very generically named namespaces and classes, if you would like to avoid that kind of pollution installing this package is not your best choice. The repo will always remain open so if you want to grab a specific namespace or class go ahead :D

Some utilities may use other utilities internally, so check the imports at the top if you grab a file to make sure you are grabbing all of the files you need to get the full functionality.
npm package: @rbxtsx/web-compiler
Description: HTML and CSS compiler for Roblox using React
Author: Harihar Nautiyal
Latest version: 0.0.3-Alpha

# @rbxtsx/web-compiler

**UNDER DEVELOPMENT**

A TypeScript-based web compiler for Roblox, allowing you to compile HTML and CSS into Roblox UI components.



## Important Configuration

### 1. Update tsconfig.json
Add `@rbxtsx` to your typeRoots:
```json
{
  "compilerOptions": {
    "typeRoots": [
      "node_modules/@rbxts",
      "node_modules/@rbxtsx",  // Add this line
      "node_modules/@types"
    ]
  }
}
```

2. Update default.project.json

Add the `@rbxtsx` scope to your Rojo configuration:

```json
{
  "ReplicatedStorage": {
    "$className": "ReplicatedStorage",
    "rbxts_include": {
      "$path": "include",
      "node_modules": {
        "$className": "Folder",
        "@rbxts": {
          "$path": "node_modules/@rbxts"
        },
        "@rbxtsx": {           // Add this block
          "$path": "node_modules/@rbxtsx"
        }
      }
    }
  }
}

```

## Installation

```bash
npm install @rbxtsx/web-compiler
```

## Features

- Converts HTML elements to Roblox UI instances
- Transforms CSS styles to Roblox properties
- Supports basic HTML tags (div, span, button, input)
- Handles common CSS properties
- TypeScript support

## Usage

```typescript
import { HTMLParser, CSSParser, Transformer } from "@rbxtsx/web-compiler";

// Parse HTML
const htmlParser = new HTMLParser(htmlString);
const htmlAst = htmlParser.parse();

// Parse CSS
const cssParser = new CSSParser(cssString);
const cssRules = cssParser.parse();

// Transform to Roblox code
const transformer = new Transformer();
const robloxCode = transformer.transformHTML(htmlAst);
const robloxStyles = transformer.transformCSS(cssRules);
```

## HTML Support

Supported HTML elements:
- `<div>` → Frame
- `<span>` → TextLabel
- `<button>` → TextButton
- `<input>` → TextBox

## CSS Support

Supported CSS properties:
- `background-color` → BackgroundColor3
- `color` → TextColor3
- `font-size` → TextSize
- `width` → Size.X
- `height` → Size.Y

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

MIT

## Author

Harihar Nautiyal

## Last Updated

2024-12-19

## Support

For issues and feature requests, please use the [GitHub issues page](https://github.com/yourusername/web-compiler/issues).

## Note

This package is under development and designed specifically for use with roblox-ts and may not work in other environments.
npm package: @rbzhang/gtran-kmz
Description: convert geojson to kmz file
Author: Haoliang Yu
Latest version: 1.1.5

# gtran-kmz

convert geojson to KMZ file

This is a sub-project of [gtran](https://github.com/haoliangyu/gtran).

## Installation

```javascript
npm install gtran-kmz
```

## Functions

* **setPromiseLib(object)**

    Specify the promise library. If not, the library will use the native Promise.

* **fromGeoJson(geojson, fileName, options)**

    Save the geojson into the given file name.

    options:

    * symbol - Symbol of saved features. See detail at [gtran-kml](https://github.com/haoliangyu/gtran-kml).

## Use Example

```javascript
var kmz = require('gtran-kmz');

var pointSymbol = {
    color: '#2dcd86',
    alpha: 255,
    scale: 1,
    icon: 'http://maps.google.com/mapfiles/kml/shapes/square.png'
};

// if specific promise library is needed
kmz.setPromiseLib(require('bluebird'));

// Save geojson into KMZ file
kmz.fromGeoJson(geojson, 'point.kmz', {
    symbol: pointSymbol,
    name: 'Name'
})
.then(function(fileName) {
    console.log('KMZ file has been saved at:' + fileName);
});

```