@mionjs/run-types 0.8.0-alpha.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"functionParams.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,43 @@
+import { TypeObjectLiteral, TypeClass, TypeIntersection } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { PropertyRunType } from '../member/property.ts';
+import { BaseRunType, CollectionRunType, MemberRunType } from '../../lib/baseRunTypes.ts';
+import { MethodSignatureRunType } from '../member/methodSignature.ts';
+import { IndexSignatureRunType } from '../member/indexProperty.ts';
+import { MethodRunType } from '../member/method.ts';
+import { CallSignatureRunType } from '../member/callSignature.ts';
+export type InterfaceMember = PropertyRunType | MethodSignatureRunType | IndexSignatureRunType | MethodRunType | CallSignatureRunType;
+export declare class InterfaceRunType<T extends TypeObjectLiteral | TypeClass | TypeIntersection = TypeObjectLiteral> extends CollectionRunType<T> {
+    getNamedChildren(comp: JitFnCompiler): InterfaceMember[];
+    isCallable(): boolean;
+    getCallSignature: () => CallSignatureRunType | undefined;
+    getJitChildren(comp: JitFnCompiler): InterfaceMember[];
+    splitJitSplitChildren(comp: JitFnCompiler): {
+        required: PropertyRunType[];
+        optional: PropertyRunType[];
+        indexSignatures: IndexSignatureRunType[];
+    };
+    isPartOfUnion(): boolean;
+    hasIndexSignature(comp: JitFnCompiler): boolean;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode;
+    getJsonStringifySortedChildren(comp: JitFnCompiler): MemberRunType<any>[];
+    allOptionalCode(comp: JitFnCompiler): string;
+    addObjectPropsToContext(comp: JitFnCompiler, jitChildrenRunTypes?: BaseRunType[], allChildrenRuntypes?: BaseRunType[]): ObjectPropsContextResult;
+}
+export interface ObjectPropsContextResult {
+    keysName: string;
+    allKeysName: string;
+    hasNonJitChildren: boolean;
+    jitChildrenNames: string[];
+    allChildrenNames: string[];
+}
+export declare type __ΩInterfaceMember = any[];
+export declare type __ΩObjectPropsContextResult = any[];

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

@@ -0,0 +1,221 @@
+import { ReflectionKind, __ΩTypeObjectLiteral as ___TypeObjectLiteral } from "@deepkit/type";
+import { memorize, getJitFnArgCallVarName, arrayToLiteral, sortDiscriminatorsFirst } from "../../lib/utils.js";
+import { PropertyRunType } from "../member/property.js";
+import { CollectionRunType, MemberRunType, BaseRunType } from "../../lib/baseRunTypes.js";
+import { MethodSignatureRunType } from "../member/methodSignature.js";
+import { IndexSignatureRunType } from "../member/indexProperty.js";
+import { MethodRunType } from "../member/method.js";
+import { CallSignatureRunType } from "../member/callSignature.js";
+import { JitFunctions } from "../../constants.functions.js";
+import { isIndexSignatureRunType } from "../../lib/guards.js";
+import { cpf_getUnknownKeysFromArray, cpf_hasUnknownKeysFromArray } from "../../run-types-pure-fns.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const __ΩInterfaceMember = [() => PropertyRunType, () => MethodSignatureRunType, () => IndexSignatureRunType, () => MethodRunType, () => CallSignatureRunType, "InterfaceMember", 'PP7!P7"P7#P7$P7%Jw&y'];
+class InterfaceRunType extends CollectionRunType {
+  getNamedChildren(comp) {
+    return this.getJitChildren(comp).filter(__assignType((prop) => !!prop.src.name, ["prop", "", 'P"2!"/"']));
+  }
+  isCallable() {
+    return this.getCallSignature() !== void 0;
+  }
+  getCallSignature = memorize(__assignType(() => {
+    return this.getChildRunTypes().find(__assignType((prop) => prop.src.kind === ReflectionKind.callSignature, ["prop", "", 'P"2!"/"']));
+  }, [() => CallSignatureRunType, "", 'PPP7!-J/"']));
+  getJitChildren(comp) {
+    const children = super.getJitChildren(comp);
+    return children.toSorted(__assignType((a, b) => sortDiscriminatorsFirst(a, b), ["a", "b", "", 'P"2!"2""/#']));
+  }
+  /** Split children in two groups: required and optional */
+  splitJitSplitChildren(comp) {
+    const children = super.getJitChildren(comp);
+    const required = children.filter(__assignType((prop) => !prop.isOptional(), ["prop", "", 'P"2!"/"']));
+    const optional = children.filter(__assignType((prop) => prop.isOptional() && !isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+    const indexSignatures = children.filter(__assignType((prop) => isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+    return { required, optional, indexSignatures };
+  }
+  isPartOfUnion() {
+    return this.getParent()?.src.kind === ReflectionKind.union;
+  }
+  hasIndexSignature(comp) {
+    return this.getJitChildren(comp).some(__assignType((prop) => isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+  }
+  // #### collection's jit code ####
+  emitIsType(comp) {
+    const varName = comp.vλl;
+    const children = this.getJitChildren(comp);
+    const childrenCode = children.map(__assignType((prop) => comp.compileIsType(prop, "E").code, ["prop", "", 'P"2!"/"'])).filter(Boolean).join(" && ");
+    if (this.isCallable())
+      return {
+        code: [this.getCallSignature().emitIsType(comp).code, childrenCode].filter(Boolean).join(" && "),
+        type: "E"
+      };
+    const objectCheck = this.isPartOfUnion() ? "" : `typeof ${varName} === 'object' && ${varName} !== null`;
+    const itemsCode = [objectCheck, this.allOptionalCode(comp), childrenCode].filter(Boolean).join(" && ");
+    return { code: `(${itemsCode})`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    const varName = comp.vλl;
+    const children = this.getJitChildren(comp);
+    const childrenCode = children.map(__assignType((prop) => comp.compileTypeErrors(prop, "S").code, ["prop", "", 'P"2!"/"'])).filter(Boolean).join(";");
+    if (this.isCallable()) {
+      return { code: `${this.getCallSignature().emitTypeErrors(comp).code} else {${childrenCode}}`, type: "S" };
+    }
+    const objectCheck = this.isPartOfUnion() ? "" : `typeof ${varName} === 'object' && ${varName} !== null`;
+    const isObjectCode = [objectCheck, this.allOptionalCode(comp)].filter(Boolean).join(" && ");
+    return {
+      code: `
+            if (!(${isObjectCode})) {
+                ${comp.callJitErr(this)};
+            } else {
+                ${childrenCode}
+            }
+        `,
+      type: "S"
+    };
+  }
+  emitPrepareForJson(comp) {
+    if (this.isCallable())
+      return this.getCallSignature().emitPrepareForJson();
+    const children = this.getJitChildren(comp);
+    const childrenCode = children.map(__assignType((prop) => comp.compilePrepareForJson(prop, "S").code, ["prop", "", 'P"2!"/"'])).filter(Boolean).join(";");
+    return { code: childrenCode, type: "S" };
+  }
+  emitRestoreFromJson(comp) {
+    if (this.isCallable())
+      return this.getCallSignature().emitRestoreFromJson();
+    const children = this.getJitChildren(comp);
+    const childrenCode = children.map(__assignType((prop) => comp.compileRestoreFromJson(prop, "S").code, ["prop", "", 'P"2!"/"'])).filter(Boolean).join(";");
+    return { code: childrenCode, type: "S" };
+  }
+  emitHasUnknownKeys(comp) {
+    const children = this.getJitChildren(comp);
+    const allChildren = this.getChildRunTypes().filter(__assignType((prop) => !isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+    const hasIndexProp = children.some(__assignType((prop) => isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+    const parentCode = hasIndexProp ? "" : callCheckUnknownProperties(this, comp, children, false, !this.isPartOfUnion(), allChildren);
+    const childrenCode = super.emitHasUnknownKeys(comp).code;
+    return { code: [parentCode, childrenCode].filter(Boolean).join(" || "), type: "E" };
+  }
+  emitUnknownKeyErrors(comp) {
+    const children = this.getJitChildren(comp);
+    const allChildren = this.getChildRunTypes().filter(__assignType((prop) => !isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+    const hasIndexProp = children.some(__assignType((prop) => isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+    const unknownVar = comp.getLocalVarName("unk", this);
+    const keyVar = comp.getLocalVarName("ky", this);
+    const unknownValue = hasIndexProp ? void 0 : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion(), allChildren);
+    const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath("never", keyVar)}}}
+        `;
+    const childrenCode = super.emitUnknownKeyErrors(comp).code;
+    return { code: [unknownValue ? parentCode : "", childrenCode].filter(Boolean).join("\n"), type: "S" };
+  }
+  emitStripUnknownKeys(comp) {
+    const children = this.getJitChildren(comp);
+    const unknownVar = comp.getLocalVarName("unk", this);
+    const keyVar = comp.getLocalVarName("ky", this);
+    const hasIndexProp = children.some(__assignType((prop) => isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+    const unknownValue = hasIndexProp ? void 0 : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());
+    const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){delete ${comp.vλl}[${keyVar}]}}
+        `;
+    const childrenCode = super.emitStripUnknownKeys(comp).code;
+    return { code: [unknownValue ? parentCode : "", childrenCode].filter(Boolean).join("\n"), type: "S" };
+  }
+  emitUnknownKeysToUndefined(comp) {
+    const children = this.getJitChildren(comp);
+    const unknownVar = comp.getLocalVarName("unk", this);
+    const keyVar = comp.getLocalVarName("ky", this);
+    const hasIndexProp = children.some(__assignType((prop) => isIndexSignatureRunType(prop), ["prop", "", 'P"2!"/"']));
+    const unknownValue = hasIndexProp ? void 0 : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());
+    const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){${comp.vλl}[${keyVar}] = undefined}}
+        `;
+    const childrenCode = super.emitUnknownKeysToUndefined(comp).code;
+    return { code: [unknownValue ? parentCode : "", childrenCode].filter(Boolean).join("\n"), type: "S" };
+  }
+  // In order to json stringify to work properly optional properties must come first
+  getJsonStringifySortedChildren(comp) {
+    return this.getJitChildren(comp).toSorted(__assignType((a, b) => {
+      const aOptional = a instanceof MemberRunType && a.isOptional();
+      const bOptional = b instanceof MemberRunType && b.isOptional();
+      if (aOptional && !bOptional)
+        return -1;
+      if (!aOptional && bOptional)
+        return 1;
+      return 0;
+    }, ["a", "b", "", 'P"2!"2""/#']));
+  }
+  // extra check to prevent empty array passing as object where all properties are optional
+  // when this check is disabled empty array will pass as object but fail when checking for properties
+  allOptionalCode(comp) {
+    const children = this.getJitChildren(comp);
+    if (children.length !== 0 && !this.areAllChildrenOptional(children))
+      return "";
+    const isNotArray = `!Array.isArray(${comp.vλl})`;
+    const ifNoNative = `Object.prototype.toString.call(${comp.vλl}) === '[object Object]'`;
+    return `(${isNotArray} && ${ifNoNative})`;
+  }
+  addObjectPropsToContext(comp, jitChildrenRunTypes, allChildrenRuntypes) {
+    const children = jitChildrenRunTypes || this.getJitChildren(comp);
+    const allChildren = allChildrenRuntypes || this.getChildRunTypes();
+    return addObjectPropsToContext(this, comp, children, allChildren);
+  }
+  static __type = [() => ___TypeObjectLiteral, "T", () => CollectionRunType, "JitFnCompiler", "comp", () => __ΩInterfaceMember, "getNamedChildren", "isCallable", "getCallSignature", function() {
+    return memorize(__assignType(() => {
+      return this.getChildRunTypes().find(__assignType((prop) => prop.src.kind === ReflectionKind.callSignature, ["prop", "", 'P"2!"/"']));
+    }, [() => CallSignatureRunType, "", 'PPP7!-J/"']));
+  }, () => __ΩInterfaceMember, "getJitChildren", () => PropertyRunType, "required", () => PropertyRunType, "optional", () => IndexSignatureRunType, "indexSignatures", "splitJitSplitChildren", "isPartOfUnion", "hasIndexSignature", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", () => MemberRunType, "getJsonStringifySortedChildren", "allOptionalCode", () => BaseRunType, "jitChildrenRunTypes", () => BaseRunType, "allChildrenRuntypes", "addObjectPropsToContext", "InterfaceRunType", `n!c"Pe"!7#P"w$2%n&F0'P)0(!3)>*P"w$2%n+F0,P"w$2%PP7-F4.P7/F40P71F42M03P)04P"w$2%)05P"w$2%"w607P"w82%"w609P"w$2%"w60:P"w$2%"w60;P"w$2%"w60<P"w82%"w60=P"w$2%"w60>P"w$2%"w60?P"w$2%P"7@F0AP"w$2%&0BP"w$2%P7CF2D8P7EF2F8"0G5e!!6"wH`];
+}
+const __ΩObjectPropsContextResult = ["keysName", "allKeysName", "hasNonJitChildren", "jitChildrenNames", "allChildrenNames", "ObjectPropsContextResult", 'P&4!&4")4#&F4$&F4%Mw&y'];
+function addObjectPropsToContext(rt, comp, jitChildrenRunTypes, allChildrenRuntypes) {
+  const jitArrNames = jitChildrenRunTypes.filter(__assignType((prop) => !!prop.src.name, ["prop", "", 'P"2!"/"'])).map(__assignType((prop) => prop.src.name, ["prop", "", 'P"2!"/"']));
+  const AllArrNames = allChildrenRuntypes?.filter(__assignType((prop) => !!prop.src.name, ["prop", "", 'P"2!"/"'])).map(__assignType((prop) => prop.src.name, ["prop", "", 'P"2!"/"']));
+  const jitChildrenNames = Array.from(new Set(jitArrNames));
+  const allChildrenNames = Array.from(new Set(AllArrNames));
+  const isSameLength = jitChildrenNames.length === allChildrenNames.length;
+  const isSameSet = isSameLength && jitChildrenNames.every(__assignType((v) => allChildrenNames.includes(v), ["v", "", 'P"2!"/"']));
+  const hasNonJitChildren = !(isSameLength && isSameSet);
+  const keysName = `k_${rt.getJitHash(comp.opts)}`;
+  const allKeysName = `kA_${rt.getJitHash(comp.opts)}`;
+  comp.setContextItem(keysName, `const ${keysName} = ${arrayToLiteral(jitChildrenNames)}`);
+  if (hasNonJitChildren)
+    comp.setContextItem(allKeysName, `const ${allKeysName} = ${arrayToLiteral(allChildrenNames)}`);
+  return {
+    keysName,
+    allKeysName,
+    hasNonJitChildren,
+    jitChildrenNames,
+    allChildrenNames
+  };
+}
+addObjectPropsToContext.__type = [() => InterfaceRunType, "rt", "JitFnCompiler", "comp", () => BaseRunType, "jitChildrenRunTypes", () => BaseRunType, "allChildrenRuntypes", () => __ΩObjectPropsContextResult, "addObjectPropsToContext", `PP"7!2""w#2$P7%F2&P7'F2(8n)/*`];
+function callCheckUnknownProperties(rt, comp, jitChildrenRunTypes, returnKeys, checkObject = true, allChildrenRuntypes) {
+  const result = addObjectPropsToContext(rt, comp, jitChildrenRunTypes, allChildrenRuntypes);
+  if (result.jitChildrenNames.length === 0 && result.allChildrenNames.length === 0)
+    return "";
+  const objectCheckCode = checkObject ? [`typeof ${comp.vλl} === 'object'`, `${comp.vλl} !== null`] : [];
+  const checkPropName = JitFunctions.hasUnknownKeys.runTimeOptions.checkNonJitProps.keyName;
+  const optsVarName = getJitFnArgCallVarName(comp, rt, JitFunctions.hasUnknownKeys.id, "θpts");
+  const conditional = allChildrenRuntypes?.length && result.hasNonJitChildren ? `${optsVarName}.${checkPropName} ? ${result.allKeysName} : ${result.keysName}` : result.keysName;
+  const getUnknownKeysFn = comp.addPureFunction(cpf_getUnknownKeysFromArray);
+  const hasUnknownKeysFn = comp.addPureFunction(cpf_hasUnknownKeysFromArray);
+  if (returnKeys)
+    return `${getUnknownKeysFn}(${comp.vλl}, ${conditional})`;
+  objectCheckCode.push(`${hasUnknownKeysFn}(${comp.vλl}, ${conditional})`);
+  const filtered = objectCheckCode.filter(Boolean);
+  if (filtered.length > 1)
+    return `(${filtered.join(" && ")})`;
+  return filtered[0];
+}
+callCheckUnknownProperties.__type = [() => InterfaceRunType, "rt", "JitFnCompiler", "comp", () => BaseRunType, "jitChildrenRunTypes", "returnKeys", "checkObject", () => BaseRunType, "allChildrenRuntypes", "callCheckUnknownProperties", `PP"7!2""w#2$P7%F2&)2'"2(P7)F2*8&/+`];
+export {
+  InterfaceRunType,
+  __ΩInterfaceMember,
+  __ΩObjectPropsContextResult
+};
+//# sourceMappingURL=interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,9 @@
+import { TypeIntersection } from '@deepkit/type';
+import { InterfaceRunType } from './interface.ts';
+import { JitCode } from '../../types.ts';
+export declare class IntersectionRunType extends InterfaceRunType<TypeIntersection> {
+    compileIsType(): JitCode;
+    compileTypeErrors(): JitCode;
+    compilePrepareForJson(): JitCode;
+    compileRestoreFromJson(): JitCode;
+}

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

@@ -0,0 +1,21 @@
+import { __ΩTypeIntersection as ___TypeIntersection } from "@deepkit/type";
+import { InterfaceRunType } from "./interface.js";
+class IntersectionRunType extends InterfaceRunType {
+  compileIsType() {
+    throw new Error("Intersection validation not supported, should be resolve to other RunTypes");
+  }
+  compileTypeErrors() {
+    throw new Error("Intersection validation not supported, should be resolve to other RunTypes");
+  }
+  compilePrepareForJson() {
+    throw new Error("Intersection serialization not supported, should be resolve to other RunTypes");
+  }
+  compileRestoreFromJson() {
+    throw new Error("Intersection serialization not supported, should be resolve to other RunTypes");
+  }
+  static __type = [() => ___TypeIntersection, () => InterfaceRunType, "JitCode", "compileIsType", "compileTypeErrors", "compilePrepareForJson", "compileRestoreFromJson", () => ___TypeIntersection, "IntersectionRunType", `Pn!7"P"w#0$P"w#0%P"w#0&P"w#0'5n(6"w)`];
+}
+export {
+  IntersectionRunType
+};
+//# sourceMappingURL=intersection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,18 @@
+import { TypeTuple } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { AnyParameterListRunType, JitCode } from '../../types.ts';
+import { ParameterRunType } from '../member/param.ts';
+import { CollectionRunType } from '../../lib/baseRunTypes.ts';
+import { TupleMemberRunType } from '../member/tupleMember.ts';
+type AnyParamRunType = ParameterRunType | TupleMemberRunType;
+export declare class TupleRunType<ParamList extends AnyParameterListRunType = TypeTuple, ParamType extends AnyParamRunType = TupleMemberRunType> extends CollectionRunType<ParamList> {
+    getChildRunTypes: () => ParamType[];
+    getParamRunTypes(comp: JitFnCompiler): ParamType[];
+    hasRestParameter(comp: JitFnCompiler): boolean;
+    totalRequiredParams(comp: JitFnCompiler): number;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+}
+export {};

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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

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

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

@@ -0,0 +1,162 @@
+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

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,21 @@
+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[];