@mionjs/run-types 0.8.8 → 0.13.0

package/src/nodes/native/nonSerializable.ts

@@ -1,42 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeClass, TypeObjectLiteral} from '@deepkit/type';
-import {JitCode} from '../../types.ts';
-import {InterfaceRunType} from '../collection/interface.ts';
-
-// Non serializable types might not be Atomic but will be skipped so it doesn't matter
-export class NonSerializableRunType extends InterfaceRunType<TypeObjectLiteral | TypeClass> {
-    skipJit() {
-        // skip return false so we ensure the compile functions will throw when a NonSerializable type is used
-        return false;
-    }
-    emitIsType(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitTypeErrors(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitPrepareForJson(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitRestoreFromJson(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitHasUnknownKeys(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitUnknownKeyErrors(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitStripUnknownKeys(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitUnknownKeysToUndefined(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-}

package/src/nodes/native/promise.ts

@@ -1,43 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import {type TypePromise} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import {MemberRunType} from '../../lib/baseRunTypes.ts';
-import {JitFunctions} from '../../constants.functions.ts';
-import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
-
-export class PromiseRunType extends MemberRunType<TypePromise> {
-    skipJit(comp: JitFnCompiler): boolean {
-        return comp?.fnID !== JitFunctions.toJSCode.id;
-    }
-    emitIsType(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitTypeErrors(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitPrepareForJson(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitRestoreFromJson(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    isOptional(): boolean {
-        return false;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getChildVarName(comp: JitFnCompiler): string | number {
-        return comp.getLocalVarName('p', this);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getChildLiteral(comp: JitFnCompiler): string | number {
-        return this.getChildVarName(comp);
-    }
-    useArrayAccessor(): boolean {
-        return false;
-    }
-}

package/src/nodes/native/set.ts

@@ -1,56 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import type {SrcType} from '../../types.ts';
-import {ReflectionSubKind} from '../../constants.kind.ts';
-import {ReflectionKind, type TypeClass} from '@deepkit/type';
-import {GenericMemberRunType} from '../member/genericMember.ts';
-import {IterableRunType} from './Iterable.ts';
-import {JitFunctions} from '../../constants.functions.ts';
-import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {cpf_safeIterableKey} from '../../run-types-pure-fns.ts';
-export class SetRunType extends IterableRunType {
-    keyRT = new SetKeyRunType();
-    children = [this.keyRT];
-    constructorName = 'Set';
-    onCreated(src: SrcType<TypeClass>): void {
-        const types = src.arguments;
-        if (!types || types.length !== 1) throw new Error(`Set expects 1 type argument: ie: Set<number>`);
-        super.onCreated(src);
-        this.keyRT.onCreated({
-            kind: ReflectionKind.parameter,
-            parent: src,
-            type: types[0],
-            subKind: ReflectionSubKind.setItem,
-        });
-    }
-    getCustomVλl(comp: JitFnCompiler) {
-        // restoreFromJson is decoding a regular array so no need to use an special case for vλl as other operations
-        if (comp.fnID === JitFunctions.restoreFromJson.id)
-            return {vλl: comp.getLocalVarName('it', this), isStandalone: false, useArrayAccessor: true};
-        // other operations use an special case for vλl where all parents are skipped
-        return {vλl: comp.getLocalVarName('it', this), isStandalone: true};
-    }
-}
-
-export class SetKeyRunType extends GenericMemberRunType<any> {
-    index = 0;
-    skipSettingAccessor() {
-        return true;
-    }
-    getStaticPathLiteral(comp: JitFnCompiler): string {
-        const parent = this.getParent()! as SetRunType;
-        const custom = parent.getCustomVλl(comp)!;
-        const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
-        return `{key:${safeKeyFn}(${custom.vλl}),index:${parent.getIndexVarName(comp)}}`;
-    }
-    getCustomVλl(comp: JitFnCompiler) {
-        if (comp.fnID === JitFunctions.fromBinary.id)
-            return {vλl: comp.getLocalVarName('sK', this), isStandalone: true, useArrayAccessor: false};
-        // other operations use an special case for vλl where all parents are skipped
-        return undefined;
-    }
-}

package/src/run-types-pure-fns.ts

@@ -1,116 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import type {TypeFormatError, StrNumber, RunTypeError} from '@mionjs/core';
-import {registerPureFnFactory} from '@mionjs/core';
-
-export const cpf_asJSONString = registerPureFnFactory('mion', 'asJSONString', function () {
-    // @ts-expect-error 2867
-    if (typeof Bun !== 'undefined') return JSON.stringify; // bun has a faster JSON.stringify
-    // eslint-disable-next-line no-control-regex
-    const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
-    const MAX_SCAPE_TEST_LENGTH = 1000;
-    return function _asJSONStringRegexOnly(str) {
-        // Always use regex test for strings >= 42 chars (n o for loop)
-        if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
-            return '"' + str + '"';
-        } else {
-            return JSON.stringify(str);
-        }
-    };
-});
-
-export const cpf_getUnknownKeysFromArray = registerPureFnFactory('mion', 'getUnknownKeysFromArray', function () {
-    const MAX_UNKNOWN_KEYS = 10;
-    return function _getUnknownKeysFromArray(obj: Record<StrNumber, any>, keys: StrNumber[]): StrNumber[] {
-        const unknownKeys: StrNumber[] = [];
-        for (const prop in obj) {
-            let found = false;
-            for (let j = 0; j < keys.length; j++) {
-                if (keys[j] === prop) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                unknownKeys.push(prop as string);
-                if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error('Too many unknown keys');
-            }
-        }
-        return unknownKeys;
-    };
-});
-
-export const cpf_hasUnknownKeysFromArray = registerPureFnFactory('mion', 'hasUnknownKeysFromArray', function () {
-    return function _hasUnknownKeysFromArray(obj: Record<StrNumber, any>, keys: StrNumber[]): boolean {
-        for (const prop in obj) {
-            // iterates over the object keys and if not found prop adds to unknownKeys
-            let found = false;
-            for (let j = 0; j < keys.length; j++) {
-                if (keys[j] === prop) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) return true;
-        }
-        return false;
-    };
-});
-
-export const cpf_newRunTypeErr = registerPureFnFactory('mion', 'newRunTypeErr', function () {
-    return function _err(
-        pλth: readonly StrNumber[],
-        εrr: RunTypeError[],
-        expected: string,
-        accessPath?: readonly StrNumber[]
-    ): void {
-        const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
-        const runTypeErr: RunTypeError = {expected, path};
-        εrr.push(runTypeErr);
-    };
-});
-
-export const cpf_formatErr = registerPureFnFactory('mion', 'formatErr', function () {
-    return function _formatErr(
-        pλth: StrNumber[],
-        εrr: RunTypeError[],
-        expected: string,
-        fmtName: string,
-        paramName: string,
-        paramVal: string | number | boolean | bigint,
-        fmtPath: StrNumber[],
-        accessPath?: StrNumber[],
-        fmtAccessPath?: StrNumber[]
-    ): void {
-        const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
-        const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];
-        const format: TypeFormatError = {name: fmtName, formatPath: formatPath, val: paramVal};
-        const runTypeErr: Required<RunTypeError> = {expected, path, format};
-        εrr.push(runTypeErr);
-    };
-});
-
-export const cpf_safeIterableKey = registerPureFnFactory('mion', 'safeIterableKey', function () {
-    return function _safeKey(value: any): any {
-        if (value === undefined) return null;
-        if (value === null) return null;
-        const type = typeof value;
-        if (type === 'number' || type === 'string' || type === 'boolean') return value;
-        return null;
-    };
-});
-
-/** @reflection never */
-export const cpf_sanitizeCompiledFn = registerPureFnFactory('mion', 'sanitizeCompiledFn', function () {
-    const anonymousRegex = /^\s*function\s+anonymous\s*\(/;
-    return function sanitizeCompiled(fnCode: string): string {
-        if (anonymousRegex.test(fnCode)) {
-            return fnCode.replace(anonymousRegex, 'function (');
-        }
-        return fnCode;
-    };
-});

package/src/types.ts

@@ -1,206 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-// ###### !IMPORTANT: all imports should be types only to prevent circular dependencies ######
-import type {Type, TypeCallSignature, TypeFunction, TypeMethod, TypeMethodSignature, TypeTuple} from '@deepkit/type';
-import type {TypeFormatParams} from '@mionjs/core';
-import type {JitFunctions} from './constants.functions.ts';
-import type {ReflectionSubKind} from './constants.kind.ts';
-import type {BaseRunTypeFormat} from './lib/baseRunTypeFormat.ts';
-import type {JitFnCompiler} from './lib/jitFnCompiler.ts';
-import type {CodeType} from './constants.functions.ts';
-
-export type StrNumber = string | number;
-
-/** Result of a jit compilation, contains the code and metadata about the code */
-export type JitCode = {
-    code: string | undefined;
-    type: CodeType;
-};
-
-// ############################################ RunTypes ############################################
-
-export type SrcType<T extends Type = Type> = T & {
-    readonly _rt: RunType;
-    readonly _typeId?: StrNumber; // Cached type ID to avoid recalculation (preserves number for atomic types)
-    readonly _formatId?: string; // Cached format ID (empty string means no format, undefined means not computed yet)
-    readonly subKind?: SubKind;
-};
-
-export type RunTypeFamily = 'A' | 'C' | 'M' | 'F'; // Atomic, Collection, Member, Function
-
-/**
- * Runtime Metadata for a typescript types.
- */
-export interface RunType {
-    readonly src: SrcType<any>;
-    getKindName(): string;
-    getFamily(): RunTypeFamily; // Atomic, Collection, Member, Function
-    mock: (options?: DeepPartial<RunTypeOptions>) => Promise<any>;
-
-    // ######## JIT functions ########
-    /** Returns a unique id for the type. it can be a long string similar to the typescript type itself but as shorter as possible */
-    getTypeID(): StrNumber;
-    getJitHash(opts: RunTypeOptions): string;
-    createJitFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any;
-}
-
-export type SubKind = (typeof ReflectionSubKind)[keyof typeof ReflectionSubKind];
-export type RunTypeVisitor = (deepkitType: Type, parents: RunType[], opts: RunTypeOptions) => RunType;
-export type SrcCollection = Type & {types: Type[]};
-export type SrcMember = Type & {type: Type};
-
-export interface JitCompilerOpts {
-    readonly fnID: string;
-    readonly typeID: StrNumber;
-    readonly jitFnHash: string;
-    readonly opts: RunTypeOptions;
-}
-
-export interface RunTypeChildAccessor extends RunType {
-    /**
-     * Returns the position of the child within the parent type.
-     */
-    getChildIndex(comp: JitFnCompiler): number;
-    /**
-     * Returns the variable name for the compiled child
-     * ie: for an object property, it should return the property name
-     * ie: for an array member, it should return the index variable name
-     */
-    getChildVarName(comp: JitFnCompiler): StrNumber;
-    /** Returns the static member name or literal as it should be inserted in source code.
-     * ie: for an object property, it should return the property name as a string encapsulated in quotes, ie: prop => 'prop'
-     * ie: for an array member, it should return the varName as is a dynamic value, ie: index => index
-     */
-    getChildLiteral(comp: JitFnCompiler): StrNumber;
-    /** Returns true if the property name is safe to use as a property accessor in source code
-     * ie: return false if a property can be accessed using the dot notation, ie: obj.prop, for properties that are numbers return false
-     * ie: for an array member return true as it should be accessed using the array accessor, ie: obj[index]
-     */
-    useArrayAccessor(): boolean;
-    /** Returns true if the property is optional */
-    isOptional(): boolean;
-    /** Some runType nodes might have some logic or being par of the AST, but we might not want to modify current stack variable vλl.
-     * Ie: (Rest params) is alway a child of a tupleMember, in this case we want vλl to point to the rest param and not the tuple member.
-     * so we want to skip setting the accessor in the parent.  */
-    skipSettingAccessor?(): boolean;
-    /** used to compile json stringify, items with the flag set will omit outputting comma after the item */
-    skipCommas?: boolean;
-}
-export interface CustomVλl {
-    vλl: string;
-    isStandalone?: boolean;
-    useArrayAccessor?: boolean;
-}
-
-export interface RunTypeOptions {
-    /** Slice parameters when parsing functions, so some parameter can be omitted from jit generation */
-    paramsSlice?: {start?: number; end?: number};
-    mock?: MockOptions;
-    /**
-     * When compiling literals will use the  Literal's type instead of the literal value.
-     * ie `type A = 'a'`  will be compiled as it was `type A = string` so will accept any string value not only 'a'
-     */
-    noLiterals?: boolean;
-    /**
-     * Skip checking array and just check for items type
-     * this speeds up isType and typeErrors functions but will not validate array length.
-     */
-    noIsArrayCheck?: boolean;
-    /** When true, isType and typeErrors will also reject objects with unknown/extra properties */
-    strictTypes?: boolean;
-}
-
-export type PartialRunTypeOptions = DeepPartial<RunTypeOptions>;
-
-// ############################################ JIT FUNCTIONS ############################################
-
-export type JitFn = (typeof JitFunctions)[keyof typeof JitFunctions];
-
-// one of the existing jit functions ids
-export type JitFnID = JitFn['id'];
-
-export type AnyFunction = TypeMethodSignature | TypeCallSignature | TypeFunction | TypeMethod;
-export type AnyParameterListRunType = AnyFunction | TypeTuple;
-
-// ############################################ MOCKING ############################################
-
-export interface MockOptions {
-    anyValuesList: any[];
-    minNumber?: number;
-    maxNumber?: number;
-    minDate?: number;
-    maxDate?: number;
-    enumIndex?: number;
-    objectList: object[];
-    promiseTimeOut: number;
-    promiseReject?: string | Error | any;
-    regexpList: RegExp[];
-    maxRandomStringLength: number;
-    stringLength?: number;
-    stringCharSet: string;
-    symbolLength?: number;
-    symbolCharSet?: string;
-    symbolName?: string;
-    maxRandomItemsLength: number;
-    arrayLength?: number;
-    /** probability to generate options types, number between 0 and 1,
-     * bigger values have bigger probability of generate the optional property */
-    optionalProbability: number;
-    /** probability to generate an specific property of an object, number between 0 and 1 */
-    optionalPropertyProbability?: Record<StrNumber, number>; // TODO change to a record of MockOptions
-    parentObj?: Record<StrNumber | symbol, any>;
-    /** the index of the object to mock withing the union */
-    unionIndex?: number;
-    tupleOptions?: MockOptions[];
-    paramsOptions?: MockOptions[];
-    maxStackDepth: number;
-    maxMockRecursion: number;
-}
-
-export interface MockOperation extends MockOptions {
-    /** Used for mocking object with circular references */
-    stack: RunType[];
-    fnID: JitFnID;
-}
-
-export type DKAnnotation = {
-    name: string;
-    options: SrcType;
-};
-
-export type FormatAnnotation = DKAnnotation & {
-    params?: TypeFormatParams;
-    formatter: BaseRunTypeFormat;
-};
-
-export type RunTypeAnnotation = {
-    name: string;
-    options: RunType;
-};
-
-// ############################################ OTHERS ############################################
-
-/** Any Class */
-export interface AnyClass<T = any> {
-    new (...args: any[]): T;
-}
-
-export type Mutable<T> = {
-    -readonly [K in keyof T]: T[K];
-};
-
-export type DeepRequired<T> = T extends object
-    ? {
-          [P in keyof T]?: DeepRequired<T[P]>;
-      }
-    : T;
-
-export type DeepPartial<T> = T extends object
-    ? {
-          [P in keyof T]?: DeepPartial<T[P]>;
-      }
-    : T;