dilswer/dist/types/data-types/type-utils.d.ts

Blazingly fast data validation library with TypeScript integration.

import type { GetTypeFromRecursive } from "./recursive-type-utils";
import type { AnyType, BasicType, BasicTypeNames, ComplexType, FieldDescriptor, RecordTypeSchema } from "./type-types";
import type { ArrayType } from "./types/array";
import type { CustomType } from "./types/custom";
import type { DictType } from "./types/dict";
import type { EnumType } from "./types/enum";
import type { EnumMemberType } from "./types/enum-member";
import type { InstanceOfType } from "./types/instance";
import type { IntersectionType } from "./types/intersection";
import type { LiteralType } from "./types/literal";
import type { RecordType } from "./types/record";
import type { SetType } from "./types/set";
import type { StringMatchingType } from "./types/string-matching";
import type { TupleType } from "./types/tuple";
import type { UnionType } from "./types/union";
export type ParseDataTypeIntersectionTuple<T extends any[], U = InferDType<T[0]>> = T extends [infer A, ...infer B] ? ParseDataTypeIntersectionTuple<B, U & InferDType<A>> : U;
export type GetDescriptorType<T extends AnyType | FieldDescriptor> = T extends {
    kind: any;
} ? T : T extends FieldDescriptor ? T["type"] : T;
export type IsRequiredDescriptor<T extends AnyType | FieldDescriptor> = T extends FieldDescriptor ? T["required"] : true;
export type ValueOf<R extends Record<any, any>> = R extends Record<any, infer T> ? T : never;
export type UnknownFunction = (...args: unknown[]) => unknown;
export declare class Static<T> {
    private _t;
}
export type ReWrap<T> = T extends Function ? T : T extends Static<infer U> ? U : T extends Set<infer ST> ? Set<ReWrap<ST>> : T extends object ? T extends infer O ? {
    [K in keyof O]: ReWrap<O[K]>;
} : never : T;
export type EnsureStringType<T> = T extends string ? T : string;
export type ExcludeRequired<S extends RecordTypeSchema> = EnsureStringType<Exclude<ValueOf<{
    [K in keyof S]: IsRequiredDescriptor<S[K]> extends false ? K : undefined;
}>, undefined>>;
export type ExcludeOptional<S extends RecordTypeSchema> = EnsureStringType<Exclude<ValueOf<{
    [K in keyof S]: IsRequiredDescriptor<S[K]> extends false ? undefined : K;
}>, undefined>>;
export type GetTypeFromArrayOf<D extends ComplexType> = D extends ArrayType<infer T> ? T[number] : never;
export type GetFieldDescriptorsFromSetOf<D extends ComplexType> = D extends SetType<infer T> ? T[number] : never;
export type GetTypeFromRecordOf<D extends ComplexType> = D extends RecordType<infer T> ? T : never;
export type GetTypeFromDict<D extends ComplexType> = D extends DictType<infer T> ? T[number] : never;
export type GetTypeFromOneOf<D extends ComplexType> = D extends UnionType<infer T> ? T[number] : never;
export type GetTypeFromAllOf<D extends ComplexType> = D extends IntersectionType<infer T> ? ParseDataTypeIntersectionTuple<T> : never;
export type GetTypeFromLiteral<D extends ComplexType> = D extends LiteralType<infer T> ? T : never;
export type GetTypeFromEnum<D extends ComplexType> = D extends EnumType<infer T> ? T : never;
export type GetTypeFromInstanceOf<D extends ComplexType> = D extends InstanceOfType<infer T> ? Static<T> : never;
export type GetFnAssertType<T> = T extends (v: any) => v is infer R ? R : unknown;
export type GetTypeFromCustom<D extends ComplexType> = D extends CustomType<infer F> ? GetFnAssertType<F> : never;
export type GetTypeFromEnumMember<D extends ComplexType> = D extends EnumMemberType<infer T> ? T : never;
export type RepackTuple<T extends AnyType[]> = T extends [
    infer A extends AnyType,
    ...infer B extends AnyType[]
] ? [InferDType<A>, ...RepackTuple<B>] : [];
export type GetTypeFromTuple<D extends ComplexType> = D extends TupleType<infer T> ? RepackTuple<T> : never;
export type GetTypeFromStringMatching<D extends ComplexType> = D extends StringMatchingType<infer T> ? T : never;
export type TypeMap<D extends ComplexType> = {
    array: Array<InferDType<GetTypeFromArrayOf<D>>>;
    tuple: GetTypeFromTuple<D>;
    record: InferRecordType<GetTypeFromRecordOf<D>>;
    dictionary: Record<string | number, InferDType<GetTypeFromDict<D>>>;
    set: Set<InferDType<GetFieldDescriptorsFromSetOf<D>>>;
    union: InferDType<GetTypeFromOneOf<D>>;
    intersection: GetTypeFromAllOf<D>;
    literal: GetTypeFromLiteral<D>;
    enumUnion: GetTypeFromEnum<D>;
    enumMember: GetTypeFromEnumMember<D>;
    instanceOf: GetTypeFromInstanceOf<D>;
    custom: GetTypeFromCustom<D>;
    stringMatching: GetTypeFromStringMatching<D>;
    circular: GetTypeFromRecursive<D>;
};
export type ParseComplexType<D extends ComplexType> = D["kind"] extends keyof TypeMap<D> ? TypeMap<D>[D["kind"]] : never;
export type ParseBasicDataType<D extends BasicTypeNames> = {
    unknown: unknown;
    string: string;
    number: number;
    integer: number;
    boolean: boolean;
    symbol: symbol;
    function: UnknownFunction;
    null: null;
    undefined: undefined;
    stringnumeral: `${number}`;
    stringinteger: `${number}`;
}[D];
export type InferDType<D> = D extends BasicType ? ParseBasicDataType<D["simpleType"]> : D extends ComplexType ? ParseComplexType<D> : never;
export type InferRecordType<S extends RecordTypeSchema> = {
    [K in ExcludeRequired<S>]?: InferDType<GetDescriptorType<S[K]>>;
} & {
    [K in ExcludeOptional<S>]: InferDType<GetDescriptorType<S[K]>>;
};
export type Infer<D extends AnyType> = ReWrap<InferDType<D>>;