@radomiej/compiler-types 3.0.9-types.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 roblox-ts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @rbxts/compiler-types

package/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "@radomiej/compiler-types",
+	"version": "3.0.9-types.0",
+	"description": "",
+	"main": "types/core.d.ts",
+	"types": "types/core.d.ts",
+	"scripts": {
+		"eslint": "npx eslint \"types/**/*.d.ts\" --max-warnings 0"
+	},
+	"author": "roblox-ts",
+	"license": "MIT",
+	"files": [
+		"types/*.d.ts"
+	],
+	"devDependencies": {
+		"@rbxts/types": "^1.0.805",
+		"@typescript-eslint/eslint-plugin": "^8.5.0",
+		"@typescript-eslint/parser": "^8.5.0",
+		"eslint": "^8.57.0",
+		"eslint-config-prettier": "^9.1.0",
+		"eslint-plugin-no-autofix": "^2.1.0",
+		"eslint-plugin-prettier": "^5.2.1",
+		"eslint-plugin-simple-import-sort": "^12.1.1",
+		"prettier": "^3.3.3",
+		"typescript": "5.9.3"
+	}
+}

package/types/Array.d.ts

@@ -0,0 +1,280 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+interface ArrayLike<T> {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This field exists to force TypeScript to recognize this as a nominal type
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _nominal_Array: unique symbol;
+
+	/**
+	 * Gets the length of the array. This is one higher than the highest index defined in an array.
+	 */
+	size(): number;
+
+	readonly [n: number]: T;
+}
+
+/** An array object which cannot be written to. */
+interface ReadonlyArray<T> extends ArrayLike<T>, Iterable<T> {
+	/**
+	 * Returns true if empty, otherwise false.
+	 */
+	isEmpty(this: ReadonlyArray<any>): boolean;
+
+	/**
+	 * Adds all the elements of an array separated by the specified separator string.
+	 * @param separator A string used to separate one element of an array from the next in the resulting String. If
+	 * omitted, the array elements are separated with a comma.
+	 */
+	join(this: ReadonlyArray<defined>, separator?: string): string;
+
+	/**
+	 * Moves elements to array a2. Returns the destination table a2.
+	 * @param f The beginning of the specified portion of a1.
+	 * @param e The end of the specified portion of a1.
+	 * @param t The beginning of the specified portion of a2.
+	 * @param a2 The target array.
+	 */
+	move(this: ReadonlyArray<defined>, f: number, e: number, t: number, a2: Array<T>): Array<T>;
+
+	/**
+	 * Moves elements to array a2. Returns the destination table a2. The destination range can overlap with the source
+	 * range.
+	 * @param f The beginning of the specified portion of a1.
+	 * @param e The end of the specified portion of a1.
+	 * @param t The beginning of the specified portion of a2.
+	 * @param a2 The target array, or the current array if unspecified.
+	 */
+	move(this: Array<defined>, f: number, e: number, t: number, a2?: Array<T>): Array<T>;
+
+	/**
+	 * Returns whether an array includes a certain element.
+	 * @param searchElement The element to search for.
+	 * @param fromIndex The position in this array at which to begin searching for searchElement.
+	 */
+	includes(this: ReadonlyArray<defined>, searchElement: T, fromIndex?: number): boolean;
+
+	/**
+	 * Returns the index of the first occurrence of a value in an array, else returns -1.
+	 * @param searchElement The value to locate in the array.
+	 * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at
+	 * index 0.
+	 */
+	indexOf(this: ReadonlyArray<defined>, searchElement: T, fromIndex?: number): number;
+
+	/**
+	 * Returns whether **all** the members of an array satisfy the specified test.
+	 * Returns true for empty Arrays.
+	 * @param callback A function that accepts up to three arguments. The every method calls the callback function for
+	 * each element in array1 until the callback returns false, or until the end of the array.
+	 */
+	every(
+		this: ReadonlyArray<defined>,
+		callback: (value: T, index: number, array: ReadonlyArray<T>) => boolean | undefined,
+	): boolean;
+
+	/**
+	 * Returns whether the specified callback function returns true for any element of an array.
+	 * Returns false for empty Arrays.
+	 * @param callback A function that accepts up to three arguments. The some method calls the callback function for
+	 * each element in array1 until the callback returns true, or until the end of the array.
+	 */
+	some(
+		this: ReadonlyArray<defined>,
+		callback: (value: T, index: number, array: ReadonlyArray<T>) => boolean | undefined,
+	): boolean;
+
+	/**
+	 * Performs the specified action for each element in an array.
+	 * @param callback  A function that accepts up to three arguments. forEach calls the callback function one time for
+	 * each element in the array.
+	 */
+	forEach(this: ReadonlyArray<defined>, callback: (value: T, index: number, array: ReadonlyArray<T>) => void): void;
+
+	/**
+	 * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+	 * @param callback A function that accepts up to three arguments. The map method calls the callback function one
+	 * time for each element in the array.
+	 */
+	map<U>(this: ReadonlyArray<defined>, callback: (value: T, index: number, array: ReadonlyArray<T>) => U): Array<U>;
+
+	/**
+	 * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+	 * Undefined values will not be included, so keep in mind this does not create a 1:1 map.
+	 * @param callback A function that accepts up to three arguments. The map method calls the callback function one
+	 * time for each element in the array.
+	 * @example
+	 * // Gets an Array of all existing characters
+	 * const characters = playerlist.mapFiltered(plr => plr.Character);
+	 */
+	mapFiltered<U>(
+		this: ReadonlyArray<defined>,
+		callback: (value: T, index: number, array: ReadonlyArray<T>) => U,
+	): Array<NonNullable<U>>;
+
+	/**
+	 * Removes all undefined values from the array safely
+	 */
+	filterUndefined(this: ReadonlyArray<T>): Array<NonNullable<T>>;
+
+	/**
+	 * Returns the elements of an array that meet the condition specified in a callback function.
+	 * @param callback A function that accepts up to three arguments. The filter method calls the callback function one
+	 * time for each element in the array.
+	 */
+	filter<S extends T>(
+		this: ReadonlyArray<defined>,
+		callback: (value: T, index: number, array: ReadonlyArray<T>) => value is S,
+	): Array<S>;
+
+	/**
+	 * Returns the elements of an array that meet the condition specified in a callback function.
+	 * @param callback A function that accepts up to three arguments. The filter method calls the callback function one
+	 * time for each element in the array.
+	 */
+	filter(
+		this: ReadonlyArray<defined>,
+		callback: (value: T, index: number, array: ReadonlyArray<T>) => boolean | undefined,
+	): Array<T>;
+
+	/**
+	 * Calls the specified callback function for all the elements in an array. The return value of the callback function
+	 * is the accumulated result, and is provided as an argument in the next call to the callback function.
+	 * @param callback A function that accepts up to four arguments. The reduce method calls the callback function one
+	 * time for each element in the array.
+	 * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The
+	 * first call to the callback function provides this value as an argument instead of an array value.
+	 */
+	reduce(
+		this: ReadonlyArray<defined>,
+		callback: (accumulator: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T,
+	): T;
+
+	/**
+	 * Calls the specified callback function for all the elements in an array. The return value of the callback function
+	 * is the accumulated result, and is provided as an argument in the next call to the callback function.
+	 * @param callback A function that accepts up to four arguments. The reduce method calls the callback function one
+	 * time for each element in the array.
+	 * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The
+	 * first call to the callback function provides this value as an argument instead of an array value.
+	 */
+	reduce<U>(
+		this: ReadonlyArray<defined>,
+		callback: (accumulator: U, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => U,
+		initialValue: U,
+	): U;
+
+	/**
+	 * Returns the value of the first element in the array where predicate is true, and undefined
+	 * otherwise.
+	 * @param predicate find calls predicate once for each element of the array, in ascending
+	 * order, until it finds one where predicate returns true. If such an element is found, find
+	 * immediately returns that element value. Otherwise, find returns undefined.
+	 */
+	find<S extends T>(
+		this: ReadonlyArray<defined>,
+		predicate: (value: T, index: number, obj: ReadonlyArray<T>) => value is S,
+	): S | undefined;
+	find(
+		this: ReadonlyArray<defined>,
+		predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean | undefined,
+	): T | undefined;
+
+	/**
+	 * Returns the index of the first element in the array that satisfies the provided testing function. Otherwise, it
+	 * returns -1, indicating no element passed the test.
+	 * @param predicate findIndex calls predicate once for each element of the array, in ascending
+	 * order, until it finds one where predicate returns true. If such an element is found, find
+	 * immediately returns the index at which it was found. Otherwise, find returns -1.
+	 */
+	findIndex(
+		this: ReadonlyArray<defined>,
+		predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean | undefined,
+	): number;
+}
+
+interface Array<T> extends ReadonlyArray<T> {
+	/**
+	 * Appends new elements to an array and returns the new length of the array.
+	 * @param items New elements of the Array.
+	 */
+	push(this: Array<defined>, ...items: Array<T>): number;
+
+	/**
+	 * Removes the last element from an array and returns it.
+	 */
+	pop(this: Array<defined>): T | undefined;
+
+	/**
+	 * Removes the first element from an array and returns it.
+	 */
+	shift(this: Array<defined>): T | undefined;
+
+	/**
+	 * Inserts new elements at the start of an array and returns the new length of the array.
+	 * @param items  Elements to insert at the start of the Array.
+	 */
+	unshift(this: Array<defined>, ...items: Array<T>): number;
+
+	/**
+	 * Inserts `value` into the array at `index` and shifts array members forwards if needed.
+	 */
+	insert(this: Array<defined>, index: number, value: T): void;
+
+	/**
+	 * Removes the array member at `index` and returns it and shifts array members backwards if needed.
+	 */
+	remove(this: Array<defined>, index: number): T | undefined;
+
+	/**
+	 * Removes a value at `index` from this array, replacing it with the last value in this array and popping the last
+	 * value.
+	 * Returns the value removed from `index` in this way if it exists, otherwise `undefined`.
+	 * @param index The index to remove from this array and return
+	 */
+	unorderedRemove(this: Array<defined>, index: number): T | undefined;
+
+	/**
+	 * Sorts list elements in a given order, in-place, from `list[1]` to `list[#list]`, so that
+	 * (`!comp(list[i+1], list[i])` will be true after the sort). Alias to Lua's `table.sort`.
+	 * @param compareFunction A function that defines the sort order. Returns true when the first element must come
+	 * before the second. If omitted, the array is sorted according to the `<` operator.
+	 */
+	sort(this: Array<defined>, compareFunction?: (a: T, b: T) => boolean): Array<T>;
+
+	/** Deletes all values in the Array */
+	clear(this: Array<T>): void;
+
+	[n: number]: T;
+}
+
+interface ArrayConstructor {
+	/** Instantiates a new empty array. */
+	new <T>(): Array<T>;
+
+	/**
+	 * Instantiates a new preallocated array.
+	 * If `length` is provided, there will be allocated `length` amount of nil's into the new array.
+	 * If `value` is provided, instead of nil, the value will be allocated instead.
+	 *
+	 * This is the same as `table.create` in Lua.
+	 *
+	 * @param length The length of the array to allocate
+	 * @param value The value that the array will be filled with (amount based on `length`)
+	 */
+	new <T>(length: number): Array<T>;
+	new <T>(length: number, value: T): Array<T>;
+}
+
+declare const Array: ArrayConstructor;
+
+interface TemplateStringsArray extends Array<string> {}
+
+type ReadVoxelsArray<T> = Array<Array<Array<T>>> & {
+	Size: Vector3;
+};

package/types/Iterable.d.ts

@@ -0,0 +1,53 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+type IteratorResult<Yields, Returns = void> = IteratorYieldResult<Yields> | IteratorReturnResult<Returns>;
+
+interface IteratorYieldResult<Yields> {
+	done: false;
+	value: Yields;
+}
+
+interface IteratorReturnResult<Returns> {
+	done: true;
+	value: Returns;
+}
+
+interface Iterator<Yields, Returns = void, Next = undefined> {
+	// Takes either 0 or 1 arguments - doesn't accept 'undefined'
+	next: (...args: [] | [Next]) => IteratorResult<Yields, Returns>;
+}
+
+interface AsyncIterator<Yields, Returns = any, Next = undefined> {
+	next: (...args: [] | [Next]) => Promise<IteratorResult<Yields, Returns>>;
+}
+
+interface Generator<Yields = unknown, Returns = void, Next = unknown> extends Iterator<Yields, Returns, Next> {
+	next: (...args: [] | [Next]) => IteratorResult<Yields, Returns>;
+	[Symbol.iterator](): Generator<Yields, Returns, Next>;
+}
+
+interface AsyncGenerator<Yields = unknown, Returns = any, Next = unknown> extends AsyncIterator<Yields, Returns, Next> {
+	next: (...args: [] | [Next]) => Promise<IteratorResult<Yields, Returns>>;
+	[Symbol.asyncIterator](): AsyncGenerator<Yields, Returns, Next>;
+}
+
+interface AsyncIterable<T> {
+	[Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+interface Iterable<T> {
+	[Symbol.iterator](): Iterator<T>;
+}
+
+interface AsyncIterableIterator<T> extends AsyncIterator<T> {
+	[Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+
+interface IterableIterator<T> extends Iterator<T> {
+	[Symbol.iterator](): IterableIterator<T>;
+}
+
+interface IterableFunction<T> extends Iterable<T> {
+	(): T;
+}

package/types/Map.d.ts

@@ -0,0 +1,126 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+/**
+ * A Map object which cannot be written to. The Map object holds key-value pairs but doesn't remember the original insertion order of the keys (like JS would). Any value (both objects and primitive values) may be used as either a key or a value.
+ * Maps are the best choice for dynamic indexing/newindexing, whereas Objects are better for explicit indexing.
+ * @example
+ * // ReadonlyMaps are particularly useful for defining readonly-associations with non-numeric, non-string keys.
+ * new ReadonlyMap<Enum.HumanoidRigType, () => void>([
+ * 	[Enum.HumanoidRigType.R6, () => {}],
+ * 	[Enum.HumanoidRigType.R15, () => {}],
+ * ]);
+ * // Do not use Maps when you can easily index from an object:
+ *
+ * // TS doesn't assume "x" | "y" are the only possible fields.
+ * // You could manually type this as ReadonlyMap<"x" | "y", number>
+ * const point = new ReadonlyMap([["x", 5], ["y", 10]]);
+ * // this is typed as possibly undefined, which isn't ideal
+ * print(point.get("x"));
+ *
+ * // Instead use an object
+ * const point = { x: 5, y: 10 } as const;
+ * print(point.x);
+ */
+interface ReadonlyMap<K, V> extends Iterable<[K, V]> {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This field exists to force TypeScript to recognize this as a nominal type
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _nominal_Map: unique symbol;
+
+	/**
+	 * Returns true if empty, otherwise false.
+	 */
+	isEmpty(this: ReadonlyMap<K, V>): boolean;
+
+	/**
+	 * Performs the specified action for each (element / pair of elements) in the Map
+	 * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time
+	 * for each (element / pair of elements) in the array.
+	 */
+	forEach(this: ReadonlyMap<K, V>, callbackfn: (value: V, key: K, self: this) => void): void;
+
+	/**
+	 * Returns the number of elements in the Map
+	 */
+	size(this: ReadonlyMap<K, V>): number;
+
+	/**
+	 * Returns a boolean for whether the given key exists in the Map
+	 */
+	has(this: ReadonlyMap<K, V>, key: K): boolean;
+
+	/**
+	 * Returns the value associated with the given key
+	 */
+	get(this: ReadonlyMap<K, V>, key: K): V | undefined;
+}
+
+interface ReadonlyMapConstructor {
+	new <K, V>(): ReadonlyMap<K, V>;
+	new <K, V>(entries: ReadonlyArray<readonly [K, V]>): ReadonlyMap<K, V>;
+}
+declare const ReadonlyMap: ReadonlyMapConstructor;
+
+/**
+ * The Map object holds key-value pairs but doesn't remember the original insertion order of the keys (like JS would). Any value (both objects and primitive values) may be used as either a key or a value.
+ * Maps are the best choice for dynamic indexing/newindexing, whereas Objects are better for explicit indexing.
+ * @example
+ * const playerData = new Map<Player, PlayerData>();
+ *
+ * function f(plr: Player) {
+ * 	const data = playerData.get(plr); // `data` could be undefined
+ * 	if (data) { // check to make sure `data` is defined
+ * 		print(`${plr.Name} has ${data.NumItems} item${data.NumItems === 1 ? "" : "s"}`);
+ * 	}
+ * }
+ * // Do not use Maps when you can easily explicitly index from an object:
+ *
+ * // TS doesn't assume "x" | "y" are the only possible fields.
+ * // You could manually type this as Map<"x" | "y", number>
+ * const point = new Map([["x", 5], ["y", 10]]);
+ * // this is typed as possibly undefined, because "x" can be deleted
+ * print(point.get("x"));
+ *
+ * // Instead use an object
+ * const point = { x: 5, y: 10 };
+ * print(point.y++);
+ * point.z = 15 // error!
+ */
+interface Map<K, V> extends ReadonlyMap<K, V> {
+	/**
+	 * Associates a key with a value which can be accessed later by `Map.get`
+	 */
+	set(this: Map<K, V>, key: K, value: V): this;
+
+	/**
+	 * Deletes the given key from the Map.
+	 *
+	 * Returns a boolean indicating whether or not a value was removed.
+	 */
+	delete(this: Map<K, V>, key: K): boolean;
+
+	/**
+	 * Deletes all members of the Map
+	 */
+	clear(this: Map<K, V>): void;
+}
+
+interface MapConstructor {
+	new <K, V>(): Map<K, V>;
+	new <K, V>(entries: ReadonlyArray<readonly [K, V]>): Map<K, V>;
+}
+declare const Map: MapConstructor;
+
+/** A Map object with its `__mode` metamethod set to "k" */
+interface WeakMap<K extends object, V> extends Map<K, V> {}
+
+interface WeakMapConstructor {
+	new <K extends object, V>(): WeakMap<K, V>;
+	new <K extends object, V>(entries: ReadonlyArray<readonly [K, V]>): WeakMap<K, V>;
+}
+declare const WeakMap: WeakMapConstructor;