@mionjs/run-types 0.8.7 → 0.8.10

package/src/constants.functions.ts

@@ -0,0 +1,196 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {type JitFnArgs, JIT_FUNCTION_IDS} from '@mionjs/core';
+
+/** Javascript code types */
+export const CodeTypes = {
+    expression: 'E', // single expression, that could be concatenated using js operators like + - * && || etc...
+    statement: 'S', // one or multiple statements, that could be concatenated using ; to ensure correct syntax
+    returnBlock: 'RB', // code block, it can not be concatenated with other code, it has an explicit return statement and needs to be wrapped in a function
+} as const;
+export type CodeType = (typeof CodeTypes)[keyof typeof CodeTypes];
+
+export interface JitFnSettings {
+    id: string;
+    name: string;
+    /** dynamically imports a single compiler function that is capable of compiling any node
+     * @see {@link ./jitCompilers/stringifyJson.ts#visitJsonStringify} as example of compiler function
+     */
+    import?: () => Promise<(...args: any[]) => any>;
+    jitArgs: JitFnArgs;
+    jitDefaultArgs: JitFnArgs;
+    returnName: string;
+    /**
+     * When no initial vλl is required by the function.
+     * This is typically used by deserializers, that do not transform the input value but create a new one from other params.
+     * an the initial vλl is used as a variable initialization for the returned values.
+     * ie binary deserialization
+     */
+    noInitialVλl?: true;
+    runTimeOptions?: Record<string, {keyName: string; type: 'boolean' | 'number' | 'string'; defaultValue: any}>;
+    /**
+     * When set to true, the format code should replace the jit code for the function.
+     * This is used when the format code is more efficient than the default code.
+     */
+    formatShouldReplaceJitCode?: true;
+} // list of available jit functions
+
+// variable names used in jit functions
+// JitUtils is passed with the name 'utl'. it is hardcoded in all jit code to avoid string interpolation
+export const jitArgs = {vλl: 'v'} as const;
+export const jitDefaultArgs = {vλl: ''} as const;
+export const jitErrorArgs = {vλl: 'v', pλth: 'pth', εrr: 'er'} as const;
+export const jitDefaultErrorArgs = {vλl: '', pλth: '[]', εrr: '[]'} as const;
+export const jitArgsWithOptions = {vλl: 'v', θpts: 'opts'} as const;
+export const jitDefaultArgsWithOptions = {vλl: '', θpts: '{}'} as const;
+export const jitBinarySerializerArgs = {vλl: 'v', sεr: 'Ser'} as const; // vλl = js value to serialize ser = serializer,
+export const jitBinaryDeserializerArgs = {vλl: 'ret', dεs: 'Des'} as const; // vλl is used as return variable ans is assigned the deserialized value, des = deserializer
+export const jitDefaultBinarySerializerArgs = {vλl: '', sεr: ''} as const;
+export const jitDefaultBinaryDeserializerArgs = {vλl: '', dεs: ''} as const;
+
+// ######## !IMPORTANT: ALL JIT FUNCTIONS IDs MUST BE UNIQUE and short ########
+
+type JitFunctionsGroup = {[key: string]: JitFnSettings};
+
+export const jitValidationFunctions = {
+    isType: {
+        id: JIT_FUNCTION_IDS.isType,
+        name: 'isType',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    typeErrors: {
+        id: JIT_FUNCTION_IDS.typeErrors,
+        name: 'typeErrors',
+        jitArgs: jitErrorArgs,
+        jitDefaultArgs: jitDefaultErrorArgs,
+        returnName: jitErrorArgs.εrr,
+    },
+} as const satisfies JitFunctionsGroup;
+
+export const jitSerializationFunctions = {
+    prepareForJson: {
+        id: JIT_FUNCTION_IDS.prepareForJson,
+        name: 'prepareForJson',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    restoreFromJson: {
+        id: JIT_FUNCTION_IDS.restoreFromJson,
+        name: 'restoreFromJson',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    stringifyJson: {
+        id: JIT_FUNCTION_IDS.stringifyJson,
+        name: 'stringifyJson',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    // similar to json stringify but outputs js code, including pure functions, already imported as size is quite small
+    toJSCode: {
+        id: JIT_FUNCTION_IDS.toJSCode,
+        name: 'toJSCode',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    // Binary serialization functions
+    toBinary: {
+        id: JIT_FUNCTION_IDS.toBinary,
+        name: 'toBinary',
+        jitArgs: jitBinarySerializerArgs,
+        jitDefaultArgs: jitDefaultBinarySerializerArgs,
+        // returns the serializer buffer
+        returnName: jitBinarySerializerArgs.sεr,
+        formatShouldReplaceJitCode: true,
+    },
+    fromBinary: {
+        id: JIT_FUNCTION_IDS.fromBinary,
+        name: 'fromBinary',
+        jitArgs: jitBinaryDeserializerArgs,
+        jitDefaultArgs: jitDefaultBinaryDeserializerArgs,
+        // deserialized value is stored in vλl that is initially undefined
+        returnName: jitBinaryDeserializerArgs.vλl,
+        noInitialVλl: true,
+        formatShouldReplaceJitCode: true,
+    },
+    // apply type formatters, ie: lowercase, uppercase, trim, etc
+    format: {
+        id: JIT_FUNCTION_IDS.format,
+        name: 'format',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+} as const satisfies JitFunctionsGroup;
+
+export const JitFunctions = {
+    ...jitValidationFunctions,
+    ...jitSerializationFunctions,
+    unknownKeyErrors: {
+        id: JIT_FUNCTION_IDS.unknownKeyErrors,
+        name: 'unknownKeyErrors',
+        jitArgs: jitErrorArgs,
+        jitDefaultArgs: jitDefaultErrorArgs,
+        returnName: jitErrorArgs.εrr,
+    },
+    hasUnknownKeys: {
+        id: JIT_FUNCTION_IDS.hasUnknownKeys,
+        name: 'hasUnknownKeys',
+        jitArgs: jitArgsWithOptions,
+        jitDefaultArgs: jitDefaultArgsWithOptions,
+        runTimeOptions: {checkNonJitProps: {keyName: 'checkNonJitProps', type: 'boolean', defaultValue: false}},
+        returnName: jitArgsWithOptions.vλl,
+    },
+    stripUnknownKeys: {
+        id: JIT_FUNCTION_IDS.stripUnknownKeys,
+        name: 'stripUnknownKeys',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    unknownKeysToUndefined: {
+        id: JIT_FUNCTION_IDS.unknownKeysToUndefined,
+        name: 'unknownKeysToUndefined',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    aux: {
+        id: JIT_FUNCTION_IDS.aux,
+        name: 'aux',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    // mock is not really a jit function but is used in a similar way, main difference is that it is not compiled
+    mock: {
+        id: JIT_FUNCTION_IDS.mock,
+        name: 'mockType',
+        import: () => import('./mocking/mockType.ts').then((m) => m.mockType),
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+    // pure function are not jit compiled but we ensure we reserve a prefix to avoid collisions
+    pureFunction: {
+        id: JIT_FUNCTION_IDS.pureFunction,
+        name: 'pureFunction',
+        jitArgs,
+        jitDefaultArgs,
+        returnName: jitArgs.vλl,
+    },
+} as const satisfies JitFunctionsGroup;
+
+export const jitFunctionList: JitFnSettings[] = Object.values(JitFunctions);
+export const jitFunctionsById = Object.fromEntries(jitFunctionList.map((f) => [f.id, f]));

package/src/constants.kind.ts

@@ -0,0 +1,76 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {ReflectionKind} from '@deepkit/type';
+import {RunType} from './types.ts';
+
+export const ReflectionKindName: {[key: number]: keyof typeof ReflectionKind} = {
+    0: 'never',
+    1: 'any',
+    2: 'unknown',
+    3: 'void',
+    4: 'objectLiteral', // name was changed from deepkit's 'object' to 'objectLiteral'
+    5: 'string',
+    6: 'number',
+    7: 'boolean',
+    8: 'symbol',
+    9: 'bigint',
+    10: 'null',
+    11: 'undefined',
+    12: 'regexp',
+    13: 'literal',
+    14: 'templateLiteral',
+    15: 'property',
+    16: 'method',
+    17: 'function',
+    18: 'parameter',
+    19: 'promise',
+    20: 'class',
+    21: 'typeParameter',
+    22: 'enum',
+    23: 'union',
+    24: 'intersection',
+    25: 'array',
+    26: 'tuple',
+    27: 'tupleMember',
+    28: 'enumMember',
+    29: 'rest',
+    30: 'object', // name was changed from deepkit's 'objectLiteral' to 'object' for better error messages
+    31: 'indexSignature',
+    32: 'propertySignature',
+    33: 'methodSignature',
+    34: 'infer',
+    35: 'callSignature',
+};
+
+// ReflectionKind from deepkit is extended with the following sub kinds
+export const ReflectionSubKind = {
+    // group of sub-kinds that extends ReflectionKind.class
+    date: 20_01,
+    map: 20_02,
+    set: 20_03,
+    nonSerializable: 20_04,
+
+    params: 17_01,
+    mapKey: 18_01,
+    mapValue: 18_02,
+    setItem: 18_03,
+} as const;
+
+export const ReflectionSubNames: {[key: number]: keyof typeof ReflectionSubKind} = {
+    20_01: 'date',
+    20_02: 'map',
+    20_03: 'set',
+    17_01: 'params',
+} as const;
+
+export type AnyKindName = keyof typeof ReflectionKind | keyof typeof ReflectionSubKind;
+
+export function getReflectionName(rt: RunType): AnyKindName {
+    if (rt.src.subKind) return ReflectionSubNames[rt.src.subKind];
+    return ReflectionKindName[rt.src.kind];
+}

package/src/constants.ts

@@ -0,0 +1,85 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+// native javascript objects that are not serializable
+export const nonSerializableClasses = [
+    // TODO: decide what to do with native errors, they should be easily serializable
+    Error,
+    EvalError,
+    RangeError,
+    ReferenceError,
+    SyntaxError,
+    TypeError,
+    URIError,
+    AggregateError,
+    // Promise, // Promise has it's own RunType
+    // data types
+    WeakMap,
+    WeakSet,
+    DataView,
+    ArrayBuffer,
+    SharedArrayBuffer,
+    Float32Array,
+    Float64Array,
+    Int8Array,
+    Int16Array,
+    Int32Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Uint16Array,
+    Uint32Array,
+    BigInt64Array,
+    BigUint64Array,
+];
+
+// these are global objects that are not serializable.
+// values are repeated from nonSerializableClasses, as if they are classes or global object depends in typescript stn lib types and these can change
+export const nonSerializableGlobals = [
+    // TODO: decide what to do with native errors, they should be easily serializable
+    'Error',
+    'EvalError',
+    'RangeError',
+    'ReferenceError',
+    'SyntaxError',
+    'TypeError',
+    'URIError',
+    'AggregateError',
+    // data types
+    'WeakMap',
+    'WeakSet',
+    'DataView',
+    'ArrayBuffer',
+    'SharedArrayBuffer',
+    'Float32Array',
+    'Float64Array',
+    'Int8Array',
+    'Int16Array',
+    'Int32Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Uint16Array',
+    'Uint32Array',
+    'BigInt64Array',
+    'BigUint64Array',
+    // bellow are common interface names from standard libraries, they added here but not tested
+    'Generator',
+    'GeneratorFunction',
+    'AsyncGenerator',
+    'Iterator',
+    'AsyncGeneratorFunction',
+    'AsyncIterator',
+];
+
+// typescript utility types
+export const nativeUtilityStringTypes = ['Uppercase', 'Lowercase', 'Capitalize', 'Uncapitalize'];
+
+// other constants
+export const validPropertyNameRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+export const maxStackErrorMessage =
+    'Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.';
+export const JIT_STACK_TRACE_MESSAGE = '\nJIT runType trace => ';
+export const MAX_UNION_ITEMS = 2 ** 16 - 1;

package/src/createRunType.ts

@@ -0,0 +1,322 @@
+/* eslint-disable no-case-declarations */
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {RunType, Mutable, SrcType} from './types.ts';
+import type {BaseRunType} from './lib/baseRunTypes.ts';
+import type {TypeClass, Type} from '@deepkit/type';
+import {ReflectionKind, resolveReceiveType, ReceiveType, reflect, typeAnnotation, stringifyType} from '@deepkit/type';
+import {
+    hasArguments,
+    hasExtendsArguments,
+    hasImplements,
+    hasIndexType,
+    hasParameters,
+    hasReturn,
+    hasType,
+    hasTypes,
+    isNativeUtilityStringTypes,
+    isNonSerializableClass,
+    isNonSerializableObject,
+} from './lib/guards.ts';
+import {StringRunType} from './nodes/atomic/string.ts';
+import {DateRunType} from './nodes/atomic/date.ts';
+import {NumberRunType} from './nodes/atomic/number.ts';
+import {BooleanRunType} from './nodes/atomic/boolean.ts';
+import {NullRunType} from './nodes/atomic/null.ts';
+import {BigIntRunType} from './nodes/atomic/bigInt.ts';
+import {AnyRunType} from './nodes/atomic/any.ts';
+import {UndefinedRunType} from './nodes/atomic/undefined.ts';
+import {UnknownRunType} from './nodes/atomic/unknown.ts';
+import {VoidRunType} from './nodes/atomic/void.ts';
+import {ArrayRunType} from './nodes/member/array.ts';
+import {LiteralRunType} from './nodes/atomic/literal.ts';
+import {RegexpRunType} from './nodes/atomic/regexp.ts';
+import {NeverRunType} from './nodes/atomic/never.ts';
+import {EnumRunType} from './nodes/atomic/enum.ts';
+import {EnumMemberRunType} from './nodes/atomic/enumMember.ts';
+import {UnionRunType} from './nodes/collection/union.ts';
+import {TupleRunType} from './nodes/collection/tuple.ts';
+import {FunctionParamsRunType} from './nodes/collection/functionParams.ts';
+import {TupleMemberRunType} from './nodes/member/tupleMember.ts';
+import {InterfaceRunType} from './nodes/collection/interface.ts';
+import {PropertyRunType} from './nodes/member/property.ts';
+import {IndexSignatureRunType} from './nodes/member/indexProperty.ts';
+import {MethodSignatureRunType} from './nodes/member/methodSignature.ts';
+import {CallSignatureRunType} from './nodes/member/callSignature.ts';
+import {FunctionRunType} from './nodes/function/function.ts';
+import {PromiseRunType} from './nodes/native/promise.ts';
+import {ObjectRunType} from './nodes/atomic/object.ts';
+import {IntersectionRunType} from './nodes/collection/intersection.ts';
+import {TemplateLiteralRunType} from './nodes/collection/templateLiteral.ts';
+import {ParameterRunType} from './nodes/member/param.ts';
+import {MethodRunType} from './nodes/member/method.ts';
+import {RestParamsRunType} from './nodes/member/restParams.ts';
+import {ClassRunType} from './nodes/collection/class.ts';
+import {MapRunType} from './nodes/native/map.ts';
+import {ReflectionSubKind} from './constants.kind.ts';
+import {SetRunType} from './nodes/native/set.ts';
+import {SymbolRunType} from './nodes/atomic/symbol.ts';
+import {NonSerializableRunType} from './nodes/native/nonSerializable.ts';
+import {registerErrorDeserializers} from '@mionjs/core';
+
+export function runType<T>(type?: ReceiveType<T>): RunType {
+    const start = Date.now();
+    const src = resolveReceiveType(type) as SrcType;
+    const took0 = Date.now() - start;
+    createRunTypes(src);
+    const took1 = Date.now() - start;
+    const diff = took1 - took0;
+    // max RunType overhead 60 ms
+    if (diff > 60) console.warn(`RunType overhead is very long: ${diff}ms for ${stringifyType(src)}`);
+    return src._rt;
+}
+
+export function reflectFunction<Fn extends (...args: any[]) => any>(fn: Fn): FunctionRunType {
+    const src = reflect(fn) as SrcType;
+    runType(src);
+    return src._rt as FunctionRunType;
+}
+
+// We need to traverse all possible associated nodes to create all the runTypes
+function createRunTypes(src: SrcType): void {
+    registerErrorDeserializers();
+    const stack: Type[] = [src];
+
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current || (current as SrcType)._rt) continue;
+
+        try {
+            createRunType(current as Mutable<SrcType>);
+        } catch (error) {
+            const typesStackMessage = '\nTypes Stack: ' + stack.map((t) => t.typeName || t.kind).join(', ');
+            (error as Error).message += typesStackMessage;
+            throw error;
+        }
+
+        // single child type nodes
+        if (hasType(current)) stack.push(current.type);
+        if (hasReturn(current)) stack.push(current.return);
+        if (hasIndexType(current)) stack.push(current.indexType);
+        if (current.origin) stack.push(current.origin);
+        if (current.indexAccessOrigin?.index) stack.push(current.indexAccessOrigin?.index);
+        if (current.indexAccessOrigin?.container) stack.push(current.indexAccessOrigin?.container);
+
+        // multiple child type nodes
+        if (hasTypes(current)) pushToStack(current.types, stack);
+        if (hasParameters(current)) pushToStack(current.parameters, stack);
+        if (hasArguments(current)) pushToStack(current.arguments, stack);
+        if (hasExtendsArguments(current)) pushToStack(current.extendsArguments, stack);
+        if (hasImplements(current)) pushToStack(current.implements, stack);
+        if (current.typeArguments) pushToStack(current.typeArguments, stack);
+        if (current.decorators) pushToStack(current.decorators, stack);
+        if (current.scheduleDecorators) pushToStack(current.scheduleDecorators, stack);
+
+        // annotations
+        if (current.annotations) {
+            const annotations = typeAnnotation.getAnnotations(current);
+            for (const annotation of annotations) stack.push(annotation.options);
+        }
+
+        // originTypes
+        current.originTypes?.forEach((ot) => {
+            if (ot.typeArguments) pushToStack(ot.typeArguments, stack);
+        });
+
+        // sometimes parent is an orphan so we need to explicitly add it to the stack
+        if (current.parent && !(current.parent as SrcType)?._rt) stack.push(current.parent);
+    }
+}
+
+function pushToStack(subTypes: Type[], stack: Type[]) {
+    if (Array.isArray(subTypes)) stack.push(...subTypes);
+}
+
+function createRunType(deepkitType: Mutable<SrcType>): RunType {
+    // console.log('deepkitType', deepkitType);
+
+    /*
+     RunType reference is stored in the deepkitType._runType so we can access both the deepkitType and the mion RunType,
+     basically every runType stores a reference to a deepkit type and vice versa.
+     This also relies on deepkit handling circular types to prevent infinite loop when we are generating RunTypes.
+    */
+    const existingType: RunType | undefined = deepkitType._rt;
+    // TODO: IMPORTANT: seems like deepkit can generate multiple types objects for the same type, so we need to handle this
+    // we are attaching the runType to the deepkit type (deepkitType._runType), to link the two types together
+    // but as deepkit can generate multiple types that means existingType will be null and the markAsCircular function is not working as expected
+    if (existingType) return existingType;
+
+    let rt: BaseRunType;
+
+    switch (deepkitType.kind) {
+        // ###################### ATOMIC RUNTYPES ######################
+        // Primitive types and other atomic types that don't contain other types
+        case ReflectionKind.any:
+            rt = new AnyRunType();
+            break;
+        case ReflectionKind.bigint:
+            rt = new BigIntRunType();
+            break;
+        case ReflectionKind.boolean:
+            rt = new BooleanRunType();
+            break;
+        case ReflectionKind.enum:
+            rt = new EnumRunType();
+            break;
+        case ReflectionKind.enumMember:
+            // enum members are resolved by the enum type, so this is not expected to be called
+            rt = new EnumMemberRunType();
+            break;
+        case ReflectionKind.literal:
+            rt = new LiteralRunType();
+            break;
+        case ReflectionKind.never:
+            // TODO add the string format feature
+            rt = isNativeUtilityStringTypes(deepkitType) ? new StringRunType() : new NeverRunType();
+            break;
+        case ReflectionKind.null:
+            rt = new NullRunType();
+            break;
+        case ReflectionKind.number:
+            rt = new NumberRunType();
+            break;
+        case ReflectionKind.object:
+            rt = new ObjectRunType();
+            break;
+        case ReflectionKind.regexp:
+            rt = new RegexpRunType();
+            break;
+        case ReflectionKind.string:
+            rt = new StringRunType();
+            break;
+        case ReflectionKind.symbol:
+            rt = new SymbolRunType();
+            break;
+        case ReflectionKind.templateLiteral:
+            // deepkit resolves finite template literal unions to literal-string unions before reaching here.
+            // this branch handles the open form ie: type T = `api/user/${number}` (children: literal/string/number/any/infer)
+            rt = new TemplateLiteralRunType();
+            break;
+        case ReflectionKind.undefined:
+            rt = new UndefinedRunType();
+            break;
+        case ReflectionKind.unknown:
+            rt = new UnknownRunType();
+            break;
+        case ReflectionKind.void:
+            rt = new VoidRunType();
+            break;
+
+        // ###################### MEMBER RUNTYPES ######################
+        // Types that represent members of collections or other structures
+        case ReflectionKind.array:
+            rt = new ArrayRunType();
+            break;
+        case ReflectionKind.callSignature:
+            rt = new CallSignatureRunType();
+            break;
+        case ReflectionKind.function:
+            if (deepkitType.subKind === ReflectionSubKind.params) {
+                rt = new FunctionParamsRunType();
+            } else {
+                const frt = new FunctionRunType();
+                // TODO review an change how we compile function parameters and return type
+                // those should also be jit functions, no need to check for array
+                // and maybe add option to target individual parameters
+                (frt.parameterRunTypes as Mutable<RunType>).src = deepkitType;
+                rt = frt;
+            }
+            break;
+        case ReflectionKind.indexSignature:
+            rt = new IndexSignatureRunType();
+            break;
+        case ReflectionKind.method:
+            rt = new MethodRunType();
+            break;
+        case ReflectionKind.methodSignature:
+            rt = new MethodSignatureRunType();
+            break;
+        case ReflectionKind.parameter:
+            rt = new ParameterRunType();
+            break;
+        case ReflectionKind.property:
+        case ReflectionKind.propertySignature:
+            rt = new PropertyRunType();
+            break;
+        case ReflectionKind.rest:
+            rt = new RestParamsRunType();
+            break;
+        case ReflectionKind.tupleMember:
+            rt = new TupleMemberRunType();
+            break;
+        case ReflectionKind.promise:
+            rt = new PromiseRunType();
+            break;
+
+        // ###################### COLLECTION RUNTYPES ######################
+        case ReflectionKind.objectLiteral:
+            if (isNonSerializableObject(deepkitType)) {
+                rt = new NonSerializableRunType();
+            } else {
+                rt = new InterfaceRunType();
+            }
+            break;
+        case ReflectionKind.class:
+            rt = initClassRunType(deepkitType);
+            break;
+        // Types that contain other types as members
+        case ReflectionKind.infer:
+            throw new Error(
+                'Infer type not supported, ie: type MyType =Type<T> = T extends (...args: any[]) => infer R ? R : any; https://www.typescriptlang.org/docs/handbook/2/conditional-types.html'
+            );
+
+        case ReflectionKind.intersection:
+            rt = new IntersectionRunType();
+            break;
+
+        case ReflectionKind.tuple:
+            rt = new TupleRunType();
+            break;
+        case ReflectionKind.typeParameter:
+            throw new Error(
+                'TypeParameter not implemented. Type parameters are the generic placeholders in type definitions (e.g., T in Array<T>, ErrType in TypedError<ErrType>). ' +
+                    'Type parameters are typically resolved during type instantiation and should not appear in runtime type checking.' +
+                    'This error is typically caused by a generic type missing type arguments, e.g.: TypedError instead of TypedError<"my-error">.'
+            );
+        // rType = resolveTypeParameter(deepkitType, opts, mapper);
+        case ReflectionKind.union:
+            rt = new UnionRunType();
+            break;
+        default:
+            rt = new AnyRunType();
+            break;
+    }
+    rt.onCreated(deepkitType);
+    // console.log('rt', rt);
+    return rt;
+}
+
+function initClassRunType(src: TypeClass & {subKind?: number}): BaseRunType {
+    switch (src.classType) {
+        case Date:
+            src.subKind = ReflectionSubKind.date;
+            return new DateRunType();
+        case Map:
+            src.subKind = ReflectionSubKind.map;
+            return new MapRunType();
+        case Set:
+            src.subKind = ReflectionSubKind.set;
+            return new SetRunType();
+        default:
+            if (isNonSerializableClass(src)) {
+                src.subKind = ReflectionSubKind.nonSerializable;
+                return new NonSerializableRunType();
+            }
+            return new ClassRunType();
+    }
+}