@mionjs/run-types 0.8.10 → 0.13.2

package/.dist/cjs/src/jitCompilers/json/toJsCode.cjs

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("@deepkit/type");
-const src_constants_kind = require("../../constants.kind.cjs");
-const src_constants_functions = require("../../constants.functions.cjs");
-const src_lib_utils = require("../../lib/utils.cjs");
-const src_jitCompilers_json_stringifyJson = require("./stringifyJson.cjs");
-const src_runTypesPureFns = require("../../run-types-pure-fns.cjs");
-function createToCodeCompiler() {
-  const fnID = src_constants_functions.JitFunctions.toJSCode.id;
-  const visitJsonStringify = src_jitCompilers_json_stringifyJson.createStringifyCompiler(fnID);
-  const visitJsonStringifyIterable = src_jitCompilers_json_stringifyJson.createStringifyIterable(fnID);
-  function compileToCode(runType, comp) {
-    const src = runType.src;
-    const kind = src.kind;
-    switch (kind) {
-      // ###################### ATOMIC RUNTYPES ######################
-      case type.ReflectionKind.undefined:
-        return { code: `'undefined'`, type: "E" };
-      case type.ReflectionKind.symbol:
-        return { code: `'Symbol('+'"'+${comp.vλl}.description+'"'+')'`, type: "E" };
-      // ###################### MEMBER RUNTYPES ######################
-      case type.ReflectionKind.methodSignature: {
-        const rt = runType;
-        const srcMS = src;
-        const accessor = srcMS.name;
-        const name = String(accessor);
-        const isSafe = src_lib_utils.isSafePropName(accessor);
-        const safeName = isSafe ? name : JSON.stringify(name);
-        const sep = rt.skipCommas ? "" : '+","';
-        if (isCompilingFnProp(rt, comp)) {
-          return { code: `'undefined'`, type: "E" };
-        } else if (isCompilingClosureFn(rt, comp)) {
-          const parentRef = getParentObjRef(srcMS, comp);
-          const isPureFn = rt.getChildVarName(comp) === "createPureFn";
-          const fnName = isPureFn ? `${parentRef}.fnName` : `${parentRef}.jitFnHash`;
-          const fnCode = `${parentRef}.code`;
-          const paramList = isPureFn ? `${parentRef}.paramNames.join(',')` : `'utl'`;
-          const closureCode = `'function get_'+${fnName}+'('+${paramList}+'){'+${fnCode}+'}'`;
-          const isWrapped = parentRef !== comp.vλl;
-          if (isWrapped) return { code: closureCode, type: "E" };
-          return { code: `'${safeName}:'+${closureCode}${sep}`, type: "E" };
-        } else if (rt.src.subKind === src_constants_kind.ReflectionSubKind.params) {
-          const paramsCode = visitJsonStringify(rt, comp);
-          if (rt.isOptional())
-            return {
-              code: `(${comp.getChildVλl()} === undefined ? "" : '${safeName}:'+${paramsCode?.code}${sep})`,
-              type: "E"
-            };
-          return { code: `'${safeName}:'+${paramsCode?.code}${sep}`, type: "E" };
-        } else {
-          const fnName = comp.addPureFunction(src_runTypesPureFns.cpf_sanitizeCompiledFn);
-          const parent = srcMS.parent;
-          const isDuplicatedChild = parent?.kind === type.ReflectionKind.propertySignature && parent?.name === srcMS.name;
-          if (isDuplicatedChild) return { code: `${fnName}(${comp.vλl}.toString())`, type: "E" };
-          const accessorCode = isSafe ? `.${safeName}` : `[${safeName}]`;
-          const fnCode = `${fnName}(${comp.vλl}${accessorCode}.toString())`;
-          if (rt.isOptional())
-            return { code: `(${comp.getChildVλl()} === undefined ? "" : '${safeName}:'+${fnCode}${sep})`, type: "E" };
-          return { code: `'${safeName}:'+${fnCode}${sep}`, type: "E" };
-        }
-      }
-      case type.ReflectionKind.function:
-      case type.ReflectionKind.method:
-      case type.ReflectionKind.callSignature:
-        if (runType.src.subKind === src_constants_kind.ReflectionSubKind.params) {
-          return visitJsonStringify(runType, comp);
-        } else {
-          return { code: `${comp.vλl}.toString()`, type: "E" };
-        }
-      // ###################### COLLECTION RUNTYPES ######################
-      case type.ReflectionKind.class: {
-        switch (runType.src.subKind) {
-          case src_constants_kind.ReflectionSubKind.date:
-            return { code: `'new Date('+${visitJsonStringify(runType, comp).code}+')'`, type: "E" };
-          case src_constants_kind.ReflectionSubKind.map: {
-            return visitJsonStringifyIterable(runType, comp, "new Map(", ")");
-          }
-          case src_constants_kind.ReflectionSubKind.set: {
-            return visitJsonStringifyIterable(runType, comp, "new Set(", ")");
-          }
-          case src_constants_kind.ReflectionSubKind.nonSerializable:
-            throw new Error(`Can not generate code for Non Serializable types.`);
-          default: {
-            const rt = runType;
-            throw new Error(`Can not generate code for classes. Class: ${rt.getClassName()}`);
-          }
-        }
-      }
-      default:
-        return visitJsonStringify(runType, comp);
-    }
-  }
-  return compileToCode;
-}
-let lazyFn = void 0;
-function emitToCode(runType, comp) {
-  if (!lazyFn) lazyFn = createToCodeCompiler();
-  return lazyFn(runType, comp);
-}
-function getParentSiblingNames(srcMS) {
-  let parent = srcMS.parent;
-  if (parent?.kind === type.ReflectionKind.propertySignature) parent = parent.parent;
-  if (parent?.kind !== type.ReflectionKind.objectLiteral) return void 0;
-  const types = parent.types;
-  if (!types) return void 0;
-  return new Set(types.map((t) => t.name).filter((n) => n !== void 0));
-}
-function isCompilingClosureFn(runType, comp) {
-  const childName = runType.getChildVarName(comp);
-  if (childName !== "createJitFn" && childName !== "createPureFn") return false;
-  const siblings = getParentSiblingNames(runType.src);
-  if (!siblings) return false;
-  if (childName === "createJitFn") return siblings.has("jitFnHash");
-  return siblings.has("bodyHash");
-}
-function isCompilingFnProp(runType, comp) {
-  if (runType.getChildVarName(comp) !== "fn") return false;
-  const siblings = getParentSiblingNames(runType.src);
-  if (!siblings) return false;
-  return siblings.has("createJitFn") && siblings.has("jitFnHash") || siblings.has("createPureFn") && siblings.has("bodyHash");
-}
-function getParentObjRef(_srcMS, comp) {
-  const stack = comp.stack;
-  const parentItem = stack[stack.length - 2];
-  if (parentItem && parentItem.vλl !== comp.vλl) return parentItem.vλl;
-  return comp.vλl;
-}
-exports.createToCodeCompiler = createToCodeCompiler;
-exports.emitToCode = emitToCode;
-//# sourceMappingURL=toJsCode.cjs.map

package/.dist/cjs/src/jitCompilers/json/toJsCode.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"toJsCode.cjs","sources":["../../../../../src/jitCompilers/json/toJsCode.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 {JitCode} from '../../types.ts';\nimport type {BaseRunType} from '../../lib/baseRunTypes.ts';\nimport type {ClassRunType} from '../../nodes/collection/class.ts';\nimport type {MethodSignatureRunType} from '../../nodes/member/methodSignature.ts';\nimport type {IterableRunType} from '../../nodes/native/Iterable.ts';\nimport {ReflectionKind, type TypeMethodSignature, type TypeObjectLiteral, type TypePropertySignature} from '@deepkit/type';\nimport {ReflectionSubKind} from '../../constants.kind.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\nimport {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {isSafePropName} from '../../lib/utils.ts';\nimport {createStringifyCompiler, createStringifyIterable} from './stringifyJson.ts';\nimport {cpf_sanitizeCompiledFn} from '../../run-types-pure-fns.ts';\n\nexport function createToCodeCompiler() {\n    const fnID = JitFunctions.toJSCode.id;\n    const visitJsonStringify = createStringifyCompiler(fnID);\n    const visitJsonStringifyIterable = createStringifyIterable(fnID);\n\n    /**\n     * Compiles jit code to generate JavaScript code from data structures that match a Type.\n     * Process is similar to transform JS to JSON, but with few differences.\n     *\n     * 1 - jitFunctions and pureFunctions are emitted as src code\n     * 2 - Some native classes are supported and initialized using the new operator, ie: new Map(<data>), new Set(<data>), new Date(<data>), etc...\n     *\n     * THIS IS MOSTLY USED INTERNALLY FOR AOT CODE GENERATION AND A VERY BASIC IMPLEMENTATION.\n     * !!! NOT INTENDED FOR PUBLIC USE !!!\n     */\n    function compileToCode(runType: BaseRunType, comp: JitFnCompiler): JitCode {\n        const src = runType.src;\n        const kind = src.kind;\n\n        switch (kind) {\n            // ###################### ATOMIC RUNTYPES ######################\n            case ReflectionKind.undefined:\n                return {code: `'undefined'`, type: 'E'};\n            case ReflectionKind.symbol:\n                return {code: `'Symbol('+'\"'+${comp.vλl}.description+'\"'+')'`, type: 'E'};\n            // ###################### MEMBER RUNTYPES ######################\n            case ReflectionKind.methodSignature: {\n                const rt = runType as MethodSignatureRunType;\n                const srcMS = src as TypeMethodSignature;\n                const accessor = srcMS.name;\n                const name = String(accessor);\n                const isSafe = isSafePropName(accessor);\n                const safeName = isSafe ? name : JSON.stringify(name);\n                const sep = rt.skipCommas ? '' : '+\",\"';\n                if (isCompilingFnProp(rt, comp)) {\n                    // special case for JitFunctions/PureFunctions that we know should return undefined for fn param\n                    return {code: `'undefined'`, type: 'E'};\n                } else if (isCompilingClosureFn(rt, comp)) {\n                    // special case for JitFunctions/PureFunctions where we generate the fn from the data instead of fn.toString()\n                    // When using Pick/Omit, deepkit wraps methodSignature in a propertySignature,\n                    // so comp.vλl points to the fn value instead of the parent object. Use getParentObjRef to get the right ref.\n                    const parentRef = getParentObjRef(srcMS, comp);\n                    const isPureFn = rt.getChildVarName(comp) === 'createPureFn';\n                    const fnName = isPureFn ? `${parentRef}.fnName` : `${parentRef}.jitFnHash`;\n                    const fnCode = `${parentRef}.code`;\n                    const paramList = isPureFn ? `${parentRef}.paramNames.join(',')` : `'utl'`;\n                    const closureCode = `'function get_'+${fnName}+'('+${paramList}+'){'+${fnCode}+'}'`;\n                    // When wrapped in a propertySignature (Pick/Omit types), the outer handler already emits the property name\n                    const isWrapped = parentRef !== comp.vλl;\n                    if (isWrapped) return {code: closureCode, type: 'E'};\n                    return {code: `'${safeName}:'+${closureCode}${sep}`, type: 'E'};\n                } else if (rt.src.subKind === ReflectionSubKind.params) {\n                    const paramsCode = visitJsonStringify(rt, comp);\n                    if (rt.isOptional())\n                        return {\n                            code: `(${comp.getChildVλl()} === undefined ? \"\" : '${safeName}:'+${paramsCode?.code}${sep})`,\n                            type: 'E',\n                        };\n                    return {code: `'${safeName}:'+${paramsCode?.code}${sep}`, type: 'E'};\n                } else {\n                    const fnName = comp.addPureFunction(cpf_sanitizeCompiledFn);\n                    const parent = srcMS.parent as any as TypePropertySignature;\n\n                    // in some scenarios the parent is a propertySignature instead the Expected TypeObjectLiteral so we have to handle that\n                    // this seems to be a deepkit bug when using omit and then redefining the property @see SrcCodeJitCompiledFn type\n                    const isDuplicatedChild = parent?.kind === ReflectionKind.propertySignature && parent?.name === srcMS.name;\n                    if (isDuplicatedChild) return {code: `${fnName}(${comp.vλl}.toString())`, type: 'E'};\n                    const accessorCode = isSafe ? `.${safeName}` : `[${safeName}]`;\n                    const fnCode = `${fnName}(${comp.vλl}${accessorCode}.toString())`;\n                    if (rt.isOptional())\n                        return {code: `(${comp.getChildVλl()} === undefined ? \"\" : '${safeName}:'+${fnCode}${sep})`, type: 'E'};\n                    return {code: `'${safeName}:'+${fnCode}${sep}`, type: 'E'};\n                }\n            }\n            case ReflectionKind.function:\n            case ReflectionKind.method:\n            case ReflectionKind.callSignature:\n                if (runType.src.subKind === ReflectionSubKind.params) {\n                    return visitJsonStringify(runType, comp);\n                } else {\n                    // TODO: we are relying in fn.toString() to generate code, this might not work properly in all js engines\n                    return {code: `${comp.vλl}.toString()`, type: 'E'};\n                }\n            // ###################### COLLECTION RUNTYPES ######################\n            case ReflectionKind.class: {\n                switch (runType.src.subKind) {\n                    case ReflectionSubKind.date:\n                        return {code: `'new Date('+${visitJsonStringify(runType, comp).code}+')'`, type: 'E'};\n                    case ReflectionSubKind.map: {\n                        return visitJsonStringifyIterable(runType as unknown as IterableRunType, comp, 'new Map(', ')');\n                    }\n                    case ReflectionSubKind.set: {\n                        return visitJsonStringifyIterable(runType as unknown as IterableRunType, comp, 'new Set(', ')');\n                    }\n                    case ReflectionSubKind.nonSerializable:\n                        throw new Error(`Can not generate code for Non Serializable types.`);\n                    default: {\n                        const rt = runType as unknown as ClassRunType;\n                        throw new Error(`Can not generate code for classes. Class: ${rt.getClassName()}`);\n                    }\n                }\n            }\n            default:\n                return visitJsonStringify(runType, comp);\n        }\n    }\n\n    return compileToCode;\n}\n\n// lazy loading as this function wont be used often just for (AOT)\n// TODO move to async code loading (but this would need a big refactor of the router)\nlet lazyFn: undefined | ((runType: BaseRunType, comp: JitFnCompiler) => JitCode) = undefined;\nexport function emitToCode(runType: BaseRunType, comp: JitFnCompiler): JitCode {\n    if (!lazyFn) lazyFn = createToCodeCompiler();\n    return lazyFn(runType, comp);\n}\n\n/** Gets sibling property/method names from a MethodSignature's parent ObjectLiteral */\nfunction getParentSiblingNames(srcMS: TypeMethodSignature): Set<string | number | symbol> | undefined {\n    let parent = srcMS.parent as any;\n    // Handle deepkit bug where parent can be TypePropertySignature instead of TypeObjectLiteral\n    if (parent?.kind === ReflectionKind.propertySignature) parent = parent.parent;\n    if (parent?.kind !== ReflectionKind.objectLiteral) return undefined;\n    const types = (parent as TypeObjectLiteral).types;\n    if (!types) return undefined;\n    return new Set(types.map((t: any) => t.name).filter((n: any) => n !== undefined));\n}\n\n/** Detects if we're compiling a createJitFn or createPureFn closure by checking sibling properties */\nfunction isCompilingClosureFn(runType: MethodSignatureRunType, comp: JitFnCompiler): boolean {\n    const childName = runType.getChildVarName(comp);\n    if (childName !== 'createJitFn' && childName !== 'createPureFn') return false;\n    const siblings = getParentSiblingNames(runType.src as TypeMethodSignature);\n    if (!siblings) return false;\n    if (childName === 'createJitFn') return siblings.has('jitFnHash');\n    return siblings.has('bodyHash'); // createPureFn\n}\n\n/** Detects if we're compiling the fn property of a JitCompiledFn or CompiledPureFunction */\nfunction isCompilingFnProp(runType: MethodSignatureRunType, comp: JitFnCompiler): boolean {\n    if (runType.getChildVarName(comp) !== 'fn') return false;\n    const siblings = getParentSiblingNames(runType.src as TypeMethodSignature);\n    if (!siblings) return false;\n    return (\n        (siblings.has('createJitFn') && siblings.has('jitFnHash')) || (siblings.has('createPureFn') && siblings.has('bodyHash'))\n    );\n}\n\n/**\n * Gets the runtime reference to the parent object that contains the methodSignature.\n * When using Pick/Omit, deepkit wraps methodSignature in a propertySignature,\n * causing comp.vλl to point to the fn value (e.g. `obj.createJitFn`) instead of the parent object (`obj`).\n * Detects this by comparing the current vλl with the previous stack item's vλl.\n * If they differ, we are inside a propertySignature wrapper and use the parent stack item's vλl.\n */\nfunction getParentObjRef(_srcMS: TypeMethodSignature, comp: JitFnCompiler): string {\n    const stack = comp.stack;\n    const parentItem = stack[stack.length - 2];\n    if (parentItem && parentItem.vλl !== comp.vλl) return parentItem.vλl;\n    return comp.vλl;\n}\n"],"names":["JitFunctions","createStringifyCompiler","createStringifyIterable","ReflectionKind","isSafePropName","ReflectionSubKind","cpf_sanitizeCompiledFn"],"mappings":"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"}

package/.dist/cjs/src/jitCompilers/json/toJsCode.d.ts

@@ -1,6 +0,0 @@
-import { JitCode } from '../../types.ts';
-import { BaseRunType } from '../../lib/baseRunTypes.ts';
-import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
-export declare function createToCodeCompiler(): (runType: BaseRunType, comp: JitFnCompiler) => JitCode;
-export declare function emitToCode(runType: BaseRunType, comp: JitFnCompiler): JitCode;
-//# sourceMappingURL=toJsCode.d.ts.map

package/.dist/cjs/src/jitCompilers/json/toJsCode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toJsCode.d.ts","sourceRoot":"","sources":["../../../../../src/jitCompilers/json/toJsCode.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,2BAA2B,CAAC;AAO3D,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAKzD,wBAAgB,oBAAoB,cAeA,WAAW,QAAQ,aAAa,KAAG,OAAO,CA6F7E;AAKD,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAG7E"}

package/.dist/cjs/src/lib/baseRunTypeFormat.cjs

@@ -1,200 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_lib_jitFnCompiler = require("./jitFnCompiler.cjs");
-const src_constants_functions = require("../constants.functions.cjs");
-const type = require("@deepkit/type");
-const src_lib_formats = require("./formats.cjs");
-const src_lib_utils = require("./utils.cjs");
-const core = require("@mionjs/core");
-class BaseRunTypeFormat {
-  /** The namespace for pure functions used by this formatter. Defaults to 'mionFormats'. */
-  namespace = "mionFormats";
-  rootFormatName = "";
-  /**
-   * The jit code for the formatter can be embedded together with the jit code for the type itself.
-   * but sometimes is better to create a separate function for code to be reused.
-   * This method is used to determine if the formatter code can be embedded or not.
-   */
-  canEmbedFormatterCode(_fnId, rt, _params) {
-    if (rt.src.kind === type.ReflectionKind.number) return true;
-    const paramsToString = rt.getFormatTypeID() || "";
-    return paramsToString.length < 300;
-  }
-  /** Params from parent formatter */
-  paramsFromParent;
-  /**
-   * When set this in the path to the params in the parent's params object.
-   * ie: if dateTime is the parent of the current formatter and params are {date: {format: 'ISO'}} then the child path will be ['date']
-   */
-  parentPath;
-  /** List of params that will be excluded from jit code */
-  extraPathLiteral;
-  /**
-   * The parentPath is the path to the params in the parent's params Formatter.
-   * ie: if dateTime is the parent of the current formatter and params are {date: {format: 'ISO'}} then the child path will be ['date']
-   */
-  constructor(parentPath) {
-    this.parentPath = parentPath;
-  }
-  pushContext(paramsFromParent) {
-    this.paramsFromParent = paramsFromParent;
-  }
-  popContext() {
-    this.paramsFromParent = void 0;
-  }
-  isRootFormat() {
-    return !this.parentPath?.length;
-  }
-  getFormatNestLevel() {
-    return this.parentPath?.length || 0;
-  }
-  getParams(rt) {
-    if (this.paramsFromParent) return this.paramsFromParent;
-    const params = src_lib_formats.getFormatterParams(rt, this.name);
-    return params;
-  }
-  getFormatName() {
-    return this.rootFormatName || this.name;
-  }
-  /** Returns the path to the params in the parent's params object */
-  getFormatPath(paramName) {
-    if (!paramName && this.parentPath) return [...this.parentPath];
-    if (!paramName) return [];
-    return this.parentPath ? [...this.parentPath, paramName] : [paramName];
-  }
-  getFormatExtraPathLiteral() {
-    return this.extraPathLiteral;
-  }
-  getIgnoredProps() {
-    return void 0;
-  }
-  mock(opts, rt, params) {
-    if (this.validateParams) this.validateParams(rt, params || this.getParams(rt));
-    this.pushContext(params);
-    const result = this._mock(opts, rt);
-    this.popContext();
-    const formatter = this.createJitCompiledFormatter(src_constants_functions.JitFunctions.format.id, rt, void 0, params);
-    if (formatter.isNoop) return result;
-    return formatter.fn(result);
-  }
-  createJitCompiledFormatter(fnID, rt, comp, params, vλl, formatName, opts = {}) {
-    const hash = src_lib_utils.getFormatterHash(rt);
-    const jitFnHash = `${src_constants_functions.JitFunctions.aux.id}_${fnID}_${hash}`;
-    const jitCompiled = core.getJitUtils().getJIT(jitFnHash);
-    if (jitCompiled) {
-      if (core.getENV("DEBUG_JIT") === "VERBOSE")
-        console.log(`\x1B[32m Using cached function: ${jitCompiled.jitFnHash} \x1B[0m`);
-      comp?.updateDependencies(jitCompiled);
-      return jitCompiled;
-    }
-    const newJitCompiler = src_lib_jitFnCompiler.createJitCompiler(rt, fnID, void 0, jitFnHash, hash, opts);
-    try {
-      const formatterCode = this.compileFormat(fnID, newJitCompiler, rt, params, vλl, formatName);
-      const withReturn = this.handleReturnValues(rt, newJitCompiler, formatterCode);
-      newJitCompiler.createJitFunction(withReturn);
-      comp?.updateDependencies(newJitCompiler);
-    } catch (e) {
-      newJitCompiler.removeFromJitCache();
-      throw e;
-    }
-    return newJitCompiler;
-  }
-  compileFormat(fnID, comp, rt, params, vλl, formatName, extraPathLiteral) {
-    if (this.validateParams) this.validateParams(rt, params || this.getParams(rt));
-    this.extraPathLiteral = extraPathLiteral;
-    const v = comp.vλl;
-    comp.vλl = vλl || v;
-    this.rootFormatName = formatName || this.name;
-    this.pushContext(params);
-    let result;
-    switch (fnID) {
-      case src_constants_functions.JitFunctions.isType.id:
-        result = this.emitIsType(comp, rt);
-        break;
-      case src_constants_functions.JitFunctions.typeErrors.id:
-        result = this.emitIsTypeErrors(comp, rt);
-        break;
-      case src_constants_functions.JitFunctions.format.id:
-        result = this.emitFormat ? this.emitFormat(comp, rt) : { code: void 0, type: "S" };
-        break;
-      case src_constants_functions.JitFunctions.toBinary.id:
-        result = this.emitToBinary ? this.emitToBinary(comp, rt) : { code: void 0, type: "S" };
-        break;
-      case src_constants_functions.JitFunctions.fromBinary.id:
-        result = this.emitFromBinary ? this.emitFromBinary(comp, rt) : { code: void 0, type: "S" };
-        break;
-      // JSON serialization functions - formats don't need special handling for JSON
-      // Just return the value as-is (expression type 'E' with empty code means use vλl)
-      case src_constants_functions.JitFunctions.prepareForJson.id:
-      case src_constants_functions.JitFunctions.restoreFromJson.id:
-      case src_constants_functions.JitFunctions.stringifyJson.id:
-      case src_constants_functions.JitFunctions.toJSCode.id:
-        result = { code: "", type: "E" };
-        break;
-      default:
-        throw new Error(`Method not implemented: ${fnID}`);
-    }
-    this.popContext();
-    this.rootFormatName = this.name;
-    this.extraPathLiteral = void 0;
-    comp.vλl = v;
-    return result;
-  }
-  /**
-   * Adds return statements if needed
-   * Unlike handleReturnValues in BaseRunType this one is only called in the root of the formatter
-   */
-  handleReturnValues(rt, comp, jitC) {
-    if (!jitC?.code) return "";
-    const codeType = jitC.type;
-    switch (codeType) {
-      case "E":
-        return `return ${jitC.code}`;
-      case "RB":
-        return jitC.code;
-      case "S": {
-        const lastChar = jitC.code.length - 1;
-        const hasFullStop = jitC.code.lastIndexOf(";") === lastChar || jitC.code.lastIndexOf("}") === lastChar;
-        const stopChar = hasFullStop ? "" : ";";
-        return `${jitC.code}${stopChar} return ${comp.returnName}`;
-      }
-    }
-  }
-  compilePureFunctionCall(comp, rt, compiledPureFn, params, dependenciesParams) {
-    const val = comp.vλl;
-    const paramsName = src_lib_formats.paramsToLiteral(comp, params || this.getParams(rt), this.getIgnoredProps());
-    const dependenciesName = src_lib_formats.dependenciesToLiteral(comp, dependenciesParams || {});
-    const callParams = [val, paramsName, dependenciesName];
-    const fnName = comp.addPureFunction(compiledPureFn);
-    const callCode = `${fnName}(${callParams.join(",")})`;
-    return { callCode, fnName, paramsName, dependenciesName };
-  }
-  compileErrorsPureFunctionCall(comp, rt, compiledPureFn, params, dependenciesParams, extraPathLiteral) {
-    const val = comp.vλl;
-    const path = comp.args.pλth;
-    const err = comp.args.εrr;
-    const expected = src_lib_formats.paramsToLiteral(comp, rt.getKindName());
-    const formatName = src_lib_formats.paramsToLiteral(comp, this.getFormatName());
-    const formatParams = src_lib_formats.paramsToLiteral(comp, params, this.getIgnoredProps());
-    const formatPath = src_lib_formats.paramsToLiteral(comp, this.getFormatPath());
-    const deps = src_lib_formats.dependenciesToLiteral(comp, dependenciesParams || {});
-    const accessPath = comp.getAccessPathLiteral(extraPathLiteral);
-    const callParams = [val, path, err, expected, formatName, formatParams, formatPath, deps];
-    if (accessPath) callParams.push(accessPath);
-    const fnName = comp.addPureFunction(compiledPureFn);
-    const callCode = `${fnName}(${callParams.join(",")})`;
-    return { callCode, fnName, paramsName: formatParams, dependenciesName: deps };
-  }
-  getCallJitFormatErr(comp, expected, formatter, shouldReturn = false, extraPathLiteral) {
-    return (paramName, paramValue) => {
-      const callCode = comp.callJitFormatErr(expected, formatter, paramName, paramValue, extraPathLiteral);
-      if (shouldReturn) return `return ${callCode}, ${comp.args.εrr}`;
-      return callCode;
-    };
-  }
-  printPath(rt, paramName) {
-    return [rt.getTypeName(), ...this.getFormatPath(paramName)].join(".");
-  }
-}
-exports.BaseRunTypeFormat = BaseRunTypeFormat;
-//# sourceMappingURL=baseRunTypeFormat.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"baseRunTypeFormat.cjs","sources":["../../../../src/lib/baseRunTypeFormat.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\nimport type {TypeFormatParams, CompiledPureFunction, TypeFormatValue, JitCompiledFn} from '@mionjs/core';\nimport type {BaseRunType} from './baseRunTypes.ts';\nimport {createJitCompiler, type JitFnCompiler, type JitErrorsFnCompiler} from './jitFnCompiler.ts';\nimport type {JitFnID, Mutable, StrNumber, JitCode, RunTypeOptions} from '../types.ts';\nimport {JitFunctions} from '../constants.functions.ts';\nimport {ReflectionKind} from '@deepkit/type';\nimport {dependenciesToLiteral, getFormatterParams, paramsToLiteral} from './formats.ts';\nimport {getFormatterHash} from './utils.ts';\nimport {getENV, getJitUtils} from '@mionjs/core';\n\n/**\n * Base class for all RunType formatters.\n * A type format is a type that satisfies some extra constrains, like emails, alphanumeric, uuids etc...\n * All those are formats of string.\n * At the moment only formats for string and numbers are supported.\n * Jit formatters receive some params and generate JIT code depending on these params.\n */\nexport abstract class BaseRunTypeFormat<P extends TypeFormatParams = any> {\n    abstract kind: ReflectionKind;\n    abstract name: string;\n    /** The namespace for pure functions used by this formatter. Defaults to 'mionFormats'. */\n    readonly namespace: string = 'mionFormats';\n    rootFormatName: string = '';\n    /**\n     * The jit code for the formatter can be embedded together with the jit code for the type itself.\n     * but sometimes is better to create a separate function for code to be reused.\n     * This method is used to determine if the formatter code can be embedded or not.\n     */\n    canEmbedFormatterCode(_fnId: JitFnID, rt: BaseRunType, _params?: P): boolean {\n        if (rt.src.kind === ReflectionKind.number) return true;\n        // getFormatterJitId is similar to convert params to string\n        const paramsToString = rt.getFormatTypeID() || '';\n        // if there are many params, is better to not inline the formatter so the formatter function can be reused\n        // in the future we could optimize this logic, to decide if a formatter should be embedded or not\n        return paramsToString.length < 300;\n    }\n\n    /** Params from parent formatter */\n    readonly paramsFromParent?: P;\n    /**\n     * When set this in the path to the params in the parent's params object.\n     * ie: if dateTime is the parent of the current formatter and params are {date: {format: 'ISO'}} then the child path will be ['date']\n     */\n    readonly parentPath?: StrNumber[];\n    /** List of params that will be excluded from jit code */\n    readonly extraPathLiteral?: StrNumber;\n\n    /**\n     * The parentPath is the path to the params in the parent's params Formatter.\n     * ie: if dateTime is the parent of the current formatter and params are {date: {format: 'ISO'}} then the child path will be ['date']\n     */\n    constructor(parentPath?: StrNumber[]) {\n        this.parentPath = parentPath;\n    }\n\n    private pushContext(paramsFromParent?: P) {\n        (this as Mutable<BaseRunTypeFormat>).paramsFromParent = paramsFromParent;\n    }\n\n    private popContext() {\n        (this as Mutable<BaseRunTypeFormat>).paramsFromParent = undefined;\n    }\n\n    isRootFormat() {\n        return !this.parentPath?.length;\n    }\n\n    getFormatNestLevel() {\n        return this.parentPath?.length || 0;\n    }\n\n    getParams(rt: BaseRunType): NonNullable<P> {\n        if (this.paramsFromParent) return this.paramsFromParent as NonNullable<P>;\n        const params = getFormatterParams(rt, this.name) as NonNullable<P>;\n        return params;\n    }\n\n    getFormatName(): string {\n        return this.rootFormatName || this.name;\n    }\n\n    /** Returns the path to the params in the parent's params object */\n    getFormatPath(paramName?: StrNumber): StrNumber[] {\n        if (!paramName && this.parentPath) return [...this.parentPath];\n        if (!paramName) return [];\n        return this.parentPath ? [...this.parentPath, paramName] : [paramName];\n    }\n\n    getFormatExtraPathLiteral(): StrNumber | undefined {\n        return this.extraPathLiteral;\n    }\n\n    getIgnoredProps(): string[] | undefined {\n        return undefined;\n    }\n\n    mock(opts: RunTypeOptions, rt: BaseRunType, params?: P): any {\n        if (this.validateParams) this.validateParams(rt, params || this.getParams(rt));\n        this.pushContext(params);\n        const result = this._mock(opts, rt);\n        this.popContext();\n        const formatter = this.createJitCompiledFormatter(JitFunctions.format.id, rt, undefined, params);\n        if (formatter.isNoop) return result;\n        return formatter.fn(result);\n    }\n\n    createJitCompiledFormatter(\n        fnID: JitFnID,\n        rt: BaseRunType,\n        comp?: JitFnCompiler,\n        params?: P,\n        vλl?: string,\n        formatName?: string,\n        opts: RunTypeOptions = {}\n    ): JitCompiledFn {\n        const hash = getFormatterHash(rt);\n        // created function will be an aux function prefixed with the original function id\n        // this is because the new jit function itself is a standalone function  and we don't want it colliding with any other jit function\n        const jitFnHash = `${JitFunctions.aux.id}_${fnID}_${hash}`;\n        const jitCompiled = getJitUtils().getJIT(jitFnHash);\n        if (jitCompiled) {\n            if (getENV('DEBUG_JIT') === 'VERBOSE')\n                console.log(`\\x1b[32m Using cached function: ${jitCompiled.jitFnHash} \\x1b[0m`);\n            comp?.updateDependencies(jitCompiled);\n            return jitCompiled;\n        }\n        // TODO: decide if we should add parent compiler or not as parent to createJitCompiler\n        const newJitCompiler: JitFnCompiler = createJitCompiler(rt, fnID, undefined, jitFnHash, hash, opts);\n        try {\n            const formatterCode = this.compileFormat(fnID, newJitCompiler, rt, params, vλl, formatName);\n            const withReturn = this.handleReturnValues(rt, newJitCompiler, formatterCode);\n            newJitCompiler.createJitFunction(withReturn);\n            comp?.updateDependencies(newJitCompiler as JitCompiledFn);\n        } catch (e) {\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            throw e;\n        }\n\n        return newJitCompiler as JitCompiledFn;\n    }\n\n    compileFormat(\n        fnID: JitFnID,\n        comp: JitFnCompiler,\n        rt: BaseRunType,\n        params?: P,\n        vλl?: string,\n        formatName?: string,\n        extraPathLiteral?: StrNumber\n    ): JitCode {\n        if (this.validateParams) this.validateParams(rt, params || this.getParams(rt));\n        (this as Mutable<BaseRunTypeFormat>).extraPathLiteral = extraPathLiteral;\n        const v = comp.vλl;\n        comp.vλl = vλl || v;\n        this.rootFormatName = formatName || this.name;\n        this.pushContext(params);\n        let result: JitCode;\n        switch (fnID) {\n            case JitFunctions.isType.id:\n                result = this.emitIsType(comp, rt);\n                break;\n            case JitFunctions.typeErrors.id:\n                result = this.emitIsTypeErrors(comp as JitErrorsFnCompiler, rt);\n                break;\n            case JitFunctions.format.id:\n                result = this.emitFormat ? this.emitFormat(comp, rt) : {code: undefined, type: 'S'};\n                break;\n            case JitFunctions.toBinary.id:\n                result = this.emitToBinary ? this.emitToBinary(comp, rt) : {code: undefined, type: 'S'};\n                break;\n            case JitFunctions.fromBinary.id:\n                result = this.emitFromBinary ? this.emitFromBinary(comp, rt) : {code: undefined, type: 'S'};\n                break;\n            // JSON serialization functions - formats don't need special handling for JSON\n            // Just return the value as-is (expression type 'E' with empty code means use vλl)\n            case JitFunctions.prepareForJson.id:\n            case JitFunctions.restoreFromJson.id:\n            case JitFunctions.stringifyJson.id:\n            case JitFunctions.toJSCode.id:\n                result = {code: '', type: 'E'};\n                break;\n            default:\n                throw new Error(`Method not implemented: ${fnID}`);\n        }\n        this.popContext();\n        this.rootFormatName = this.name;\n        (this as Mutable<BaseRunTypeFormat>).extraPathLiteral = undefined;\n        comp.vλl = v;\n        return result;\n    }\n\n    /**\n     * Adds return statements if needed\n     * Unlike handleReturnValues in BaseRunType this one is only called in the root of the formatter\n     */\n    handleReturnValues(rt: BaseRunType, comp: JitFnCompiler, jitC: JitCode): string {\n        if (!jitC?.code) return '';\n        const codeType = jitC.type;\n        switch (codeType) {\n            case 'E':\n                return `return ${jitC.code}`;\n            case 'RB':\n                return jitC.code;\n            case 'S': {\n                // For non-expressions, add a return statement with the default return value\n                // if the code doesn't already have a return statement\n                const lastChar = jitC.code.length - 1;\n                const hasFullStop = jitC.code.lastIndexOf(';') === lastChar || jitC.code.lastIndexOf('}') === lastChar;\n                const stopChar = hasFullStop ? '' : ';';\n                return `${jitC.code}${stopChar} return ${comp.returnName}`;\n            }\n        }\n    }\n\n    abstract _mock(opts: RunTypeOptions, rt: BaseRunType): any;\n    abstract emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;\n    abstract emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;\n\n    // ###### optional methods for type formatters ########\n\n    /** Optional method to compile the formatter function that transforms/sanitize a value */\n    emitFormat?(comp: JitFnCompiler, rt: BaseRunType): JitCode;\n\n    /** Optional method that customizes the binary serialization */\n    emitToBinary?(comp: JitFnCompiler, rt: BaseRunType): JitCode;\n    /** Optional method that customizes the binary deserialization */\n    emitFromBinary?(comp: JitFnCompiler, rt: BaseRunType): JitCode;\n\n    /** Throws an error if params are not valid */\n    validateParams?(rt: BaseRunType, params: P): void;\n\n    compilePureFunctionCall(\n        comp: JitFnCompiler,\n        rt: BaseRunType,\n        compiledPureFn: CompiledPureFunction,\n        params?: TypeFormatValue,\n        dependenciesParams?: Record<string, string | CompiledPureFunction>\n    ): {callCode: string; fnName: string; paramsName: string; dependenciesName?: string} {\n        // PureFunction arguments =>\n\n        // val: any\n        // formatParams: TypeFormatValue,\n        // deps: PureFunctionDeps\n\n        const val = comp.vλl;\n        const paramsName = paramsToLiteral(comp, params || this.getParams(rt), this.getIgnoredProps());\n        const dependenciesName = dependenciesToLiteral(comp, dependenciesParams || {});\n        const callParams = [val, paramsName, dependenciesName];\n        const fnName = comp.addPureFunction(compiledPureFn);\n        const callCode = `${fnName}(${callParams.join(',')})`;\n        return {callCode, fnName, paramsName, dependenciesName};\n    }\n\n    compileErrorsPureFunctionCall(\n        comp: JitErrorsFnCompiler,\n        rt: BaseRunType,\n        compiledPureFn: CompiledPureFunction,\n        params: TypeFormatValue,\n        dependenciesParams?: Record<string, string | CompiledPureFunction>,\n        extraPathLiteral?: StrNumber // TODO: this might not be needed\n    ): {callCode: string; fnName: string; paramsName: string; dependenciesName?: string} {\n        // ErrorsPureFunction arguments =>\n\n        // val: any,\n        // pλth: StrNumber[],\n        // εrr: RunTypeError[],\n        // expected: string,\n\n        // formatName: string,\n        // formatParams: P,\n        // formatPath: StrNumber[],\n        // deps: PureFunctionDeps,\n        // accessPath?: StrNumber[]\n\n        const val = comp.vλl;\n        const path = comp.args.pλth;\n        const err = comp.args.εrr;\n        const expected = paramsToLiteral(comp, rt.getKindName());\n\n        const formatName = paramsToLiteral(comp, this.getFormatName());\n        const formatParams = paramsToLiteral(comp, params, this.getIgnoredProps());\n        const formatPath = paramsToLiteral(comp, this.getFormatPath());\n        const deps = dependenciesToLiteral(comp, dependenciesParams || {});\n        const accessPath = comp.getAccessPathLiteral(extraPathLiteral);\n\n        const callParams = [val, path, err, expected, formatName, formatParams, formatPath, deps];\n        if (accessPath) callParams.push(accessPath);\n\n        const fnName = comp.addPureFunction(compiledPureFn);\n        const callCode = `${fnName}(${callParams.join(',')})`;\n        return {callCode, fnName, paramsName: formatParams, dependenciesName: deps};\n    }\n\n    getCallJitFormatErr(\n        comp: JitErrorsFnCompiler,\n        expected: BaseRunType<any>,\n        formatter: BaseRunTypeFormat<any>,\n        shouldReturn = false,\n        extraPathLiteral?: StrNumber\n    ) {\n        return (paramName: string, paramValue: string | number | boolean | bigint) => {\n            const callCode = comp.callJitFormatErr(expected, formatter, paramName, paramValue, extraPathLiteral);\n            if (shouldReturn) return `return ${callCode}, ${comp.args.εrr}`;\n            return callCode;\n        };\n    }\n\n    printPath(rt: BaseRunType, paramName?: string): string {\n        return [rt.getTypeName(), ...this.getFormatPath(paramName)].join('.');\n    }\n}\n"],"names":["ReflectionKind","getFormatterParams","JitFunctions","getFormatterHash","getJitUtils","getENV","createJitCompiler","paramsToLiteral","dependenciesToLiteral"],"mappings":"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"}

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

@@ -1,51 +0,0 @@
-import { TypeFormatParams, CompiledPureFunction, TypeFormatValue, JitCompiledFn } from '@mionjs/core';
-import { BaseRunType } from './baseRunTypes.ts';
-import { JitFnCompiler, JitErrorsFnCompiler } from './jitFnCompiler.ts';
-import { JitFnID, StrNumber, JitCode, RunTypeOptions } from '../types.ts';
-import { ReflectionKind } from '@deepkit/type';
-export declare abstract class BaseRunTypeFormat<P extends TypeFormatParams = any> {
-    abstract kind: ReflectionKind;
-    abstract name: string;
-    readonly namespace: string;
-    rootFormatName: string;
-    canEmbedFormatterCode(_fnId: JitFnID, rt: BaseRunType, _params?: P): boolean;
-    readonly paramsFromParent?: P;
-    readonly parentPath?: StrNumber[];
-    readonly extraPathLiteral?: StrNumber;
-    constructor(parentPath?: StrNumber[]);
-    private pushContext;
-    private popContext;
-    isRootFormat(): boolean;
-    getFormatNestLevel(): number;
-    getParams(rt: BaseRunType): NonNullable<P>;
-    getFormatName(): string;
-    getFormatPath(paramName?: StrNumber): StrNumber[];
-    getFormatExtraPathLiteral(): StrNumber | undefined;
-    getIgnoredProps(): string[] | undefined;
-    mock(opts: RunTypeOptions, rt: BaseRunType, params?: P): any;
-    createJitCompiledFormatter(fnID: JitFnID, rt: BaseRunType, comp?: JitFnCompiler, params?: P, vλl?: string, formatName?: string, opts?: RunTypeOptions): JitCompiledFn;
-    compileFormat(fnID: JitFnID, comp: JitFnCompiler, rt: BaseRunType, params?: P, vλl?: string, formatName?: string, extraPathLiteral?: StrNumber): JitCode;
-    handleReturnValues(rt: BaseRunType, comp: JitFnCompiler, jitC: JitCode): string;
-    abstract _mock(opts: RunTypeOptions, rt: BaseRunType): any;
-    abstract emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
-    abstract emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
-    emitFormat?(comp: JitFnCompiler, rt: BaseRunType): JitCode;
-    emitToBinary?(comp: JitFnCompiler, rt: BaseRunType): JitCode;
-    emitFromBinary?(comp: JitFnCompiler, rt: BaseRunType): JitCode;
-    validateParams?(rt: BaseRunType, params: P): void;
-    compilePureFunctionCall(comp: JitFnCompiler, rt: BaseRunType, compiledPureFn: CompiledPureFunction, params?: TypeFormatValue, dependenciesParams?: Record<string, string | CompiledPureFunction>): {
-        callCode: string;
-        fnName: string;
-        paramsName: string;
-        dependenciesName?: string;
-    };
-    compileErrorsPureFunctionCall(comp: JitErrorsFnCompiler, rt: BaseRunType, compiledPureFn: CompiledPureFunction, params: TypeFormatValue, dependenciesParams?: Record<string, string | CompiledPureFunction>, extraPathLiteral?: StrNumber): {
-        callCode: string;
-        fnName: string;
-        paramsName: string;
-        dependenciesName?: string;
-    };
-    getCallJitFormatErr(comp: JitErrorsFnCompiler, expected: BaseRunType<any>, formatter: BaseRunTypeFormat<any>, shouldReturn?: boolean, extraPathLiteral?: StrNumber): (paramName: string, paramValue: string | number | boolean | bigint) => string;
-    printPath(rt: BaseRunType, paramName?: string): string;
-}
-//# sourceMappingURL=baseRunTypeFormat.d.ts.map

package/.dist/cjs/src/lib/baseRunTypeFormat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"baseRunTypeFormat.d.ts","sourceRoot":"","sources":["../../../../src/lib/baseRunTypeFormat.ts"],"names":[],"mappings":"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"}