open-index/open-npm huggingface dataset:
npm package: @rbxts-js/shared
Description: A Roblox Lua port of the `shared` pseudo-package from React, which contains a number of common utilities and definitions used across the React monorepo.
Latest version: 17.3.7-ts.1

# shared
A Roblox Lua port of the `shared` pseudo-package from React, which contains a number of common utilities and definitions used across the React monorepo.

Status: ✔️ Ported

Source: https://github.com/facebook/react/tree/master/packages/shared

---

### ✏️ Notes
* `ReactTypes.js` contains a number of complex flow-type definitions that are not yet possible with Luau, so it's been simplified to a stub called `ReactTypes.roblox.lua`
* `ReactComponentStackFrame.js` is replaced by a partially-ported stub (`ReactComponentStackFrame.roblox.lua`) since it contains logic for parsing/navigating JS-specific stack structure. This needs to be ported to the equivalent functionality in Luau.
* Some slight changes to `isValidElement.lua` that account for the divergent shape of Component and PureComponent objects in our port (for `react`, they're functions; for us, they're tables)

### ❌ Excluded

#### Forked Config
```
forks/ReactFeatureFlags.native-fb.js
forks/ReactFeatureFlags.native-oss.js
forks/ReactFeatureFlags.readonly.js
forks/ReactFeatureFlags.test-renderer.js
forks/ReactFeatureFlags.test-renderer.native.js
forks/ReactFeatureFlags.test-renderer.www.js
forks/ReactFeatureFlags.testing.js
forks/ReactFeatureFlags.testing.www.js
forks/ReactFeatureFlags.www-dynamic.js
forks/ReactFeatureFlags.www.js
forks/Scheduler.umd.js
forks/SchedulerTracing.umd.js
forks/consoleWithStackDev.www.js
forks/invokeGuardedCallbackImpl.www.js
forks/object-assign.inline-umd.js
forks/object-assign.umd.js
```

Forks that specify different flag states are used in React with the help of a bundler that swaps in the correct file for the given environment. We don't have this kind of functionality yet, nor the same set of environments.

#### Integration Tests
```
__tests__/describeComponentFrame-test.js
__tests__/ReactError-test.internal.js
```
These tests required use of React and ReactDOM, and are not viable to port until we have more of the reconciler ported.
npm package: @rbxts-js/symbol-luau
Description: A Symbol object to mimic [JavaScript's Symbol type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol).
Latest version: 1.0.0-ts.1

## Symbol

A Symbol object to mimic [JavaScript's Symbol type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol).

## API

### Symbol()
```
Symbol(name: string?): Symbol
```

Create a new symbol object. Symbols use the `newproxy` function under the hood to create an opaque, unique sentinel value. The optional string value will be included in value returned by calling `tostring` on the resulting symbol.

```
local Foo = Symbol("Foo")
print(tostring(Foo)) -- prints: 'Symbol("Foo")'
```

### Symbol.for_
```
Symbol.for_(name: string)
```

Returns globally-shared symbol for the provided name, creating it in a global registry if it has not yet been accessed. `Symbol.for_` uses a global registry for the lifetime of the lua execution.

## Types

### Symbol

Calling `Symbol.new` returns an object with type `Symbol`.

## License
Licensed under the MIT license ([LICENSE.txt](LICENSE.txt) or http://opensource.org/licenses/MIT).
npm package: @rbxts-js/test-utils
Description: Upstream: https://github.com/jestjs/jest/tree/v28.0.0/packages/test-utils
Latest version: 3.16.0-ts.1

# test-utils

Upstream: https://github.com/jestjs/jest/tree/v28.0.0/packages/test-utils

---

### :pencil2: Notes
npm package: @rbxts/airfoil
Description: Widgeon's modified Sleitnick airfoil module, ported to roblox-ts
Latest version: 1.0.5

# AirFoil

Simple AirFoil simulation; originally made by Sleitnick (Crazyman32), modified By Widgeon, and ported to roblox-ts by InfinityDesign.

This module handles the aerodynamic physics of a single airfoil by constantly calculating the lift and drag forces that act upon the foil.

## Example

```typescript
import { RunService } from "@rbxts/services"
import { Airfoil } from "../Airfoil"

const wing = new AirFoil(part, massOfPlane)

RunService.Heartbeat.Connect(() => {
    wing.Update()
})

// NOTE: airFoil.Update() should be called every "Heartbeat" (RunService.Heartbeat)
```

## Fields
```typescript
airFoil.Part
airFoil.Area
airFoil.FrontalArea
airFoil.VectorForce
airFoil.DragAtZero
airFoil.DragEfficiency
airFoil.MaxForceLift
airFoil.MaxForceDrag
airFoil.LiftCoMultiplier
airFoil.AspectRatio
```

## Methods
```typescript
airFoil.Update()
airFoil.Stop()
airFoil.GetLiftCoefficient(angleOfAttack)
airFoil.GetDragCoefficient(liftCoefficient)
```

## References:
[NASA.gov Modern Lift Equation](https://www.grc.nasa.gov/www/Wright/airplane/lifteq.html)

[NASA.gov Modern Drag Equation](https://www.grc.nasa.gov/www/Wright/airplane/drageq.html)

[NASA.gov Inclination Effects on Lift](https://www.grc.nasa.gov/www/Wright/airplane/incline.html)

["CM32 Modified Fin Module" Roblox model by Widgeon](https://www.roblox.com/library/892419359/CM32-Modified-Fin-Module)
npm package: @rbxts/altmake
Description: Alternative to @rbxts/make to increase Typescript speed.
Latest version: 0.1.5

# Altmake

An alternative to `@rbxts/make` which removes children rebuilding to try to get a bit of a Typescript speedup.
All credits to the author of `@rbxts/make` ([@Validark](https://github.com/Validark)), it's a clever package and a great utility, and there is no reason to switch if you need the children
rebuilding aspect.

There are some notable differences, such as the `Modify` function, which lets you modify an existing instance instead of creating a new one, which can be pretty handy, and letting you pass a single instance instead of an array as the children property if you wish.

Note that the `Modify` function should not be used to modify like one or two properties since it will most likely present a slowdown because of all of the things it does besides `instance.X = Y`.

# Example

```ts
const part = Make('Part', {
	Parent: Workspace,
	Name: "Look at me, I'm a Part!",
    	Touched: (hit) => print(`Get away from me ${hit.Parent ? hit.Parent : hit}!`)
	Children: Make('Part'),
});
```

```ts
Modify(Lighting, {
	Name: 'Not Lighting',
	Ambient: Color3.fromRGB(255, 0, 0),
});
```
npm package: @rbxts/api-dump-fetcher
Description: Fully types MaximumADHD Api-Dump (mostly for plugins)
Author: Catargo
Latest version: 1.0.2

# Api-dump-fetcher

Fully types MaximumADHD Api-Dump (mostly for plugins)

# [NPM](https://www.npmjs.com/package/@rbxts/api-dump-fetcher)

### Start

```bash
#bun
bun add @rbxts/api-dump-fetcher

#npm
npm i @rbxts/api-dump-fetcher
```

Saves api-dump in the plugin and auto updates it.

```ts
interface IGetApiDumpOptions {
	/**doesnt save in the plugin
	 * @default false */
	DontSave?: boolean;
	/**name of the plugin.SetSetting where compressed api dump is going to be saved
	 * @default API_DUMP*/
	SaveName?: string;
	/**name of the plugin.SetSetting where version of the api dump is going to be saved
	 * @default API_DUMP_VERSION*/
	VersionSaveName?: string;
}

export function LoadApiDump(plugin?: Plugin, options?: IGetApiDumpOptions): Promise<void>;
export function GetApiDump(): Promise<ApiDumpTypes.IAPIDump>;
```

## Example usage:

Extracting all classes with propeties that are of type Color3

```ts
import { ApiDumpConstants, GetApiDump, LoadApiDump } from "@rbxts/api-dump-fetcher";

LoadApiDump(plugin); //has to be executed once from the .client.ts or .server.ts

const api_dump = GetApiDump().expect();

const class_properties_map = new Map<string, string[]>();

api_dump.Classes.forEach((value) =>
	value.Members.forEach((member) => {
		if (member.MemberType !== ApiDumpConstants.EMemberMemberType.Property) return;
		if (member.ValueType?.Category !== ApiDumpConstants.EMemberValueTypeCategory.DataType) return;
		if (member.ValueType.Name !== ApiDumpConstants.EMemberValueTypeCategoryDataTypeName.Color3)
			return;
		const properties_list =
			class_properties_map.get(value.Name) ??
			class_properties_map.set(value.Name, []).get(value.Name)!;
		properties_list.push(member.Name);
	}),
);

for (const [classname] of class_properties_map) {
	let superclass = classname;
	while (superclass !== ApiDumpConstants.ROOT_SUPER_CLASS) {
		superclass = api_dump.Classes.find((value) => value.Name === superclass)!.Superclass;
		const properties = class_properties_map.get(superclass);
		if (properties === undefined) continue;
		for (const property_name of class_properties_map.get(superclass)!) {
			class_properties_map.get(classname)!.push(property_name);
		}
	}
}

print(class_properties_map);
```
npm package: @rbxts/asciify
Description: Package to convert UTF-8 to ASCII with minimal loss
Author: Catargo
Latest version: 1.0.3

# ASCIIFY
Package to convert UTF-8 to ASCII with minimal loss

Example usage
```ts
const str = "Hello and Привет";
const ascii_str = Asciify(str); //Hello and Privet;
```



Test:

  Hello World!123 -> Hello World!123
  
   -> 
   
     	
 ->    	
 

  ÀÁÂÃÄÅàáâãäå -> AAAAAAaaaaaa
  
  ÇÈÉÊËçèéêë -> CEEEEceeee
  
  ÌÍÎÏìíîï -> IIIIiiii
  
  ÑÒÓÔÕÖñòóôõö -> NOOOOOnooooo
  
  ÙÚÛÜùúûü -> UUUUuuuu
  
  ÝŸýÿ -> YYyy
  
  ŁłŃńŚśŹźŻż -> LlNnSsZzZz
  
  «»“”‘’–— -> <<>>""''---
  
  ±°©®§¶ -> +-deg(c)(r)SSP
  
  Currency: €£¥¢₩₺₽ -> Currency: EURPSY=C/WLR
  
  αβγδεζηθικλμνξοπρσςτυφχψω -> abgdezethiklmnxoprsstuphkhpso
  
  АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ -> ABVGDEIoZhZIIKLMNOPRSTUFKhTsChShShch'Y'EIuIa
  
  אבגדהוזחטנסעףפץצקרשת -> AbgdhvzHTns`ppTSTSkrSHt
  
  漢字 -> HanZi
  
  日本語 -> RiBenYu
  
  한글 -> hangeul
  
  ⺀⺙⺮⺲ -> ####
  
  😀🤢🎉🚀⭐️❤️🔥 -> #########
  
  ✓∞≠≤≥÷ -> ###<=>=/
  
  Françoise -> Francoise
  
  ßeta -> sseta
  
  ENCYCLOPÆDIA -> ENCYCLOPAEDIA
  
  ça va! mon élève -> ca va! mon eleve
  
  mIxEd CaSe ßÖ -> mIxEd CaSe ssO
  
  Ligatures: ﬁﬂﬃﬄ -> Ligatures: fiflffiffl
  
  ¹²³¼½¾ -> 1231/41/23/4
  
  ①❷➂⓸ -> 1##4
  
  ÅÅ -> AA
  
  ﷺ -> #
  
  ⁵⅞∭∞ -> 57/8##
  
  \u00ef -> \u00ef
  
  \u00C6 -> \u00C6
  
  Daniël Renée François Bjørn in’t Veld -> Daniel Renee Francois Bjorn in't Veld
  
  北京→東京 -> BeiJing-DongJing
npm package: @rbxts/atlas
Description: Atlas is a rbxts library designed to help eliminate the repetitive aspects of Roblox Development.
Author: surfdev7
Latest version: 1.1.4

<p align="center">
	<img src=".github/logo.png" height="180">
	<br>
	Atlas is a rbxts library designed to help eliminate the repetitive aspects of Roblox Development. 
</p>

## Docs
Documentation can be found in the [docs](https://github.com/surfdev7/atlas-ts-npm/tree/main/docs) directory.

## Installation
2) Begin by installing [Roblox-TS](https://roblox-ts.com/).
2) Next, use npm to install Atlas and it's dependencies.
```node
npm install @rbxts/atlas
```

## Usage
Once installation is complete, import packages to get started.
```typescript
import { <module> } from "@rbxts/atlas"
```


## Dependencies
- @rbxts/net (2.1.3) <--- NetMap will fail if not using this version!!
- @rbxts/services
- @rbxts/signal
- @rbxts/string-utils

## Contributing
Want to contribute?

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Written with ❤️️ by @surfdev7.
npm package: @rbxts/atomic-binding
Description: Types for AtomicBinding module
Author: Ivan Leontev
Latest version: 0.8.1

# Atomic Binding

The credit for the original source code goes to [Roblox](https://www.roblox.com).
The contents of this file were taken from [Roblox](https://www.roblox.com)-provided `AtomicBinding` ModuleScript located under the `RbxCharacterSounds` LocalScript, which itself is located in the `StarterPlayerScript` service.

## Basic Usage

Note that there is autocomplete support for alias values.
You should use slash (/) to see the possible paths.

```ts
type Character = Model & {
	Humanoid: Humanoid & {
		Animator: Animator;
	};
	HumanoidRootPart: BasePart;
};

// Notice how we first invoke an empty function.
const bindingFromBase = createAtomicBinding<Character>()({
    animator: "Humanoid/Animator",
    humanoid: "Humanoid",
    rootPart: "HumanoidRootPart",
}, ({ root, animator, humanoid, rootPart }) => {
    // do something with "Animator"
    // do something with "Humanoid"
    // do something with "HumanoidRootPart"

    return () => {
        // Disconnect all "instances" related connections
    };
});

const manifest = createManifest<Character>({
    animator: "Humanoid/Animator",
    humanoid: "Humanoid",
    rootPart: "HumanoidRootPart",
})

const binding = createAtomicBinding(manifest, ({ root, animator, humanoid, rootPart }) => {
    // do something with "Animator"
    // do something with "Humanoid"
    // do something with "HumanoidRootPart"

    return () => {
        // Disconnect all "instances" related connections
    };
})

const character = {} as Character

// some CharacterAdded event handler
binding.bindRoot(character);

// some CharacterRemoving event handler
binding.unbindRoot(character);

binding.destroy();

```

The "getInstanceFromPath" function is quite helpful when we just want to ensure that the instance exists at the provided path.
```ts
type SomeModel = Model & {
    Particles: Folder & {
        Particle1: ParticleEmitter;
        Particle2: ParticleEmitter;
    }
}

const someModel = {} as SomeModel

const particle = getInstanceFromPath(someModel, "Particles/Particle1")
if (!particle) {
    return
}
```

The `waitForInstanceFromPath` function does the same as the `getInstanceFromPath` function, but instead utilizes `WaitForChild` method of the Instance. This means that the return type will never be `undefined`.
npm package: @rbxts/attribute
Description: A small attribute manager for Roblox TS.
Author: typechecked
Latest version: 1.0.0

# @rbxts/attribute
A small attribute manager for Roblox TS.

```ts
import { Attributes } from "@rbxts/attribute"

const MyPart = new Instance("Part")

const AttributeManager = new Attributes(MyPart, {
    Speed: 52
})

AttributeManager.GetAttributeChangedSignal("Speed").Connect((Speed: number) => {
    print(`My new speed is ${Speed}!`)
})
```
npm package: @rbxts/attribute-util
Description: Typed instance attribute helper functions for Roblox.
Author: jackTabsCode
Latest version: 1.0.1

# Attribute Util

Makes dealing with attributes on Roblox instances a bit easier in Typescript.

## Installation

Use npm to install:

```bash
npm install @rbxts/attribute-util
```

## Usage

```ts
interface PartAttributes {
	foo: string
	bar: number
}

const part = new Instance("Part")

// set all the attributes
setAllAttributes<PartAttributes>(part, {
	foo: "hello",
	bar: 42
})

// get all the attributes
const attributes = getAllAttributes<PartAttributes>(part)

// get a singular attribute
const foo = getAttribute<PartAttributes>(part)("foo")

// set a singular attribute
setAttribute<PartAttributes>(part)("foo", "goodbye")

// get a changed signal for a singular attribute
const signal = getAttributeChangedSignal<PartAttributes>(part)
```
npm package: @rbxts/axis
Description: roblox-ts typings for NeonD00m/axis
Author: teakzc
Latest version: 0.2.5

# @rbxts/axis

roblox-ts typings for [axis](https://neond00m.github.io/Axis/)

## Deviations

### Map<T>

```diff
- export type Map<T> = { [any]: any }
+ export type _Map<T> = Map<defined, T> | defined[];
```

### InputConstructor

```diff
- export type InputConstructor = <T>(Map<T> | (Map<T> & { deadzone: number? })) -> Input<T>
+ export type InputConstructor = <T>(keyMap: _Map<T>, deadzone?: number) => Input<T>;
```
### Input Constructor function

```diff
- local function new<T>(inputMap: types.Map<T> & { deadzone: number? }): types.Input<T>
+ local function new<T>(inputMap: types.Map<T>, deadzone: number?): types.Input<T>
    local input: types.Input<T> = {
		vector = false,
		current = {},
		previous = {},
		active = {
			{}, -- separate input axes for each controller
		},
		resets = {}, --resets input on next update
		connections = {},
		inputMap = inputMap,
-       deadzone = inputMap.deadzone
+       deadzone = deadzone,

		read = read,
		pressing = pressing,
		pressed = pressed,
		released = released,
		changed = changed,
		hold = hold,
		map = map,
		update = update,
		move = move,
	}
	map(input, inputMap)

	return input
end
```

## Examples

```ts
input(
	new Map<Enum.KeyCode, Vector3>([
		[Enum.KeyCode.Up, new Vector3(0, 1, 0)],
		[Enum.KeyCode.Down, new Vector3(0, -1, 0)],
		[Enum.KeyCode.Left, new Vector3(-1, 0, 0)],
		[Enum.KeyCode.Right, new Vector3(1, 0, 0)],
	]),
, 1);

input([Enum.KeyCode.W, Enum.KeyCode.A, Enum.KeyCode.S, Enum.KeyCode.D], 1);
```