@mionjs/run-types 0.8.8 → 0.13.0

package/.dist/esm/src/nodes/collection/tuple.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/collection/tuple.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAe,SAAS,EAAC,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AACnF,OAAO,KAAK,EAAC,uBAAuB,EAAW,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAC,iBAAiB,EAAC,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAC;AAE5D,KAAK,eAAe,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;AAE7D,qBAAa,YAAY,CACrB,SAAS,SAAS,uBAAuB,GAAG,SAAS,EACrD,SAAS,SAAS,eAAe,GAAG,kBAAkB,CACxD,SAAQ,iBAAiB,CAAC,SAAS,CAAC;IAClC,gBAAgB,QAAO,SAAS,EAAE,CAGhC;IACF,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE;IAQlD,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAK9C,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAKhD,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IASxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAUlD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAShD,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CASpD"}

package/.dist/esm/src/nodes/collection/tuple.js

@@ -1,74 +0,0 @@
-import { TupleMemberRunType } from "../member/tupleMember.js";
-import { CollectionRunType } from "../../lib/baseRunTypes.js";
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-class TupleRunType extends CollectionRunType {
-  getChildRunTypes = __assignType(() => {
-    const childTypes = this.src.parameters || this.src.types || [];
-    return childTypes.map(__assignType((t) => t._rt, ["t", "", 'P"2!"/"']));
-  }, ["", "P!F/!"]);
-  getParamRunTypes(comp) {
-    const start = comp.opts?.paramsSlice?.start;
-    const end = comp.opts?.paramsSlice?.end;
-    const children = this.getChildRunTypes();
-    if (!start && !end)
-      return children;
-    return children.slice(start, end);
-  }
-  hasRestParameter(comp) {
-    return !!this.getParamRunTypes(comp).length && this.getParamRunTypes(comp)[this.getParamRunTypes(comp).length - 1].isRest();
-  }
-  totalRequiredParams(comp) {
-    return this.getParamRunTypes(comp).filter(__assignType((p) => !p.isOptional() && !p.isRest(), ["p", "", 'P"2!"/"'])).length;
-  }
-  // ####### params #######
-  emitIsType(comp) {
-    const children = this.getParamRunTypes(comp);
-    if (children.length === 0 && comp.opts.noIsArrayCheck)
-      return { code: void 0, type: "E" };
-    if (children.length === 0)
-      return { code: `Array.isArray(${comp.vλl}) && ${comp.vλl}.length === 0`, type: "E" };
-    const lengthCode = this.hasRestParameter(comp) ? "" : `&& ${comp.vλl}.length <= ${this.getParamRunTypes(comp).length}`;
-    const paramsCode = children.map(__assignType((p) => `(${comp.compileIsType(p, "E").code})`, ["p", "", 'P"2!"/"'])).join(" && ");
-    const checkIsArrayCode = comp.opts.noIsArrayCheck ? "" : `Array.isArray(${comp.vλl})${lengthCode} && `;
-    return { code: `(${checkIsArrayCode} ${paramsCode})`, type: "E" };
-  }
-  emitTypeErrors(comp) {
-    const children = this.getParamRunTypes(comp);
-    if (children.length === 0 && comp.opts.noIsArrayCheck)
-      return { code: void 0, type: "S" };
-    if (children.length === 0)
-      return { code: `if (!Array.isArray(${comp.vλl}) || && ${comp.vλl}.length === 0) ${comp.callJitErr(this)}`, type: "S" };
-    const lengthCode = this.hasRestParameter(comp) ? "" : `|| ${comp.vλl}.length > ${this.getParamRunTypes(comp).length}`;
-    const paramsCode = children.map(__assignType((p) => comp.compileTypeErrors(p, "S").code, ["p", "", 'P"2!"/"'])).join(";");
-    if (comp.opts.noIsArrayCheck)
-      return { code: paramsCode, type: "S" };
-    return { code: `if (!Array.isArray(${comp.vλl})${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode}}`, type: "S" };
-  }
-  emitPrepareForJson(comp) {
-    const children = this.getParamRunTypes(comp);
-    if (!children.length)
-      return { code: void 0, type: "S" };
-    const code = children.map(__assignType((p) => comp.compilePrepareForJson(p, "S").code, ["p", "", 'P"2!"/"'])).filter(Boolean).join(";");
-    return { code, type: "S" };
-  }
-  emitRestoreFromJson(comp) {
-    const children = this.getParamRunTypes(comp);
-    if (!children.length)
-      return { code: void 0, type: "S" };
-    const code = children.map(__assignType((p) => comp.compileRestoreFromJson(p, "S").code, ["p", "", 'P"2!"/"'])).filter(Boolean).join(";");
-    return { code, type: "S" };
-  }
-  static __type = ["TypeTuple", "ParamList", () => TupleMemberRunType, "ParamType", () => CollectionRunType, "getChildRunTypes", function() {
-    return __assignType(() => {
-      const childTypes = this.src.parameters || this.src.types || [];
-      return childTypes.map(__assignType((t) => t._rt, ["t", "", 'P"2!"/"']));
-    }, ["", "P!F/!"]);
-  }, "JitFnCompiler", "comp", "getParamRunTypes", "hasRestParameter", "totalRequiredParams", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "TupleRunType", `"w!c"P7#c$Pe"!7%!3&>'P"w(2)e""F0*P"w(2))0+P"w(2)'0,P"w(2)"w-0.P"w/2)"w-00P"w(2)"w-01P"w(2)"w-025e!!6"w3`];
-}
-export {
-  TupleRunType
-};
-//# sourceMappingURL=tuple.js.map

package/.dist/esm/src/nodes/collection/tuple.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tuple.js","sources":["../../../../../src/nodes/collection/tuple.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 {TypeFunction, TypeTuple} from '@deepkit/type';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {AnyParameterListRunType, SrcType, JitCode} from '../../types.ts';\nimport {ParameterRunType} from '../member/param.ts';\nimport {CollectionRunType} from '../../lib/baseRunTypes.ts';\nimport {TupleMemberRunType} from '../member/tupleMember.ts';\n\ntype AnyParamRunType = ParameterRunType | TupleMemberRunType;\n\nexport class TupleRunType<\n    ParamList extends AnyParameterListRunType = TypeTuple,\n    ParamType extends AnyParamRunType = TupleMemberRunType,\n> extends CollectionRunType<ParamList> {\n    getChildRunTypes = (): ParamType[] => {\n        const childTypes = ((this.src as TypeFunction).parameters || (this.src as TypeTuple).types || []) as SrcType[];\n        return childTypes.map((t) => t._rt as ParamType);\n    };\n    getParamRunTypes(comp: JitFnCompiler): ParamType[] {\n        const start = comp.opts?.paramsSlice?.start;\n        const end = comp.opts?.paramsSlice?.end;\n        const children = this.getChildRunTypes();\n        if (!start && !end) return children;\n        // Get all child run types first without using comp to avoid recursion\n        return children.slice(start, end);\n    }\n    hasRestParameter(comp: JitFnCompiler): boolean {\n        return (\n            !!this.getParamRunTypes(comp).length && this.getParamRunTypes(comp)[this.getParamRunTypes(comp).length - 1].isRest()\n        );\n    }\n    totalRequiredParams(comp: JitFnCompiler): number {\n        return this.getParamRunTypes(comp).filter((p) => !p.isOptional() && !p.isRest()).length;\n    }\n    // ####### params #######\n\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const children = this.getParamRunTypes(comp);\n        if (children.length === 0 && comp.opts.noIsArrayCheck) return {code: undefined, type: 'E'};\n        if (children.length === 0) return {code: `Array.isArray(${comp.vλl}) && ${comp.vλl}.length === 0`, type: 'E'};\n        const lengthCode = this.hasRestParameter(comp) ? '' : `&& ${comp.vλl}.length <= ${this.getParamRunTypes(comp).length}`;\n        const paramsCode = children.map((p) => `(${comp.compileIsType(p, 'E').code})`).join(' && ');\n        const checkIsArrayCode = comp.opts.noIsArrayCheck ? '' : `Array.isArray(${comp.vλl})${lengthCode} && `;\n        return {code: `(${checkIsArrayCode} ${paramsCode})`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        const children = this.getParamRunTypes(comp);\n        if (children.length === 0 && comp.opts.noIsArrayCheck) return {code: undefined, type: 'S'};\n        if (children.length === 0)\n            return {code: `if (!Array.isArray(${comp.vλl}) || && ${comp.vλl}.length === 0) ${comp.callJitErr(this)}`, type: 'S'};\n        const lengthCode = this.hasRestParameter(comp) ? '' : `|| ${comp.vλl}.length > ${this.getParamRunTypes(comp).length}`;\n        const paramsCode = children.map((p) => comp.compileTypeErrors(p, 'S').code).join(';');\n        if (comp.opts.noIsArrayCheck) return {code: paramsCode, type: 'S'};\n        return {code: `if (!Array.isArray(${comp.vλl})${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode}}`, type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        const children = this.getParamRunTypes(comp);\n        if (!children.length) return {code: undefined, type: 'S'};\n        const code = children\n            .map((p) => comp.compilePrepareForJson(p, 'S').code)\n            .filter(Boolean)\n            .join(';');\n        return {code: code, type: 'S'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        const children = this.getParamRunTypes(comp);\n        if (!children.length) return {code: undefined, type: 'S'};\n        const code = children\n            .map((p) => comp.compileRestoreFromJson(p, 'S').code)\n            .filter(Boolean)\n            .join(';');\n        return {code: code, type: 'S'};\n    }\n}\n"],"names":[],"mappings":";;;;;;AAgBM,MAAO,qBAGH,kBAA4B;AAAA,EAClC,mBAAgB,aAAG,MAAkB;AACjC,UAAM,aAAe,KAAK,IAAqB,cAAe,KAAK,IAAkB,SAAS,CAAA;AAC9F,WAAO,WAAW,IAAG,aAAC,CAAC,MAAM,EAAE;EACnC,GAAC,CAAA,IAAA,OAAA,CAAA;AAAA,EACD,iBAAiB,MAAmB;AAChC,UAAM,QAAQ,KAAK,MAAM,aAAa;AACtC,UAAM,MAAM,KAAK,MAAM,aAAa;AACpC,UAAM,WAAW,KAAK,iBAAA;AACtB,QAAI,CAAC,SAAS,CAAC;AAAK,aAAO;AAE3B,WAAO,SAAS,MAAM,OAAO,GAAG;AAAA,EACpC;AAAA,EACA,iBAAiB,MAAmB;AAChC,WACI,CAAC,CAAC,KAAK,iBAAiB,IAAI,EAAE,UAAU,KAAK,iBAAiB,IAAI,EAAE,KAAK,iBAAiB,IAAI,EAAE,SAAS,CAAC,EAAE,OAAA;AAAA,EAEpH;AAAA,EACA,oBAAoB,MAAmB;AACnC,WAAO,KAAK,iBAAiB,IAAI,EAAE,OAAM,aAAC,CAAC,MAAM,CAAC,EAAE,WAAA,KAAgB,CAAC,EAAE,UAAQ,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA,EAAE;AAAA,EACrF;AAAA;AAAA,EAGA,WAAW,MAAmB;AAC1B,UAAM,WAAW,KAAK,iBAAiB,IAAI;AAC3C,QAAI,SAAS,WAAW,KAAK,KAAK,KAAK;AAAgB,aAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AACtF,QAAI,SAAS,WAAW;AAAG,aAAO,EAAC,MAAM,iBAAiB,KAAK,GAAG,QAAQ,KAAK,GAAG,iBAAiB,MAAM,IAAA;AACzG,UAAM,aAAa,KAAK,iBAAiB,IAAI,IAAI,KAAK,MAAM,KAAK,GAAG,cAAc,KAAK,iBAAiB,IAAI,EAAE,MAAM;AACpH,UAAM,aAAa,SAAS,IAAG,aAAC,CAAC,MAAM,IAAI,KAAK,cAAc,GAAG,GAAG,EAAE,IAAI,KAAG,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA,EAAE,KAAK,MAAM;AAC1F,UAAM,mBAAmB,KAAK,KAAK,iBAAiB,KAAK,iBAAiB,KAAK,GAAG,IAAI,UAAU;AAChG,WAAO,EAAC,MAAM,IAAI,gBAAgB,IAAI,UAAU,KAAK,MAAM,IAAA;AAAA,EAC/D;AAAA,EACA,eAAe,MAAyB;AACpC,UAAM,WAAW,KAAK,iBAAiB,IAAI;AAC3C,QAAI,SAAS,WAAW,KAAK,KAAK,KAAK;AAAgB,aAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AACtF,QAAI,SAAS,WAAW;AACpB,aAAO,EAAC,MAAM,sBAAsB,KAAK,GAAG,WAAW,KAAK,GAAG,kBAAkB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AACpH,UAAM,aAAa,KAAK,iBAAiB,IAAI,IAAI,KAAK,MAAM,KAAK,GAAG,aAAa,KAAK,iBAAiB,IAAI,EAAE,MAAM;AACnH,UAAM,aAAa,SAAS,IAAG,aAAC,CAAC,MAAM,KAAK,kBAAkB,GAAG,GAAG,EAAE,MAAI,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA,EAAE,KAAK,GAAG;AACpF,QAAI,KAAK,KAAK;AAAgB,aAAO,EAAC,MAAM,YAAY,MAAM,IAAA;AAC9D,WAAO,EAAC,MAAM,sBAAsB,KAAK,GAAG,IAAI,UAAU,KAAK,KAAK,WAAW,IAAI,CAAC,WAAW,UAAU,KAAK,MAAM,IAAA;AAAA,EACxH;AAAA,EACA,mBAAmB,MAAmB;AAClC,UAAM,WAAW,KAAK,iBAAiB,IAAI;AAC3C,QAAI,CAAC,SAAS;AAAQ,aAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AACrD,UAAM,OAAO,SACR,iBAAI,CAAC,MAAM,KAAK,sBAAsB,GAAG,GAAG,EAAE,MAAI,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA,EAClD,OAAO,OAAO,EACd,KAAK,GAAG;AACb,WAAO,EAAC,MAAY,MAAM,IAAA;AAAA,EAC9B;AAAA,EACA,oBAAoB,MAAmB;AACnC,UAAM,WAAW,KAAK,iBAAiB,IAAI;AAC3C,QAAI,CAAC,SAAS;AAAQ,aAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AACrD,UAAM,OAAO,SACR,iBAAI,CAAC,MAAM,KAAK,uBAAuB,GAAG,GAAG,EAAE,MAAI,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA,EACnD,OAAO,OAAO,EACd,KAAK,GAAG;AACb,WAAO,EAAC,MAAY,MAAM,IAAA;AAAA,EAC9B;AAAA,EA1DmB,OAAA,SAAA,CAAA,aAAA,aAAA,MAAA,oBAAA,aAAA,MAAA,mBAAA,oBAAA,WAAA;AAAA,WAAA,aAAA,MAAkB;AACjC,YAAM,aAAe,KAAK,IAAqB,cAAe,KAAK,IAAkB,SAAS,CAAA;AAC9F,aAAO,WAAW,IAAG,aAAC,CAAC,MAAM,EAAE;IACnC,GAAC,CAAA,IAAA,OAAA,CAAA;AAAA,EAAA,GAAA,iBAAA,QAAA,oBAAA,oBAAA,uBAAA,WAAA,cAAA,uBAAA,kBAAA,sBAAA,uBAAA,gBAAA,yGAAA;;"}

package/.dist/esm/src/nodes/collection/union.d.ts

@@ -1,20 +0,0 @@
-import { TypeUnion } from '@deepkit/type';
-import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
-import { JitCode } from '../../types.ts';
-import { BaseRunType, CollectionRunType } from '../../lib/baseRunTypes.ts';
-import { SplitUnionResult } from './unionDiscriminator.ts';
-export declare class UnionRunType extends CollectionRunType<TypeUnion> {
-    hasDiscriminators: boolean | undefined;
-    hasObjectTypes: boolean | undefined;
-    isTypeWithProperties(rt: BaseRunType): boolean;
-    getUnionChildren(comp: JitFnCompiler): SplitUnionResult;
-    getUnionItemIndex(comp: JitFnCompiler, unionItem: BaseRunType): number;
-    getChildIsTypeWithLooseCheck(rt: BaseRunType, comp: JitFnCompiler): string;
-    emitIsType(comp: JitFnCompiler): JitCode;
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
-    emitPrepareForJson(comp: JitFnCompiler): JitCode;
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
-    getUnionTypeNames(): string;
-    checkAllowedChildren(comp: JitFnCompiler): void;
-}
-//# sourceMappingURL=union.d.ts.map

package/.dist/esm/src/nodes/collection/union.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/collection/union.ts"],"names":[],"mappings":"AAOA,OAAO,EAAiB,KAAK,SAAS,EAAC,MAAM,eAAe,CAAC;AAC7D,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AACnF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,WAAW,EAAE,iBAAiB,EAAC,MAAM,2BAA2B,CAAC;AAGzE,OAAO,EAAsC,gBAAgB,EAAC,MAAM,yBAAyB,CAAC;AAU9F,qBAAa,YAAa,SAAQ,iBAAiB,CAAC,SAAS,CAAC;IAC1D,iBAAiB,EAAE,OAAO,GAAG,SAAS,CAAa;IACnD,cAAc,EAAE,OAAO,GAAG,SAAS,CAAa;IAEhD,oBAAoB,CAAC,EAAE,EAAE,WAAW;IAOpC,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,gBAAgB;IAMvD,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,GAAG,MAAM;IAetE,4BAA4B,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM;IA6B1E,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAgBxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAalD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IA+ChD,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAgCjD,iBAAiB,IAAI,MAAM;IAM3B,oBAAoB,CAAC,IAAI,EAAE,aAAa;CAM3C"}

package/.dist/esm/src/nodes/collection/union.js

@@ -1,162 +0,0 @@
-import { ReflectionKind } from "@deepkit/type";
-import { CollectionRunType, BaseRunType } from "../../lib/baseRunTypes.js";
-import { createIfElseFn, toLiteral, childIsExpression } from "../../lib/utils.js";
-import { isInterfaceRunType, isClassRunType, isObjectLiteralRunType, isIntersectionRunType } from "../../lib/guards.js";
-import { markDiscriminators, splitUnionItems, __ΩSplitUnionResult as ___SplitUnionResult } from "./unionDiscriminator.js";
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-class UnionRunType extends CollectionRunType {
-  hasDiscriminators = void 0;
-  hasObjectTypes = void 0;
-  isTypeWithProperties(rt) {
-    return rt.getFamily() === "C" && (isInterfaceRunType(rt) || isClassRunType(rt) || isObjectLiteralRunType(rt) || isIntersectionRunType(rt));
-  }
-  getUnionChildren(comp) {
-    const children = this.getJitChildren(comp);
-    markDiscriminators(comp, this, children);
-    return splitUnionItems(comp, this, children);
-  }
-  getUnionItemIndex(comp, unionItem) {
-    const children = this.getJitChildren(comp);
-    const index = children.findIndex(__assignType((child) => child === unionItem, ["child", "", 'P"2!"/"']));
-    if (index === -1)
-      throw new Error(`Item ${unionItem.getTypeName()} not found in union ${this.getTypeName()}`);
-    return index;
-  }
-  /**
-   * Returns isType check for a union child with loose matching.
-   * Uses first-match strategy: returns first matching type in declaration order.
-   * For all-optional types (weak types), ensures at least one property matches or is empty object.
-   * Note: Use ESLint rules @mionjs/no-unreachable-union-types and @mionjs/no-mixed-union-properties
-   * to detect overlapping union types at compile time.
-   * @see union.spec.ts 'Union Obj' and 'Union Mixed' test suites for examples.
-   */
-  getChildIsTypeWithLooseCheck(rt, comp) {
-    const isTypeCode = comp.compileIsType(rt, "E").code || "";
-    const isTypeWithProperties = isInterfaceRunType(rt) || isClassRunType(rt) || isObjectLiteralRunType(rt) || isIntersectionRunType(rt);
-    if (!isTypeWithProperties || rt.getFamily() !== "C")
-      return isTypeCode;
-    const props = rt.getJitChildren(comp);
-    const hasIndexProperty = props.some(__assignType((prop) => prop.src.kind === ReflectionKind.indexSignature, ["prop", "", 'P"2!"/"']));
-    if (hasIndexProperty)
-      return isTypeCode;
-    const isAllOptional = rt.areAllChildrenOptional(props);
-    if (isAllOptional && props.length > 0) {
-      const hasOwnPropCheck = props.map(__assignType((p) => {
-        const name = p.getPropertyName();
-        return `(${toLiteral(name)} in ${comp.vλl})`;
-      }, ["p", "", 'P"2!"/"']));
-      hasOwnPropCheck.push(`Object.keys(${comp.vλl}).length === 0`);
-      const weakTypeCheck = `(${hasOwnPropCheck.join(" || ")})`;
-      return `(${isTypeCode} && ${weakTypeCheck})`;
-    }
-    return isTypeCode;
-  }
-  /**
-   * Loose union matching: returns first matching type in declaration order.
-   * Objects with properties from multiple union types will match the first compatible type.
-   * Use ESLint rules to detect overlapping types at compile time.
-   */
-  emitIsType(comp) {
-    this.checkAllowedChildren(comp);
-    const { simpleItems, objectTypes, anyItem } = this.getUnionChildren(comp);
-    const simpleChecks = simpleItems.map(__assignType((rt) => this.getChildIsTypeWithLooseCheck(rt, comp), ["rt", "", 'P"2!"/"'])).filter(Boolean);
-    const objChecks = objectTypes.map(__assignType((rt) => this.getChildIsTypeWithLooseCheck(rt, comp), ["rt", "", 'P"2!"/"'])).filter(Boolean);
-    const objCode = objChecks.length ? `(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && (${objChecks.join(" || ")}))` : "";
-    const anyCheck = anyItem ? this.getChildIsTypeWithLooseCheck(anyItem, comp) : "";
-    const allChecks = [...simpleChecks, objCode, anyCheck].filter(Boolean);
-    return { code: `(${allChecks.join(" || ")})`, type: "E" };
-  }
-  emitTypeErrors(comp) {
-    this.checkAllowedChildren(comp);
-    const isType = comp.compileIsType(this, "E").code;
-    const code = `if (!${isType}) ${comp.callJitErr(this)};`;
-    return { code, type: "S" };
-  }
-  /**
-   * When a union is encodes to json is encode into and array with two elements: [unionDiscriminator, encoded Value]
-   * the first element is the index of the type in the union.
-   * the second element is the encoded value of the type.
-   * ie: type union = string | number | bigint;  var v1: union = 123n;  v1 is encoded as [2, "123n"]
-   */
-  emitPrepareForJson(comp) {
-    this.checkAllowedChildren(comp);
-    const { simpleItems, objectTypes, anyItem } = this.getUnionChildren(comp);
-    const errName = comp.getLocalVarName("uErr", this);
-    const fail = `throw new Error(${errName});`;
-    comp.setContextItem(errName, `const ${errName} = "Can not json encode union: item does not belong to the union"`);
-    const ifElse = createIfElseFn();
-    const getEncodeCode = __assignType((childRt) => {
-      const toJit = comp.compilePrepareForJson(childRt, "S");
-      const fromJit = comp.compileRestoreFromJson(childRt, "S");
-      const needsTupleEncoding = !!toJit.code || !!fromJit.code;
-      const isExpression = childIsExpression(toJit, childRt);
-      const encodeCode = isExpression && toJit.code ? `${comp.vλl} = ${toJit.code};` : toJit.code || "";
-      const index = this.getUnionItemIndex(comp, childRt);
-      const tupleEncode = needsTupleEncoding ? `${comp.vλl} = [${index}, ${comp.vλl}]` : "/*noop*/";
-      return `${encodeCode} ${tupleEncode}`;
-    }, [() => BaseRunType, "childRt", "", 'PP7!2""/#']);
-    const simpleCode = simpleItems.map(__assignType((rt) => {
-      const isTypeCode = this.getChildIsTypeWithLooseCheck(rt, comp);
-      return `${ifElse()} (${isTypeCode}) {${getEncodeCode(rt)}}`;
-    }, ["rt", "", 'P"2!"/"']));
-    const objCode = objectTypes.length ? objectTypes.map(__assignType((rt) => {
-      const isTypeCode = this.getChildIsTypeWithLooseCheck(rt, comp);
-      return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getEncodeCode(rt)}}`;
-    }, ["rt", "", 'P"2!"/"'])) : [];
-    const anyCode = anyItem ? `${ifElse(true)} {${getEncodeCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;
-    return { code: [...simpleCode, ...objCode, anyCode].join(""), type: "S" };
-  }
-  /**
-   * When a union is decoded from json it expects de two elements array format: [unionDiscriminator, Value to decode]
-   * the first element is the index of the type in the union.
-   * the second element is the encoded value of the type.
-   * ie: type union = string | number | bigint;  var v1: union = 123n;  v1 is encoded as [2, "123n"]
-   */
-  emitRestoreFromJson(comp) {
-    this.checkAllowedChildren(comp);
-    const decVar = comp.getLocalVarName("dec", this);
-    const errVarName = comp.getLocalVarName("uErr", this);
-    comp.setContextItem(errVarName, `const ${errVarName} = "Can not json decode union: invalid union index"`);
-    const children = this.getJitChildren(comp);
-    const ifElse = createIfElseFn();
-    const itemsCode = children.map(__assignType((unionItem) => {
-      const childJit = comp.compileRestoreFromJson(unionItem, "S");
-      const isExpression = childIsExpression(childJit, unionItem);
-      const code2 = isExpression && childJit.code && childJit.code !== comp.vλl ? `${comp.vλl} = ${childJit.code}` : childJit.code || "";
-      const index = this.getUnionItemIndex(comp, unionItem);
-      return `${ifElse()} (${decVar} === ${index}) {${code2 || "/*noop*/"}}`;
-    }, ["unionItem", "", 'P"2!"/"'])).filter(Boolean);
-    const childrenCode = itemsCode.join("");
-    const failCode = childrenCode ? `else {throw new Error(${errVarName})}` : "";
-    const code = `
-            if (${comp.vλl}?.length === 2 && Array.isArray(${comp.vλl}) && typeof ${comp.vλl}[0] === 'number') {
-                const ${decVar} = ${comp.vλl}[0]; ${comp.vλl} = ${comp.vλl}[1];
-                ${childrenCode}
-                ${failCode}
-            }
-        `;
-    return { code, type: "S" };
-  }
-  getUnionTypeNames() {
-    return this.getChildRunTypes().map(__assignType((rt) => rt.getTypeName(), ["rt", "", 'P"2!"/"'])).join(" | ");
-  }
-  checkAllowedChildren(comp) {
-    const allChildren = this.getChildRunTypes();
-    const toSkip = allChildren.filter(__assignType((rt) => rt.skipJit(comp), ["rt", "", 'P"2!"/"']));
-    if (toSkip.length)
-      throw new Error(`Union can not have non serializable types, ie: Symbol, Function, etc. 
-Type: ${this.stringify()}`);
-  }
-  static __type = ["TypeUnion", () => CollectionRunType, "hasDiscriminators", function() {
-    return void 0;
-  }, "hasObjectTypes", function() {
-    return void 0;
-  }, () => BaseRunType, "rt", "isTypeWithProperties", "JitFnCompiler", "comp", () => ___SplitUnionResult, "getUnionChildren", () => BaseRunType, "unionItem", "getUnionItemIndex", () => BaseRunType, "getChildIsTypeWithLooseCheck", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "getUnionTypeNames", "checkAllowedChildren", "UnionRunType", `P"w!7"P)-J3#>$P)-J3%>&PP7'2("0)P"w*2+n,0-P"w*2+P7.2/'00PP712("w*2+&02P"w*2+"w304P"w52+"w306P"w*2+"w307P"w*2+"w308P&09P"w*2+"0:5"w!6"w;`];
-}
-export {
-  UnionRunType
-};
-//# sourceMappingURL=union.js.map

package/.dist/esm/src/nodes/collection/union.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"union.js","sources":["../../../../../src/nodes/collection/union.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 {ReflectionKind, type TypeUnion} from '@deepkit/type';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {JitCode} from '../../types.ts';\nimport {BaseRunType, CollectionRunType} from '../../lib/baseRunTypes.ts';\nimport {childIsExpression, createIfElseFn, toLiteral} from '../../lib/utils.ts';\nimport {isClassRunType, isInterfaceRunType, isIntersectionRunType, isObjectLiteralRunType} from '../../lib/guards.ts';\nimport {markDiscriminators, splitUnionItems, SplitUnionResult} from './unionDiscriminator.ts';\nimport type {PropertyRunType} from '../member/property.ts';\n\n/**\n * Unions get encoded into an array where arr[0] is the discriminator and arr[1] is the value.\n * this is because some times we can't distinguish the type of an union.\n * ie: bigint gets encoded into an string, so if we have an union 'type U = string | bigint' we can't distinguish between the when encoding/decoding the json.\n * to solve this issue the index of the type is used as a discriminator.\n * So [0, \"123n\"] is interpreted as a string and [1, \"123n\"] is interpreted as a bigint.\n * */\nexport class UnionRunType extends CollectionRunType<TypeUnion> {\n    hasDiscriminators: boolean | undefined = undefined;\n    hasObjectTypes: boolean | undefined = undefined;\n\n    isTypeWithProperties(rt: BaseRunType) {\n        return (\n            rt.getFamily() === 'C' &&\n            (isInterfaceRunType(rt) || isClassRunType(rt) || isObjectLiteralRunType(rt) || isIntersectionRunType(rt))\n        );\n    }\n\n    getUnionChildren(comp: JitFnCompiler): SplitUnionResult {\n        const children = this.getJitChildren(comp);\n        markDiscriminators(comp, this, children);\n        return splitUnionItems(comp, this, children);\n    }\n\n    getUnionItemIndex(comp: JitFnCompiler, unionItem: BaseRunType): number {\n        const children = this.getJitChildren(comp);\n        const index = children.findIndex((child) => child === unionItem);\n        if (index === -1) throw new Error(`Item ${unionItem.getTypeName()} not found in union ${this.getTypeName()}`);\n        return index;\n    }\n\n    /**\n     * Returns isType check for a union child with loose matching.\n     * Uses first-match strategy: returns first matching type in declaration order.\n     * For all-optional types (weak types), ensures at least one property matches or is empty object.\n     * Note: Use ESLint rules @mionjs/no-unreachable-union-types and @mionjs/no-mixed-union-properties\n     * to detect overlapping union types at compile time.\n     * @see union.spec.ts 'Union Obj' and 'Union Mixed' test suites for examples.\n     */\n    getChildIsTypeWithLooseCheck(rt: BaseRunType, comp: JitFnCompiler): string {\n        const isTypeCode = comp.compileIsType(rt, 'E').code || '';\n        const isTypeWithProperties =\n            isInterfaceRunType(rt) || isClassRunType(rt) || isObjectLiteralRunType(rt) || isIntersectionRunType(rt);\n        if (!isTypeWithProperties || rt.getFamily() !== 'C') return isTypeCode;\n        const props = rt.getJitChildren(comp);\n        const hasIndexProperty = props.some((prop) => prop.src.kind === ReflectionKind.indexSignature);\n        if (hasIndexProperty) return isTypeCode;\n        const isAllOptional = rt.areAllChildrenOptional(props);\n        // For all-optional types (weak types), TypeScript requires at least one matching property\n        // or an empty object. This prevents {c: 'hello'} from matching {a?: string; b?: string}\n        if (isAllOptional && props.length > 0) {\n            // Must have at least one of this type's own props OR be empty\n            const hasOwnPropCheck = props.map((p) => {\n                const name = (p as PropertyRunType).getPropertyName();\n                return `(${toLiteral(name)} in ${comp.vλl})`;\n            });\n            hasOwnPropCheck.push(`Object.keys(${comp.vλl}).length === 0`);\n            const weakTypeCheck = `(${hasOwnPropCheck.join(' || ')})`;\n            return `(${isTypeCode} && ${weakTypeCheck})`;\n        }\n        return isTypeCode;\n    }\n\n    /**\n     * Loose union matching: returns first matching type in declaration order.\n     * Objects with properties from multiple union types will match the first compatible type.\n     * Use ESLint rules to detect overlapping types at compile time.\n     */\n    emitIsType(comp: JitFnCompiler): JitCode {\n        this.checkAllowedChildren(comp);\n        const {simpleItems, objectTypes, anyItem} = this.getUnionChildren(comp);\n        // Simple items (atomic types) don't need null guard\n        const simpleChecks = simpleItems.map((rt) => this.getChildIsTypeWithLooseCheck(rt, comp)).filter(Boolean);\n        // Object types need null guard to prevent accessing properties on null\n        const objChecks = objectTypes.map((rt) => this.getChildIsTypeWithLooseCheck(rt, comp)).filter(Boolean);\n        const objCode = objChecks.length\n            ? `(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && (${objChecks.join(' || ')}))`\n            : '';\n        // any/unknown checked last as fallback\n        const anyCheck = anyItem ? this.getChildIsTypeWithLooseCheck(anyItem, comp) : '';\n        const allChecks = [...simpleChecks, objCode, anyCheck].filter(Boolean);\n        return {code: `(${allChecks.join(' || ')})`, type: 'E'};\n    }\n\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        this.checkAllowedChildren(comp);\n        const isType = comp.compileIsType(this, 'E').code;\n        const code = `if (!${isType}) ${comp.callJitErr(this)};`;\n        return {code, type: 'S'};\n    }\n\n    /**\n     * When a union is encodes to json is encode into and array with two elements: [unionDiscriminator, encoded Value]\n     * the first element is the index of the type in the union.\n     * the second element is the encoded value of the type.\n     * ie: type union = string | number | bigint;  var v1: union = 123n;  v1 is encoded as [2, \"123n\"]\n     */\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        this.checkAllowedChildren(comp);\n        const {simpleItems, objectTypes, anyItem} = this.getUnionChildren(comp);\n        const errName = comp.getLocalVarName('uErr', this);\n        const fail = `throw new Error(${errName});`;\n        comp.setContextItem(errName, `const ${errName} = \"Can not json encode union: item does not belong to the union\"`);\n\n        const ifElse = createIfElseFn();\n\n        // Helper to generate encode code for a union item\n        const getEncodeCode = (childRt: BaseRunType) => {\n            const toJit = comp.compilePrepareForJson(childRt, 'S');\n            const fromJit = comp.compileRestoreFromJson(childRt, 'S');\n            const needsTupleEncoding = !!toJit.code || !!fromJit.code;\n            const isExpression = childIsExpression(toJit, childRt);\n            const encodeCode = isExpression && toJit.code ? `${comp.vλl} = ${toJit.code};` : toJit.code || '';\n            const index = this.getUnionItemIndex(comp, childRt);\n            const tupleEncode = needsTupleEncoding ? `${comp.vλl} = [${index}, ${comp.vλl}]` : '/*noop*/';\n            return `${encodeCode} ${tupleEncode}`;\n        };\n\n        // Generate code for simple items (atomic types)\n        const simpleCode = simpleItems.map((rt) => {\n            const isTypeCode = this.getChildIsTypeWithLooseCheck(rt, comp);\n            return `${ifElse()} (${isTypeCode}) {${getEncodeCode(rt)}}`;\n        });\n\n        // Generate code for object types (need null guard)\n        const objCode = objectTypes.length\n            ? objectTypes.map((rt) => {\n                  const isTypeCode = this.getChildIsTypeWithLooseCheck(rt, comp);\n                  return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getEncodeCode(rt)}}`;\n              })\n            : [];\n\n        // Generate code for anyItem (always matches, checked last as fallback)\n        const anyCode = anyItem ? `${ifElse(true)} {${getEncodeCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;\n\n        return {code: [...simpleCode, ...objCode, anyCode].join(''), type: 'S'};\n    }\n\n    /**\n     * When a union is decoded from json it expects de two elements array format: [unionDiscriminator, Value to decode]\n     * the first element is the index of the type in the union.\n     * the second element is the encoded value of the type.\n     * ie: type union = string | number | bigint;  var v1: union = 123n;  v1 is encoded as [2, \"123n\"]\n     */\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        this.checkAllowedChildren(comp);\n        const decVar = comp.getLocalVarName('dec', this);\n        const errVarName = comp.getLocalVarName('uErr', this);\n        comp.setContextItem(errVarName, `const ${errVarName} = \"Can not json decode union: invalid union index\"`);\n        const children = this.getJitChildren(comp);\n        const ifElse = createIfElseFn();\n        const itemsCode = children\n            .map((unionItem) => {\n                const childJit = comp.compileRestoreFromJson(unionItem, 'S');\n                const isExpression = childIsExpression(childJit, unionItem);\n                const code =\n                    isExpression && childJit.code && childJit.code !== comp.vλl\n                        ? `${comp.vλl} = ${childJit.code}`\n                        : childJit.code || '';\n                // item is decoded before being extracted from the array\n                const index = this.getUnionItemIndex(comp, unionItem);\n                return `${ifElse()} (${decVar} === ${index}) {${code || '/*noop*/'}}`;\n            })\n            .filter(Boolean);\n        const childrenCode = itemsCode.join('');\n        const failCode = childrenCode ? `else {throw new Error(${errVarName})}` : '';\n        const code = `\n            if (${comp.vλl}?.length === 2 && Array.isArray(${comp.vλl}) && typeof ${comp.vλl}[0] === 'number') {\n                const ${decVar} = ${comp.vλl}[0]; ${comp.vλl} = ${comp.vλl}[1];\n                ${childrenCode}\n                ${failCode}\n            }\n        `;\n        return {code, type: 'S'};\n    }\n\n    getUnionTypeNames(): string {\n        return this.getChildRunTypes()\n            .map((rt) => rt.getTypeName())\n            .join(' | ');\n    }\n\n    checkAllowedChildren(comp: JitFnCompiler) {\n        const allChildren = this.getChildRunTypes();\n        const toSkip = allChildren.filter((rt) => rt.skipJit(comp));\n        if (toSkip.length)\n            throw new Error(`Union can not have non serializable types, ie: Symbol, Function, etc. \\nType: ${this.stringify()}`);\n    }\n}\n"],"names":["code","__ΩSplitUnionResult"],"mappings":"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"}

package/.dist/esm/src/nodes/collection/unionDiscriminator.d.ts

@@ -1,22 +0,0 @@
-import { BaseRunType, CollectionRunType } from '../../lib/baseRunTypes.ts';
-import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
-import { UnionRunType } from './union.ts';
-import { PropertyRunType } from '../member/property.ts';
-export type FlattenedProp = {
-    unionItem: CollectionRunType<any>;
-    unionIndex: string | number;
-    prop: PropertyRunType;
-    typeID: string | number;
-    compiledName: string;
-};
-export type SplitUnionResult = {
-    simpleItems: BaseRunType[];
-    objectTypes: CollectionRunType<any>[];
-    anyItem?: BaseRunType;
-};
-export declare function splitUnionItems(comp: JitFnCompiler, urt: UnionRunType, unionChildren?: BaseRunType[]): SplitUnionResult;
-export declare function sortUnreachableTypes(comp: JitFnCompiler, objectTypes: CollectionRunType<any>[]): CollectionRunType<any>[];
-export declare function markDiscriminators(comp: JitFnCompiler, urt: UnionRunType, unionItems: BaseRunType[]): void;
-export declare type __ΩFlattenedProp = any[];
-export declare type __ΩSplitUnionResult = any[];
-//# sourceMappingURL=unionDiscriminator.d.ts.map

package/.dist/esm/src/nodes/collection/unionDiscriminator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unionDiscriminator.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/collection/unionDiscriminator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAE,iBAAiB,EAAgB,MAAM,2BAA2B,CAAC;AAC7F,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAI3D,MAAM,MAAM,aAAa,GAAG;IAExB,SAAS,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC;IAElC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5B,IAAI,EAAE,eAAe,CAAC;IAEtB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAExB,YAAY,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,WAAW,EAAE,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC;IAEtC,OAAO,CAAC,EAAE,WAAW,CAAC;CACzB,CAAC;AAQF,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,WAAW,EAAE,GAAG,gBAAgB,CAsBvH;AAQD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,CAAC,GAAG,CAAC,EAAE,GAAG,iBAAiB,CAAC,GAAG,CAAC,EAAE,CA4DzH;AAOD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,QAOnG"}

package/.dist/esm/src/nodes/collection/unionDiscriminator.js

@@ -1,198 +0,0 @@
-import { getTotalComplexity, sortRunTypeByComplexity } from "../../lib/utils.js";
-import { isAnyRunType, isUnknownRunType } from "../../lib/guards.js";
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-const __ΩFlattenedProp = ["CollectionRunType", "unionItem", "unionIndex", "PropertyRunType", "prop", "typeID", "compiledName", "FlattenedProp", `P"w!4"P&'J4#"w$4%P&'J4&&4'Mw(y`];
-const __ΩSplitUnionResult = ["BaseRunType", "simpleItems", "CollectionRunType", "objectTypes", "anyItem", "SplitUnionResult", 'P"w!F4""w#F4$"w!4%8Mw&y'];
-function splitUnionItems(comp, urt, unionChildren) {
-  const unionItems = unionChildren || urt.getJitChildren(comp);
-  const objectTypes = [];
-  const simpleItems = [];
-  let anyItem;
-  unionItems.forEach(__assignType((unionItem) => {
-    if (isAnyRunType(unionItem) || isUnknownRunType(unionItem)) {
-      if (!anyItem)
-        anyItem = unionItem;
-      return;
-    }
-    const isObj = urt.isTypeWithProperties(unionItem);
-    if (!isObj)
-      return simpleItems.push(unionItem);
-    return objectTypes.push(unionItem);
-  }, ["unionItem", "", 'P"2!"/"']));
-  const sortedObjectTypes = sortUnreachableTypes(comp, objectTypes);
-  return { simpleItems, objectTypes: sortedObjectTypes, anyItem };
-}
-splitUnionItems.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "BaseRunType", "unionChildren", () => __ΩSplitUnionResult, "splitUnionItems", `P"w!2""w#2$"w%F2&8n'/(`];
-function sortUnreachableTypes(comp, objectTypes) {
-  if (objectTypes.length <= 1)
-    return objectTypes;
-  const typePropsMap = (Map.Ω = [["CollectionRunType", '"w!'], ["P&'JD"]], /* @__PURE__ */ new Map());
-  objectTypes.forEach(__assignType((objType) => {
-    const props = objType.getJitChildren(comp);
-    const propTypeIDs = (Set.Ω = [["P&'J"]], /* @__PURE__ */ new Set());
-    props.forEach(__assignType((prop) => propTypeIDs.add(prop.getTypeID()), ["prop", "", 'P"2!"/"']));
-    typePropsMap.set(objType, propTypeIDs);
-  }, ["objType", "", 'P"2!"/"']));
-  const isSubsetOf = __assignType((smaller, larger) => {
-    const smallerProps = typePropsMap.get(smaller);
-    const largerProps = typePropsMap.get(larger);
-    if (smallerProps.size >= largerProps.size)
-      return false;
-    for (const typeID of smallerProps) {
-      if (!largerProps.has(typeID))
-        return false;
-    }
-    return true;
-  }, ["CollectionRunType", "smaller", "larger", "", 'P"w!2""w!2#)/$']);
-  const processed = (Set.Ω = [["CollectionRunType", '"w!']], /* @__PURE__ */ new Set());
-  const result = [];
-  for (let i = 0; i < objectTypes.length; i++) {
-    const current = objectTypes[i];
-    if (processed.has(current))
-      continue;
-    const relatedGroup = [current];
-    processed.add(current);
-    for (let j = 0; j < objectTypes.length; j++) {
-      if (i === j)
-        continue;
-      const other = objectTypes[j];
-      if (processed.has(other))
-        continue;
-      if (isSubsetOf(current, other) || isSubsetOf(other, current)) {
-        relatedGroup.push(other);
-        processed.add(other);
-      }
-    }
-    if (relatedGroup.length > 1) {
-      relatedGroup.sort(__assignType((a, b) => {
-        const aSize = typePropsMap.get(a).size;
-        const bSize = typePropsMap.get(b).size;
-        return bSize - aSize;
-      }, ["a", "b", "", 'P"2!"2""/#']));
-    }
-    result.push(...relatedGroup);
-  }
-  return result;
-}
-sortUnreachableTypes.__type = ["JitFnCompiler", "comp", "CollectionRunType", "objectTypes", "sortUnreachableTypes", 'P"w!2""w#F2$"w#F/%'];
-function markDiscriminators(comp, urt, unionItems) {
-  if (urt.hasDiscriminators !== void 0 && urt.hasObjectTypes !== void 0)
-    return;
-  const objectTypes = unionItems.filter(__assignType((item) => urt.isTypeWithProperties(item), ["item", "", 'P"2!"/"']));
-  const namedDiscriminators = getDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
-  const uniqueDiscriminators = getUniqueDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
-  urt.hasObjectTypes = !!objectTypes.length;
-  urt.hasDiscriminators = !!namedDiscriminators.length || !!uniqueDiscriminators.length;
-}
-markDiscriminators.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "BaseRunType", "unionItems", "markDiscriminators", `P"w!2""w#2$"w%F2&"/'`];
-const __ΩPropUnionItemPair = ["PropertyRunType", "prop", "CollectionRunType", "unionItem", "PropUnionItemPair", 'P"w!4""w#4$Mw%y'];
-function getDiscriminatorProperties(comp, urt, unionTypes, getCompiledName) {
-  if (!unionTypes.length)
-    return [];
-  const propByName = (Map.Ω = [["P&'J"], [() => __ΩPropUnionItemPair, "n!F"]], /* @__PURE__ */ new Map());
-  unionTypes.forEach(__assignType((unionItem) => {
-    const props = unionItem.getJitChildren(comp);
-    props.forEach(__assignType((prop) => {
-      const name = prop.getChildVarName(comp);
-      const existing = propByName.get(name) || [];
-      propByName.set(name, [...existing, { prop, unionItem }]);
-    }, ["prop", "", 'P"2!"/"']));
-  }, ["unionItem", "", 'P"2!"/"']));
-  const propsOnAllTypes = Array.from(propByName.entries()).filter(__assignType(([, props]) => props.length === unionTypes.length, ["param0", "", 'P"2!"/"'])).map(__assignType(([key, props]) => ({
-    name: key,
-    props,
-    complexity: props.reduce(__assignType((acc, item) => acc + getTotalComplexity(comp, item.prop), ["acc", "item", "", 'P"2!"2""/#']), 0),
-    isUniqueType: props.every(__assignType((item) => {
-      const child = item;
-      const typeID = child.prop.getTypeID();
-      const isDiff = props.every(__assignType((otherItem) => child.prop === otherItem.prop || otherItem.prop.getTypeID() !== typeID, ["otherItem", "", 'P"2!"/"']));
-      return isDiff;
-    }, ["item", "", 'P"2!"/"']))
-  }), ["param0", "", 'P"2!"/"'])).filter(__assignType((item) => item.isUniqueType, ["item", "", 'P"2!"/"']));
-  const lessComplexProps = propsOnAllTypes.toSorted(__assignType((a, b) => a.complexity - b.complexity, ["a", "b", "", 'P"2!"2""/#']));
-  const lessComplex = lessComplexProps[0];
-  if (!lessComplex)
-    return [];
-  return lessComplex.props.map(__assignType((item) => {
-    item.prop.isUnionDiscriminator = true;
-    const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
-    const typeID = item.prop.getTypeID();
-    return {
-      unionItem: item.unionItem,
-      unionIndex,
-      prop: item.prop,
-      typeID,
-      compiledName: getCompiledName(comp, urt, typeID)
-    };
-  }, ["item", "", 'P"2!"/"']));
-}
-getDiscriminatorProperties.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "CollectionRunType", "unionTypes", "propTypeID", "", "getCompiledName", () => __ΩFlattenedProp, "getDiscriminatorProperties", `P"w!2""w#2$"w%F2&P"w!2""w#2$P&'J2'&/(2)n*F/+`];
-function getUniqueDiscriminatorProperties(comp, urt, unionTypes, getCompiledName) {
-  if (!unionTypes.length)
-    return [];
-  const uniquePropByUnionItem = (Map.Ω = [["CollectionRunType", '"w!'], [() => __ΩPropUnionItemPair, "n!"]], /* @__PURE__ */ new Map());
-  unionTypes.forEach(__assignType((unionItem) => {
-    const props = unionItem.getJitChildren(comp);
-    props.forEach(__assignType((prop) => {
-      const typeID = prop.getTypeID();
-      const isUnique = unionTypes.every(__assignType((otherUnionItem) => {
-        if (otherUnionItem === unionItem)
-          return true;
-        const otherProps = otherUnionItem.getJitChildren(comp);
-        return otherProps.every(__assignType((otherProp) => otherProp.getTypeID() !== typeID, ["otherProp", "", 'P"2!"/"']));
-      }, ["otherUnionItem", "", 'P"2!"/"']));
-      if (isUnique) {
-        const existing = uniquePropByUnionItem.get(unionItem);
-        if (!existing) {
-          uniquePropByUnionItem.set(unionItem, {
-            prop,
-            unionItem
-          });
-          return;
-        }
-        const newItem = { prop, unionItem };
-        const lessComplex = [newItem, existing].toSorted(__assignType((a, b) => sortRunTypeByComplexity(comp, a.prop, b.prop), ["a", "b", "", 'P"2!"2""/#']))[0];
-        uniquePropByUnionItem.set(unionItem, lessComplex);
-      }
-    }, ["prop", "", 'P"2!"/"']));
-  }, ["unionItem", "", 'P"2!"/"']));
-  if (!uniquePropByUnionItem.size)
-    return [];
-  const uniqueProps = Array.from(uniquePropByUnionItem.values());
-  return uniqueProps.map(__assignType((item) => {
-    item.prop.isUnionDiscriminator = true;
-    const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
-    const typeID = item.prop.getTypeID();
-    return {
-      unionItem: item.unionItem,
-      unionIndex,
-      prop: item.prop,
-      typeID,
-      compiledName: getCompiledName(comp, urt, typeID)
-    };
-  }, ["item", "", 'P"2!"/"']));
-}
-getUniqueDiscriminatorProperties.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "CollectionRunType", "unionTypes", "propTypeID", "", "getCompiledName", () => __ΩFlattenedProp, "getUniqueDiscriminatorProperties", `P"w!2""w#2$"w%F2&P"w!2""w#2$P&'J2'&/(2)n*F/+`];
-function initGetCompiledName() {
-  const typeIDs = (Map.Ω = [["P&'J"], ["'"]], /* @__PURE__ */ new Map());
-  return __assignType(function getCompiledName(comp, urt, typeID) {
-    const existingIndex = typeIDs.get(typeID);
-    if (existingIndex)
-      return comp.getLocalVarName("prop", urt) + `_${existingIndex}`;
-    const newIndex = typeIDs.size;
-    typeIDs.set(typeID, newIndex);
-    return comp.getLocalVarName("prop", urt) + `_${newIndex}`;
-  }, ["JitFnCompiler", "comp", "UnionRunType", "urt", "typeID", "getCompiledName", `P"w!2""w#2$P&'J2%&/&`]);
-}
-initGetCompiledName.__type = ["initGetCompiledName", 'P"/!'];
-export {
-  __ΩFlattenedProp,
-  __ΩSplitUnionResult,
-  markDiscriminators,
-  sortUnreachableTypes,
-  splitUnionItems
-};
-//# sourceMappingURL=unionDiscriminator.js.map

package/.dist/esm/src/nodes/collection/unionDiscriminator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unionDiscriminator.js","sources":["../../../../../src/nodes/collection/unionDiscriminator.ts"],"sourcesContent":["import type {BaseRunType, CollectionRunType, MemberRunType} from '../../lib/baseRunTypes.ts';\nimport type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {UnionRunType} from './union.ts';\nimport type {PropertyRunType} from '../member/property.ts';\nimport {getTotalComplexity, sortRunTypeByComplexity} from '../../lib/utils.ts';\nimport {isAnyRunType, isUnknownRunType} from '../../lib/guards.ts';\n\nexport type FlattenedProp = {\n    /** union item, parent of the property */\n    unionItem: CollectionRunType<any>;\n    /** index of the union item in the union */\n    unionIndex: string | number;\n    /** one property of the union item  */\n    prop: PropertyRunType;\n    /** typeID of the property */\n    typeID: string | number;\n    /** name of the property as it should be used in the code */\n    compiledName: string;\n};\n\nexport type SplitUnionResult = {\n    simpleItems: BaseRunType[];\n    objectTypes: CollectionRunType<any>[];\n    /** any or unknown type if present in the union, should be checked last */\n    anyItem?: BaseRunType;\n};\n\n/**\n * Split the union types in two groups: interface types and simple types\n * interface types are types that have properties, simple types are the rest (atomic types, tuples, etc)\n * If any or unknown types are present, they are extracted and returned separately as anyItem\n * so they can be checked last (any/unknown would match anything, so must be last resort)\n */\nexport function splitUnionItems(comp: JitFnCompiler, urt: UnionRunType, unionChildren?: BaseRunType[]): SplitUnionResult {\n    const unionItems = unionChildren || urt.getJitChildren(comp);\n    const objectTypes: CollectionRunType<any>[] = [];\n    const simpleItems: BaseRunType[] = [];\n    let anyItem: BaseRunType | undefined;\n\n    unionItems.forEach((unionItem) => {\n        // Extract any/unknown types to be checked last\n        if (isAnyRunType(unionItem) || isUnknownRunType(unionItem)) {\n            // Only keep the first any/unknown type (having multiple is redundant)\n            if (!anyItem) anyItem = unionItem;\n            return;\n        }\n        const isObj = urt.isTypeWithProperties(unionItem);\n        if (!isObj) return simpleItems.push(unionItem);\n        return objectTypes.push(unionItem as CollectionRunType<any>);\n    });\n\n    // Sort object types to prevent unreachable types (objects with more props should come first when they share same prop types)\n    const sortedObjectTypes = sortUnreachableTypes(comp, objectTypes);\n\n    return {simpleItems, objectTypes: sortedObjectTypes, anyItem};\n}\n\n/**\n * Sorts object types to prevent unreachable union types.\n * When two objects share the same properties (by typeID), the one with more properties must come first.\n * This ensures that at runtime, the more specific type is checked before the less specific one.\n * Objects that don't share properties with others maintain their relative order.\n */\nexport function sortUnreachableTypes(comp: JitFnCompiler, objectTypes: CollectionRunType<any>[]): CollectionRunType<any>[] {\n    if (objectTypes.length <= 1) return objectTypes;\n\n    // Get property typeIDs for each object type\n    const typePropsMap = new Map<CollectionRunType<any>, Set<string | number>>();\n    objectTypes.forEach((objType) => {\n        const props = objType.getJitChildren(comp) as PropertyRunType[];\n        const propTypeIDs = new Set<string | number>();\n        props.forEach((prop) => propTypeIDs.add(prop.getTypeID()));\n        typePropsMap.set(objType, propTypeIDs);\n    });\n\n    // Check if one object's props are a subset of another's (all props have same typeIDs)\n    const isSubsetOf = (smaller: CollectionRunType<any>, larger: CollectionRunType<any>): boolean => {\n        const smallerProps = typePropsMap.get(smaller)!;\n        const largerProps = typePropsMap.get(larger)!;\n        if (smallerProps.size >= largerProps.size) return false;\n        for (const typeID of smallerProps) {\n            if (!largerProps.has(typeID)) return false;\n        }\n        return true;\n    };\n\n    // Find groups of objects that share properties (one is subset of another)\n    const processed = new Set<CollectionRunType<any>>();\n    const result: CollectionRunType<any>[] = [];\n\n    for (let i = 0; i < objectTypes.length; i++) {\n        const current = objectTypes[i];\n        if (processed.has(current)) continue;\n\n        // Find all objects that are related (subset/superset) to current\n        const relatedGroup: CollectionRunType<any>[] = [current];\n        processed.add(current);\n\n        for (let j = 0; j < objectTypes.length; j++) {\n            if (i === j) continue;\n            const other = objectTypes[j];\n            if (processed.has(other)) continue;\n\n            // Check if current and other are related (one is subset of the other)\n            if (isSubsetOf(current, other) || isSubsetOf(other, current)) {\n                relatedGroup.push(other);\n                processed.add(other);\n            }\n        }\n\n        // Sort related group by number of properties (more props first)\n        if (relatedGroup.length > 1) {\n            relatedGroup.sort((a, b) => {\n                const aSize = typePropsMap.get(a)!.size;\n                const bSize = typePropsMap.get(b)!.size;\n                return bSize - aSize; // descending order (more props first)\n            });\n        }\n\n        result.push(...relatedGroup);\n    }\n\n    return result;\n}\n\n/**\n * Mark discriminator properties so they can be sorted and validate union more efficiently.\n * @param comp\n * @param urt\n */\nexport function markDiscriminators(comp: JitFnCompiler, urt: UnionRunType, unionItems: BaseRunType[]) {\n    if (urt.hasDiscriminators !== undefined && urt.hasObjectTypes !== undefined) return;\n    const objectTypes = unionItems.filter((item) => urt.isTypeWithProperties(item)) as CollectionRunType<any>[];\n    const namedDiscriminators = getDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());\n    const uniqueDiscriminators = getUniqueDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());\n    urt.hasObjectTypes = !!objectTypes.length;\n    urt.hasDiscriminators = !!namedDiscriminators.length || !!uniqueDiscriminators.length;\n}\n\ntype PropUnionItemPair = {prop: PropertyRunType; unionItem: CollectionRunType<any>};\n\n/**\n * Find a property with the same name in all the types of the union and that has different types.\n * It also marks those properties as discriminator properties so can be sorted later\n */\nfunction getDiscriminatorProperties(\n    comp: JitFnCompiler,\n    urt: UnionRunType,\n    unionTypes: CollectionRunType<any>[],\n    getCompiledName: (comp: JitFnCompiler, urt: UnionRunType, propTypeID: string | number) => string\n): FlattenedProp[] {\n    if (!unionTypes.length) return [];\n    const propByName = new Map<string | number, PropUnionItemPair[]>();\n    unionTypes.forEach((unionItem) => {\n        const props = unionItem.getJitChildren(comp) as PropertyRunType[];\n        props.forEach((prop) => {\n            const name = prop.getChildVarName(comp);\n            const existing = propByName.get(name) || [];\n            // index no needed now\n            propByName.set(name, [...existing, {prop, unionItem}]);\n        });\n    });\n    const propsOnAllTypes = Array.from(propByName.entries())\n        // filter all properties that are in all types\n        .filter(([, props]) => props.length === unionTypes.length)\n        // calculate complexity and check if all types are different in all props\n        .map(([key, props]) => ({\n            name: key,\n            props,\n            complexity: props.reduce((acc, item) => acc + getTotalComplexity(comp, item.prop), 0),\n            isUniqueType: props.every((item) => {\n                const child = item;\n                const typeID = child.prop.getTypeID();\n                const isDiff = props.every((otherItem) => child.prop === otherItem.prop || otherItem.prop.getTypeID() !== typeID);\n                return isDiff;\n            }),\n        }))\n        .filter((item) => item.isUniqueType);\n    const lessComplexProps = propsOnAllTypes.toSorted((a, b) => a.complexity - b.complexity);\n    const lessComplex = lessComplexProps[0];\n    if (!lessComplex) return [];\n    // we need to marks the property as discriminator so they can be sorted and checked first later\n    return lessComplex.props.map((item) => {\n        item.prop.isUnionDiscriminator = true;\n        const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);\n        const typeID = item.prop.getTypeID();\n        return {\n            unionItem: item.unionItem,\n            unionIndex,\n            prop: item.prop,\n            typeID,\n            compiledName: getCompiledName(comp, urt, typeID),\n        };\n    });\n}\n\n/**\n * Get unique properties in the union as discriminators.\n * These properties can be of different name but are unique in the union so can act as discriminators.\n * It also marks those properties as discriminator properties so can be sorted later.\n * */\nfunction getUniqueDiscriminatorProperties(\n    comp: JitFnCompiler,\n    urt: UnionRunType,\n    unionTypes: CollectionRunType<any>[],\n    getCompiledName: (comp: JitFnCompiler, urt: UnionRunType, propTypeID: string | number) => string\n): FlattenedProp[] {\n    if (!unionTypes.length) return [];\n    const uniquePropByUnionItem = new Map<CollectionRunType<any>, PropUnionItemPair>();\n    unionTypes.forEach((unionItem) => {\n        const props = unionItem.getJitChildren(comp) as PropertyRunType[];\n        props.forEach((prop) => {\n            const typeID = prop.getTypeID();\n            const isUnique = unionTypes.every((otherUnionItem) => {\n                if (otherUnionItem === unionItem) return true;\n                const otherProps = otherUnionItem.getJitChildren(comp) as MemberRunType<any>[];\n                return otherProps.every((otherProp) => otherProp.getTypeID() !== typeID);\n            });\n            if (isUnique) {\n                const existing = uniquePropByUnionItem.get(unionItem);\n                if (!existing) {\n                    uniquePropByUnionItem.set(unionItem, {\n                        prop,\n                        unionItem,\n                    });\n                    return;\n                }\n                const newItem = {prop, unionItem};\n                const lessComplex = [newItem, existing].toSorted((a, b) => sortRunTypeByComplexity(comp, a.prop, b.prop))[0];\n                uniquePropByUnionItem.set(unionItem, lessComplex);\n            }\n        });\n    });\n    if (!uniquePropByUnionItem.size) return [];\n    const uniqueProps = Array.from(uniquePropByUnionItem.values());\n    return uniqueProps.map((item) => {\n        item.prop.isUnionDiscriminator = true;\n        const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);\n        const typeID = item.prop.getTypeID();\n        return {\n            unionItem: item.unionItem,\n            unionIndex,\n            prop: item.prop,\n            typeID,\n            compiledName: getCompiledName(comp, urt, typeID),\n        };\n    });\n}\n\nfunction initGetCompiledName() {\n    const typeIDs = new Map<string | number, number>();\n    return function getCompiledName(comp: JitFnCompiler, urt: UnionRunType, typeID: string | number): string {\n        const existingIndex = typeIDs.get(typeID);\n        if (existingIndex) return comp.getLocalVarName('prop', urt) + `_${existingIndex}`;\n        const newIndex = typeIDs.size;\n        typeIDs.set(typeID, newIndex);\n        return comp.getLocalVarName('prop', urt) + `_${newIndex}`;\n    };\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/nodes/function/function.d.ts

@@ -1,35 +0,0 @@
-import { AnyFunction, SrcType, JitFn, JitCode, RunTypeOptions } from '../../types.ts';
-import { TypeFunction } from '@deepkit/type';
-import { BaseRunType } from '../../lib/baseRunTypes.ts';
-import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
-import { FunctionParamsRunType } from '../collection/functionParams.ts';
-import { JitCompiledFn } from '@mionjs/core';
-export declare class FunctionRunType<CallType extends AnyFunction = TypeFunction> extends BaseRunType<CallType> {
-    parameterRunTypes: FunctionParamsRunType;
-    skipJit(comp: JitFnCompiler): boolean;
-    onCreated(deepkitType: SrcType): void;
-    getFamily(): 'F';
-    getFnName(): string | number;
-    createJitParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any;
-    createJitCompiledParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn;
-    createJitReturnFunction(jitFn: JitFn): (...args: any[]) => any;
-    createJitCompiledReturnFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn;
-    emitIsType(comp: JitFnCompiler): JitCode;
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
-    emitPrepareForJson(): JitCode;
-    emitRestoreFromJson(): JitCode;
-    emitHasUnknownKeys(): JitCode;
-    emitUnknownKeyErrors(): JitCode;
-    emitStripUnknownKeys(): JitCode;
-    emitUnknownKeysToUndefined(): JitCode;
-    getReturnType(): BaseRunType;
-    getResolvedReturnType(): BaseRunType;
-    getParameters(): FunctionParamsRunType;
-    getParameterNames(opts?: RunTypeOptions): string[];
-    hasReturnData(): boolean;
-    isAsync(): boolean;
-    returnIsPromise(): boolean;
-    mockReturn(ctx?: RunTypeOptions): Promise<any>;
-    mockParams(ctx?: RunTypeOptions): Promise<any[]>;
-}
-//# sourceMappingURL=function.d.ts.map