@mionjs/run-types 0.8.0-alpha.0

package/.dist/esm/src/jitCompilers/json/toJsCode.js

@@ -0,0 +1,123 @@
+import { ReflectionKind } from "@deepkit/type";
+import { ReflectionSubKind } from "../../constants.kind.js";
+import { JitFunctions } from "../../constants.functions.js";
+import { isSafePropName } from "../../lib/utils.js";
+import { createStringifyCompiler, createStringifyIterable } from "./stringifyJson.js";
+import { cpf_sanitizeCompiledFn } from "../../run-types-pure-fns.js";
+function getParentSiblingNames(srcMS) {
+  let parent = srcMS.parent;
+  if (parent?.kind === ReflectionKind.propertySignature) parent = parent.parent;
+  if (parent?.kind !== 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 createToCodeCompiler() {
+  const fnID = JitFunctions.toJSCode.id;
+  const visitJsonStringify = createStringifyCompiler(fnID);
+  const visitJsonStringifyIterable = createStringifyIterable(fnID);
+  function compileToCode(runType, comp) {
+    const src = runType.src;
+    const kind = src.kind;
+    switch (kind) {
+      // ###################### ATOMIC RUNTYPES ######################
+      case ReflectionKind.undefined:
+        return { code: `'undefined'`, type: "E" };
+      case ReflectionKind.symbol:
+        return { code: `'Symbol('+'"'+${comp.vλl}.description+'"'+')'`, type: "E" };
+      // ###################### MEMBER RUNTYPES ######################
+      case ReflectionKind.methodSignature: {
+        const rt = runType;
+        const srcMS = src;
+        const accessor = srcMS.name;
+        const name = String(accessor);
+        const isSafe = 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 isPureFn = rt.getChildVarName(comp) === "createPureFn";
+          const fnName = isPureFn ? `${comp.vλl}.fnName` : `${comp.vλl}.jitFnHash`;
+          const fnCode = `${comp.vλl}.code`;
+          const paramList = isPureFn ? `${comp.vλl}.paramNames.join(',')` : `'utl'`;
+          const closureCode = `'function get_'+${fnName}+'('+${paramList}+'){'+${fnCode}+'}'`;
+          return { code: `'${safeName}:'+${closureCode}${sep}`, type: "E" };
+        } else if (rt.src.subKind === 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(cpf_sanitizeCompiledFn);
+          const parent = srcMS.parent;
+          const isDuplicatedChild = parent?.kind === 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 ReflectionKind.function:
+      case ReflectionKind.method:
+      case ReflectionKind.callSignature:
+        if (runType.src.subKind === ReflectionSubKind.params) {
+          return visitJsonStringify(runType, comp);
+        } else {
+          return { code: `${comp.vλl}.toString()`, type: "E" };
+        }
+      // ###################### COLLECTION RUNTYPES ######################
+      case ReflectionKind.class: {
+        switch (runType.src.subKind) {
+          case ReflectionSubKind.date:
+            return { code: `'new Date('+${visitJsonStringify(runType, comp).code}+')'`, type: "E" };
+          case ReflectionSubKind.map: {
+            return visitJsonStringifyIterable(runType, comp, "new Map(", ")");
+          }
+          case ReflectionSubKind.set: {
+            return visitJsonStringifyIterable(runType, comp, "new Set(", ")");
+          }
+          case 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);
+    }
+  }
+  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 (!siblings.has("code")) 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("code") && (siblings.has("createJitFn") || siblings.has("createPureFn"));
+  }
+  return compileToCode;
+}
+let lazyFn = void 0;
+function emitToCode(runType, comp) {
+  if (!lazyFn) lazyFn = createToCodeCompiler();
+  return lazyFn(runType, comp);
+}
+export {
+  createToCodeCompiler,
+  emitToCode
+};
+//# sourceMappingURL=toJsCode.js.map

package/.dist/esm/src/jitCompilers/json/toJsCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toJsCode.js","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\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\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                    const isPureFn = rt.getChildVarName(comp) === 'createPureFn';\n                    const fnName = isPureFn ? `${comp.vλl}.fnName` : `${comp.vλl}.jitFnHash`;\n                    const fnCode = `${comp.vλl}.code`;\n                    const paramList = isPureFn ? `${comp.vλl}.paramNames.join(',')` : `'utl'`;\n                    const closureCode = `'function get_'+${fnName}+'('+${paramList}+'){'+${fnCode}+'}'`;\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    /** Detects if we're compiling a createJitFn or createPureFn closure by checking sibling properties */\n    function 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 (!siblings.has('code')) 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 */\n    function 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 siblings.has('code') && (siblings.has('createJitFn') || siblings.has('createPureFn'));\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"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,50 @@
+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;
+}

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

@@ -0,0 +1,200 @@
+import { createJitCompiler } from "./jitFnCompiler.js";
+import { JitFunctions } from "../constants.functions.js";
+import { ReflectionKind } from "@deepkit/type";
+import { getFormatterParams, paramsToLiteral, dependenciesToLiteral } from "./formats.js";
+import { getFormatterHash } from "./utils.js";
+import { getJitUtils, getENV } from "@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 === 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 = 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(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 = getFormatterHash(rt);
+    const jitFnHash = `${JitFunctions.aux.id}_${fnID}_${hash}`;
+    const jitCompiled = getJitUtils().getJIT(jitFnHash);
+    if (jitCompiled) {
+      if (getENV("DEBUG_JIT") === "VERBOSE")
+        console.log(`\x1B[32m Using cached function: ${jitCompiled.jitFnHash} \x1B[0m`);
+      comp?.updateDependencies(jitCompiled);
+      return jitCompiled;
+    }
+    const newJitCompiler = 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 JitFunctions.isType.id:
+        result = this.emitIsType(comp, rt);
+        break;
+      case JitFunctions.typeErrors.id:
+        result = this.emitIsTypeErrors(comp, rt);
+        break;
+      case JitFunctions.format.id:
+        result = this.emitFormat ? this.emitFormat(comp, rt) : { code: void 0, type: "S" };
+        break;
+      case JitFunctions.toBinary.id:
+        result = this.emitToBinary ? this.emitToBinary(comp, rt) : { code: void 0, type: "S" };
+        break;
+      case 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 JitFunctions.prepareForJson.id:
+      case JitFunctions.restoreFromJson.id:
+      case JitFunctions.stringifyJson.id:
+      case 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 = paramsToLiteral(comp, params || this.getParams(rt), this.getIgnoredProps());
+    const dependenciesName = 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 = paramsToLiteral(comp, rt.getKindName());
+    const formatName = paramsToLiteral(comp, this.getFormatName());
+    const formatParams = paramsToLiteral(comp, params, this.getIgnoredProps());
+    const formatPath = paramsToLiteral(comp, this.getFormatPath());
+    const deps = 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(".");
+  }
+}
+export {
+  BaseRunTypeFormat
+};
+//# sourceMappingURL=baseRunTypeFormat.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"baseRunTypeFormat.js","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":[],"mappings":"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"}

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

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