@mionjs/run-types 0.8.8 → 0.13.0

package/src/constants.kind.ts

@@ -1,76 +0,0 @@
-/* ########
- * 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

@@ -1,85 +0,0 @@
-/* ########
- * 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

@@ -1,323 +0,0 @@
-/* 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 {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 automatically resolves template literals unions to literals
-            // this is only called when you define the type of a template literal i.e: type T = `foo${string}`;
-            // this is not supported at the moment but would be useful for type safe urls etc
-            throw new Error(
-                'Template Literals are resolved by the compiler to Literals ie: const tl = `${string}World`. Template literal types are not supported. ie type TL = `${string}World`'
-            );
-        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();
-    }
-}

package/src/createRunTypeFunctions.ts

@@ -1,93 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {JitFunctions} from './constants.functions.ts';
-import {ReceiveType} from '@deepkit/type';
-import {runType} from './createRunType.ts';
-import {RunTypeOptions} from './types.ts';
-import {
-    FromBinaryFn,
-    IsTypeFn,
-    JsonStringifyFn,
-    PrepareForJsonFn,
-    RestoreFromJsonFn,
-    ToBinaryFn,
-    ToCodeFn,
-    TypeErrorsFn,
-} from '@mionjs/core';
-import {BaseRunType} from './lib/baseRunTypes.ts';
-import {registerJitFunctionCompiler} from './lib/jitFnsRegistry.ts';
-
-// All these functions are async because they might need to compile the jit function first
-// At the moment they are compiled synchronously, but in the future they might be async
-// Also some the src code to compile or functionality of the JIT functions might be loaded dynamically
-// ie: mocking functionality is loaded only when mockTypeFn is called
-
-/** Returns a function that checks if the given value is of the specified type. */
-export async function createIsTypeFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<IsTypeFn> {
-    const rt = runType(type);
-    return rt.createJitFunction(JitFunctions.isType, opts);
-}
-
-/** Returns a function that get Type error data. */
-export async function createTypeErrorsFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<TypeErrorsFn> {
-    const rt = runType(type);
-    return rt.createJitFunction(JitFunctions.typeErrors, opts);
-}
-
-/**
- * Returns a function that prepares a javascript type to be compatible with json.stringify.
- * Allows json.stringify special types like dates, bigints, maps, set, etc... that are not supported by json.stringify
- */
-export async function createPrepareForJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<PrepareForJsonFn> {
-    const rt = runType(type);
-    return rt.createJitFunction(JitFunctions.prepareForJson, opts);
-}
-
-/**
- * Returns a function that restores a javascript type from json.parse.
- * Allows restoring special types like dates, bigints, maps, set, etc... that are not supported by json.parse
- * */
-export async function createRestoreFromJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<RestoreFromJsonFn> {
-    const rt = runType(type);
-    return rt.createJitFunction(JitFunctions.restoreFromJson, opts);
-}
-
-/**
- * Returns a function that stringifies a javascript value to a json string.
- * Stringifies special types like dates, bigints, maps, set, etc...
- * Is equivalent to calling prepareForJson and then json.stringify but more efficient.
- */
-export async function createStringifyJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<JsonStringifyFn> {
-    const rt = runType(type);
-    return rt.createJitFunction(JitFunctions.stringifyJson, opts);
-}
-
-/** Returns a function that serializes any type value to a binary format. */
-export async function createToBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<ToBinaryFn> {
-    const rt = runType(type);
-    return rt.createJitFunction(JitFunctions.toBinary, opts);
-}
-
-/** Returns a function that deserializes a binary value to the specified type. */
-export async function createFromBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<FromBinaryFn> {
-    const rt = runType(type);
-    return rt.createJitFunction(JitFunctions.fromBinary, opts);
-}
-
-/** Returns a function that converts a value to javascript code, including set etc */
-export function createToJavascriptFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): ToCodeFn {
-    const rt = runType(type);
-    return rt.createJitFunction(JitFunctions.toJSCode, opts);
-}
-
-/** Returns a function that mocks a value of the specified type. */
-export async function createMockTypeFn<T>(type?: ReceiveType<T>): Promise<(opts?: Partial<RunTypeOptions>) => T> {
-    const rt = runType(type) as BaseRunType;
-    await registerJitFunctionCompiler(JitFunctions.mock);
-    return (opts?: Partial<RunTypeOptions>) => rt.mockType(opts) as T;
-}

package/src/formats.runtype.ts

@@ -1,35 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-// ###################### Types FORMATS #####################
-
-import {TypeAnnotation} from '@deepkit/core';
-// ⚠️ CRITICAL: Do NOT use `import type` - Deepkit needs the actual import for reflection!
-import {TypeFormatParams, Brand, TypeFormatPrimitives} from '@mionjs/core';
-
-/**
- * A base type that satisfies some extra constrains. (at the moment only Branded types of strings and numbers are supported)
- * ie: an Alphanumeric type is an string that only allow letters and numbers.
- * ie: in Integer type is a number that only allow integer values.
- *
- * TypeFormat is the equivalent ot TypeAnnotation in DK but with slight modifications @deepkit/type<TypeAnnotation>
- *
- * @param BaseType - The base type (string, number, or bigint)
- * @param Name - The format name used for runtime validation
- * @param P - Format parameters for validation rules
- * @param BrandName - Optional brand name for nominal typing (defaults to never = no brand)
- *
- * When BrandName is provided, the type becomes nominally branded, preventing
- * accidental assignment of plain strings/numbers to branded types.
- * */
-export type TypeFormat<
-    BaseType extends TypeFormatPrimitives,
-    Name extends string,
-    P extends TypeFormatParams,
-    BrandName extends string = never,
-> = [BrandName] extends [never]
-    ? BaseType & TypeAnnotation<Name, P>
-    : Brand<BaseType, BrandName> & TypeAnnotation<Name, P & {brand: BrandName}>;