@radomiej/compiler-types 3.0.9-types.0

package/types/Set.d.ts

@@ -0,0 +1,74 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+interface ReadonlySet<T> extends Iterable<T> {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This field exists to force TypeScript to recognize this as a nominal type
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _nominal_Set: unique symbol;
+
+	/**
+	 * Returns true if empty, otherwise false.
+	 */
+	isEmpty(this: ReadonlySet<T>): boolean;
+
+	/**
+	 * Performs the specified action for each (element / pair of elements) in the set
+	 * @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: ReadonlySet<T>, callbackfn: (value: T, value2: T, self: ReadonlySet<T>) => void): void;
+
+	/**
+	 * Returns the number of elements in the set
+	 */
+	size(this: ReadonlySet<T>): number;
+
+	/**
+	 * Returns a boolean for whether the given key exists in the set
+	 */
+	has(this: ReadonlySet<T>, value: T): boolean;
+}
+
+interface ReadonlySetConstructor {
+	new <T>(): ReadonlySet<T>;
+	new <T>(values: ReadonlyArray<T>): ReadonlySet<T>;
+}
+declare const ReadonlySet: ReadonlySetConstructor;
+
+interface Set<T> extends ReadonlySet<T> {
+	/**
+	 * Adds a value to the set
+	 */
+	add(this: Set<T>, value: T): this;
+
+	/**
+	 * Deletes the given key from the set.
+	 *
+	 * Returns a boolean indicating whether or not a value was removed.
+	 */
+	delete(this: Set<T>, value: T): boolean;
+
+	/**
+	 * Deletes all members of the set.
+	 */
+	clear(this: Set<T>): void;
+}
+
+interface SetConstructor {
+	new <T>(): Set<T>;
+	new <T>(values: ReadonlyArray<T>): Set<T>;
+}
+declare const Set: SetConstructor;
+
+/** A Set object with its `__mode` metamethod set to "k" */
+interface WeakSet<T extends object> extends Set<T> {}
+
+interface WeakSetConstructor {
+	new <T extends object>(): WeakSet<T>;
+	new <T extends object>(values: ReadonlyArray<T>): WeakSet<T>;
+}
+declare const WeakSet: WeakSetConstructor;

package/types/SharedTable.d.ts

@@ -0,0 +1,4 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+interface SharedTable extends Iterable<[string | number, SharedTableValue]> {}

package/types/String.d.ts

@@ -0,0 +1,16 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+interface String extends Iterable<string> {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This field exists to force TypeScript to recognize this as a nominal type
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _nominal_String: unique symbol;
+
+	/** The current number of characters in the string. */
+	size(this: string): number;
+}

package/types/Symbol.d.ts

@@ -0,0 +1,19 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+interface Symbol {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This field exists to force TypeScript to recognize this as a nominal type
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _nominal_Symbol: unique symbol;
+}
+
+interface SymbolConstructor {
+	readonly iterator: symbol;
+	readonly asyncIterator: symbol;
+}
+declare const Symbol: SymbolConstructor;

package/types/callMacros.d.ts

@@ -0,0 +1,88 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+/** Throws an error if the provided value is false or nil. */
+declare function assert<T>(condition: T, message?: string): asserts condition;
+
+/**
+ * Returns the type of the given object as a string. This function works similarly to Lua’s native type function, with
+ * the exceptions that Roblox-defined data types like Vector3 and CFrame return their respective data types as strings.
+ */
+declare function typeOf(value: any): keyof CheckableTypes;
+
+/**
+ * Returns true if `typeof(value) == type`, otherwise false.
+ * This function allows for type narrowing. i.e.
+ * ```
+ * // v is unknown
+ * if (typeIs(v, "Vector3")) {
+ * 	// v is a Vector3
+ * 	print(v.X, v.Y, v.Z);
+ * }
+ * ```
+ */
+declare function typeIs<T extends keyof CheckableTypes>(value: any, type: T): value is CheckableTypes[T];
+
+/**
+ * Returns true if `instance.ClassName == className`, otherwise false.
+ */
+declare function classIs<T extends keyof Instances>(instance: Instance, className: T): instance is Instances[T];
+
+/**
+ * Returns the passed argument. This function is a macro that compiles to just `arg`.
+ *
+ * This is useful for ensuring that a value matches the given type in areas where it is not directly possible to do so.
+ * @example
+ * type P = { x: number, y: number };
+ * const obj = {
+ *   pos: identity<P>({ x: 5, y: 10 });
+ * }
+ */
+declare function identity<T>(arg: T): T;
+
+/**
+ * **Only valid as the expression of a for-of loop!**
+ *
+ * Used to compile directly to normal Lua numeric for loops. For example,
+ * ```ts
+ * for (const i of $range(1, 10)) {
+ * 	print(i);
+ * }
+ * ```
+ * will compile into
+ * ```lua
+ * for i = 1, 10 do
+ * 	print(i)
+ * end
+ * ```
+ *
+ * The `step` argument controls the amount incremented per loop. It defaults to `1`.
+ */
+declare function $range(start: number, finish: number, step?: number): Iterable<number>;
+
+/**
+ * **Only valid as the expression of a return statement!**
+ *
+ * Compiles directly to a multiple return in Lua. For example,
+ * ```ts
+ * return $tuple(123, "abc", true);
+ * ```
+ * will compile into
+ * ```lua
+ * return 123, "abc", true
+ * ```
+ */
+declare function $tuple<T extends Array<any>>(...values: T): LuaTuple<T>;
+
+/**
+ * Provides the instance tree representation to `path` at runtime.
+ *
+ * ```ts
+ * $getModuleTree("@rbxts/services");
+ * ```
+ * will, assuming the default rojo game project, compile into
+ * ```lua
+ * { game:GetService("ReplicatedStorage"), { "rbxts_include", "node_modules", "@rbxts", "services" } }
+ * ```
+ */
+declare function $getModuleTree(module: string): [root: Instance, parts: Array<string>];

package/types/core.d.ts

@@ -0,0 +1,157 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+/// <reference path="Array.d.ts" />
+/// <reference path="callMacros.d.ts" />
+/// <reference path="Iterable.d.ts" />
+/// <reference path="Map.d.ts" />
+/// <reference path="Promise.d.ts" />
+/// <reference path="Set.d.ts" />
+/// <reference path="SharedTable.d.ts" />
+/// <reference path="String.d.ts" />
+/// <reference path="Symbol.d.ts" />
+/// <reference path="typeUtils.d.ts" />
+/// <reference path="eslintIgnore.d.ts" />
+
+/**
+ * **DO NOT USE!**
+ *
+ * This type only exists because TypeScript requires it!
+ *
+ * **Use `boolean` instead!**
+ */
+interface Boolean {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This field exists to force TypeScript to recognize this as a nominal type
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _nominal_Boolean: unique symbol;
+}
+
+/**
+ * **DO NOT USE!**
+ *
+ * This type only exists because TypeScript requires it!
+ * @hidden
+ * @deprecated
+ */
+interface IArguments {}
+
+/**
+ * **DO NOT USE!**
+ *
+ * This type only exists because TypeScript requires it!
+ *
+ * **Use `number` instead!**
+ */
+interface Number {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This field exists to force TypeScript to recognize this as a nominal type
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _nominal_Number: unique symbol;
+}
+
+/**
+ * **DO NOT USE!**
+ *
+ * This type only exists because TypeScript requires it!
+ *
+ * **Use `object` instead!**
+ * @hidden
+ * @deprecated
+ */
+interface Object {}
+
+/**
+ * **DO NOT USE!**
+ *
+ * This type only exists because TypeScript requires it!
+ * @hidden
+ * @deprecated
+ */
+interface RegExp {}
+
+/**
+ * **DO NOT USE!**
+ *
+ * This type only exists because TypeScript requires it!
+ *
+ * **Use `Callback` instead!**
+ *
+ * For example,`(a: string, b: number) => boolean` represents a function that takes a `string` and a `number` and
+ * returns a `boolean`.
+ *
+ * More generally, `(a: A, b: B, c: C) => R`, where `A`, `B`, and `C` are different function argument types and `R` is
+ * the return type.
+ *
+ * You can use `void` as a return type for functions that do not return anything: `() => void`
+ * @hidden
+ * @deprecated
+ */
+interface Function {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This type only exists because TypeScript requires it!
+	 * @hidden
+	 * @deprecated
+	 */
+	prototype: never;
+}
+
+/**
+ * **DO NOT USE!**
+ *
+ * **Use `Callback` instead!**
+ *
+ * This type only exists because TypeScript requires it!
+ * @hidden
+ * @deprecated
+ */
+interface CallableFunction extends Function {}
+
+/**
+ * **DO NOT USE!**
+ *
+ * **Use `Callback` instead!**
+ *
+ * This type only exists because TypeScript requires it!
+ * @hidden
+ * @deprecated
+ */
+interface NewableFunction extends Function {}
+
+/** unknown - undefined = defined */
+type defined = {};
+
+/** Marker for contextual 'this' type */
+interface ThisType<T> {}
+
+/** A function type which is assignable to any other function type (and any function is assignable to). */
+type Callback = (...args: Array<any>) => any;
+
+type LuaTuple<T extends Array<any>> = T & {
+	/**
+	 * **DO NOT USE!**
+	 *
+	 * This field exists to force TypeScript to recognize this as a nominal type
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _nominal_LuaTuple: unique symbol;
+};
+
+interface TypedPropertyDescriptor<T> {
+	value: (self: InferThis<T>, ...parameters: Parameters<T>) => ReturnType<T>;
+}
+
+/**
+ * Marker for non-inference type position
+ */
+type NoInfer<T> = intrinsic;

package/types/eslintIgnore.d.ts

@@ -0,0 +1,16 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+// prettier crashes with `intrinsic` keyword
+
+/** Convert string literal type to uppercase */
+type Uppercase<S extends string> = intrinsic;
+
+/** Convert string literal type to lowercase */
+type Lowercase<S extends string> = intrinsic;
+
+/** Convert first character of string literal type to uppercase */
+type Capitalize<S extends string> = intrinsic;
+
+/** Convert first character of string literal type to lowercase */
+type Uncapitalize<S extends string> = intrinsic;

package/types/typeUtils.d.ts

@@ -0,0 +1,126 @@
+/// <reference no-default-lib="true"/>
+/// <reference types="@rbxts/types"/>
+
+/** Placeholder that sometimes helps force TS to display what you want it to. */
+type _<T> = T;
+
+/** Make all properties in T optional */
+type Partial<T> = { [P in keyof T]?: T[P] };
+
+/** Make all properties in T required */
+type Required<T> = { [P in keyof T]-?: T[P] };
+
+/** Make all properties in T readonly */
+type Readonly<T> = { readonly [P in keyof T]: T[P] };
+
+/** Make all properties in T non-readonly. */
+type Writable<T> = { -readonly [P in keyof T]: T[P] };
+
+/** From T pick a set of properties K */
+type Pick<T, K extends keyof T> = { [P in K]: T[P] };
+
+/** Returns a subset of type T which excludes properties K */
+type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+
+/** Construct a type with a set of properties K of type T */
+type Record<K extends keyof any, T> = { [P in K]: T };
+
+/** Exclude from T those types that are assignable to U */
+type Exclude<T, U> = T extends U ? never : T;
+
+/** Extract from T those types that are assignable to U */
+type Extract<T, U> = T extends U ? T : never;
+
+/** Returns a union of all the keys of T whose values extend from U */
+type ExtractKeys<T, U> = { [K in keyof T]-?: T[K] extends U ? K : never }[keyof T];
+
+/** Returns a new object type of all the keys of T whose values extend from U */
+type ExtractMembers<T, U> = Pick<T, ExtractKeys<T, U>>;
+
+/** Returns a union of all the keys of T whose values do not extend from U */
+type ExcludeKeys<T, U> = { [K in keyof T]-?: T[K] extends U ? never : K }[keyof T];
+
+/** Returns a new object type of all the keys of T whose values do not extend from U */
+type ExcludeMembers<T, U> = Pick<T, ExcludeKeys<T, U>>;
+
+/** Exclude null and undefined from T */
+type NonNullable<T> = T & {};
+
+/** Obtain the parameters of a function type in a `tuple | never`. */
+type Parameters<T> = T extends (...args: infer P) => any ? P : never;
+
+/** Obtain the parameters of a constructor function type in a `tuple | never` */
+type ConstructorParameters<T extends new (...args: any) => any> = T extends new (...args: infer P) => any ? P : never;
+
+/** Obtain the return type of a function type */
+type ReturnType<T> = T extends (...args: Array<any>) => infer R ? R : never;
+
+/** Returns the type of `this` for a given function type */
+type InferThis<T> = T extends (this: infer U, ...parameters: Array<any>) => any ? U : never;
+
+/** Obtain the return type of a constructor function type */
+type InstanceType<T> = T extends new (...args: Array<any>) => infer R ? R : never;
+
+/** Combines a series of intersections into one object, e.g. { x: number } & { y: number } becomes { x: number, y: number } */
+type Reconstruct<T> = _<{ [K in keyof T]: T[K] }>;
+
+/** Converts a series of object unions to a series of intersections, e.g. A | B becomes A & B */
+type UnionToIntersection<T> = (T extends object ? (k: T) => void : never) extends (k: infer U) => void ? U : never;
+
+/** Extracts the type of the 'this' parameter of a function type, or 'unknown' if the function type has no 'this' parameter. */
+type ThisParameterType<T> = T extends (this: infer U, ...args: Array<any>) => any ? U : unknown;
+
+/** Removes the 'this' parameter from a function type. */
+type OmitThisParameter<T> =
+	unknown extends ThisParameterType<T> ? T : T extends (...args: infer A) => infer R ? (...args: A) => R : T;
+
+/** Given an object `T`, returns a unioned type of all non-readonly property names. */
+type WritablePropertyNames<T> = {
+	[K in keyof T]-?: T[K] extends Callback
+		? never
+		: (<F>() => F extends { [Q in K]: T[K] } ? 1 : 2) extends <F>() => F extends {
+					-readonly [Q in K]: T[K];
+			  }
+					? 1
+					: 2
+			? K
+			: never;
+}[keyof T];
+
+/** Given an object `T`, returns an object with readonly fields filtered out. */
+type WritableProperties<T> = Pick<T, WritablePropertyNames<T>>;
+
+/** Given an Instance `T`, returns a unioned type of all property names. */
+type InstancePropertyNames<T extends Instance> = Exclude<
+	ExcludeKeys<T, RBXScriptSignal | Callback | symbol>,
+	"Changed"
+>;
+
+/** Given an Instance `T`, returns a unioned type of all method names. */
+type InstanceMethodNames<T extends Instance> = ExtractKeys<T, Callback>;
+
+/** Given an Instance `T`, returns a unioned type of all event names. */
+type InstanceEventNames<T extends Instance> = ExtractKeys<T, RBXScriptSignal>;
+
+/** Given an Instance `T`, returns an object with only properties. */
+type InstanceProperties<T extends Instance> = Pick<T, InstancePropertyNames<T>>;
+
+/** Given an Instance `T`, returns an object with only methods. */
+type InstanceMethods<T extends Instance> = Pick<T, InstanceMethodNames<T>>;
+
+/** Given an Instance `T`, returns an object with only events. */
+type InstanceEvents<T extends Instance> = Pick<T, InstanceEventNames<T>>;
+
+/** Given an Instance `T`, returns an object with readonly fields, methods, and events filtered out. */
+type WritableInstanceProperties<T extends Instance> = WritableProperties<InstanceProperties<T>>;
+
+/** Returns a union of all the keys of T which do not start with `_nominal_` */
+type ExcludeNominalKeys<T> = {
+	[K in keyof T]-?: K extends `_nominal_${infer _U}` ? never : K;
+}[keyof T];
+
+/** Returns a new object type of all the keys of T which do not start with `_nominal_` */
+type ExcludeNominalMembers<T> = Pick<T, ExcludeNominalKeys<T>>;
+
+/** Unwraps a Promise<T> */
+type Awaited<T> = T extends PromiseLike<infer U> ? U : T;