lib0 0.2.109 → 0.2.111

package/schema.d.ts

@@ -0,0 +1,317 @@
+/**
+ * @template T
+ */
+export class $Schema<T> {
+    /**
+     * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
+     * Schema. Validate will check the structure of the parameter and return true iff the instance
+     * really is an instance of Schema.
+     *
+     * @param {T} o
+     * @return {boolean}
+     */
+    validate(o: T): boolean;
+    /**
+     * Similar to validate, but this method accepts untyped parameters.
+     *
+     * @param {any} _o
+     * @return {_o is T}
+     */
+    check(_o: any): _o is T;
+    /**
+     * @type {$Schema<T?>}
+     */
+    get nullable(): $Schema<T | null>;
+    /**
+     * @type {$Schema<T|undefined>}
+     */
+    get optional(): $Schema<T | undefined>;
+    /**
+     * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
+     * Use this if you know that the type is of a specific type and you just want to convince the type
+     * system.
+     *
+     * **Do not rely on these error messages!**
+     * Performs an assertion check only if not in a production environment.
+     *
+     * @param {any} o
+     * @return {o extends T ? T : never}
+     */
+    cast(o: any): any extends T ? T : never;
+    /**
+     * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
+     * Use this if you know that the type is of a specific type and you just want to convince the type
+     * system.
+     *
+     * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).ensure((n) => n + 1)`
+     *
+     * **Do not rely on these error messages!**
+     * Performs an assertion check if not in a production environment.
+     *
+     * @param {T} o
+     * @return {o extends T ? T : never}
+     */
+    ensure(o: T): T extends T ? T : never;
+    get [schemaSymbol](): boolean;
+}
+/**
+ * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} C
+ * @extends {$Schema<C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)>}
+ */
+export class $ConstructedBy<C extends (new (...args: any[]) => any) | ((...args: any[]) => any)> extends $Schema<C extends (...args: any[]) => infer T ? T : C extends new (...args: any[]) => any ? InstanceType<C> : never> {
+    /**
+     * @param {C} c
+     */
+    constructor(c: C);
+    v: C;
+    /**
+     * @param {any} o
+     * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
+     */
+    check(o: any): o is C extends (...args: any[]) => infer T_1 ? T_1 : C extends new (...args: any[]) => any ? InstanceType<C> : never;
+}
+export function constructedBy<C extends (new (...args: any[]) => any) | ((...args: any[]) => any)>(c: C): $Schema<C extends (...args: any[]) => infer T ? T : C extends new (...args: any[]) => any ? InstanceType<C> : never>;
+/**
+ * @template {LiteralType} T
+ * @extends {$Schema<T>}
+ */
+export class $Literal<T extends LiteralType> extends $Schema<T> {
+    /**
+     * @param {Array<T>} literals
+     */
+    constructor(literals: Array<T>);
+    v: T[];
+}
+export function literal<T extends LiteralType[]>(...literals: T): $Schema<T[number]>;
+/**
+ * @template {{[key:string|symbol|number]: $Schema<any>}} S
+ * @extends {$Schema<{ [Key in keyof S]: S[Key] extends $Schema<infer Type> ? Type : never }>}
+ */
+export class $Object<S extends {
+    [key: string]: $Schema<any>;
+    [key: number]: $Schema<any>;
+    [key: symbol]: $Schema<any>;
+}> extends $Schema<{ [Key in keyof S]: S[Key] extends $Schema<infer Type> ? Type : never; }> {
+    /**
+     * @param {S} v
+     */
+    constructor(v: S);
+    v: S;
+    /**
+     * @param {any} o
+     * @return {o is { [K in keyof S]: S[K] extends $Schema<infer Type> ? Type : never }}
+     */
+    check(o: any): o is { [K in keyof S]: S[K] extends $Schema<infer Type_1> ? Type_1 : never; };
+}
+export function object<T extends {
+    [key: string]: $Schema<any>;
+    [key: number]: $Schema<any>;
+    [key: symbol]: $Schema<any>;
+}>(def: T): $Schema<{ [Key in keyof T]: T[Key] extends $Schema<infer Type> ? Type : never; }>;
+/**
+ * @template {$Schema<string|number|symbol>} Keys
+ * @template {$Schema<any>} Values
+ * @extends {$Schema<Record<Keys extends $Schema<infer K> ? K : never,Values extends $Schema<infer T> ? T : never>>}
+ */
+export class $Record<Keys extends $Schema<string | number | symbol>, Values extends $Schema<any>> extends $Schema<Record<Keys extends $Schema<infer K> ? K : never, Values extends $Schema<infer T> ? T : never>> {
+    /**
+     * @param {Keys} keys
+     * @param {Values} values
+     */
+    constructor(keys: Keys, values: Values);
+    keys: Keys;
+    values: Values;
+    /**
+     * @param {any} o
+     * @return {o is Record<Keys extends $Schema<infer K> ? K : never,Values extends $Schema<infer T> ? T : never>}
+     */
+    check(o: any): o is Record<Keys extends $Schema<infer K_1> ? K_1 : never, Values extends $Schema<infer T_1> ? T_1 : never>;
+}
+export function record<Keys extends $Schema<string | number | symbol>, Values extends $Schema<any>>(keys: Keys, values: Values): $Schema<Record<Keys extends $Schema<infer K> ? K : never, Values extends $Schema<infer T> ? T : never>>;
+/**
+ * @template {$Schema<any>[]} S
+ * @extends {$Schema<{ [Key in keyof S]: S[Key] extends $Schema<infer Type> ? Type : never }>}
+ */
+export class $Tuple<S extends $Schema<any>[]> extends $Schema<{ [Key in keyof S]: S[Key] extends $Schema<infer Type> ? Type : never; }> {
+    /**
+     * @param {S} v
+     */
+    constructor(v: S);
+    v: S;
+    /**
+     * @param {any} o
+     * @return {o is { [K in keyof S]: S[K] extends $Schema<infer Type> ? Type : never }}
+     */
+    check(o: any): o is { [K in keyof S]: S[K] extends $Schema<infer Type_1> ? Type_1 : never; };
+}
+export function tuple<T extends $Schema<any>[]>(...def: T): $Schema<{ [Key in keyof T]: T[Key] extends $Schema<infer Type> ? Type : never; }>;
+/**
+ * @template {$Schema<any>} S
+ * @extends {$Schema<Array<S extends $Schema<infer T> ? T : never>>}
+ */
+export class $Array<S extends $Schema<any>> extends $Schema<(S extends $Schema<infer T> ? T : never)[]> {
+    /**
+     * @param {Array<S>} v
+     */
+    constructor(v: Array<S>);
+    /**
+     * @type {$Schema<S extends $Schema<infer T> ? T : never>}
+     */
+    v: $Schema<S extends $Schema<infer T_1> ? T_1 : never>;
+    /**
+     * @param {any} o
+     * @return {o is Array<S extends $Schema<infer T> ? T : never>} o
+     */
+    check(o: any): o is (S extends $Schema<infer T_2> ? T_2 : never)[];
+}
+export function array<T extends $Schema<any>[]>(...def: T): $Schema<(T extends $Schema<infer S>[] ? S : never)[]>;
+/**
+ * @template T
+ * @extends {$Schema<T>}
+ */
+export class $InstanceOf<T> extends $Schema<T> {
+    /**
+     * @param {new (...args:any) => T} constructor
+     */
+    constructor(constructor: new (...args: any) => T);
+    v: new (...args: any) => T;
+}
+export function instance<T>(c: new (...args: any) => T): $Schema<T>;
+/**
+ * @template {$Schema<any>[]} Args
+ * @typedef {(...args:ExtractTypesFromSchemaArray<TuplePop<Args>>)=>TypeOfSchema<TupleLast<Args>>} _LArgsToLambdaDef
+ */
+/**
+ * @template {Array<$Schema<any>>} Args
+ * @extends {$Schema<_LArgsToLambdaDef<Args>>}
+ */
+export class $Lambda<Args extends $Schema<any>[]> extends $Schema<_LArgsToLambdaDef<Args>> {
+    /**
+     * @param {Args} args
+     */
+    constructor(args: Args);
+    len: number;
+    args: $Schema<any[]>;
+    res: $Schema<any>;
+}
+export function lambda<Args extends $Schema<any>[]>(...args: Args): $Schema<(...args: ExtractTypesFromSchemaArray<TuplePop<Args>>) => TypeOfSchema<TupleLast<Args>>>;
+/**
+ * @template {Array<$Schema<any>>} T
+ * @extends {$Schema<Intersect<ExtractTypesFromSchemaArray<T>>>}
+ */
+export class $Intersection<T extends $Schema<any>[]> extends $Schema<Intersect<ExtractTypesFromSchemaArray<T>>> {
+    /**
+     * @param {T} v
+     */
+    constructor(v: T);
+    /**
+     * @type {T}
+     */
+    v: T;
+}
+export function intersect<T extends $Schema<any>[]>(...def: T): $Schema<Intersect<ExtractTypesFromSchemaArray<T>>>;
+/**
+ * @template S
+ * @extends {$Schema<S>}
+ */
+export class $Union<S> extends $Schema<S> {
+    static schema: $Schema<$Union<unknown>>;
+    /**
+     * @param {Array<$Schema<S>>} v
+     */
+    constructor(v: Array<$Schema<S>>);
+    v: $Schema<S>[];
+}
+export function union<T extends $Schema<any>[]>(...def: T): $Schema<T extends $Schema<infer S>[] ? S : never>;
+/**
+ * @type {$Schema<any>}
+ */
+export const any: $Schema<any>;
+/**
+ * @type {$Schema<bigint>}
+ */
+export const bigint: $Schema<bigint>;
+/**
+ * @type {$Schema<Symbol>}
+ */
+export const symbol: $Schema<Symbol>;
+/**
+ * @type {$Schema<number>}
+ */
+export const number: $Schema<number>;
+/**
+ * @type {$Schema<string>}
+ */
+export const string: $Schema<string>;
+/**
+ * Assert that a variable is of this specific type.
+ * The assertion check is only performed in non-production environments.
+ *
+ * @type {<T>(o:any,schema:$Schema<T>) => asserts o is T}
+ */
+export const assert: <T>(o: any, schema: $Schema<T>) => asserts o is T;
+export type LiteralType = string | number | bigint | boolean | null | undefined;
+export type AnyObject = {
+    [k: string]: any;
+    [k: number]: any;
+    [k: symbol]: any;
+};
+export type TypeOfSchema<T> = T extends $Schema<infer X> ? X : T;
+export type Intersect<T extends readonly unknown[]> = T extends [] ? {} : T extends [infer First] ? First : T extends [infer First_1, ...infer Rest] ? First_1 & Intersect<Rest> : never;
+export type ExtractTypesFromSchemaArray<T extends readonly unknown[]> = T extends readonly [$Schema<infer First>, ...infer Rest] ? [First, ...ExtractTypesFromSchemaArray<Rest>] : [];
+export type CastToSchema<T> = T extends $Schema<infer S> ? $Schema<S> : never;
+export type TupleLast<Arr extends unknown[]> = Arr extends [...unknown[], infer L] ? L : never;
+export type TuplePop<Arr extends unknown[]> = Arr extends [...infer Fs, unknown] ? Fs : never;
+export type _LArgsToLambdaDef<Args extends $Schema<any>[]> = (...args: ExtractTypesFromSchemaArray<TuplePop<Args>>) => TypeOfSchema<TupleLast<Args>>;
+/**
+ * @typedef {string|number|bigint|boolean|null|undefined} LiteralType
+ */
+/**
+ * @typedef {{ [k:string|number|symbol]: any }} AnyObject
+ */
+/**
+ * @template T
+ * @typedef {T extends $Schema<infer X> ? X : T} TypeOfSchema
+ */
+/**
+ * @template {readonly unknown[]} T
+ * @typedef {T extends []
+ *   ? {}
+ *   : T extends [infer First]
+ *   ? First
+ *   : T extends [infer First, ...infer Rest]
+ *   ? First & Intersect<Rest>
+ *   : never
+ * } Intersect
+ */
+/**
+ * @template {readonly unknown[]} T
+ * @typedef {T extends readonly [$Schema<infer First>, ...infer Rest] ? [First, ...ExtractTypesFromSchemaArray<Rest>] : [] } ExtractTypesFromSchemaArray
+ */
+/**
+ * @template T
+ * @typedef {T extends $Schema<infer S> ? $Schema<S> : never} CastToSchema
+ */
+/**
+ * @template {unknown[]} Arr
+ * @typedef {Arr extends [...unknown[], infer L] ? L : never} TupleLast
+ */
+/**
+ * @template {unknown[]} Arr
+ * @typedef {Arr extends [...infer Fs, unknown] ? Fs : never} TuplePop
+ */
+declare const schemaSymbol: unique symbol;
+/**
+ * @type {$Schema<null>}
+ */
+declare const null_: $Schema<null>;
+/**
+ * @type {$Schema<void>}
+ */
+declare const void_: $Schema<void>;
+/**
+ * @type {$Schema<undefined>}
+ */
+declare const undefined_: $Schema<undefined>;
+export { null_ as null, _null as null, void_ as void, _void as void, undefined_ as undefined };
+//# sourceMappingURL=schema.d.ts.map

package/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["schema.js"],"names":[],"mappings":"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"}