@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/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/cjs/src/nodes/collection/unionDiscriminator.cjs

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_utils = require("../../lib/utils.cjs");
+const src_lib_guards = require("../../lib/guards.cjs");
+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 (src_lib_guards.isAnyRunType(unionItem) || src_lib_guards.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 + src_lib_utils.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) => src_lib_utils.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"/!'];
+exports.__ΩFlattenedProp = __ΩFlattenedProp;
+exports.__ΩSplitUnionResult = __ΩSplitUnionResult;
+exports.markDiscriminators = markDiscriminators;
+exports.sortUnreachableTypes = sortUnreachableTypes;
+exports.splitUnionItems = splitUnionItems;
+//# sourceMappingURL=unionDiscriminator.cjs.map

package/.dist/cjs/src/nodes/collection/unionDiscriminator.cjs.map

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

package/.dist/cjs/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[];

package/.dist/cjs/src/nodes/function/function.cjs

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_lib_guards = require("../../lib/guards.cjs");
+const src_lib_jitFnCompiler = require("../../lib/jitFnCompiler.cjs");
+const src_constants_kind = require("../../constants.kind.cjs");
+const src_nodes_collection_functionParams = require("../collection/functionParams.cjs");
+const core = require("@mionjs/core");
+const src_lib_jitFnsRegistry = require("../../lib/jitFnsRegistry.cjs");
+const src_constants_functions = require("../../constants.functions.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class FunctionRunType extends src_lib_baseRunTypes.BaseRunType {
+  // parameterRunTypes.src must be set after FunctionRunType creation
+  parameterRunTypes = new src_nodes_collection_functionParams.FunctionParamsRunType();
+  skipJit(comp) {
+    if (!comp)
+      return true;
+    return comp.fnID !== src_constants_functions.JitFunctions.toJSCode.id;
+  }
+  onCreated(deepkitType) {
+    super.onCreated(deepkitType);
+    const paramsType = { ...deepkitType, subKind: src_constants_kind.ReflectionSubKind.params };
+    delete paramsType._typeId;
+    delete paramsType._formatId;
+    this.parameterRunTypes.onCreated(paramsType);
+  }
+  getFamily() {
+    return "F";
+  }
+  getFnName() {
+    const name = this.src.name;
+    if (!name)
+      return "";
+    if (typeof name === "symbol")
+      return name.toString();
+    return name;
+  }
+  createJitParamsFunction(jitFn, opts) {
+    return this.createJitCompiledParamsFunction(jitFn, opts).fn;
+  }
+  createJitCompiledParamsFunction(jitFn, opts) {
+    const start = opts?.paramsSlice?.start;
+    const end = opts?.paramsSlice?.end;
+    if (start && end) {
+      if (start < 0 || end > this.parameterRunTypes.getChildRunTypes().length)
+        throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}.`);
+      if (end <= start)
+        throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}`);
+    }
+    return this.parameterRunTypes.createJitCompiledFunction(jitFn.id, void 0, opts);
+  }
+  createJitReturnFunction(jitFn) {
+    return this.createJitCompiledReturnFunction(jitFn).fn;
+  }
+  createJitCompiledReturnFunction(jitFn, opts) {
+    let currentType = this;
+    while (true) {
+      if (src_lib_guards.isAnyFunctionRunType(currentType)) {
+        const returnType = currentType.getReturnType();
+        if (src_lib_guards.isPromiseRunType(returnType) || src_lib_guards.isFunctionRunType(returnType)) {
+          currentType = returnType;
+          continue;
+        }
+        return returnType.createJitCompiledFunction(jitFn.id, void 0, opts);
+      }
+      const memberType = currentType.getMemberType();
+      if (src_lib_guards.isPromiseRunType(memberType) || src_lib_guards.isFunctionRunType(memberType)) {
+        currentType = memberType;
+        continue;
+      }
+      return memberType.createJitCompiledFunction(jitFn.id, void 0, opts);
+    }
+  }
+  // ######## JIT functions (all throw error) ########
+  // can't know the types of the run type function parameters, neither the return type, so only compare function name and length
+  emitIsType(comp) {
+    const minLength = this.parameterRunTypes.totalRequiredParams(comp);
+    const totalParams = this.parameterRunTypes.getParamRunTypes(comp).length;
+    const hasOptional = totalParams > minLength;
+    const maxLength = this.parameterRunTypes.hasRestParameter(comp) || !hasOptional ? "" : ` && ${comp.vλl}.length <= ${totalParams}`;
+    return { code: `(typeof ${comp.vλl} === 'function' && ${comp.vλl}.length >= ${minLength} ${maxLength})`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (!(${this.emitIsType(comp).code})) ${comp.callJitErr(this)};`, type: "S" };
+  }
+  /**
+   * json encode a function
+   */
+  emitPrepareForJson() {
+    throw new Error(`Compile function PrepareForJson not supported, call compileParams or compileReturn instead.`);
+  }
+  emitRestoreFromJson() {
+    throw new Error(`Compile function RestoreFromJson not supported, call compileParams or compileReturn instead.`);
+  }
+  emitHasUnknownKeys() {
+    return { code: "", type: "E" };
+  }
+  emitUnknownKeyErrors() {
+    return { code: "", type: "S" };
+  }
+  emitStripUnknownKeys() {
+    return { code: "", type: "S" };
+  }
+  emitUnknownKeysToUndefined() {
+    return { code: "", type: "S" };
+  }
+  // TODO: paramsSlice has been removed as options are not jet passed when building the run type. maybe we can pass it to the JitCompileOperation instead
+  // constructor() {
+  //     const start = opts?.paramsSlice?.start;
+  //     const end = opts?.paramsSlice?.end;
+  //     parameterRunTypes = src.parameters.slice(start, end).map((p) => visitor(p, parents, opts)) as ParameterRunType[];
+  // }
+  getReturnType() {
+    return this.src.return._rt;
+  }
+  getParameters() {
+    return this.parameterRunTypes;
+  }
+  getParameterNames(opts) {
+    const start = opts?.paramsSlice?.start;
+    const end = opts?.paramsSlice?.end;
+    if (start || end) {
+      return this.src.parameters.slice(start, end).map(__assignType((p) => p.name, ["p", "", 'P"2!"/"']));
+    }
+    return this.src.parameters.map(__assignType((p) => p.name, ["p", "", 'P"2!"/"']));
+  }
+  hasReturnData() {
+    const returnKind = this.getReturnType().src.kind;
+    return returnKind !== type.ReflectionKind.void && returnKind !== type.ReflectionKind.never && returnKind !== type.ReflectionKind.undefined;
+  }
+  isAsync() {
+    const returnKind = this.getReturnType().src.kind;
+    return returnKind === type.ReflectionKind.promise || returnKind === type.ReflectionKind.any || returnKind === type.ReflectionKind.unknown;
+  }
+  returnIsPromise() {
+    return src_lib_guards.isPromiseRunType(this.getReturnType());
+  }
+  async mockReturn(ctx) {
+    await src_lib_jitFnsRegistry.registerJitFunctionCompiler(src_constants_functions.JitFunctions.mock);
+    return this.getReturnType().mockType(ctx);
+  }
+  async mockParams(ctx) {
+    await src_lib_jitFnsRegistry.registerJitFunctionCompiler(src_constants_functions.JitFunctions.mock);
+    return this.parameterRunTypes.mockType(ctx);
+  }
+  static __type = [() => type.__ΩTypeFunction, "CallType", () => src_lib_baseRunTypes.BaseRunType, () => src_nodes_collection_functionParams.FunctionParamsRunType, "parameterRunTypes", function() {
+    return new src_nodes_collection_functionParams.FunctionParamsRunType();
+  }, () => src_lib_jitFnCompiler.JitFnCompiler, "comp", "skipJit", "SrcType", "deepkitType", "onCreated", "F", "getFamily", "getFnName", "JitFn", "jitFn", "RunTypeOptions", "opts", "args", "", "createJitParamsFunction", () => core.__ΩJitCompiledFn, "createJitCompiledParamsFunction", "createJitReturnFunction", () => core.__ΩJitCompiledFn, "createJitCompiledReturnFunction", () => src_lib_jitFnCompiler.JitFnCompiler, "JitCode", "emitIsType", () => src_lib_jitFnCompiler.JitErrorsFnCompiler, "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", () => src_lib_baseRunTypes.BaseRunType, "getReturnType", () => src_nodes_collection_functionParams.FunctionParamsRunType, "getParameters", "getParameterNames", "hasReturnData", "isAsync", "returnIsPromise", "ctx", "mockReturn", "mockParams", "FunctionRunType", 'n!c"Pe"!7#P7$3%>&PP7\'2()0)P"w*2+$0,P.-0.PP&\'J0/P"w021"w2238P"@24"/506P"w021"w2238n708P"w021P"@24"/509P"w021"w2238n:0;PP7<2("w=0>PP7?2("w=0@P"w=0AP"w=0BP"w=0CP"w=0DP"w=0EP"w=0FPP7G0HPP7I0JP"w2238&F0KP)0LP)0MP)0NP"w22O8"`0PP"w22O8"F`0Q5e!!6"wR'];
+}
+exports.FunctionRunType = FunctionRunType;
+//# sourceMappingURL=function.cjs.map

package/.dist/cjs/src/nodes/function/function.cjs.map

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

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

@@ -0,0 +1,33 @@
+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;
+    getParameters(): FunctionParamsRunType;
+    getParameterNames(opts?: RunTypeOptions): string[];
+    hasReturnData(): boolean;
+    isAsync(): boolean;
+    returnIsPromise(): boolean;
+    mockReturn(ctx?: RunTypeOptions): Promise<any>;
+    mockParams(ctx?: RunTypeOptions): Promise<any[]>;
+}

package/.dist/cjs/src/nodes/member/array.cjs

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+class ArrayRunType extends src_lib_baseRunTypes.MemberRunType {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  startIndex(comp) {
+    return 0;
+  }
+  getChildVarName(comp) {
+    return comp.getLocalVarName("i", this);
+  }
+  getChildLiteral(comp) {
+    return this.getChildVarName(comp);
+  }
+  useArrayAccessor() {
+    return true;
+  }
+  isOptional() {
+    return false;
+  }
+  // #### jit code ####
+  emitIsType(comp) {
+    this.checkNonSkipTypes(comp);
+    const resultVal = comp.getLocalVarName("res", this);
+    const index = this.getChildVarName(comp);
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileIsType(child, "E");
+    if (!childJit?.code && comp.opts.noIsArrayCheck)
+      return { code: void 0, type: "E" };
+    if (!childJit?.code)
+      return { code: `Array.isArray(${comp.vλl})`, type: "E" };
+    const isArrayCheckCode = comp.opts.noIsArrayCheck ? "" : `if (!Array.isArray(${comp.vλl})) return false;`;
+    return {
+      code: `
+            ${isArrayCheckCode}
+            for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
+                const ${resultVal} = ${childJit.code};
+                if (!(${resultVal})) return false;
+            }
+            return true;
+        `,
+      type: "RB"
+    };
+  }
+  emitTypeErrors(comp) {
+    this.checkNonSkipTypes(comp);
+    const index = this.getChildVarName(comp);
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileTypeErrors(child, "S");
+    if (!childJit?.code && comp.opts.noIsArrayCheck)
+      return { code: void 0, type: "E" };
+    if (!childJit?.code)
+      return { code: `if (!Array.isArray(${comp.vλl})) ${comp.callJitErr(this)};`, type: "S" };
+    const itemsCode = `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${childJit.code}}`;
+    if (comp.opts.noIsArrayCheck)
+      return { code: itemsCode, type: "S" };
+    return {
+      code: `if (!Array.isArray(${comp.vλl})) {${comp.callJitErr(this)}} else {${itemsCode}}`,
+      type: "S"
+    };
+  }
+  emitPrepareForJson(comp) {
+    this.checkNonSkipTypes(comp);
+    const index = this.getChildVarName(comp);
+    const child = this.getJitChild(comp);
+    const childJit = comp.compilePrepareForJson(child, "S");
+    if (!childJit?.code || !child)
+      return { code: void 0, type: "S" };
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    return {
+      code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${code}}`,
+      type: "S"
+    };
+  }
+  emitRestoreFromJson(comp) {
+    this.checkNonSkipTypes(comp);
+    const index = this.getChildVarName(comp);
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileRestoreFromJson(child, "S");
+    if (!childJit?.code || !child)
+      return { code: void 0, type: "S" };
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    return {
+      code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${code}}`,
+      type: "S"
+    };
+  }
+  emitHasUnknownKeys(comp) {
+    this.checkNonSkipTypes(comp);
+    if (this.getMemberType().getFamily() === "A")
+      return { code: void 0, type: "E" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileHasUnknownKeys(child, "E");
+    if (!childJit?.code)
+      return { code: void 0, type: "E" };
+    const resultVal = comp.getLocalVarName("res", this);
+    const index = this.getChildVarName(comp);
+    return {
+      code: `
+            if (!Array.isArray(${comp.vλl})) return false;
+            for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
+                const ${resultVal} = ${childJit.code};
+                if (${resultVal}) return true;
+            }
+            return false;
+        `,
+      type: "RB"
+    };
+  }
+  emitUnknownKeyErrors(comp) {
+    this.checkNonSkipTypes(comp);
+    if (this.getMemberType().getFamily() === "A")
+      return { code: "", type: "E" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileUnknownKeyErrors(child, "S");
+    return this.traverseCode(comp, childJit);
+  }
+  emitStripUnknownKeys(comp) {
+    this.checkNonSkipTypes(comp);
+    if (this.getMemberType().getFamily() === "A")
+      return { code: "", type: "E" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileStripUnknownKeys(child, "S");
+    return this.traverseCode(comp, childJit);
+  }
+  emitUnknownKeysToUndefined(comp) {
+    this.checkNonSkipTypes(comp);
+    if (this.getMemberType().getFamily() === "A")
+      return { code: "", type: "E" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileUnknownKeysToUndefined(child, "S");
+    return this.traverseCode(comp, childJit);
+  }
+  traverseCode(comp, childJit) {
+    if (!childJit?.code)
+      return { code: void 0, type: "S" };
+    const index = this.getChildVarName(comp);
+    return {
+      code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${childJit.code}}`,
+      type: "S"
+    };
+  }
+  checkNonSkipTypes(comp) {
+    const child = this.getMemberType();
+    if (child.skipJit(comp))
+      throw new Error(`Arrays can not have non serializable types, ie: Symbol[], Function[], etc.`);
+  }
+  static __type = ["TypeArray", "T", () => src_lib_baseRunTypes.MemberRunType, "JitFnCompiler", "comp", "startIndex", "getChildVarName", "getChildLiteral", true, "useArrayAccessor", "isOptional", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", "childJit", "code", "S", "type", "traverseCode", "checkNonSkipTypes", "ArrayRunType", `"w!c"Pe"!7#P"w$2%'0&P"w$2%&0'P"w$2%&0(P.)0*P)0+P"w$2%"w,0-P"w.2%"w,0/P"w$2%"w,00P"w$2%"w,01P"w$2%"w,02P"w.2%"w,03P"w$2%"w,04P"w$2%"w,05P"w$2%P"w,-J26PP&-J47.849M0:P"w$2%"0;5e!!6"w<`];
+}
+exports.ArrayRunType = ArrayRunType;
+//# sourceMappingURL=array.cjs.map

package/.dist/cjs/src/nodes/member/array.cjs.map

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

package/.dist/cjs/src/nodes/member/array.d.ts

@@ -0,0 +1,24 @@
+import { Type, TypeArray } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { MemberRunType } from '../../lib/baseRunTypes.ts';
+export declare class ArrayRunType<T extends Type = TypeArray> extends MemberRunType<T> {
+    startIndex(comp: JitFnCompiler): number;
+    getChildVarName(comp: JitFnCompiler): string;
+    getChildLiteral(comp: JitFnCompiler): string;
+    useArrayAccessor(): true;
+    isOptional(): 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;
+    traverseCode(comp: JitFnCompiler, childJit: JitCode | undefined): {
+        code: string | undefined;
+        type: 'S';
+    };
+    checkNonSkipTypes(comp: JitFnCompiler): void;
+}

package/.dist/cjs/src/nodes/member/callSignature.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_types = require("../../types.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+const src_nodes_function_function = require("../function/function.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class CallSignatureRunType extends src_nodes_function_function.FunctionRunType {
+  getChildIndex = __assignType((comp) => {
+    const start = comp?.opts?.paramsSlice?.start;
+    if (start)
+      return src_lib_utils.getPropIndex(this.src) - start;
+    return src_lib_utils.getPropIndex(this.src);
+  }, ["JitFnCompiler", "comp", "", 'P"w!2""/#']);
+  getChildVarName = () => "";
+  getChildLiteral = () => '""';
+  useArrayAccessor = () => false;
+  isOptional = () => false;
+  static __type = [() => type.__ΩTypeCallSignature, () => src_nodes_function_function.FunctionRunType, "getChildIndex", function() {
+    return __assignType((comp) => {
+      const start = comp?.opts?.paramsSlice?.start;
+      if (start)
+        return src_lib_utils.getPropIndex(this.src) - start;
+      return src_lib_utils.getPropIndex(this.src);
+    }, ["JitFnCompiler", "comp", "", 'P"w!2""/#']);
+  }, "getChildVarName", function() {
+    return () => "";
+  }, "getChildLiteral", function() {
+    return () => '""';
+  }, "useArrayAccessor", function() {
+    return () => false;
+  }, "isOptional", function() {
+    return () => false;
+  }, () => type.__ΩTypeCallSignature, () => src_types.__ΩRunTypeChildAccessor, "CallSignatureRunType", `Pn!7"!3#>$!3%>&!3'>(!3)>*!3+>,5n-6"n.x"w/`];
+}
+exports.CallSignatureRunType = CallSignatureRunType;
+//# sourceMappingURL=callSignature.cjs.map