@mionjs/run-types 0.8.0-alpha.0

package/.dist/esm/src/lib/jitFnCompiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitFnCompiler.js","sources":["../../../../src/lib/jitFnCompiler.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {JitCompiledFn, JitCompiledFnData, JitFnArgs, JITUtils, CompiledPureFunction} from '@mionjs/core';\nimport {MAX_STACK_DEPTH, getJitUtils, quickHash} from '@mionjs/core';\nimport type {TypeFunction} from '@deepkit/type';\nimport type {Mutable, JitFnID, StrNumber, JitCode, RunTypeOptions, JitCompilerOpts, RunTypeChildAccessor} from '../types.ts';\nimport type {BaseRunType} from './baseRunTypes.ts';\nimport type {BaseRunTypeFormat} from './baseRunTypeFormat.ts';\nimport {getReflectionName, type AnyKindName} from '../constants.kind.ts';\nimport {maxStackErrorMessage, JIT_STACK_TRACE_MESSAGE} from '../constants.ts';\nimport {type CodeType, CodeTypes, jitErrorArgs, type JitFnSettings} from '../constants.functions.ts';\nimport {getJITFnName, getJitFnSettings} from './jitFnsRegistry.ts';\nimport {JitFunctions} from '../constants.functions.ts';\nimport {isChildAccessorType, isFunctionParamsRunType, isJitErrorsCompiler} from './guards.ts';\nimport {addFullStop, getJitFnArgCallVarName, toLiteral, toLiteralInContext} from './utils.ts';\nimport {getRunTypeFormat} from './formats.ts';\nimport {emitJsonStringify} from '../jitCompilers/json/stringifyJson.ts';\nimport {emitToBinary} from '../jitCompilers/binary/toBinary.ts';\nimport {emitFromBinary} from '../jitCompilers/binary/fromBinary.ts';\nimport {emitToCode} from '../jitCompilers/json/toJsCode.ts';\nimport {createJitFunction, getJITFnHash} from './createJitFunction.ts';\nimport {cpf_newRunTypeErr, cpf_formatErr} from '../run-types-pure-fns.ts';\n\nconst RB = CodeTypes.returnBlock;\nconst S = CodeTypes.statement;\nconst E = CodeTypes.expression;\n\nexport type StackItem = {\n    /** current compile stack full variable accessor */\n    vλl: string;\n    /** current compile stack variable accessor */\n    rt: BaseRunType;\n    /** if should call a dependency instead inline code, then this would contain the id of the dependency to call */\n    dependencyId?: string;\n    staticPath?: StrNumber[];\n};\n\nexport type JitCompilerLike = BaseFnCompiler | JitCompiledFnData;\n\n/**\n * Program to compile a Jit function to be used at runtime.\n * These jit functions are used to validate, serialize, deserialize, etc... based on runTypes.\n */\nexport class BaseFnCompiler<FnArgsNames extends JitFnArgs = JitFnArgs, ID extends JitFnID = any>\n    implements JitCompiledFnData, JitCompilerOpts\n{\n    // !!! DO NOT MODIFY METHOD WITHOUT REVIEWING JIT CODE INVOCATIONS!!!\n    /** The Jit Generated function once the compilation is finished */\n    readonly fn: ((...args: any[]) => any) | undefined;\n    readonly createJitFn: ((utl: JITUtils) => (...args: any[]) => any) | undefined;\n    private isCompiled = false;\n\n    constructor(\n        public readonly rootType: BaseRunType,\n        // the id of the function to be compiled (isType, typeErrors, prepareForJson, restoreFromJson, etc)\n        public readonly fnID: ID,\n        jitFnSettings: JitFnSettings,\n        public readonly parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        public readonly opts: RunTypeOptions = {}\n    ) {\n        this.typeName = this.rootType.getTypeName();\n        this.jitFnHash = jitFnHash || getJITFnHash(this.fnID, this.rootType, opts);\n        this.typeID = typeID || this.rootType.getTypeID();\n        this.args = {...jitFnSettings.jitArgs} as FnArgsNames;\n        this.defaultParamValues = {...jitFnSettings.jitDefaultArgs} as FnArgsNames;\n        this.returnName = jitFnSettings.returnName;\n        if (this.args.vλl) this.vλl = this.args.vλl;\n        // At the time of adding this compiler to the jit cache, the fn is undefined which is technically not allowed\n        // but this prevents issues with circular types and loading order of jit dependencies\n        getJitUtils().addToJitCache(this as JitCompiledFn);\n        validateCompilerOptions(opts);\n    }\n    readonly typeName: string;\n    readonly typeID: StrNumber;\n    readonly jitFnHash: string;\n    readonly args: FnArgsNames;\n    readonly defaultParamValues: FnArgsNames;\n    readonly returnName: string;\n\n    /** Alternative arguments to use when calling a child function */\n    readonly childrenCallArgs: Partial<Record<JitFnID, Partial<JitFnArgs>>> = {};\n\n    /** Code for the jit function. after the operation has been compiled */\n    readonly code: string = '';\n    /** Code for the context function enclosing the jit function.\n     * This can be used to initialize constant or some other things that will be required across all invocation.\n     * By default this contains constants for the direct dependencies of the jit function.\n     * */\n    readonly contextCodeItems = new Map<string, string>();\n    /**\n     * This flag is set to true when the result of a jit compilation is a no operation (empty function).\n     * Some jit compiled functions could execute no operations (ie: string, boolean and numbers does not require prepareForJson/restoreFromJson)\n     */\n    readonly isNoop?: boolean = false;\n    /** The list of all jit functions that are used by this function and it's children. */\n    readonly jitDependencies: Array<string> = [];\n    readonly pureFnDependencies: Array<string> = [];\n    /** The list of types being compiled.*/\n    readonly stack: StackItem[] = [];\n    popItem: StackItem | undefined;\n    /** shorthand for  this.length */\n    get length() {\n        return this.stack.length;\n    }\n    get totalLength() {\n        if (this.parentCompiler) return this.stack.length + this.parentCompiler.totalLength;\n        return this.stack.length;\n    }\n    /** The variable name for the current item in the stack. */\n    vλl: string = '';\n    getNestLevel(rt: BaseRunType<any>): number {\n        let index = -1;\n        this.stack.forEach((item, i) => {\n            if (item.rt === rt) index = i;\n            if (item.rt.src.id && item.rt.src.id === rt.src.id) index = i;\n        });\n        if (index !== -1) return index;\n        const fromParent = this.parentCompiler?.getNestLevel(rt);\n        if (fromParent && fromParent !== -1) return fromParent;\n        return -1; // not found\n    }\n    private varNameindex: Map<BaseRunType<any> | number, number> = new Map();\n    getLocalVarName(prefix: string, rt: BaseRunType<any>): string {\n        const key = rt.src.id || rt; // duplicated elements might have same index (that means they are the same deepkit type)\n        const index = this.varNameindex.get(key);\n        if (index !== undefined) return `${prefix}${index}`;\n        const newIndex = this.varNameindex.size;\n        this.varNameindex.set(key, newIndex);\n        return `${prefix}${newIndex}`;\n    }\n    /**\n     * The path to the current item in the stack,\n     * This path can contain prop names array indexes or event literal variable values, ie: if parsing an array the path item would be the name if the index variable.\n     * This is used to generate the correct code to access the value at runtime of the current item in the stack.\n     * ie: if parsing the tuple ['A','B','C'] and the current item is 'B', the path would [1] as is the index of the item in the stack.\n     * ie: if parsing the object {a: {b: {c: 'C'}}} and the current item is 'b', the path would ['a','b'] as is the path to the item in the stack.\n     * At runtime this path gets combined with the runtime pλth variable to generate the correct path to access the value\n     * */\n    private _accessPathLiterals: StrNumber[] = [];\n    /** push new item to the stack, returns true if new child is already in the stack (is circular type) */\n    pushStack(newChild: BaseRunType): void {\n        const totalLength = this.stack.length + this.totalLength;\n        if (totalLength > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);\n        if (this.stack.length === 0) {\n            if (newChild !== this.rootType) throw new Error('rootType should be the first item in the stack');\n            newChild.getTypeID(); // ensures the constants are generated in correct order\n        }\n        this.vλl = getStackVλl(this);\n        // static path must be called before pushing the new item\n        if (isJitErrorsCompiler(this)) this._accessPathLiterals = getAccessPath(this);\n        const newStackItem: StackItem = {vλl: this.vλl, rt: newChild, staticPath: this._accessPathLiterals};\n        this.stack.push(newStackItem);\n    }\n    popStack(resultCode: JitCode): void | ((...args: any[]) => any) {\n        if (resultCode?.code) (this as Mutable<BaseFnCompiler>).code = resultCode.code;\n        this.popItem = this.stack.pop();\n        const item = this.stack[this.stack.length - 1];\n        this.vλl = item?.vλl || this.args.vλl;\n        if (isJitErrorsCompiler(this)) this._accessPathLiterals = item?.staticPath || [];\n    }\n    siplePushStack(newChild: BaseRunType): void {\n        const newStackItem: StackItem = {vλl: this.vλl, rt: newChild, staticPath: this._accessPathLiterals};\n        this.stack.push(newStackItem);\n    }\n    simplePopStack(): void {\n        this.popItem = this.stack.pop();\n    }\n    createJitFunction(overrideCode?: string): (...args: any[]) => any {\n        try {\n            if (overrideCode) {\n                (this as Mutable<BaseFnCompiler>).code = overrideCode;\n                this.isCompiled = false;\n            }\n            this.handleFunctionReturn();\n            return createJitFunction(this); // add the compiled function to jit cache\n        } catch (e: any) {\n            const fnName = getJITFnName(this.fnID);\n            const fnCode = ` Code:\\nfunction ${fnName}(){${this.code}}`;\n            const name = `(${this.rootType.getTypeName()}:${this.rootType.getTypeID()})`;\n            const typeString = `Type: ${this.rootType.stringify()}`;\n            throw new Error(`Error building ${fnName} JIT function for type ${name}: ${e?.message} \\n${typeString} \\n${fnCode}`);\n        }\n    }\n    /** Returns a copy of the access pat for current stack item */\n    getAccessPath(): StrNumber[] {\n        return [...this._accessPathLiterals];\n    }\n\n    getAccessPathArgs(): string {\n        return this._accessPathLiterals.join(',');\n    }\n    getAccessPathLength(): number {\n        return this._accessPathLiterals.length;\n    }\n    getAccessPathArgsForFnCall(): {args: string; length: number} {\n        return {args: this.getAccessPathArgs(), length: this.getAccessPathLength()};\n    }\n    getCurrentStackItem(): StackItem {\n        const item = this.stack[this.stack.length - 1];\n        if (!item) throw new Error('Compiler stack is empty, no current item');\n        return item;\n    }\n    getChildVλl(): string {\n        const parent = this.getCurrentStackItem();\n        if (!parent) return this.args.vλl;\n        const rt = parent.rt;\n        if (!isChildAccessorType(rt)) throw new Error(`cant get child var name from ${rt.getKindName()}`);\n        if (rt.skipSettingAccessor?.()) return parent.vλl;\n        return parent.vλl + (rt.useArrayAccessor() ? `[${rt.getChildLiteral(this)}]` : `.${rt.getChildVarName(this)}`);\n    }\n    shouldCallDependency(): boolean {\n        const stackItem = this.getCurrentStackItem();\n        return !stackItem.rt.isJitInlined() && this.stack.length > 1;\n    }\n    updateDependencies(childComp: JitCompiledFnData): void {\n        if (childComp.isNoop) return; // noop functions are not added to dependencies as shouldn't be used inside jit code neither\n        if (this.jitDependencies.includes(childComp.jitFnHash)) return;\n        this.jitDependencies.push(childComp.jitFnHash);\n    }\n    removeFromJitCache(): void {\n        getJitUtils().removeFromJitCache(this as JitCompiledFn);\n    }\n    getStackTrace(): string {\n        const separator = '.';\n        const parentTrace = this.parentCompiler ? this.parentCompiler.getStackTrace() + separator : JIT_STACK_TRACE_MESSAGE;\n        const lastParentItem = this.parentCompiler?.getCurrentStackItem();\n        const filteredStack = lastParentItem ? this.stack.filter((item) => item.rt !== lastParentItem?.rt) : this.stack;\n        return parentTrace + filteredStack.map((item) => this.getTypeTraceInfo(item.rt)).join(separator);\n    }\n    hasStackTrace(errorMessage: string) {\n        return errorMessage.includes(JIT_STACK_TRACE_MESSAGE);\n    }\n\n    /** Set a context code item */\n    setContextItem(key: string, value: string): void {\n        this.contextCodeItems.set(key, value);\n    }\n\n    /** Get a context code item */\n    getContextItem(key: string): string | undefined {\n        return this.contextCodeItems.get(key);\n    }\n\n    /** Check if a context code item exists */\n    hasContextItem(key: string): boolean {\n        return this.contextCodeItems.has(key);\n    }\n\n    /** Get all context code items values */\n    getContextItemValues(): string[] {\n        return Array.from(this.contextCodeItems.values());\n    }\n\n    setChildrenCallArgs(fnID: string, args: Partial<JitFnArgs>): void {\n        this.childrenCallArgs[fnID] = args;\n    }\n\n    getChildrenCallArgs(fnID: string): Partial<JitFnArgs> | undefined {\n        return this.childrenCallArgs[fnID];\n    }\n\n    /**\n     * Compiles the current function.\n     * This function handles the logic to determine if the operation should be compiled and code should be inlined, or called as a dependency.\n     * Note current JitCompiler operation might be different from the passed operation id.\n     * ie: typeErrors might want to compile isType to generate the part of the code that checks for the type.\n     * @param comp current jit compiler operation\n     * @param fnID operation id\n     * @returns\n     */\n    compile(rt: BaseRunType | undefined, expectedCType: CodeType, fnID: JitFnID): JitCode {\n        if (!rt) return {code: undefined, type: expectedCType};\n        let jCode: JitCode;\n        this.pushStack(rt);\n        if (this.shouldCallDependency()) {\n            const compiledOp = rt.createJitCompiledFunction(fnID, this, this.opts);\n            jCode = this.callDependency(rt, compiledOp);\n            this.updateDependencies(compiledOp);\n        } else {\n            // prettier-ignore\n            switch (fnID) {\n                    case JitFunctions.isType.id:\n                        jCode = this.compileFormatter(rt, fnID, rt.emitIsType(this, expectedCType), expectedCType, '&&'); break;\n                    case JitFunctions.typeErrors.id:\n                        jCode = this.compileFormatter(rt, fnID, rt.emitTypeErrors(this as any, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.prepareForJson.id:\n                        jCode = this.compileFormatter(rt, fnID,rt.emitPrepareForJson(this, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.restoreFromJson.id:\n                        jCode = this.compileFormatter(rt, fnID,rt.emitRestoreFromJson(this, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.stringifyJson.id:\n                        jCode = this.compileFormatter(rt, fnID,emitJsonStringify(rt, this), expectedCType, ';'); break;\n                    case JitFunctions.toBinary.id:\n                        jCode = this.compileFormatter(rt, fnID,emitToBinary(rt, this as any), expectedCType, ';'); break;\n                    case JitFunctions.fromBinary.id:\n                        jCode = this.compileFormatter(rt, fnID,emitFromBinary(rt, this as any), expectedCType, ';'); break;\n                    case JitFunctions.toJSCode.id:\n                        jCode =this.compileFormatter(rt, fnID, emitToCode(rt, this), expectedCType, ';'); break;\n                    case JitFunctions.unknownKeyErrors.id:\n                        jCode = rt.emitUnknownKeyErrors(this as any, expectedCType); break;\n                    case JitFunctions.hasUnknownKeys.id:\n                        jCode = rt.emitHasUnknownKeys(this, expectedCType); break;\n                    case JitFunctions.stripUnknownKeys.id:\n                        jCode = rt.emitStripUnknownKeys(this, expectedCType); break;\n                    case JitFunctions.unknownKeysToUndefined.id:\n                        jCode = rt.emitUnknownKeysToUndefined(this, expectedCType); break;\n                    case JitFunctions.format.id:\n                        jCode = {code: undefined, type: E}; break;\n                    default:\n                        throw new Error(`Unknown compile operation: ${fnID}`);\n                }\n            if (jCode?.code) {\n                // endure the child code type is compatible with the parent code type.\n                // ie: a code statement can not be interpolated within an expression\n                const compatibleCode = this.handleCodeInterpolation(rt, jCode, expectedCType);\n                jCode = {code: compatibleCode, type: jCode.type};\n            }\n        }\n        this.popStack(jCode);\n        return jCode;\n    }\n\n    private compileFormatter(\n        rt: BaseRunType,\n        fnID: JitFnID,\n        childJCode: JitCode,\n        expectedCType: CodeType,\n        separator: ';' | '&&'\n    ): JitCode {\n        const expectedCT = childJCode.code ? childJCode.type : expectedCType;\n        const typeFormatter = getRunTypeFormat(rt);\n        if (!typeFormatter) return childJCode;\n        let jitCode: JitCode | undefined = undefined;\n        const formatterCode = typeFormatter.compileFormat(fnID, this, rt);\n        // Check if the formatter code can be embedded AND is compatible with the function ID\n        const canEmbed = typeFormatter.canEmbedFormatterCode(fnID, rt);\n        const codeHasReturn = formatterCode.type === RB;\n\n        // For isType and similar functions that are expressions, we need to ensure\n        // the formatter code is also an expression or has a return statement\n        const isCompatible = formatterCode.type === expectedCT;\n        if (canEmbed && isCompatible && !codeHasReturn) {\n            jitCode = formatterCode;\n        } else {\n            // Otherwise, create a separate function\n            const compiled = typeFormatter.createJitCompiledFormatter(fnID, rt, this, undefined, undefined, undefined, this.opts);\n            if (!compiled.isNoop) {\n                this.updateDependencies(compiled);\n                jitCode = this.callDependency(rt, compiled);\n            }\n        }\n        if (!jitCode?.code) return childJCode;\n        const shouldReplace = getJitFnSettings(fnID).formatShouldReplaceJitCode;\n        const joiner = separator === '&&' ? ' && ' : '; ';\n        if (shouldReplace) {\n            return jitCode;\n        }\n        const finalCode = childJCode?.code ? childJCode.code + joiner + jitCode.code : jitCode.code;\n        return {code: finalCode, type: expectedCT};\n    }\n\n    private callDependency(rt: BaseRunType, dependencyComp: JitCompiledFn): JitCode {\n        if (dependencyComp.isNoop) return {code: '', type: E}; // we don't need to call noop functions\n        const isErrorCall =\n            dependencyComp.fnID === JitFunctions.typeErrors.id || dependencyComp.fnID === JitFunctions.unknownKeyErrors.id;\n\n        // Use the dependency's args, not the current compiler's args\n        const depArgs = getJitFnSettings(dependencyComp.fnID as JitFnID).jitArgs;\n        const callArgsCode = Object.keys(depArgs)\n            .map((key) => getJitFnArgCallVarName(this, rt, dependencyComp.fnID as JitFnID, key))\n            .join(',');\n        const isSelf = this.jitFnHash === dependencyComp.jitFnHash;\n        const varName = dependencyComp.jitFnHash;\n        // call local variable instead directly calling jitUtils to avoid lookups.\n        // ie function context (local variable created when compiling the function): const abc = jitUtils.getJIT('abc);\n        // ie calling context variable: abc.fn();\n        // if operation is the same as the current operation we can call the function directly\n\n        const callCode = isSelf ? `${varName}(${callArgsCode})` : `${varName}.fn(${callArgsCode})`;\n        if (!isSelf) this.setContextItem(varName, `const ${varName} = utl.getJIT(${toLiteral(varName)})`);\n        if (isErrorCall) {\n            const pathArgs = this.getAccessPathArgs();\n            const pathLength = this.getAccessPathLength();\n            if (!pathLength) return {code: callCode, type: 'E'};\n            // increase and decrease the static path before and after calling the dependency function\n            // TODO, maybe we can improve performance by using something else than push and splice\n            return {\n                code: `${jitErrorArgs.pλth}.push(${pathArgs}); ${callCode}; ${jitErrorArgs.pλth}.splice(-${pathLength});`,\n                type: 'S',\n            };\n        }\n        return {code: callCode, type: 'E'};\n    }\n\n    /** Check if root type is a FunctionParamsRunType with no children (empty params) */\n    private isEmptyFunctionParams(): boolean {\n        if (!isFunctionParamsRunType(this.rootType)) return false;\n        return this.rootType.getChildRunTypes().length === 0;\n    }\n\n    /**\n     * Set the isNoop flag based on the code of the operation.\n     * must be called before function gets compiled.\n     * The isNoop flag is used to avoid calling the function when the result of compilation is an empty function.\n     */\n    private handleFunctionReturn(): void {\n        if (this.isCompiled) return;\n        let isNoop = false;\n        // trims code and transforms multiple whitespaces into a single one, does not affect new lines as those can be significant\n        let code = this.code.replace(/[ \\t]+/g, ' ').replace(/;+/g, ';');\n        // For functions with no params, all validation/serialization functions are noop\n        const isEmptyParams = this.isEmptyFunctionParams();\n        switch (this.fnID) {\n            case JitFunctions.isType.id:\n                isNoop = isEmptyParams || !this.code || this.code === 'true' || this.code === 'return true';\n                if (isNoop) code = `return true`; // if code is a noop, we still need to return true\n                break;\n            case JitFunctions.hasUnknownKeys.id:\n                isNoop = !this.code || this.code === 'false' || this.code === 'return false';\n                if (isNoop) code = `return false`; // if code is a noop, we still need return false\n                break;\n            case JitFunctions.prepareForJson.id:\n            case JitFunctions.restoreFromJson.id:\n            case JitFunctions.stripUnknownKeys.id:\n            case JitFunctions.unknownKeysToUndefined.id:\n                isNoop = isEmptyParams || !this.code || this.code === this.args.vλl || this.code === `return ${this.args.vλl}`;\n                if (isNoop) code = `return ${this.args.vλl}`; // if code is a noop, we need to return the value\n                break;\n            case JitFunctions.typeErrors.id:\n            case JitFunctions.unknownKeyErrors.id:\n                isNoop = isEmptyParams || !this.code || this.code === this.args.εrr || this.code === `return ${this.args.εrr}`;\n                if (isNoop) code = `return ${this.args.εrr}`; // if code is a noop, we need to return the error array\n                break;\n            case JitFunctions.format.id:\n                isNoop = !this.code || this.code === this.args.vλl || this.code === `return ${this.args.vλl}`;\n                if (isNoop) code = `return ${this.args.vλl}`; // if code is a noop, we need to return the value\n                break;\n        }\n        (this as Mutable<BaseFnCompiler>).isNoop = isNoop;\n        (this as Mutable<BaseFnCompiler>).code = code;\n        this.isCompiled = true;\n    }\n\n    /** Ensures the child code type is compatible with the parent code type */\n    private handleCodeInterpolation(rt: BaseRunType, childJCode: JitCode, parentCodeType: CodeType): string {\n        const code = childJCode.code || '';\n        const childCodeType = childJCode.type;\n        const isRoot = this.length === 1;\n        // root code must ensure values are returned\n        if (isRoot) {\n            // prettier-ignore\n            switch (childCodeType) {\n                case E: return `return ${code}`;\n                case S: return  `${addFullStop(code)} return ${this.returnName}`;\n                case RB: return code;\n            }\n        }\n        switch (true) {\n            case parentCodeType === E && childCodeType === E:\n                return code;\n            case parentCodeType === E && childCodeType === S:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === E && childCodeType === RB:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === S && childCodeType === E:\n                return code; // no need for full stop, parent should handle it\n            case parentCodeType === S && childCodeType === S:\n                return addFullStop(code);\n            case parentCodeType === S && childCodeType === RB:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === RB && childCodeType === E:\n                throw new Error('Expected an block code but got an expression, rt should not happen as would be useless code.');\n            case parentCodeType === RB && childCodeType === S:\n                return addFullStop(code);\n            case parentCodeType === RB && childCodeType === RB:\n                return `${addFullStop(code)} return ${this.returnName}`;\n            default:\n                throw new Error(`Unexpected code type (expected: ${parentCodeType}, got: ${childCodeType})`);\n        }\n    }\n\n    /**\n     * If code should be an expression, but code has return a statement, we need to wrap it in a self invoking function to avoid syntax errors\n     * IMPORTANT TODO, WE CAN IMPROVE PERF QUITE A BIT BY CREATING A NEW FUNCTION IN CONTEXT INSTEAD SELF INVOkING\n     * TODO: we could create a new function and cache instead a self invoking function a performance is same but code is not repeated\n     * IE: this.selfInvoke(code), rt will create a new function in context and call that function instead of self invoking\n     * rt is specially for atomic types as we can be sure there are no references to children types inside the code block\n     */\n    private callSelfInvokingFunction(jCode: JitCode): string {\n        if (jCode.type === E) throw new Error('Javascript expressions never need to be wrapped in a self invoking function.');\n        if (!jCode.code) return '';\n        const code = jCode.code.trim();\n        const isSelfInvoking = code.startsWith('(function()') && code.endsWith(')()');\n        if (isSelfInvoking) return code;\n        const addReturn = jCode.type !== RB;\n        const returnCode = addReturn ? `return ` : '';\n        return `(function(){${returnCode}${jCode.code}})()`;\n    }\n\n    getTypeTraceInfo(rt: BaseRunType): string {\n        if (rt.getFamily() === 'C') return rt.src.typeName || getReflectionName(rt);\n        if (rt.getFamily() === 'F') return String((rt.src as TypeFunction).name) || getReflectionName(rt);\n        if (rt.getFamily() === 'M') {\n            const rtChild = rt as any as RunTypeChildAccessor;\n            const isRunTypeChildAccessor = !!rtChild.getChildVarName;\n            if (!isRunTypeChildAccessor) return getReflectionName(rt);\n            return String(rtChild.getChildVarName(this));\n        }\n        return getReflectionName(rt);\n    }\n\n    // ########## Compile Methods shorthands ##########\n\n    compileIsType(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.isType.id);\n    }\n    compileTypeErrors(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.typeErrors.id);\n    }\n    compilePrepareForJson(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.prepareForJson.id);\n    }\n    compileRestoreFromJson(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.restoreFromJson.id);\n    }\n    compileJsonStringify(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.stringifyJson.id);\n    }\n    compileToBinary(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.toBinary.id);\n    }\n    compileFromBinary(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.fromBinary.id);\n    }\n    compileUnknownKeyErrors(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.unknownKeyErrors.id);\n    }\n    compileHasUnknownKeys(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.hasUnknownKeys.id);\n    }\n    compileStripUnknownKeys(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.stripUnknownKeys.id);\n    }\n    compileUnknownKeysToUndefined(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.unknownKeysToUndefined.id);\n    }\n\n    // ################### Pure Functions Operations ###################\n\n    addPureFunction(compiledPureFn: CompiledPureFunction): string {\n        const {namespace, fnName} = compiledPureFn;\n        const varName = quickHash(fnName, 8);\n        if (this.hasContextItem(varName)) return varName;\n        this.addPureFnDependency(compiledPureFn);\n        // Add context code for the pure function and params\n        const pureFunctionCode = `const ${varName} = utl.getPureFn(${toLiteral(namespace)}, ${toLiteral(fnName)})`;\n        this.setContextItem(varName, pureFunctionCode);\n        return varName;\n    }\n\n    addPureFnDependency(compiledPureFn: CompiledPureFunction): void {\n        const {namespace, fnName} = compiledPureFn;\n        if (!getJitUtils().hasPureFn(namespace, fnName))\n            throw new Error(\n                `Pure function with name ${fnName} can not be added as jit dependency in namespace ${namespace}, be sure to register the pure function first by calling getJitUtils().addPureFn()`\n            );\n        // Store as \"namespace::fnName\" format (using :: to avoid conflicts with : in names)\n        const key = `${namespace}::${fnName}`;\n        if (this.pureFnDependencies.includes(key)) return;\n        this.pureFnDependencies.push(key);\n    }\n}\n\n// ################### Compile Operations ###################\n\nexport class JitFnCompiler<ID extends JitFnID = any> extends BaseFnCompiler<JitFnArgs, ID> {\n    constructor(\n        rt: BaseRunType,\n        fnID: ID,\n        parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        opts: RunTypeOptions = {}\n    ) {\n        const fnSettings = getJitFnSettings(fnID);\n        super(rt, fnID, fnSettings, parentCompiler, jitFnHash, typeID, opts);\n    }\n}\n\nexport class JitErrorsFnCompiler<ID extends JitFnID = any> extends BaseFnCompiler<typeof jitErrorArgs, ID> {\n    constructor(\n        rt: BaseRunType,\n        fnID: ID,\n        parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        opts: RunTypeOptions = {}\n    ) {\n        const fnSettings = getJitFnSettings(fnID);\n        super(rt, fnID, fnSettings, parentCompiler, jitFnHash, typeID, opts);\n    }\n    callJitErr(expected: AnyKindName | BaseRunType<any>): string {\n        // TODO: most of the time jit path is an empty array, so a new array is created every time\n        // this can be optimized by adding it to the compiler context, or maybe make the param optional in jitUtils.err\n        return this.callJitErrWithPath(expected);\n    }\n    /**\n     * This is used when we add an extra item to the path,\n     * for extra info, ie union items, maps keys, etc...\n     * This is because we don't want the item int the real path as it is not part of the runtime path of an object.\n     * but we still want to add that info to process the error.\n     * ie: type  AorBList = ({a: string} | {b: string})[];\n     * we want the error to contain the info if it is union item a or b, but the path to the the doesn't have that info is just list[index]\n     * */\n    callJitErrWithPath(exp: AnyKindName | BaseRunType<any>, extraPathLiteral?: StrNumber): string {\n        const args = this._getJitErrorArgs(exp);\n        const accessPath = this.getAccessPathLiteral(extraPathLiteral);\n        if (accessPath) args.push(accessPath);\n        const errFn = this.addPureFunction(cpf_newRunTypeErr);\n        return `${errFn}(${args.join(',')})`;\n    }\n    callJitFormatErr(\n        expected: AnyKindName | BaseRunType<any>,\n        formatter: BaseRunTypeFormat<any>,\n        paramName: string,\n        paramValue: string | number | boolean | bigint,\n        extraPathLiteral?: StrNumber\n    ): string {\n        // jitUtil.formatErr function arguments =>\n\n        // pλth: StrNumber[],\n        // εrr: RunTypeError[],\n        // expected: string,\n\n        // fmtName: string,\n        // paramName: string,\n        // paramVal: StrNumber,\n        // fmtPath: StrNumber[],\n        // accessPath?: StrNumber[],\n        // fmtAccessPath?: StrNumber[]\n\n        const typeErrArgs = this._getJitErrorArgs(expected);\n        const fmtName = toLiteralInContext(this, formatter.getFormatName());\n        const pName = toLiteralInContext(this, paramName);\n        const pVal = toLiteralInContext(this, paramValue);\n        const fmtPath = toLiteralInContext(this, formatter.getFormatPath());\n        const formatArgs = [fmtName, pName, pVal, fmtPath];\n        const optionalArgs: string[] = [];\n        const accessPath = this.getAccessPathLiteral(extraPathLiteral);\n        const formatAccessPath = this.getFormatAccessPathLiteral(formatter);\n        if (!accessPath && formatAccessPath) optionalArgs.push('undefined');\n        if (accessPath) optionalArgs.push(accessPath);\n        if (formatAccessPath) optionalArgs.push(formatAccessPath);\n        const formatErrFn = this.addPureFunction(cpf_formatErr);\n        return `${formatErrFn}(${[...typeErrArgs, ...formatArgs, ...optionalArgs].join(',')})`;\n    }\n\n    private _getJitErrorArgs(exp: AnyKindName | BaseRunType<any>): string[] {\n        // jitUtil.err function arguments =>\n        // pλth: StrNumber[],\n        // εrr: RunTypeError[],\n        // expected: string,\n        const path = this.args.pλth;\n        const err = this.args.εrr;\n        const expected = typeof exp === 'string' ? toLiteral(exp) : toLiteral(exp.getKindName());\n        return [path, err, expected];\n    }\n\n    getAccessPathLiteral(extraPathLiteral?: StrNumber): string {\n        const accessPath = this.getAccessPath();\n        if (extraPathLiteral) accessPath.push(extraPathLiteral);\n        return accessPath.length ? `[${accessPath.join(',')}]` : '';\n    }\n\n    getFormatAccessPathLiteral(formatter: BaseRunTypeFormat<any>): string {\n        const formatExtraPathLiteral = formatter.getFormatExtraPathLiteral();\n        return formatExtraPathLiteral ? `[${formatExtraPathLiteral}]` : '';\n    }\n}\n\n/**\n * This is an special compiler for mock Function as mock is not technically a jit compiled function\n * but still needs to be created to reuse all jit functionality.\n */\nexport class MockJitCompiler extends BaseFnCompiler<JitFnArgs, 'mock'> {\n    constructor(rt: BaseRunType, opts: RunTypeOptions, parentCompiler?: BaseFnCompiler, jitFnHash?: string, typeID?: StrNumber) {\n        super(rt, JitFunctions.mock.id, JitFunctions.mock, parentCompiler, jitFnHash, typeID, opts);\n    }\n}\n\n// ################### Compiler Creation ###################\n\nexport function createJitCompiler(\n    rt: BaseRunType,\n    fnID: JitFnID,\n    parent?: BaseFnCompiler,\n    jitFnHash?: string,\n    typeID?: StrNumber,\n    opts: RunTypeOptions = {}\n): BaseFnCompiler {\n    switch (fnID) {\n        case JitFunctions.isType.id:\n        case JitFunctions.prepareForJson.id:\n        case JitFunctions.restoreFromJson.id:\n        case JitFunctions.stringifyJson.id:\n        case JitFunctions.hasUnknownKeys.id:\n        case JitFunctions.stripUnknownKeys.id:\n        case JitFunctions.unknownKeysToUndefined.id:\n        case JitFunctions.format.id:\n        case JitFunctions.toJSCode.id:\n        case JitFunctions.toBinary.id:\n        case JitFunctions.fromBinary.id:\n            return new JitFnCompiler(rt, fnID, parent, jitFnHash, typeID, opts);\n        case JitFunctions.typeErrors.id:\n        case JitFunctions.unknownKeyErrors.id:\n            return new JitErrorsFnCompiler(rt, fnID, parent, jitFnHash, typeID, opts);\n        case JitFunctions.mock.id:\n            return new MockJitCompiler(rt, opts, parent, jitFnHash, typeID);\n        default:\n            throw new Error(`Unknown compile operation: ${fnID}`);\n    }\n}\n\nexport function printClosure(fnWithContext: string, functionName: string): string {\n    return `function get_${functionName}(utl){${fnWithContext}}`;\n}\n\n// ################### utils ###################\n\nfunction getStackVλl(comp: BaseFnCompiler): string {\n    let vλl: string = comp.args.vλl;\n    for (let i = 0; i < comp.stack.length; i++) {\n        const rt = comp.stack[i].rt;\n        const custom = rt.getCustomVλl(comp);\n        if (custom && custom.isStandalone) {\n            vλl = custom.vλl;\n        } else if (custom) {\n            vλl += custom.useArrayAccessor ? `[${custom.vλl}]` : `.${custom.vλl}`;\n        } else if (isChildAccessorType(rt) && !rt.skipSettingAccessor?.()) {\n            vλl += rt.useArrayAccessor() ? `[${rt.getChildLiteral(comp)}]` : `.${rt.getChildVarName(comp)}`;\n        }\n    }\n    return vλl;\n}\nfunction getAccessPath(comp: BaseFnCompiler): StrNumber[] {\n    const path: StrNumber[] = [];\n    const rtName: any = [];\n    for (let i = 0; i < comp.stack.length; i++) {\n        const rt = comp.stack[i].rt;\n        const pathItem = rt.getStaticPathLiteral(comp);\n        if (pathItem) {\n            path.push(pathItem);\n        } else if (isChildAccessorType(rt) && !rt.skipSettingAccessor?.()) {\n            path.push(rt.getChildLiteral(comp));\n        }\n        rtName.push({path: [...path], name: rt.constructor.name});\n    }\n    return path;\n}\n\nfunction validateCompilerOptions(opts: RunTypeOptions): void {\n    if (opts.paramsSlice) {\n        const start = opts.paramsSlice?.start;\n        const end = opts.paramsSlice?.end;\n        if (start && start < 0) {\n            throw new Error(`paramsSlice.start must be greater than 0`);\n        }\n        if (end && end < 0) {\n            throw new Error(`paramsSlice.end must be greater than 0`);\n        }\n        if (end && start && end <= start) {\n            throw new Error(`paramsSlice.end must be greater than paramsSlice.start`);\n        }\n    }\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/lib/jitFnsRegistry.d.ts

@@ -0,0 +1,6 @@
+import { JitFnID } from '../types.ts';
+import { JitFnSettings } from '../constants.functions.ts';
+export declare function registerJitFunctionCompiler(jitFnSettings: JitFnSettings): Promise<(...args: any[]) => any>;
+export declare function getJitFunctionCompiler(jitFnSettings: JitFnSettings): (...args: any[]) => any;
+export declare function getJitFnSettings(fnID: JitFnID): JitFnSettings;
+export declare function getJITFnName(fnID: JitFnID): string;

package/.dist/esm/src/lib/jitFnsRegistry.js

@@ -0,0 +1,41 @@
+import { jitFunctionsById, jitFunctionList } from "../constants.functions.js";
+const jitFunctionsRegistry = /* @__PURE__ */ new Map();
+const nativeIds = new Set(jitFunctionList.filter((f) => !f.import).map((f) => f.id));
+async function registerJitFunctionCompiler(jitFnSettings) {
+  const existing = jitFunctionsRegistry.get(jitFnSettings.id);
+  if (nativeIds.has(jitFnSettings.id))
+    throw new Error(`Jit function ${jitFnSettings.name} is native and can not be registered`);
+  if (existing) return existing.compiler;
+  if (!jitFnSettings.import) throw new Error(`Jit function ${jitFnSettings.name} has no import function`);
+  try {
+    const newFn = await jitFnSettings.import();
+    jitFunctionsRegistry.set(jitFnSettings.id, {
+      jitFnSettings,
+      compiler: newFn
+    });
+    return newFn;
+  } catch (e) {
+    console.warn(e);
+    throw new Error(`Error loading jit function ${jitFnSettings.name}: ${e?.message}`);
+  }
+}
+function getJitFunctionCompiler(jitFnSettings) {
+  const existing = jitFunctionsRegistry.get(jitFnSettings.id);
+  if (existing) return existing.compiler;
+  throw new Error(`Function ${jitFnSettings.name} has not been loaded.`);
+}
+function getJitFnSettings(fnID) {
+  const fnConfig = jitFunctionsById[fnID] || jitFunctionsRegistry.get(fnID)?.jitFnSettings;
+  if (fnConfig === void 0) throw new Error(`Unknown jit function id: ${fnID}`);
+  return fnConfig;
+}
+function getJITFnName(fnID) {
+  return getJitFnSettings(fnID).name;
+}
+export {
+  getJITFnName,
+  getJitFnSettings,
+  getJitFunctionCompiler,
+  registerJitFunctionCompiler
+};
+//# sourceMappingURL=jitFnsRegistry.js.map

package/.dist/esm/src/lib/jitFnsRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitFnsRegistry.js","sources":["../../../../src/lib/jitFnsRegistry.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 type {JitFnID} from '../types.ts';\nimport {JitFnSettings, jitFunctionList, jitFunctionsById} from '../constants.functions.ts';\n\ntype resolvedCompiler = {\n    jitFnSettings: JitFnSettings;\n    compiler: (...args: any[]) => any;\n};\n\nconst jitFunctionsRegistry: Map<string, resolvedCompiler> = new Map();\nconst nativeIds: Set<string> = new Set(jitFunctionList.filter((f) => !f.import).map((f) => f.id));\n\nexport async function registerJitFunctionCompiler(jitFnSettings: JitFnSettings): Promise<(...args: any[]) => any> {\n    const existing = jitFunctionsRegistry.get(jitFnSettings.id);\n    if (nativeIds.has(jitFnSettings.id))\n        throw new Error(`Jit function ${jitFnSettings.name} is native and can not be registered`);\n    if (existing) return existing.compiler;\n    if (!jitFnSettings.import) throw new Error(`Jit function ${jitFnSettings.name} has no import function`);\n    try {\n        const newFn = await jitFnSettings.import();\n        jitFunctionsRegistry.set(jitFnSettings.id, {\n            jitFnSettings: jitFnSettings,\n            compiler: newFn,\n        });\n        return newFn;\n    } catch (e: any) {\n        console.warn(e);\n        throw new Error(`Error loading jit function ${jitFnSettings.name}: ${e?.message}`);\n    }\n}\n\n/** synchronous version of loadRegisteredFunction, throws an error if the function has not been loaded */\nexport function getJitFunctionCompiler(jitFnSettings: JitFnSettings): (...args: any[]) => any {\n    const existing = jitFunctionsRegistry.get(jitFnSettings.id);\n    if (existing) return existing.compiler;\n    throw new Error(`Function ${jitFnSettings.name} has not been loaded.`);\n}\n\nexport function getJitFnSettings(fnID: JitFnID): JitFnSettings {\n    const fnConfig = jitFunctionsById[fnID] || jitFunctionsRegistry.get(fnID)?.jitFnSettings;\n    if (fnConfig === undefined) throw new Error(`Unknown jit function id: ${fnID}`);\n    return fnConfig;\n}\n\nexport function getJITFnName(fnID: JitFnID): string {\n    return getJitFnSettings(fnID).name;\n}\n"],"names":[],"mappings":";AAeA,MAAM,2CAA0D,IAAA;AAChE,MAAM,YAAyB,IAAI,IAAI,gBAAgB,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AAEhG,eAAsB,4BAA4B,eAAgE;AAC9G,QAAM,WAAW,qBAAqB,IAAI,cAAc,EAAE;AAC1D,MAAI,UAAU,IAAI,cAAc,EAAE;AAC9B,UAAM,IAAI,MAAM,gBAAgB,cAAc,IAAI,sCAAsC;AAC5F,MAAI,iBAAiB,SAAS;AAC9B,MAAI,CAAC,cAAc,OAAQ,OAAM,IAAI,MAAM,gBAAgB,cAAc,IAAI,yBAAyB;AACtG,MAAI;AACA,UAAM,QAAQ,MAAM,cAAc,OAAA;AAClC,yBAAqB,IAAI,cAAc,IAAI;AAAA,MACvC;AAAA,MACA,UAAU;AAAA,IAAA,CACb;AACD,WAAO;AAAA,EACX,SAAS,GAAQ;AACb,YAAQ,KAAK,CAAC;AACd,UAAM,IAAI,MAAM,8BAA8B,cAAc,IAAI,KAAK,GAAG,OAAO,EAAE;AAAA,EACrF;AACJ;AAGO,SAAS,uBAAuB,eAAuD;AAC1F,QAAM,WAAW,qBAAqB,IAAI,cAAc,EAAE;AAC1D,MAAI,iBAAiB,SAAS;AAC9B,QAAM,IAAI,MAAM,YAAY,cAAc,IAAI,uBAAuB;AACzE;AAEO,SAAS,iBAAiB,MAA8B;AAC3D,QAAM,WAAW,iBAAiB,IAAI,KAAK,qBAAqB,IAAI,IAAI,GAAG;AAC3E,MAAI,aAAa,OAAW,OAAM,IAAI,MAAM,4BAA4B,IAAI,EAAE;AAC9E,SAAO;AACX;AAEO,SAAS,aAAa,MAAuB;AAChD,SAAO,iBAAiB,IAAI,EAAE;AAClC;"}

package/.dist/esm/src/lib/typeId.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@deepkit/type';
+import { SrcType, StrNumber } from '../types.ts';
+export type TypeWithCachedIds = Type & Pick<Partial<SrcType>, '_typeId' | '_formatId'>;
+export declare function createTypeId(type: TypeWithCachedIds, stack?: Type[]): StrNumber;
+export declare function computeDeepkitFormatID(deepkitType: TypeWithCachedIds): string | undefined;
+export declare type __ΩTypeWithCachedIds = any[];

package/.dist/esm/src/lib/typeId.js

@@ -0,0 +1,205 @@
+import { ReflectionKind, typeAnnotation } from "@deepkit/type";
+import { MAX_STACK_DEPTH } from "@mionjs/core";
+import { ReflectionSubKind } from "../constants.kind.js";
+import { hasTypes, hasType, hasParameters } from "./guards.js";
+import { getFormatterFromCache, defaultIgnoreFormatProps } from "./formats.js";
+import { typeParamsToString } from "./utils.js";
+function createTypeId(type, stack = []) {
+  if (type._typeId !== void 0) return type._typeId;
+  const typeId = _createTypeId(type, stack);
+  type._typeId = typeId;
+  return typeId;
+}
+function _createTypeId(type, stack) {
+  if (stack.length > MAX_STACK_DEPTH) {
+    throw new Error(`Max stack depth exceeded while computing type ID. This usually indicates a circular type reference.`);
+  }
+  const circularId = checkCircularAndGetRefId(type, stack);
+  if (circularId !== void 0) return circularId;
+  const kind = type.subKind || type.kind;
+  const baseTypeId = computeBaseTypeId(type, kind, stack);
+  const formatId = computeDeepkitFormatID(type);
+  if (formatId) return `${baseTypeId}${formatId}`;
+  return baseTypeId;
+}
+function computeBaseTypeId(type, kind, stack) {
+  const subKind = type.subKind;
+  if (subKind === ReflectionSubKind.params) return computeParamsTypeId(type, stack);
+  switch (type.kind) {
+    // Atomic types - just return the kind
+    case ReflectionKind.any:
+    case ReflectionKind.bigint:
+    case ReflectionKind.boolean:
+    case ReflectionKind.never:
+    case ReflectionKind.null:
+    case ReflectionKind.number:
+    case ReflectionKind.object:
+    case ReflectionKind.regexp:
+    case ReflectionKind.string:
+    case ReflectionKind.symbol:
+    case ReflectionKind.undefined:
+    case ReflectionKind.unknown:
+    case ReflectionKind.void:
+    case ReflectionKind.enum:
+    case ReflectionKind.enumMember:
+    case ReflectionKind.promise:
+      return kind;
+    case ReflectionKind.literal: {
+      const literal = type.literal;
+      return `${kind}:${String(literal)}`;
+    }
+    // Collection types - contain multiple child types
+    case ReflectionKind.union:
+    case ReflectionKind.intersection:
+    case ReflectionKind.objectLiteral:
+    case ReflectionKind.tuple:
+      return computeCollectionTypeId(type, stack);
+    // Member types - contain a single child type
+    case ReflectionKind.array:
+    case ReflectionKind.property:
+    case ReflectionKind.propertySignature:
+    case ReflectionKind.tupleMember:
+    case ReflectionKind.parameter:
+    case ReflectionKind.rest:
+    case ReflectionKind.indexSignature:
+      return computeMemberTypeId(type, stack);
+    // Function types
+    case ReflectionKind.function: {
+      const parent = type.parent;
+      const name = type.name;
+      if (name && parent && (parent.kind === ReflectionKind.objectLiteral || parent.kind === ReflectionKind.class)) {
+        return `${ReflectionKind.function}${String(name)}`;
+      }
+      return ReflectionKind.function;
+    }
+    case ReflectionKind.method:
+    case ReflectionKind.methodSignature:
+    case ReflectionKind.callSignature:
+      return computeFunctionTypeId(type);
+    // Class types
+    case ReflectionKind.class:
+      return computeClassTypeId(type, stack);
+    default:
+      if (hasTypes(type)) return computeCollectionTypeId(type, stack);
+      if (hasType(type)) return computeMemberTypeId(type, stack);
+      return kind;
+  }
+}
+function computeCollectionTypeId(type, stack) {
+  const types = type.types;
+  if (!Array.isArray(types)) return type.subKind || type.kind;
+  stack.push(type);
+  const childIds = [];
+  for (const childType of types) childIds.push(_createTypeId(childType, stack));
+  stack.pop();
+  const isTuple = type.kind === ReflectionKind.tuple;
+  const groupID = isTuple ? `[${childIds.join(",")}]` : `{${childIds.join(",")}}`;
+  const kind = type.subKind || type.kind;
+  return `${kind}${groupID}`;
+}
+function computeMemberTypeId(type, stack) {
+  const memberType = type.type;
+  if (!memberType || typeof memberType.kind !== "number") return type.subKind || type.kind;
+  const isRest = memberType.kind === ReflectionKind.rest;
+  const isTupleParam = type.kind === ReflectionKind.tupleMember || type.kind === ReflectionKind.parameter;
+  const hasDefault = isTupleParam && type.default !== void 0;
+  const optional = type.optional || type.kind === ReflectionKind.indexSignature || isRest || hasDefault ? "?" : "";
+  const propName = type.name?.toString() || type.index?.kind || type.subKind || type.kind;
+  const kindID = `${propName}${optional}`;
+  const circularId = checkCircularAndGetRefId(type, stack);
+  if (circularId) return `${kindID}:${circularId}`;
+  stack.push(type);
+  const memberTypeId = _createTypeId(memberType, stack);
+  stack.pop();
+  return `${kindID}:${memberTypeId}`;
+}
+function computeFunctionTypeId(type) {
+  const kind = ReflectionKind.function;
+  const parent = type.parent;
+  const name = type.name;
+  let baseId;
+  if (name && parent && (parent.kind === ReflectionKind.objectLiteral || parent.kind === ReflectionKind.class)) {
+    baseId = `${kind}${String(name)}`;
+  } else {
+    baseId = String(kind);
+  }
+  const isOptional = !!type.optional;
+  return isOptional ? `${baseId}:?` : baseId;
+}
+function computeClassTypeId(type, stack) {
+  if (type.classType === Date) return ReflectionSubKind.date;
+  if (type.classType === Map) {
+    const args = type.arguments;
+    if (!args || args.length !== 2) return ReflectionSubKind.map;
+    stack.push(type);
+    const keyTypeId = _createTypeId(args[0], stack);
+    const valueTypeId = _createTypeId(args[1], stack);
+    stack.pop();
+    return `${ReflectionSubKind.map}{${ReflectionSubKind.mapKey}:${keyTypeId},${ReflectionSubKind.mapValue}:${valueTypeId}}`;
+  }
+  if (type.classType === Set) {
+    const args = type.arguments;
+    if (!args || args.length !== 1) return ReflectionSubKind.set;
+    stack.push(type);
+    const itemTypeId = _createTypeId(args[0], stack);
+    stack.pop();
+    return `${ReflectionSubKind.set}{${ReflectionSubKind.setItem}:${itemTypeId}}`;
+  }
+  const kind = type.subKind || type.kind;
+  const types = type.types;
+  if (Array.isArray(types) && types.length > 0) {
+    stack.push(type);
+    const childIds = types.map((t) => _createTypeId(t, stack));
+    stack.pop();
+    return `${kind}{${childIds.join(",")}}`;
+  }
+  return kind;
+}
+function computeParamsTypeId(type, stack) {
+  if (!hasParameters(type)) return type.subKind || type.kind;
+  const circularId = checkCircularAndGetRefId(type, stack);
+  if (circularId) return circularId;
+  stack.push(type);
+  const childIds = [];
+  for (const param of type.parameters) childIds.push(_createTypeId(param, stack));
+  stack.pop();
+  const kind = type.subKind || type.kind;
+  return `${kind}{${childIds.join(",")}}`;
+}
+function checkCircularAndGetRefId(type, stack) {
+  const inStackIndex = stack.findIndex((t) => {
+    if (t === type) return true;
+    return t.id && type.id && t.id === type.id;
+  });
+  if (inStackIndex >= 0) {
+    const name = type.typeName || "";
+    return "$" + type.kind + `_${inStackIndex}` + name;
+  }
+  return void 0;
+}
+function computeDeepkitFormatID(deepkitType) {
+  if (deepkitType._formatId !== void 0) return deepkitType._formatId || void 0;
+  const annotations = typeAnnotation.getAnnotations(deepkitType);
+  if (annotations.length === 0) {
+    deepkitType._formatId = "";
+    return void 0;
+  }
+  for (const annotation of annotations) {
+    const formatAnnotation = annotation;
+    if (!formatAnnotation.name) continue;
+    const formatter = getFormatterFromCache(deepkitType.kind, formatAnnotation.name);
+    if (!formatter) continue;
+    const params = typeAnnotation.getOption(deepkitType, formatAnnotation.name);
+    if (!params) continue;
+    const formatId = `<${typeParamsToString(params, defaultIgnoreFormatProps)}>`;
+    deepkitType._formatId = formatId;
+    return formatId;
+  }
+  deepkitType._formatId = "";
+  return void 0;
+}
+export {
+  computeDeepkitFormatID,
+  createTypeId
+};
+//# sourceMappingURL=typeId.js.map

package/.dist/esm/src/lib/typeId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeId.js","sources":["../../../../src/lib/typeId.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {Type, TypeIndexSignature, TypeProperty, ReflectionKind, TypeClass, typeAnnotation} from '@deepkit/type';\nimport {MAX_STACK_DEPTH, TypeFormatParams} from '@mionjs/core';\nimport {ReflectionSubKind} from '../constants.kind.ts';\nimport {hasType, hasTypes, hasParameters} from './guards.ts';\nimport {getFormatterFromCache, defaultIgnoreFormatProps} from './formats.ts';\nimport {typeParamsToString} from './utils.ts';\nimport type {FormatAnnotation, SrcType, StrNumber} from '../types.ts';\n\n/** Type with optional cached _typeId and _formatId properties - compatible with SrcType */\nexport type TypeWithCachedIds = Type & Pick<Partial<SrcType>, '_typeId' | '_formatId'>;\n\n/** Generates a unique type ID directly from a deepkit Type object. Caches result in type._typeId */\nexport function createTypeId(type: TypeWithCachedIds, stack: Type[] = []): StrNumber {\n    if (type._typeId !== undefined) return type._typeId;\n    const typeId = _createTypeId(type, stack);\n    (type as any)._typeId = typeId;\n    return typeId;\n}\n\nfunction _createTypeId(type: Type, stack: Type[]): StrNumber {\n    if (stack.length > MAX_STACK_DEPTH) {\n        throw new Error(`Max stack depth exceeded while computing type ID. This usually indicates a circular type reference.`);\n    }\n    const circularId = checkCircularAndGetRefId(type, stack);\n    if (circularId !== undefined) return circularId;\n    const kind = (type as any).subKind || type.kind;\n    const baseTypeId = computeBaseTypeId(type, kind, stack);\n    const formatId = computeDeepkitFormatID(type as TypeWithCachedIds);\n    if (formatId) return `${baseTypeId}${formatId}`;\n    return baseTypeId;\n}\n\nfunction computeBaseTypeId(type: Type, kind: number, stack: Type[]): StrNumber {\n    const subKind = (type as any).subKind;\n    if (subKind === ReflectionSubKind.params) return computeParamsTypeId(type, stack);\n\n    switch (type.kind) {\n        // Atomic types - just return the kind\n        case ReflectionKind.any:\n        case ReflectionKind.bigint:\n        case ReflectionKind.boolean:\n        case ReflectionKind.never:\n        case ReflectionKind.null:\n        case ReflectionKind.number:\n        case ReflectionKind.object:\n        case ReflectionKind.regexp:\n        case ReflectionKind.string:\n        case ReflectionKind.symbol:\n        case ReflectionKind.undefined:\n        case ReflectionKind.unknown:\n        case ReflectionKind.void:\n        case ReflectionKind.enum:\n        case ReflectionKind.enumMember:\n        case ReflectionKind.promise:\n            return kind;\n        case ReflectionKind.literal: {\n            const literal = (type as any).literal;\n            return `${kind}:${String(literal)}`;\n        }\n        // Collection types - contain multiple child types\n        case ReflectionKind.union:\n        case ReflectionKind.intersection:\n        case ReflectionKind.objectLiteral:\n        case ReflectionKind.tuple:\n            return computeCollectionTypeId(type, stack);\n        // Member types - contain a single child type\n        case ReflectionKind.array:\n        case ReflectionKind.property:\n        case ReflectionKind.propertySignature:\n        case ReflectionKind.tupleMember:\n        case ReflectionKind.parameter:\n        case ReflectionKind.rest:\n        case ReflectionKind.indexSignature:\n            return computeMemberTypeId(type, stack);\n        // Function types\n        case ReflectionKind.function: {\n            const parent = type.parent;\n            const name = (type as any).name;\n            if (name && parent && (parent.kind === ReflectionKind.objectLiteral || parent.kind === ReflectionKind.class)) {\n                return `${ReflectionKind.function}${String(name)}`;\n            }\n            return ReflectionKind.function;\n        }\n        case ReflectionKind.method:\n        case ReflectionKind.methodSignature:\n        case ReflectionKind.callSignature:\n            return computeFunctionTypeId(type);\n        // Class types\n        case ReflectionKind.class:\n            return computeClassTypeId(type as TypeClass, stack);\n        default:\n            if (hasTypes(type)) return computeCollectionTypeId(type, stack);\n            if (hasType(type)) return computeMemberTypeId(type, stack);\n            return kind;\n    }\n}\n\nfunction computeCollectionTypeId(type: Type, stack: Type[]): StrNumber {\n    const types = (type as any).types as Type[] | undefined;\n    if (!Array.isArray(types)) return (type as any).subKind || type.kind;\n    stack.push(type);\n    const childIds: StrNumber[] = [];\n    for (const childType of types) childIds.push(_createTypeId(childType, stack));\n    stack.pop();\n    const isTuple = type.kind === ReflectionKind.tuple;\n    const groupID = isTuple ? `[${childIds.join(',')}]` : `{${childIds.join(',')}}`;\n    const kind = (type as any).subKind || type.kind;\n    return `${kind}${groupID}`;\n}\n\nfunction computeMemberTypeId(type: Type, stack: Type[]): StrNumber {\n    const memberType = (type as any).type as Type | undefined;\n    if (!memberType || typeof memberType.kind !== 'number') return (type as any).subKind || type.kind;\n    const isRest = memberType.kind === ReflectionKind.rest;\n    const isTupleParam = type.kind === ReflectionKind.tupleMember || type.kind === ReflectionKind.parameter;\n    const hasDefault = isTupleParam && (type as any).default !== undefined;\n    const optional = (type as any).optional || type.kind === ReflectionKind.indexSignature || isRest || hasDefault ? '?' : '';\n    const propName =\n        (type as TypeProperty).name?.toString() || (type as TypeIndexSignature).index?.kind || (type as any).subKind || type.kind;\n    const kindID = `${propName}${optional}`;\n    const circularId = checkCircularAndGetRefId(type, stack);\n    if (circularId) return `${kindID}:${circularId}`;\n    stack.push(type);\n    const memberTypeId = _createTypeId(memberType, stack);\n    stack.pop();\n    return `${kindID}:${memberTypeId}`;\n}\n\nfunction computeFunctionTypeId(type: Type): StrNumber {\n    const kind = ReflectionKind.function;\n    const parent = type.parent;\n    const name = (type as any).name;\n    let baseId: string;\n    if (name && parent && (parent.kind === ReflectionKind.objectLiteral || parent.kind === ReflectionKind.class)) {\n        baseId = `${kind}${String(name)}`;\n    } else {\n        baseId = String(kind);\n    }\n    const isOptional = !!(type as any).optional;\n    return isOptional ? `${baseId}:?` : baseId;\n}\n\nfunction computeClassTypeId(type: TypeClass, stack: Type[]): StrNumber {\n    if (type.classType === Date) return ReflectionSubKind.date;\n    if (type.classType === Map) {\n        const args = type.arguments;\n        if (!args || args.length !== 2) return ReflectionSubKind.map;\n        stack.push(type);\n        const keyTypeId = _createTypeId(args[0], stack);\n        const valueTypeId = _createTypeId(args[1], stack);\n        stack.pop();\n        return `${ReflectionSubKind.map}{${ReflectionSubKind.mapKey}:${keyTypeId},${ReflectionSubKind.mapValue}:${valueTypeId}}`;\n    }\n    if (type.classType === Set) {\n        const args = type.arguments;\n        if (!args || args.length !== 1) return ReflectionSubKind.set;\n        stack.push(type);\n        const itemTypeId = _createTypeId(args[0], stack);\n        stack.pop();\n        return `${ReflectionSubKind.set}{${ReflectionSubKind.setItem}:${itemTypeId}}`;\n    }\n    const kind = (type as any).subKind || type.kind;\n    const types = (type as any).types as Type[] | undefined;\n    if (Array.isArray(types) && types.length > 0) {\n        stack.push(type);\n        const childIds = types.map((t) => _createTypeId(t, stack));\n        stack.pop();\n        return `${kind}{${childIds.join(',')}}`;\n    }\n    return kind;\n}\n\nfunction computeParamsTypeId(type: Type, stack: Type[]): StrNumber {\n    if (!hasParameters(type)) return (type as any).subKind || type.kind;\n    const circularId = checkCircularAndGetRefId(type, stack);\n    if (circularId) return circularId;\n    stack.push(type);\n    const childIds: StrNumber[] = [];\n    for (const param of type.parameters) childIds.push(_createTypeId(param, stack));\n    stack.pop();\n    const kind = (type as any).subKind || type.kind;\n    return `${kind}{${childIds.join(',')}}`;\n}\n\nfunction checkCircularAndGetRefId(type: Type, stack: Type[]): StrNumber | undefined {\n    const inStackIndex = stack.findIndex((t) => {\n        if (t === type) return true;\n        return t.id && type.id && t.id === type.id;\n    });\n    if (inStackIndex >= 0) {\n        const name = type.typeName || '';\n        return '$' + type.kind + `_${inStackIndex}` + name;\n    }\n    return undefined;\n}\n\n/** Computes the format ID from a deepkit Type. Caches result in type._formatId */\nexport function computeDeepkitFormatID(deepkitType: TypeWithCachedIds): string | undefined {\n    if (deepkitType._formatId !== undefined) return deepkitType._formatId || undefined;\n    const annotations = typeAnnotation.getAnnotations(deepkitType);\n    if (annotations.length === 0) {\n        (deepkitType as any)._formatId = '';\n        return undefined;\n    }\n    for (const annotation of annotations) {\n        const formatAnnotation = annotation as FormatAnnotation;\n        if (!formatAnnotation.name) continue;\n        const formatter = getFormatterFromCache(deepkitType.kind, formatAnnotation.name);\n        if (!formatter) continue;\n        const params = typeAnnotation.getOption(deepkitType, formatAnnotation.name) as TypeFormatParams;\n        if (!params) continue;\n        const formatId = `<${typeParamsToString(params, defaultIgnoreFormatProps)}>`;\n        (deepkitType as any)._formatId = formatId;\n        return formatId;\n    }\n    (deepkitType as any)._formatId = '';\n    return undefined;\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/lib/utils.d.ts

@@ -0,0 +1,32 @@
+import { ReflectionKind, Type, TypeParameter, TypeTupleMember } from '@deepkit/type';
+import { CompiledPureFunction, TypeFormatValue } from '@mionjs/core';
+import { AnyClass, JitFnID, RunType, JitCode } from '../types.ts';
+import { BaseRunType } from './baseRunTypes.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from './jitFnCompiler.ts';
+export declare function toLiteral(value: number | string | boolean | undefined | null | bigint | RegExp | symbol): string;
+export declare function arrayToLiteral(value: any[]): string;
+export declare function arrayToArgumentsLiteral(value: any[]): string;
+export declare function isFunctionKind(kind: ReflectionKind): boolean;
+export declare function isClass(cls: AnyClass | any): cls is AnyClass;
+export declare function isSameJitType(a: RunType, b: RunType): boolean;
+export declare function isSameJitCompiler(a: JitFnCompiler, b: JitFnCompiler): boolean;
+export declare function memorize<Fn extends (...args: any[]) => any>(fn: Fn): Fn;
+export declare function isSafePropName(name: string | number | symbol): boolean;
+export declare function sanitizePropName(name: string | number | symbol): string;
+export declare function getPropVarName(name: string | number | symbol): string | number;
+export declare function getPropLiteral(name: string | number | symbol): string | number;
+export declare function useArrayAccessorForProp(name: string | number | symbol): boolean;
+export declare function getPropIndex(src: Type): number;
+export declare function getParamIndex(src: TypeParameter | TypeTupleMember): number;
+export declare function childIsExpression(childJCode: JitCode, child: BaseRunType): boolean;
+export declare function toLiteralInContext(comp: JitFnCompiler | JitErrorsFnCompiler, params: TypeFormatValue | Record<string, string | CompiledPureFunction>, ignoreProps?: string[], isDependencies?: boolean): string;
+export declare function dependencyValueToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler | undefined, propVal: any): string;
+export declare function typeParamsToString(params: TypeFormatValue | Record<string, string | CompiledPureFunction>, ignoreProps: string[]): string;
+export declare function getFormatterHash(rt: BaseRunType): string;
+export declare function getTotalComplexity(comp: JitFnCompiler, rt: BaseRunType, stack?: BaseRunType[]): number;
+export declare function sortRunTypeByComplexity(comp: JitFnCompiler, a: BaseRunType, b: BaseRunType): number;
+export declare function sortDiscriminatorsFirst(a: BaseRunType, b: BaseRunType): number;
+export declare function createIfElseFn(): (isEnd?: boolean) => string;
+export declare function getJitFnArgCallVarName(parentComp: JitFnCompiler, rt: BaseRunType, idFnToCall: JitFnID, argKey: string): string;
+export declare function parentIs(rt: BaseRunType, kind: ReflectionKind | ReflectionKind[]): boolean;
+export declare function addFullStop(code: string): string;