@tolokoban/tgd
Version:
ToloGameDev library for WebGL2
107 lines • 5.73 kB
TypeScript
export declare function isObject(data: unknown): data is Record<string, unknown>;
export declare function isString(data: unknown): data is string;
export declare function isNumber(data: unknown): data is number;
export declare function isNull(data: unknown): data is null;
export declare function isFunction(data: unknown): data is () => unknown;
export declare function isUndefined(data: unknown): data is undefined;
export declare function isBoolean(data: unknown): data is boolean;
export declare function isArrayBuffer(data: unknown): data is ArrayBuffer;
export declare function isArrayBufferView(data: unknown): data is ArrayBufferView;
export declare function isBufferSource(data: unknown): data is BufferSource;
export declare function isStringArray(data: unknown): data is string[];
export declare function assertNumber(data: unknown, name?: string): asserts data is number;
export declare function assertString(data: unknown, name?: string): asserts data is string;
export declare function assertOptionalString(data: unknown, name?: string): asserts data is string | undefined;
export declare function assertBoolean(data: unknown, name?: string): asserts data is boolean;
export declare function assertObject(data: unknown, name?: string): asserts data is Record<string, unknown>;
export declare function assertArray(data: unknown, name?: string): asserts data is unknown[];
export declare function assertArrayBuffer(data: unknown, name?: string): asserts data is ArrayBuffer;
export declare function assertOptionalArrayBuffer(data: unknown, name?: string): asserts data is ArrayBuffer | undefined;
export type TypeDefFunction = (data: unknown) => boolean;
export type TypeDefArray = ["array", TypeDef] | ["array", TypeDef, number] | ["array", TypeDef, {
min?: number;
max?: number;
}];
export type TypeDef = (() => TypeDef) | "boolean" | "function" | "null" | "number" | "string" | "undefined" | "unknown" | ["custom", TypeDefFunction] | ["number", {
min?: number;
max?: number;
}] | ["|", ...TypeDef[]] | ["?", TypeDef] | TypeDefArray | ["map", TypeDef] | ["tuple", ...TypeDef[]] | ["tuple...", ...TypeDef[], TypeDef] | ["literal", ...string[]] | ["partial", {
[name: string]: TypeDef;
}] | {
[name: string]: TypeDef;
};
type RealType<T extends TypeDef> = T extends "boolean" ? boolean : T extends "function" ? () => unknown : T extends "null" ? null : T extends "number" ? number : T extends "string" ? string : T extends "undefined" ? undefined : T extends "unknown" ? unknown : T extends ["?", TypeDef] ? RealType<T[1]> | undefined : T extends ["tuple", TypeDef] ? Array<RealType<T[1]>> : T extends ["array", TypeDef] ? Array<RealType<T[1]>> : T extends {
[name: string]: TypeDef;
} ? {
[key in keyof T]: RealType<T[key]>;
} : T extends ["partial", {
[name: string]: TypeDef;
}] ? Partial<{
[key in keyof T[1]]: RealType<T[1][key]>;
}> : T extends ["map", TypeDef] ? Record<string, RealType<T[1]>> : T extends ["literal", ...string[]] ? NonNullable<T[1] | T[2] | T[3] | T[4] | T[5] | T[6] | T[7] | T[8] | T[9] | T[10] | T[11] | T[12] | T[13] | T[14] | T[15] | T[16] | T[17] | T[18] | T[19] | T[20]> : unknown;
export declare function isType<T extends TypeDef>(data: unknown, type: T, logErrors?: string | null): data is RealType<T>;
export declare function isType$<T>(data: unknown, type: TypeDef, logErrors?: string | null): data is T;
export declare function assertType<T extends TypeDef>(data: unknown, type: T, prefix?: string): asserts data is RealType<T>;
export declare function assertType$<T>(data: unknown, type: TypeDef, prefix?: string): asserts data is T;
/**
* Basically, this function checks a `data` against a `type` and returns a `defaultValue`
* if `data` is not of the expected type.
*
* But if the `defaultValue` is a function returning the expected `type`, then `ensureType`
* can be use to update old data that you have retrieved from local storage, for example.
*
* @example
* ```
* interface Complex { r: number, i: number }
* const complex = ensureType<Complex>(data, {r: "number", i: "number"}, { r: 1, i: 0 })
* ```
*
* @example
* ```
* interpace PersonVersion1 {
* name: string
* female: boolean
* }
* interpace PersonVersion2 {
* name: string
* gender: "male" | "female" | "nonbinary" | "unknown"
* }
*
* const data = JSON.parse(LocalStorate.getItem("person") ?? "null")
* const TypePersonVersion1 = {
* name: "string",
* female: "boolean"
* }
* const TypePersonVersion2 = {
* name: "string",
* gender: ["literal", "male", "female", "nonbinary", "unknown"]
* }
* const person = ensureType<PersonVersion2>(
* data,
* TypePersonVersion2,
* (value: unknown) => {
* if (isType<PersonVersion2>(value, TypePersonVersion2)) {
* return value
* }
* if (isType<PersonVersion1>(value, TypePersonVersion1)) {
* return {
* name: value.name,
* gender: value.female === true ? "female" : "unknown"
* }
* }
* return { name: "Anonymous", gender: "unknown" }
* }
* )
* ```
*
* @param data Value with unknown type.
* @param type The type to check against.
* @param defaultValue If the type doesn't check, we can return `defaultValue`, or call it if this is a function.
* @returns A value that is of the expected type.
*/
export declare function ensureType<T>(data: unknown, type: TypeDef, defaultValue: T | ((v: unknown) => T)): T;
export declare function ensureBoolean(data: unknown, defaultValue: boolean): boolean;
export declare function ensureNumber(data: unknown, defaultValue: number): number;
export declare function ensureString(data: unknown, defaultValue: string): string;
export {};
//# sourceMappingURL=guards.d.ts.map