@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/src/lib/baseRunTypes.cjs

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const src_constants = require("../constants.cjs");
+const src_constants_functions = require("../constants.functions.cjs");
+const type = require("@deepkit/type");
+const src_lib_utils = require("./utils.cjs");
+const src_lib_jitFnCompiler = require("./jitFnCompiler.cjs");
+const src_lib_createJitFunction = require("./createJitFunction.cjs");
+const src_constants_kind = require("../constants.kind.cjs");
+const src_lib_formats = require("./formats.cjs");
+const src_lib_typeId = require("./typeId.cjs");
+const src_lib_jitFnsRegistry = require("./jitFnsRegistry.cjs");
+const src_mocking_constants_mock = require("../mocking/constants.mock.cjs");
+src_constants_functions.CodeTypes.returnBlock;
+const S = src_constants_functions.CodeTypes.statement;
+const E = src_constants_functions.CodeTypes.expression;
+class BaseRunType {
+  isCircular;
+  src = null;
+  // Atomic, Collection, Member, Function
+  /**
+   * This single functions controls whether or not the code for a type should be inlined into the parent function
+   * or should create a separate jit function for it, add as a dependency and call it.
+   * @returns
+   */
+  isJitInlined = () => {
+    if (this.isCircular) return false;
+    if (core.getENV("DEBUG_JIT") === "INLINED") return true;
+    if (this.src.kind === type.ReflectionKind.array) return false;
+    if (this.src.typeName && this.getFamily() === "C") return false;
+    return true;
+  };
+  getKindName = src_lib_utils.memorize(() => src_constants_kind.getReflectionName(this));
+  getTypeName = () => this.src.typeName || this.getKindName();
+  stringify = src_lib_utils.memorize(() => type.stringifyType(this.src));
+  skipJit(comp) {
+    return false;
+  }
+  /** Returns the format portion of the type ID (cached in src._formatId), or undefined if no format. */
+  getFormatTypeID() {
+    const formatId = this.src._formatId;
+    return formatId || void 0;
+  }
+  /** Returns the type ID which is cached in src._typeId by getDeepkitTypeId(). Format ID is already included. */
+  getTypeID() {
+    if (this.src._typeId === void 0) {
+      throw new Error(`Missing cached type ID for ${this.getTypeName()}. Ensure getDeepkitTypeId() has been called.`);
+    }
+    return this.src._typeId;
+  }
+  getJitHash(opts) {
+    const optsCopy = { ...opts };
+    if (optsCopy.mock) delete optsCopy.mock;
+    return core.createUniqueHash(this.getTypeID().toString() + JSON.stringify(optsCopy));
+  }
+  getParent = () => this.src.parent?._rt;
+  checkIsCircularAndGetRefId(stack = []) {
+    const inStackIndex = stack.findIndex((rt) => {
+      if (rt === this) return true;
+      return rt.src.id && this.src.id && rt.src.id === this.src.id;
+    });
+    stack.findIndex((rt) => rt.src.id && this.src.id && rt.src.id === this.src.id);
+    const isInStack = inStackIndex >= 0;
+    if (isInStack) {
+      this.isCircular = true;
+      const name = this.src.typeName || "";
+      const refId = "$" + this.src.kind + `_${inStackIndex}` + name;
+      return refId;
+    }
+    return void 0;
+  }
+  /**
+   * Method that should be called Immediately after the RunType gets created to link the SrcType and RunType.
+   * This is more flexible than passing params to the constructor helps to avoid circular dependencies, etc.
+   * */
+  onCreated(src) {
+    this.src = src;
+    src._rt = this;
+    src_lib_formats.initFormatAnnotations(this);
+    src_lib_typeId.createTypeId(src);
+  }
+  /**
+   * Some elements might need a standalone name variable that ignores the vλl value of the parents.
+   * returns a variable that is being compiled, ignores the parents variable names */
+  getCustomVλl(comp) {
+    return void 0;
+  }
+  /**
+   * Some elements might need a custom static path to be able to reference the source of an error.
+   * ie: when validating a Map we need to differentiate if the value that failed is the  key or the value of a map's entry.
+   */
+  getStaticPathLiteral(comp) {
+    return void 0;
+  }
+  // ########## Mock ##########
+  async mock(opts) {
+    await src_lib_jitFnsRegistry.registerJitFunctionCompiler(src_constants_functions.JitFunctions.mock);
+    return this.mockType(opts);
+  }
+  /** synchronous version of mock, throws an error if the mock function has not been loaded */
+  mockType(opts = {}) {
+    const mockFn = src_lib_jitFnsRegistry.getJitFunctionCompiler(src_constants_functions.JitFunctions.mock);
+    if (!mockFn)
+      throw new Error(
+        `Function ${src_constants_functions.JitFunctions.mock.name} has not been loaded. make sure you have called loadJitCompilerFunction(JitFunctions.mock) before calling mockType.`
+      );
+    const fnID = src_constants_functions.JitFunctions.mock.id;
+    const mockingOpts = { ...opts, mock: { ...src_mocking_constants_mock.defaultMockOptions, ...opts.mock || {} } };
+    const hash = src_lib_createJitFunction.getJITFnHash(fnID, this, mockingOpts);
+    const comp = new src_lib_jitFnCompiler.MockJitCompiler(this, mockingOpts, void 0, hash, this.getTypeID());
+    return mockFn(this, comp);
+  }
+  // ########## Create Jit Functions ##########
+  createJitFunction = (jitFn, opts = {}) => {
+    return this.createJitCompiledFunction(jitFn.id, void 0, opts).fn;
+  };
+  createJitCompiledFunction(fnID, parentCop, opts = {}) {
+    const fnHash = src_lib_createJitFunction.getJITFnHash(fnID, this, opts);
+    const jitCompiled = core.getJitUtils().getJIT(fnHash);
+    if (jitCompiled) {
+      if (core.getENV("DEBUG_JIT") === "VERBOSE")
+        console.log(`\x1B[32m Using cached function: ${jitCompiled.jitFnHash} \x1B[0m`);
+      return jitCompiled;
+    }
+    const newJitCompiler = src_lib_jitFnCompiler.createJitCompiler(
+      this,
+      fnID,
+      parentCop,
+      void 0,
+      void 0,
+      opts
+    );
+    try {
+      const codeType = this.getFamily() === "A" ? E : S;
+      newJitCompiler.compile(this, codeType, fnID);
+      newJitCompiler.createJitFunction();
+    } catch (e) {
+      newJitCompiler.removeFromJitCache();
+      if (typeof e?.message === "string" && !newJitCompiler.hasStackTrace(e.message))
+        e.message += newJitCompiler.getStackTrace();
+      throw e;
+    }
+    return newJitCompiler;
+  }
+}
+class AtomicRunType extends BaseRunType {
+  getFamily() {
+    return "A";
+  }
+  emitPrepareForJson(comp) {
+    return { code: void 0, type: S };
+  }
+  emitRestoreFromJson(comp) {
+    return { code: void 0, type: S };
+  }
+  emitHasUnknownKeys(comp) {
+    return { code: void 0, type: E };
+  }
+  emitUnknownKeyErrors(comp) {
+    return { code: void 0, type: S };
+  }
+  emitStripUnknownKeys(comp) {
+    return { code: void 0, type: S };
+  }
+  emitUnknownKeysToUndefined(comp) {
+    return { code: void 0, type: S };
+  }
+}
+class CollectionRunType extends BaseRunType {
+  getFamily() {
+    return "C";
+  }
+  getChildRunTypes = () => {
+    const childTypes = this.src.types || [];
+    return childTypes.map((t) => t._rt);
+  };
+  getJitChildren(comp) {
+    let skipIndex = false;
+    return this.getChildRunTypes().filter((c) => {
+      if (c.skipJit(comp)) return false;
+      const isIndex = c.src.kind === type.ReflectionKind.indexSignature;
+      if (isIndex && skipIndex) return false;
+      if (isIndex) skipIndex = true;
+      return true;
+    });
+  }
+  areAllChildrenOptional(children) {
+    return children.every(
+      (prop) => prop?.isOptional() || prop.src?.optional || prop.src.kind === type.ReflectionKind.indexSignature
+    );
+  }
+  emitHasUnknownKeys(comp) {
+    const codes = this.getJitChildren(comp).map((c) => comp.compileHasUnknownKeys(c, E).code).filter((code) => !!code);
+    return { code: codes.join(" || "), type: E };
+  }
+  emitUnknownKeyErrors(comp) {
+    const codes = this.getJitChildren(comp).map((c) => comp.compileUnknownKeyErrors(c, S).code).filter((code) => !!code);
+    return { code: codes.join(";"), type: S };
+  }
+  emitStripUnknownKeys(comp) {
+    const codes = this.getJitChildren(comp).map((c) => comp.compileStripUnknownKeys(c, S).code).filter((code) => !!code);
+    return { code: codes.join(";"), type: S };
+  }
+  emitUnknownKeysToUndefined(comp) {
+    const codes = this.getJitChildren(comp).map((c) => comp.compileUnknownKeysToUndefined(c, S).code).filter((code) => !!code);
+    return { code: codes.join(";"), type: S };
+  }
+  getChildrenTypeID = src_lib_utils.memorize((stack = []) => {
+    if (stack.length > core.MAX_STACK_DEPTH) throw new Error(src_constants.maxStackErrorMessage);
+    const circularJitConf = this.checkIsCircularAndGetRefId(stack);
+    if (circularJitConf) return circularJitConf;
+    stack.push(this);
+    const childrenIds = [];
+    const children = this.getChildRunTypes();
+    for (const child of children) {
+      childrenIds.push(child.getTypeID());
+    }
+    const isArray = this.src.kind === type.ReflectionKind.tuple || this.src.kind === type.ReflectionKind.array;
+    const groupID = isArray ? `[${childrenIds.join(",")}]` : `{${childrenIds.join(",")}}`;
+    const kind = this.src.subKind || this.src.kind;
+    stack.pop();
+    return `${kind}${groupID}`;
+  });
+}
+class MemberRunType extends BaseRunType {
+  /** used to compile json stringify */
+  skipCommas;
+  /** used to compile json stringify */
+  tempChildVλl;
+  getFamily() {
+    return "M";
+  }
+  getMemberType() {
+    const memberType = this.src.type;
+    return memberType._rt;
+  }
+  getChildIndex(comp) {
+    const start = comp?.opts?.paramsSlice?.start;
+    if (start) return src_lib_utils.getPropIndex(this.src) - start;
+    return src_lib_utils.getPropIndex(this.src);
+  }
+  getJitChild(comp) {
+    const member = this.getMemberType();
+    if (member.skipJit(comp)) return void 0;
+    return member;
+  }
+  emitHasUnknownKeys(comp) {
+    const child = this.getJitChild(comp);
+    const codeResult = comp.compileHasUnknownKeys(child, E);
+    if (!codeResult?.code) return { code: void 0, type: E };
+    const childName = comp.getChildVλl();
+    const finalCode = this.isOptional() ? `(${childName} !== undefined && ${codeResult.code})` : codeResult.code;
+    return { code: finalCode, type: codeResult.type };
+  }
+  emitUnknownKeyErrors(comp) {
+    const child = this.getJitChild(comp);
+    const codeResult = comp.compileUnknownKeyErrors(child, S);
+    if (!codeResult?.code) return { code: void 0, type: S };
+    const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
+    return { code: finalCode, type: codeResult.type };
+  }
+  emitStripUnknownKeys(comp) {
+    const child = this.getJitChild(comp);
+    const codeResult = comp.compileStripUnknownKeys(child, S);
+    if (!codeResult?.code) return { code: void 0, type: S };
+    const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
+    return { code: finalCode, type: codeResult.type };
+  }
+  emitUnknownKeysToUndefined(comp) {
+    const child = this.getJitChild(comp);
+    const codeResult = comp.compileUnknownKeysToUndefined(child, S);
+    if (!codeResult?.code) return { code: void 0, type: S };
+    const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
+    return { code: finalCode, type: codeResult.type };
+  }
+  visitToBinary(comp) {
+    const child = this.getJitChild(comp);
+    const code = comp.compileToBinary(child, S);
+    if (!code?.code) return { code: void 0, type: S };
+    return this.isOptional() ? { code: `(${comp.getChildVλl()} !== undefined ? ${code.code} : utl.writeBinaryNull())`, type: S } : code;
+  }
+  visitFromBinary(comp) {
+    const child = this.getJitChild(comp);
+    const code = comp.compileFromBinary(child, S);
+    if (!code?.code) return { code: void 0, type: S };
+    return code;
+  }
+  getMemberTypeID = src_lib_utils.memorize((stack = []) => {
+    if (stack.length > core.MAX_STACK_DEPTH) throw new Error(src_constants.maxStackErrorMessage);
+    const optional = this.isOptional() ? "?" : "";
+    const kind = this.src.name?.toString() || this.src.index?.kind || this.src.subKind || this.src.kind;
+    const kindID = `${kind}${optional}`;
+    const circularJitConf = this.checkIsCircularAndGetRefId(stack);
+    if (circularJitConf) return `${kindID}:${circularJitConf}`;
+    stack.push(this);
+    const member = this.getMemberType();
+    const memberTypeID = member.getTypeID();
+    const typeID = `${kindID}:${memberTypeID}`;
+    stack.pop();
+    return typeID;
+  });
+}
+exports.AtomicRunType = AtomicRunType;
+exports.BaseRunType = BaseRunType;
+exports.CollectionRunType = CollectionRunType;
+exports.MemberRunType = MemberRunType;
+//# sourceMappingURL=baseRunTypes.cjs.map

package/.dist/cjs/src/lib/baseRunTypes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseRunTypes.cjs","sources":["../../../../src/lib/baseRunTypes.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\nimport {MAX_STACK_DEPTH, JitCompiledFn, createUniqueHash, getJitUtils, getENV} from '@mionjs/core';\nimport type {\n    RunType,\n    Mutable,\n    RunTypeChildAccessor,\n    JitFnID,\n    SrcType,\n    SrcCollection,\n    CustomVλl,\n    JitFn,\n    JitCode,\n    RunTypeOptions,\n    StrNumber,\n    DeepPartial,\n    RunTypeFamily,\n} from '../types.ts';\nimport type {mockType} from '../mocking/mockType.ts';\nimport {maxStackErrorMessage} from '../constants.ts';\nimport {type CodeType, JitFunctions, CodeTypes} from '../constants.functions.ts';\nimport {ReflectionKind, stringifyType} from '@deepkit/type';\nimport type {TypeIndexSignature, TypeProperty, Type} from '@deepkit/type';\nimport {getPropIndex, memorize} from './utils.ts';\nimport {createJitCompiler, MockJitCompiler} from './jitFnCompiler.ts';\nimport {getJITFnHash} from './createJitFunction.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from './jitFnCompiler.ts';\nimport {type AnyKindName, getReflectionName} from '../constants.kind.ts';\nimport {initFormatAnnotations} from './formats.ts';\nimport {createTypeId} from './typeId.ts';\nimport {getJitFunctionCompiler, registerJitFunctionCompiler} from './jitFnsRegistry.ts';\nimport {defaultMockOptions} from '../mocking/constants.mock.ts';\n\nconst RB = CodeTypes.returnBlock;\nconst S = CodeTypes.statement;\nconst E = CodeTypes.expression;\n\nexport abstract class BaseRunType<T extends Type = Type> implements RunType {\n    isCircular?: boolean;\n    readonly src: SrcType<T> = null as any; // real value will be set after construction by the createRunType function\n    abstract getFamily(): RunTypeFamily; // Atomic, Collection, Member, Function\n    /**\n     * This single functions controls whether or not the code for a type should be inlined into the parent function\n     * or should create a separate jit function for it, add as a dependency and call it.\n     * @returns\n     */\n    isJitInlined = (): boolean => {\n        // if is circular, always create a separate jit function as need to self invoke\n        if (this.isCircular) return false;\n        if (getENV('DEBUG_JIT') === 'INLINED') return true;\n        // all array  are self invoked for isType and are usually repeated type like string[] or number[] so worth deduplicating\n        if (this.src.kind === ReflectionKind.array) return false;\n        // collection with name might be used in different places so worth deduplicating\n        if (this.src.typeName && this.getFamily() === 'C') return false;\n        return true;\n    };\n    getKindName = memorize((): AnyKindName => getReflectionName(this));\n    getTypeName = (): string => this.src.typeName || this.getKindName();\n    stringify = memorize((): string => stringifyType(this.src));\n    skipJit(comp: JitFnCompiler): boolean {\n        return false;\n    }\n    /** Returns the format portion of the type ID (cached in src._formatId), or undefined if no format. */\n    getFormatTypeID(): string | undefined {\n        // _formatId is cached by computeDeepkitFormatID during getDeepkitTypeId call\n        // Empty string means no format, undefined means not computed yet\n        const formatId = (this.src as any)._formatId;\n        return formatId || undefined;\n    }\n    /** Returns the type ID which is cached in src._typeId by getDeepkitTypeId(). Format ID is already included. */\n    getTypeID(): StrNumber {\n        if (this.src._typeId === undefined) {\n            throw new Error(`Missing cached type ID for ${this.getTypeName()}. Ensure getDeepkitTypeId() has been called.`);\n        }\n        return this.src._typeId;\n    }\n    getJitHash(opts: RunTypeOptions): string {\n        const optsCopy = {...opts};\n        // remove mock options as not relevant for jit functionality\n        if (optsCopy.mock) delete optsCopy.mock;\n        return createUniqueHash(this.getTypeID().toString() + JSON.stringify(optsCopy));\n    }\n    getParent = (): BaseRunType | undefined => (this.src.parent as SrcType)?._rt as BaseRunType;\n    checkIsCircularAndGetRefId(stack: RunType[] = []): StrNumber | undefined {\n        const inStackIndex = stack.findIndex((rt) => {\n            if (rt === this) return true;\n            // some nodes seems to be different objects in memory but are the same id, so we check by id as well\n            return rt.src.id && this.src.id && rt.src.id === this.src.id;\n        }); // cant use isSameJitType because it uses getTypeID and would loop forever\n        const inStackSrcId = stack.findIndex((rt) => rt.src.id && this.src.id && rt.src.id === this.src.id);\n        const isInStack = inStackIndex >= 0; // recursive reference\n        if (isInStack) {\n            this.isCircular = true;\n            const name = this.src.typeName || ''; // todo: not sure if all the circular references will have a name\n            const refId = '$' + this.src.kind + `_${inStackIndex}` + name; // ensures different circular types have different typeID\n            return refId;\n        }\n        return undefined;\n    }\n    /**\n     * Method that should be called Immediately after the RunType gets created to link the SrcType and RunType.\n     * This is more flexible than passing params to the constructor helps to avoid circular dependencies, etc.\n     * */\n    onCreated(src: SrcType<any>): void {\n        (this as Mutable<RunType>).src = src;\n        (src as Mutable<SrcType>)._rt = this;\n        initFormatAnnotations(this);\n        // Cache the type ID on the src object - this includes format information\n        createTypeId(src);\n    }\n    /**\n     * Some elements might need a standalone name variable that ignores the vλl value of the parents.\n     * returns a variable that is being compiled, ignores the parents variable names */\n    getCustomVλl(comp: JitFnCompiler): CustomVλl | undefined {\n        return undefined;\n    }\n    /**\n     * Some elements might need a custom static path to be able to reference the source of an error.\n     * ie: when validating a Map we need to differentiate if the value that failed is the  key or the value of a map's entry.\n     */\n    getStaticPathLiteral(comp: JitFnCompiler): string | number | undefined {\n        return undefined;\n    }\n\n    // ########## Mock ##########\n\n    async mock(opts?: DeepPartial<RunTypeOptions>): Promise<any> {\n        // although the mock function is not jit, it is also stored in the registry\n        // this is because we don't want to load mock related functionality if not needed\n        await registerJitFunctionCompiler(JitFunctions.mock);\n        return this.mockType(opts);\n    }\n\n    /** synchronous version of mock, throws an error if the mock function has not been loaded */\n    mockType(opts: DeepPartial<RunTypeOptions> = {}): any {\n        const mockFn = getJitFunctionCompiler(JitFunctions.mock) as typeof mockType;\n        if (!mockFn)\n            throw new Error(\n                `Function ${JitFunctions.mock.name} has not been loaded. make sure you have called loadJitCompilerFunction(JitFunctions.mock) before calling mockType.`\n            );\n        const fnID = JitFunctions.mock.id;\n        // options sent to the compiler will be set to empty as mock options are handled separately from the compiler\n        const mockingOpts = {...opts, mock: {...defaultMockOptions, ...(opts.mock || {})}} as RunTypeOptions;\n        const hash = getJITFnHash(fnID, this, mockingOpts);\n        const comp = new MockJitCompiler(this, mockingOpts, undefined, hash, this.getTypeID());\n        return mockFn(this, comp);\n    }\n\n    // ########## Create Jit Functions ##########\n\n    createJitFunction = (jitFn: JitFn, opts: RunTypeOptions = {}): ((...args: any[]) => any) => {\n        return this.createJitCompiledFunction(jitFn.id, undefined, opts).fn;\n    };\n\n    createJitCompiledFunction(fnID: JitFnID, parentCop?: JitFnCompiler, opts: RunTypeOptions = {}): JitCompiledFn {\n        const fnHash = getJITFnHash(fnID, this, opts);\n        const jitCompiled = getJitUtils().getJIT(fnHash);\n        if (jitCompiled) {\n            if (getENV('DEBUG_JIT') === 'VERBOSE')\n                console.log(`\\x1b[32m Using cached function: ${jitCompiled.jitFnHash} \\x1b[0m`);\n            return jitCompiled;\n        }\n        const newJitCompiler: JitFnCompiler = createJitCompiler(\n            this,\n            fnID,\n            parentCop,\n            undefined,\n            undefined,\n            opts\n        ) as JitFnCompiler;\n        try {\n            const codeType = this.getFamily() === 'A' ? E : S;\n            newJitCompiler.compile(this, codeType, fnID);\n            newJitCompiler.createJitFunction();\n        } catch (e: any) {\n            // if something goes wrong during compilation we want to remove the compiler from\n            // the cache as this is automatically added to jitUtils cache during compilation\n            newJitCompiler.removeFromJitCache();\n            // TODO: we need to print the full path to the type that is causing the error\n            // for this ideally we should add a parent Compiler and print the trace only from the root\n            if (typeof e?.message === 'string' && !newJitCompiler.hasStackTrace(e.message))\n                e.message += newJitCompiler.getStackTrace();\n            throw e;\n        }\n        return newJitCompiler as JitCompiledFn;\n    }\n\n    // ########## emit Methods that generates src code ##########\n\n    abstract emitIsType(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitTypeErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitHasUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitUnknownKeyErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitStripUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitUnknownKeysToUndefined(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    // todo: maybe we should move these two into a single file like the rest of serializers\n    abstract emitPrepareForJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitRestoreFromJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n}\n\n/**\n * RunType that is atomic an does not contains any other child runTypes.\n * ie: string, number, boolean, any, null, undefined, void, never, bigint, etc.\n * */\nexport abstract class AtomicRunType<T extends Type> extends BaseRunType<T> {\n    getFamily(): 'A' {\n        return 'A';\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: E};\n    }\n    emitUnknownKeyErrors(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n}\n\n/**\n * RunType that contains a collection or child runTypes.\n * Collection RunTypes are the only ones that can have circular references. as a child of a collection RunType can be the parent of the collection RunType.\n * i.e: interface, child runTypes are it's properties\n * i.e: tuple, it's child runTypes are the tuple members\n */\nexport abstract class CollectionRunType<T extends Type> extends BaseRunType<T> {\n    getFamily(): 'C' {\n        return 'C';\n    }\n    getChildRunTypes = (): BaseRunType[] => {\n        const childTypes = ((this.src as SrcCollection).types as SrcType[]) || []; // deepkit stores child types in the types property\n        return childTypes.map((t) => t._rt as BaseRunType);\n    };\n    getJitChildren(comp: JitFnCompiler): BaseRunType[] {\n        let skipIndex = false; // if there are multiple index signatures, only the first one will be used as they must be same type just different keys\n        return this.getChildRunTypes().filter((c) => {\n            if (c.skipJit(comp)) return false;\n            const isIndex = c.src.kind === ReflectionKind.indexSignature;\n            if (isIndex && skipIndex) return false;\n            if (isIndex) skipIndex = true;\n            return true;\n        });\n    }\n    areAllChildrenOptional(children: BaseRunType[]) {\n        return children.every(\n            (prop) =>\n                (prop as MemberRunType<any>)?.isOptional() ||\n                (prop.src as TypeProperty)?.optional ||\n                prop.src.kind === ReflectionKind.indexSignature\n        );\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        const codes = this.getJitChildren(comp)\n            .map((c) => comp.compileHasUnknownKeys(c, E).code)\n            .filter((code) => !!code);\n        return {code: codes.join(' || '), type: E};\n    }\n    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n        const codes = this.getJitChildren(comp)\n            .map((c) => comp.compileUnknownKeyErrors(c, S).code)\n            .filter((code) => !!code);\n        return {code: codes.join(';'), type: S};\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        const codes = this.getJitChildren(comp)\n            .map((c) => comp.compileStripUnknownKeys(c, S).code)\n            .filter((code) => !!code);\n        return {code: codes.join(';'), type: S};\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        const codes = this.getJitChildren(comp)\n            .map((c) => comp.compileUnknownKeysToUndefined(c, S).code)\n            .filter((code) => !!code);\n        return {code: codes.join(';'), type: S};\n    }\n    private getChildrenTypeID = memorize((stack: BaseRunType<any>[] = []): StrNumber => {\n        if (stack.length > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);\n        const circularJitConf = this.checkIsCircularAndGetRefId(stack);\n        if (circularJitConf) return circularJitConf;\n        stack.push(this);\n        const childrenIds: (string | number)[] = [];\n        const children = this.getChildRunTypes();\n        for (const child of children) {\n            childrenIds.push(child.getTypeID());\n        }\n        const isArray = this.src.kind === ReflectionKind.tuple || this.src.kind === ReflectionKind.array;\n        const groupID = isArray ? `[${childrenIds.join(',')}]` : `{${childrenIds.join(',')}}`;\n        const kind = this.src.subKind || this.src.kind;\n        stack.pop();\n        return `${kind}${groupID}`;\n    });\n}\n\n/**\n * RunType that contains a single member or child RunType. usually part of a collection RunType.\n * i.e object properties, {prop: memberType} where memberType is the child RunType\n */\nexport abstract class MemberRunType<T extends Type> extends BaseRunType<T> implements RunTypeChildAccessor {\n    abstract isOptional(): boolean;\n    abstract getChildVarName(comp: JitFnCompiler): string | number;\n    abstract getChildLiteral(comp: JitFnCompiler): string | number;\n    abstract useArrayAccessor(): boolean;\n    /** used to compile json stringify */\n    skipCommas?: boolean;\n    /** used to compile json stringify */\n    tempChildVλl?: string;\n    getFamily(): 'M' {\n        return 'M';\n    }\n    getMemberType(): BaseRunType {\n        const memberType = (this.src as any).type as SrcType; // deepkit stores member types in the type property\n        return memberType._rt as BaseRunType;\n    }\n    getChildIndex(comp: JitFnCompiler) {\n        const start = comp?.opts?.paramsSlice?.start;\n        if (start) return getPropIndex(this.src) - start;\n        return getPropIndex(this.src);\n    }\n    getJitChild(comp: JitFnCompiler): BaseRunType | undefined {\n        const member: BaseRunType = this.getMemberType();\n        if (member.skipJit(comp)) return undefined;\n        return member;\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const codeResult = comp.compileHasUnknownKeys(child, E);\n        if (!codeResult?.code) return {code: undefined, type: E};\n        const childName = comp.getChildVλl();\n        const finalCode = this.isOptional() ? `(${childName} !== undefined && ${codeResult.code})` : codeResult.code;\n        return {code: finalCode, type: codeResult.type};\n    }\n    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const codeResult = comp.compileUnknownKeyErrors(child, S);\n        if (!codeResult?.code) return {code: undefined, type: S};\n        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n        return {code: finalCode, type: codeResult.type};\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const codeResult = comp.compileStripUnknownKeys(child, S);\n        if (!codeResult?.code) return {code: undefined, type: S};\n        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n        return {code: finalCode, type: codeResult.type};\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const codeResult = comp.compileUnknownKeysToUndefined(child, S);\n        if (!codeResult?.code) return {code: undefined, type: S};\n        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n        return {code: finalCode, type: codeResult.type};\n    }\n    visitToBinary(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const code = comp.compileToBinary(child, S);\n        if (!code?.code) return {code: undefined, type: S};\n        return this.isOptional()\n            ? {code: `(${comp.getChildVλl()} !== undefined ? ${code.code} : utl.writeBinaryNull())`, type: S}\n            : code;\n    }\n    visitFromBinary(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const code = comp.compileFromBinary(child, S);\n        if (!code?.code) return {code: undefined, type: S};\n        return code;\n    }\n    private getMemberTypeID = memorize((stack: BaseRunType<any>[] = []): StrNumber => {\n        if (stack.length > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);\n        const optional = this.isOptional() ? '?' : '';\n        const kind =\n            (this.src as TypeProperty).name?.toString() ||\n            (this.src as TypeIndexSignature).index?.kind ||\n            this.src.subKind ||\n            this.src.kind;\n        const kindID = `${kind}${optional}`;\n        const circularJitConf = this.checkIsCircularAndGetRefId(stack);\n        if (circularJitConf) return `${kindID}:${circularJitConf}`;\n        // TODO: some properties could be skipped from the JIT ID. so we could implement a mechanism to mark them to be skipped\n        // ie: sample and sampleChars from StringFormat are too large but they do not affect jit code generation as those properties are only used during mocking\n        stack.push(this);\n        const member = this.getMemberType();\n        const memberTypeID = member.getTypeID();\n        const typeID = `${kindID}:${memberTypeID}`;\n        stack.pop();\n        return typeID;\n    });\n}\n\n// ########## Load Composable Functions ##########\n"],"names":["CodeTypes","getENV","ReflectionKind","memorize","getReflectionName","stringifyType","createUniqueHash","initFormatAnnotations","createTypeId","registerJitFunctionCompiler","JitFunctions","getJitFunctionCompiler","defaultMockOptions","getJITFnHash","MockJitCompiler","getJitUtils","createJitCompiler","MAX_STACK_DEPTH","maxStackErrorMessage","getPropIndex"],"mappings":"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"}

package/.dist/cjs/src/lib/baseRunTypes.d.ts

@@ -0,0 +1,75 @@
+import { JitCompiledFn } from '@mionjs/core';
+import { RunType, RunTypeChildAccessor, JitFnID, SrcType, CustomVλl, JitFn, JitCode, RunTypeOptions, StrNumber, DeepPartial, RunTypeFamily } from '../types.ts';
+import { CodeType } from '../constants.functions.ts';
+import { Type } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler } from './jitFnCompiler.ts';
+import { AnyKindName } from '../constants.kind.ts';
+export declare abstract class BaseRunType<T extends Type = Type> implements RunType {
+    isCircular?: boolean;
+    readonly src: SrcType<T>;
+    abstract getFamily(): RunTypeFamily;
+    isJitInlined: () => boolean;
+    getKindName: () => AnyKindName;
+    getTypeName: () => string;
+    stringify: () => string;
+    skipJit(comp: JitFnCompiler): boolean;
+    getFormatTypeID(): string | undefined;
+    getTypeID(): StrNumber;
+    getJitHash(opts: RunTypeOptions): string;
+    getParent: () => BaseRunType | undefined;
+    checkIsCircularAndGetRefId(stack?: RunType[]): StrNumber | undefined;
+    onCreated(src: SrcType<any>): void;
+    getCustomVλl(comp: JitFnCompiler): CustomVλl | undefined;
+    getStaticPathLiteral(comp: JitFnCompiler): string | number | undefined;
+    mock(opts?: DeepPartial<RunTypeOptions>): Promise<any>;
+    mockType(opts?: DeepPartial<RunTypeOptions>): any;
+    createJitFunction: (jitFn: JitFn, opts?: RunTypeOptions) => ((...args: any[]) => any);
+    createJitCompiledFunction(fnID: JitFnID, parentCop?: JitFnCompiler, opts?: RunTypeOptions): JitCompiledFn;
+    abstract emitIsType(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitTypeErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitHasUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitUnknownKeyErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitStripUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitUnknownKeysToUndefined(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitPrepareForJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitRestoreFromJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+}
+export declare abstract class AtomicRunType<T extends Type> extends BaseRunType<T> {
+    getFamily(): 'A';
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeyErrors(comp: JitFnCompiler): JitCode;
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode;
+}
+export declare abstract class CollectionRunType<T extends Type> extends BaseRunType<T> {
+    getFamily(): 'C';
+    getChildRunTypes: () => BaseRunType[];
+    getJitChildren(comp: JitFnCompiler): BaseRunType[];
+    areAllChildrenOptional(children: BaseRunType[]): boolean;
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode;
+    private getChildrenTypeID;
+}
+export declare abstract class MemberRunType<T extends Type> extends BaseRunType<T> implements RunTypeChildAccessor {
+    abstract isOptional(): boolean;
+    abstract getChildVarName(comp: JitFnCompiler): string | number;
+    abstract getChildLiteral(comp: JitFnCompiler): string | number;
+    abstract useArrayAccessor(): boolean;
+    skipCommas?: boolean;
+    tempChildVλl?: string;
+    getFamily(): 'M';
+    getMemberType(): BaseRunType;
+    getChildIndex(comp: JitFnCompiler): number;
+    getJitChild(comp: JitFnCompiler): BaseRunType | undefined;
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode;
+    visitToBinary(comp: JitFnCompiler): JitCode;
+    visitFromBinary(comp: JitFnCompiler): JitCode;
+    private getMemberTypeID;
+}

package/.dist/cjs/src/lib/createJitFunction.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const src_lib_jitFnCompiler = require("./jitFnCompiler.cjs");
+const src_lib_jitFnsRegistry = require("./jitFnsRegistry.cjs");
+function getJITFnHash(id, rt, opts) {
+  if (opts) return `${id}_${rt.getJitHash(opts)}`;
+  return `${id}_${rt.getJitHash({})}`;
+}
+function createJitFunction(comp) {
+  if (comp.fn) return comp.fn;
+  if (comp.stack.length !== 0) throw new Error("Can not get compiled function before the compile operation is finished");
+  if (core.getJitUtils().hasJitFn(comp.jitFnHash)) return core.getJitUtils().getJitFn(comp.jitFnHash);
+  const { fnCode, fnName, contextCode } = getJitFnCode(comp);
+  const { createJitFn, fn, code } = createJitFnWithContext(comp, fnName, fnCode, contextCode);
+  comp.code = code;
+  comp.fn = fn;
+  comp.createJitFn = createJitFn;
+  return fn;
+}
+function createJitFnWithContext(comp, fnName, fnCode, contextCode) {
+  const context = contextCode ? `${contextCode};` : "";
+  let fnWithContext = `'use strict'; ${context} return ${fnCode}`;
+  if (core.getENV("DEBUG_RUN_TIME")) {
+    const fnArgs = getJitFnArgs(comp);
+    const argsCall = getJitFnArgs(comp, false);
+    const debugWrapper = `function debug_${fnName}(${fnArgs}){
+            const resp = ${fnName}(${argsCall});
+            console.log('${fnName} ${src_lib_jitFnsRegistry.getJITFnName(comp.fnID)} ${comp.rootType.getTypeName()}', 'result:', resp, ' value:', ${argsCall});
+            return resp;
+        }`;
+    fnWithContext = `'use strict'; ${context} ${fnCode} ${debugWrapper} return debug_${fnName};`;
+  }
+  try {
+    const wrapperWithContext = new Function("utl", fnWithContext);
+    if (core.getENV("DEBUG_JIT")) console.log(src_lib_jitFnCompiler.printClosure(fnWithContext, fnName));
+    return { createJitFn: wrapperWithContext, fn: wrapperWithContext(core.getJitUtils()), code: fnWithContext };
+  } catch (e) {
+    if (core.getENV("DEBUG_JIT")) {
+      console.warn("Error creating jit function with context code:\n", src_lib_jitFnCompiler.printClosure(fnWithContext, fnName));
+    }
+    throw e;
+  }
+}
+function getJitFnCode(comp) {
+  const fnName = comp.jitFnHash;
+  const fnArgs = getJitFnArgs(comp);
+  const fnCode = `function ${fnName}(${fnArgs}){${comp.code}}`;
+  return { fnName, fnCode, contextCode: comp.getContextItemValues().join(";\n") };
+}
+function getJitFnArgs(comp, defaultValues = true) {
+  return Object.entries(comp.args).map(([key, name]) => {
+    if (!comp.defaultParamValues[key] || !defaultValues) return name;
+    const value = comp.defaultParamValues[key];
+    return `${name}=${value}`;
+  }).join(",");
+}
+exports.createJitFunction = createJitFunction;
+exports.getJITFnHash = getJITFnHash;
+//# sourceMappingURL=createJitFunction.cjs.map

package/.dist/cjs/src/lib/createJitFunction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJitFunction.cjs","sources":["../../../../src/lib/createJitFunction.ts"],"sourcesContent":["import {getENV, getJitUtils, type JITUtils} from '@mionjs/core';\nimport type {JitFnID, Mutable, RunTypeOptions} from '../types.ts';\nimport {BaseFnCompiler, JitCompilerLike, printClosure} from './jitFnCompiler.ts';\nimport type {BaseRunType} from './baseRunTypes.ts';\nimport {getJITFnName} from './jitFnsRegistry.ts';\n\n/**\n * Creates a function name/hash based on the jitHash of the runType and the id of the function.\n * it is a valid js variable name.\n * @param id\n * @param rt\n * @returns\n */\nexport function getJITFnHash(id: JitFnID, rt: BaseRunType, opts?: RunTypeOptions): string {\n    if (opts) return `${id}_${rt.getJitHash(opts)}`;\n    return `${id}_${rt.getJitHash({})}`;\n}\n\n/**\n * Creates a jit function from a compiler.\n * This function handles the logic to determine if the function should be created or retrieved from the cache.\n * @param comp\n * @returns\n */\nexport function createJitFunction(comp: BaseFnCompiler): (...args: any[]) => any {\n    if (comp.fn) return comp.fn;\n    if (comp.stack.length !== 0) throw new Error('Can not get compiled function before the compile operation is finished');\n    if (getJitUtils().hasJitFn(comp.jitFnHash)) return getJitUtils().getJitFn(comp.jitFnHash);\n    const {fnCode, fnName, contextCode} = getJitFnCode(comp);\n    const {createJitFn, fn, code} = createJitFnWithContext(comp, fnName, fnCode, contextCode);\n    (comp as Mutable<BaseFnCompiler>).code = code;\n    (comp as Mutable<BaseFnCompiler>).fn = fn;\n    (comp as Mutable<BaseFnCompiler>).createJitFn = createJitFn;\n    return fn;\n}\n\n/**\n * Create a JIT function that has jitUtils (and possibly other required variables) in the context,\n * This way jitUtils ca be used without passing them as arguments to every atomic jit function (kind of global variables).\n * @param varName\n * @param fnCode\n * @returns\n */\nfunction createJitFnWithContext(comp: BaseFnCompiler, fnName: string, fnCode: string, contextCode?: string) {\n    // this function will have jitUtils as context as is an argument of the enclosing function\n    const context = contextCode ? `${contextCode};` : '';\n    let fnWithContext = `'use strict'; ${context} return ${fnCode}`;\n    if (getENV('DEBUG_RUN_TIME')) {\n        const fnArgs = getJitFnArgs(comp);\n        const argsCall = getJitFnArgs(comp, false);\n        const debugWrapper = `function debug_${fnName}(${fnArgs}){\n            const resp = ${fnName}(${argsCall});\n            console.log('${fnName} ${getJITFnName(comp.fnID)} ${comp.rootType.getTypeName()}', 'result:', resp, ' value:', ${argsCall});\n            return resp;\n        }`;\n        fnWithContext = `'use strict'; ${context} ${fnCode} ${debugWrapper} return debug_${fnName};`;\n    }\n    try {\n        // wrapper functions that works as a factory and returns the actual jit function, context contains all constants and heavy to create objects\n        const wrapperWithContext = new Function('utl', fnWithContext) as (utl: JITUtils) => (...args: any[]) => any;\n        if (getENV('DEBUG_JIT')) console.log(printClosure(fnWithContext, fnName));\n        return {createJitFn: wrapperWithContext, fn: wrapperWithContext(getJitUtils()), code: fnWithContext}; // returns the jit internal function with the context\n    } catch (e: any) {\n        if (getENV('DEBUG_JIT')) {\n            console.warn('Error creating jit function with context code:\\n', printClosure(fnWithContext, fnName));\n        }\n        throw e;\n    }\n}\n\nfunction getJitFnCode(comp: BaseFnCompiler): {fnName: string; fnCode: string; contextCode: string} {\n    const fnName = comp.jitFnHash;\n    const fnArgs = getJitFnArgs(comp); // function arguments with default values ie: 'vλl, pλth=[], εrr=[]'\n    const fnCode = `function ${fnName}(${fnArgs}){${comp.code}}`;\n    return {fnName, fnCode, contextCode: comp.getContextItemValues().join(';\\n')};\n}\n\n/** Returns the arguments of the function with default values */\nfunction getJitFnArgs(comp: JitCompilerLike, defaultValues = true): string {\n    return Object.entries(comp.args)\n        .map(([key, name]) => {\n            if (!comp.defaultParamValues[key] || !defaultValues) return name;\n            const value = comp.defaultParamValues[key];\n            return `${name}=${value}`;\n        })\n        .join(',');\n}\n"],"names":["getJitUtils","getENV","getJITFnName","printClosure"],"mappings":";;;;;AAaO,SAAS,aAAa,IAAa,IAAiB,MAA+B;AACtF,MAAI,aAAa,GAAG,EAAE,IAAI,GAAG,WAAW,IAAI,CAAC;AAC7C,SAAO,GAAG,EAAE,IAAI,GAAG,WAAW,CAAA,CAAE,CAAC;AACrC;AAQO,SAAS,kBAAkB,MAA+C;AAC7E,MAAI,KAAK,GAAI,QAAO,KAAK;AACzB,MAAI,KAAK,MAAM,WAAW,EAAG,OAAM,IAAI,MAAM,wEAAwE;AACrH,MAAIA,iBAAA,EAAc,SAAS,KAAK,SAAS,EAAG,QAAOA,KAAAA,cAAc,SAAS,KAAK,SAAS;AACxF,QAAM,EAAC,QAAQ,QAAQ,YAAA,IAAe,aAAa,IAAI;AACvD,QAAM,EAAC,aAAa,IAAI,KAAA,IAAQ,uBAAuB,MAAM,QAAQ,QAAQ,WAAW;AACvF,OAAiC,OAAO;AACxC,OAAiC,KAAK;AACtC,OAAiC,cAAc;AAChD,SAAO;AACX;AASA,SAAS,uBAAuB,MAAsB,QAAgB,QAAgB,aAAsB;AAExG,QAAM,UAAU,cAAc,GAAG,WAAW,MAAM;AAClD,MAAI,gBAAgB,iBAAiB,OAAO,WAAW,MAAM;AAC7D,MAAIC,KAAAA,OAAO,gBAAgB,GAAG;AAC1B,UAAM,SAAS,aAAa,IAAI;AAChC,UAAM,WAAW,aAAa,MAAM,KAAK;AACzC,UAAM,eAAe,kBAAkB,MAAM,IAAI,MAAM;AAAA,2BACpC,MAAM,IAAI,QAAQ;AAAA,2BAClB,MAAM,IAAIC,oCAAa,KAAK,IAAI,CAAC,IAAI,KAAK,SAAS,aAAa,kCAAkC,QAAQ;AAAA;AAAA;AAG7H,oBAAgB,iBAAiB,OAAO,IAAI,MAAM,IAAI,YAAY,iBAAiB,MAAM;AAAA,EAC7F;AACA,MAAI;AAEA,UAAM,qBAAqB,IAAI,SAAS,OAAO,aAAa;AAC5D,QAAID,KAAAA,OAAO,WAAW,EAAG,SAAQ,IAAIE,mCAAa,eAAe,MAAM,CAAC;AACxE,WAAO,EAAC,aAAa,oBAAoB,IAAI,mBAAmBH,iBAAA,CAAa,GAAG,MAAM,cAAA;AAAA,EAC1F,SAAS,GAAQ;AACb,QAAIC,KAAAA,OAAO,WAAW,GAAG;AACrB,cAAQ,KAAK,oDAAoDE,sBAAAA,aAAa,eAAe,MAAM,CAAC;AAAA,IACxG;AACA,UAAM;AAAA,EACV;AACJ;AAEA,SAAS,aAAa,MAA6E;AAC/F,QAAM,SAAS,KAAK;AACpB,QAAM,SAAS,aAAa,IAAI;AAChC,QAAM,SAAS,YAAY,MAAM,IAAI,MAAM,KAAK,KAAK,IAAI;AACzD,SAAO,EAAC,QAAQ,QAAQ,aAAa,KAAK,qBAAA,EAAuB,KAAK,KAAK,EAAA;AAC/E;AAGA,SAAS,aAAa,MAAuB,gBAAgB,MAAc;AACvE,SAAO,OAAO,QAAQ,KAAK,IAAI,EAC1B,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM;AAClB,QAAI,CAAC,KAAK,mBAAmB,GAAG,KAAK,CAAC,cAAe,QAAO;AAC5D,UAAM,QAAQ,KAAK,mBAAmB,GAAG;AACzC,WAAO,GAAG,IAAI,IAAI,KAAK;AAAA,EAC3B,CAAC,EACA,KAAK,GAAG;AACjB;;;"}

package/.dist/cjs/src/lib/createJitFunction.d.ts

@@ -0,0 +1,5 @@
+import { JitFnID, RunTypeOptions } from '../types.ts';
+import { BaseFnCompiler } from './jitFnCompiler.ts';
+import { BaseRunType } from './baseRunTypes.ts';
+export declare function getJITFnHash(id: JitFnID, rt: BaseRunType, opts?: RunTypeOptions): string;
+export declare function createJitFunction(comp: BaseFnCompiler): (...args: any[]) => any;

package/.dist/cjs/src/lib/dkProxy.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+function getRunTypeAnnotations(rt) {
+  const annotations = type.typeAnnotation.getAnnotations(rt.src);
+  return annotations.map((a) => {
+    const annotation = {
+      name: a.name,
+      options: a.options._rt
+    };
+    return annotation;
+  });
+}
+function getParsedAnnotationOptions(rt) {
+  return getRunTypeAnnotations(rt).map((a) => type.typeAnnotation.getOption(rt.src, a.name));
+}
+function getTypeToObject(rt) {
+  return type.typeToObject(rt.src);
+}
+exports.getParsedAnnotationOptions = getParsedAnnotationOptions;
+exports.getRunTypeAnnotations = getRunTypeAnnotations;
+exports.getTypeToObject = getTypeToObject;
+//# sourceMappingURL=dkProxy.cjs.map

package/.dist/cjs/src/lib/dkProxy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dkProxy.cjs","sources":["../../../../src/lib/dkProxy.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {typeAnnotation, typeToObject} from '@deepkit/type';\nimport {RunType, RunTypeAnnotation, SrcType} from '../types.ts';\n\n/**\n * Returns RunType annotations, ie:\n *\n * type WithSuffix<Suffix extends string> = string & TypeAnnotation<'suffix', Suffix>;\n * const rt = runType<WithSuffix<'hello'>>();\n * const annotations = rt.getRunTypeAnnotations();\n * annotations = [{name: 'suffix', options: LiteralRunType<'hello'>}];\n */\nexport function getRunTypeAnnotations(rt: RunType): RunTypeAnnotation[] {\n    const annotations = typeAnnotation.getAnnotations(rt.src);\n    return annotations.map((a) => {\n        const annotation: RunTypeAnnotation = {\n            name: a.name,\n            options: (a.options as SrcType)._rt as RunType,\n        };\n        return annotation;\n    });\n}\n\n/**\n * Returns the options of the annotations parsed js data, ie:\n *\n * type WithSuffix<Suffix extends string> = string & TypeAnnotation<'suffix', Suffix>;\n * const rt = runType<WithSuffix<'hello'>>();\n * const parsedOptions = rt.getParsedAnnotationOptions();\n * parsedOptions = 'hello';\n */\nexport function getParsedAnnotationOptions(rt: RunType): any[] {\n    return getRunTypeAnnotations(rt).map((a) => typeAnnotation.getOption(rt.src, a.name));\n}\n\n/**\n * Returns the deepkit type as a js object, this is useful to extract metadata from the type.\n */\nexport function getTypeToObject(rt: RunType): any {\n    return typeToObject(rt.src);\n}\n"],"names":["typeAnnotation","typeToObject"],"mappings":";;;AAkBO,SAAS,sBAAsB,IAAkC;AACpE,QAAM,cAAcA,KAAAA,eAAe,eAAe,GAAG,GAAG;AACxD,SAAO,YAAY,IAAI,CAAC,MAAM;AAC1B,UAAM,aAAgC;AAAA,MAClC,MAAM,EAAE;AAAA,MACR,SAAU,EAAE,QAAoB;AAAA,IAAA;AAEpC,WAAO;AAAA,EACX,CAAC;AACL;AAUO,SAAS,2BAA2B,IAAoB;AAC3D,SAAO,sBAAsB,EAAE,EAAE,IAAI,CAAC,MAAMA,oBAAe,UAAU,GAAG,KAAK,EAAE,IAAI,CAAC;AACxF;AAKO,SAAS,gBAAgB,IAAkB;AAC9C,SAAOC,KAAAA,aAAa,GAAG,GAAG;AAC9B;;;;"}

package/.dist/cjs/src/lib/dkProxy.d.ts

@@ -0,0 +1,4 @@
+import { RunType, RunTypeAnnotation } from '../types.ts';
+export declare function getRunTypeAnnotations(rt: RunType): RunTypeAnnotation[];
+export declare function getParsedAnnotationOptions(rt: RunType): any[];
+export declare function getTypeToObject(rt: RunType): any;

package/.dist/cjs/src/lib/formats.cjs

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_constants_kind = require("../constants.kind.cjs");
+const type = require("@deepkit/type");
+const src_lib_utils = require("./utils.cjs");
+const typeAnnotationsCache = /* @__PURE__ */ new Map();
+const formatterPrefix = "f";
+function registerFormatter(operation, shouldThrow = false) {
+  const id = getFormatterKey(formatterPrefix, operation.kind, operation.name);
+  const exiting = typeAnnotationsCache.get(id);
+  if (exiting && exiting !== operation) {
+    if (shouldThrow)
+      throw new Error(`Annotation type ${operation.name} already registered for ${src_constants_kind.ReflectionKindName[operation.kind]}`);
+    return operation;
+  }
+  typeAnnotationsCache.set(id, operation);
+  return operation;
+}
+function getFormatterFromCache(typeKind, name, shouldThrow = false) {
+  const formatter = typeAnnotationsCache.get(getFormatterKey(formatterPrefix, typeKind, name));
+  if (!formatter) {
+    if (shouldThrow) throw new Error(`Annotation type ${name} not found for ${src_constants_kind.ReflectionKindName[typeKind]}`);
+    return void 0;
+  }
+  return formatter;
+}
+function getFormatterKey(prefix, kind, name) {
+  return `${prefix}:${kind}:${name}`;
+}
+function getRunTypeFormat(rt) {
+  return getFormatAnnotation(rt)?.formatter;
+}
+function getRunTypeTransformer(rt) {
+  const rtFormat = getRunTypeFormat(rt);
+  if (rtFormat?.emitFormat) return rtFormat;
+  return void 0;
+}
+function initFormatAnnotations(rt) {
+  const annotations = type.typeAnnotation.getAnnotations(rt.src);
+  if (annotations.length === 0) return;
+  if (annotations.length > 1)
+    throw new Error(`Only one type annotation is allowed for runTypes and ${rt.getTypeName()} has ${annotations.length}`);
+  const annotation = annotations[0];
+  if (!annotation.name) throw new Error(`Type annotation must have a name for ${rt.getTypeName()}`);
+  const params = annotation.options;
+  const formatter = getFormatterFromCache(rt.src.kind, annotation.name);
+  if (formatter && params.kind === type.ReflectionKind.objectLiteral) {
+    annotation.formatter = formatter;
+    return annotation;
+  }
+  return annotation;
+}
+function getFormatterParams(rt, fmtName) {
+  const annotation = getFormatAnnotation(rt);
+  if (annotation?.name === fmtName) {
+    if (annotation.params) return annotation.params;
+    annotation.params = type.typeAnnotation.getOption(rt.src, annotation.name);
+    return annotation.params;
+  }
+  throw new Error(`Type Formatter ${fmtName} not found for ${rt.getTypeName()}`);
+}
+function getFormatAnnotation(rt) {
+  const parsedAnnotations = type.typeAnnotation.getAnnotations(rt.src);
+  const formatAnnotations = parsedAnnotations.filter((a) => a.formatter);
+  return formatAnnotations[0];
+}
+const defaultIgnoreFormatProps = ["mockSamples"];
+function paramsToLiteral(comp, params, ignoreProps) {
+  return src_lib_utils.toLiteralInContext(comp, params, ignoreProps, false);
+}
+function getToLiteralFn(comp, ignoreProps) {
+  return (params) => paramsToLiteral(comp, params, ignoreProps);
+}
+function dependenciesToLiteral(comp, params, ignoreProps = []) {
+  return src_lib_utils.toLiteralInContext(comp, params, ignoreProps, true);
+}
+exports.defaultIgnoreFormatProps = defaultIgnoreFormatProps;
+exports.dependenciesToLiteral = dependenciesToLiteral;
+exports.getFormatAnnotation = getFormatAnnotation;
+exports.getFormatterFromCache = getFormatterFromCache;
+exports.getFormatterKey = getFormatterKey;
+exports.getFormatterParams = getFormatterParams;
+exports.getRunTypeFormat = getRunTypeFormat;
+exports.getRunTypeTransformer = getRunTypeTransformer;
+exports.getToLiteralFn = getToLiteralFn;
+exports.initFormatAnnotations = initFormatAnnotations;
+exports.paramsToLiteral = paramsToLiteral;
+exports.registerFormatter = registerFormatter;
+//# sourceMappingURL=formats.cjs.map