@mionjs/run-types 0.8.0-alpha.0

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

@@ -0,0 +1,325 @@
+import { ReflectionKind } from "@deepkit/type";
+import { createHashLiteral } from "@mionjs/core";
+import { validPropertyNameRegExp } from "../constants.js";
+import { ReflectionSubKind } from "../constants.kind.js";
+import { getJitFnSettings } from "./jitFnsRegistry.js";
+function toLiteral(value) {
+  switch (typeof value) {
+    case "number":
+      return `${value}`;
+    case "string":
+      return JSON.stringify(value);
+    case "boolean":
+      return value ? "true" : "false";
+    case "undefined":
+      return "undefined";
+    case "bigint":
+      return `${value}n`;
+    case "symbol":
+      return `Symbol(${toLiteral(value.description)})`;
+    case "object":
+      if (value === null) return "null";
+      if (value instanceof RegExp) return value.toString();
+      throw new Error(`Unsupported literal type ${value}`);
+    default:
+      throw new Error(`Unsupported literal type ${value}`);
+  }
+}
+function arrayToLiteral(value) {
+  return `[${arrayToArgumentsLiteral(value)}]`;
+}
+function arrayToArgumentsLiteral(value) {
+  return value.map((v) => `${toLiteral(v)}`).join(", ");
+}
+function isFunctionKind(kind) {
+  return kind === ReflectionKind.callSignature || kind === ReflectionKind.method || kind === ReflectionKind.function || kind === ReflectionKind.methodSignature || kind === ReflectionKind.indexSignature;
+}
+function isClass(cls) {
+  return typeof cls === "function" && cls.prototype && cls.prototype.constructor === cls && cls.prototype.constructor.name && cls.toString().startsWith("class");
+}
+function isSameJitType(a, b) {
+  if (a === b) return true;
+  if (a.src.kind !== b.src.kind) return false;
+  return a.getTypeID() === b.getTypeID();
+}
+function isSameJitCompiler(a, b) {
+  return a.fnID === b.fnID && isSameJitType(a.rootType, b.rootType);
+}
+function memorize(fn) {
+  let cached;
+  return ((...args) => {
+    if (!cached) cached = fn(...args);
+    return cached;
+  });
+}
+function isSafePropName(name) {
+  return typeof name === "string" && validPropertyNameRegExp.test(name) || typeof name === "number";
+}
+function sanitizePropName(name) {
+  const sName = typeof name === "string" ? name : String(name);
+  return sName.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function getPropVarName(name) {
+  if (typeof name === "symbol") return name.toString();
+  return name;
+}
+function getPropLiteral(name) {
+  return toLiteral(name);
+}
+function useArrayAccessorForProp(name) {
+  if (typeof name === "number") return true;
+  return !isSafePropName(name);
+}
+function getPropIndex(src) {
+  const parent = src.parent;
+  if (!parent) return -1;
+  const types = parent.types;
+  if (types) return types.indexOf(src);
+  return 0;
+}
+function getParamIndex(src) {
+  const parent = src.parent;
+  if (!parent) return -1;
+  if (parent.parameters) return parent.parameters.indexOf(src);
+  if (parent.types) return parent.types.indexOf(src);
+  return 0;
+}
+function childIsExpression(childJCode, child) {
+  return childJCode.type === "E" || !child.isJitInlined();
+}
+const maxStringLength = 10;
+function toLiteralInContext(comp, params, ignoreProps = [], isDependencies = false) {
+  switch (true) {
+    case typeof params === "string": {
+      const literal = toLiteral(params);
+      if (params.length > maxStringLength) {
+        const hash = createHashLiteral(params);
+        const strName = hash;
+        if (!comp.hasContextItem(strName)) comp.setContextItem(strName, `const ${strName} = ${literal}`);
+        return strName;
+      }
+      return literal;
+    }
+    case typeof params === "number":
+      return `${params}`;
+    case typeof params === "boolean":
+      return params ? "true" : "false";
+    case params instanceof RegExp: {
+      const regCode = params.toString();
+      const hash = createHashLiteral(regCode);
+      const regName = hash;
+      if (!comp.hasContextItem(regName)) comp.setContextItem(regName, `const ${regName} = ${regCode}`);
+      return regName;
+    }
+    case Array.isArray(params): {
+      const arrCode = `[${params.map((v) => toLiteralInContext(comp, v, ignoreProps, isDependencies)).join(",")}]`;
+      const hash = createHashLiteral(arrCode);
+      const arrName = hash;
+      if (!comp.hasContextItem(arrName)) comp.setContextItem(arrName, `const ${arrName} = ${arrCode}`);
+      return arrName;
+    }
+    case typeof params === "object": {
+      const entriesLiterals = Object.entries(params).map(([k, v]) => {
+        if (ignoreProps.includes(k) || typeof v === "undefined") return void 0;
+        const propName = isSafePropName(k) ? k : toLiteral(k);
+        if (!isDependencies) return `${propName}:${toLiteralInContext(comp, v, ignoreProps, isDependencies)}`;
+        return `${propName}:${dependencyValueToLiteral(comp, v)}`;
+      });
+      const objCode = `{${entriesLiterals.filter(Boolean).join(",")}}`;
+      const hash = createHashLiteral(objCode);
+      const objName = hash;
+      if (!comp.hasContextItem(objName)) comp.setContextItem(objName, `const ${objName} = ${objCode}`);
+      return objName;
+    }
+    case typeof params === "bigint":
+      return toLiteral(params);
+    default:
+      throw new Error(`Unsupported type format params ${params}`);
+  }
+}
+function dependencyValueToLiteral(comp, propVal) {
+  if (typeof propVal === "object" && propVal !== null && "createJitFn" in propVal && "namespace" in propVal && "fnName" in propVal) {
+    if (!comp) throw new Error("Dependencies must be pure functions or code");
+    comp.addPureFnDependency(propVal);
+    return `utl.getPureFn(${toLiteral(propVal.namespace)}, ${toLiteral(propVal.fnName)})`;
+  }
+  if (typeof propVal === "string") return propVal;
+  throw new Error("Dependencies must be CompiledPureFunction objects or code strings");
+}
+function typeParamsToString(params, ignoreProps) {
+  switch (true) {
+    case typeof params === "string":
+      return toLiteral(params);
+    case typeof params === "number":
+      return `${params}`;
+    case typeof params === "boolean":
+      return params ? "true" : "false";
+    case params instanceof RegExp:
+      return params.toString();
+    case Array.isArray(params):
+      return `[${params.map((v) => typeParamsToString(v, ignoreProps)).join(", ")}]`;
+    case typeof params === "object": {
+      const entriesLiterals = Object.entries(params).map(([k, v]) => {
+        if (ignoreProps.includes(k) || typeof v === "undefined") return void 0;
+        return `${k}:${typeParamsToString(v, ignoreProps)}`;
+      });
+      return `{${entriesLiterals.filter(Boolean).join(",")}}`;
+    }
+    case typeof params === "bigint":
+      return `${params}n`;
+    default:
+      throw new Error(`Unsupported type format params ${params}`);
+  }
+}
+function getFormatterHash(rt) {
+  const literal = rt.getFormatTypeID();
+  if (!literal) throw new Error("Formatter JIT ID not found");
+  return createHashLiteral(literal);
+}
+const familyComplexity = {
+  A: 2,
+  M: 20,
+  // member usually involves iteration
+  C: 10,
+  // collection usually involves calling and extra jit function
+  F: 1e7
+};
+const typesComplexity = {
+  [ReflectionKind.indexSignature]: 20,
+  // index involves traversing all object keys
+  [ReflectionKind.array]: 30,
+  // array involves iterating all items
+  [ReflectionKind.property]: 0,
+  // property involves just checking a single property
+  [ReflectionKind.propertySignature]: 0,
+  // property involves just checking a single property
+  [ReflectionKind.boolean]: 1,
+  // boolean is fast to check
+  [ReflectionKind.null]: 1,
+  // null is fast to check
+  [ReflectionKind.undefined]: 1,
+  // undefined is fast to check
+  [ReflectionKind.enum]: 20
+  // enum can involve checking multiple values
+};
+const subTypesComplexity = {
+  [ReflectionSubKind.date]: 3
+};
+function getTotalComplexity(comp, rt, stack = []) {
+  if (!rt) return 0;
+  if (stack.includes(rt)) return 0;
+  stack.push(rt);
+  let result = 0;
+  const subKindC = rt.src.subKind ? subTypesComplexity[rt.src.subKind] : void 0;
+  const typeC = subKindC || typesComplexity[rt.src.kind];
+  const familyC = rt.getFamily();
+  if (familyC === "A") result = typeC || familyComplexity.A;
+  else if (familyC === "M") {
+    const childRT = rt.getJitChild(comp);
+    if (!childRT) return typeC ?? familyComplexity.M;
+    const childC = getTotalComplexity(comp, childRT, stack);
+    result = (typeC ?? familyComplexity.M) + childC;
+  } else if (familyC === "C") {
+    const childrenC = rt.getJitChildren(comp).map((child) => getTotalComplexity(comp, child, stack));
+    const totalChildrenC = childrenC.reduce((acc, childC) => acc + childC, 0);
+    result = (typeC ?? familyComplexity.C) + totalChildrenC;
+  } else {
+    result = typeC ?? familyComplexity.F;
+  }
+  stack.pop();
+  return result;
+}
+function sortRunTypeByComplexity(comp, a, b) {
+  if (a.getFamily() === "M" && b.getFamily() === "M") {
+    const aIsDiscriminator = a.isUnionDiscriminator;
+    const bIsDiscriminator = b.isUnionDiscriminator;
+    if (aIsDiscriminator && !bIsDiscriminator) return -1;
+    if (!aIsDiscriminator && bIsDiscriminator) return 1;
+  }
+  if (b.getFamily() === "M" && b.isUnionDiscriminator) return 1;
+  const aTotal = getTotalComplexity(comp, a);
+  const bTotal = getTotalComplexity(comp, b);
+  return aTotal - bTotal;
+}
+function sortDiscriminatorsFirst(a, b) {
+  if (a.getFamily() === "M" && b.getFamily() === "M") {
+    const aIsDiscriminator = a.isUnionDiscriminator;
+    const bIsDiscriminator = b.isUnionDiscriminator;
+    if (aIsDiscriminator && !bIsDiscriminator) return -1;
+    if (!aIsDiscriminator && bIsDiscriminator) return 1;
+  }
+  return 0;
+}
+function createIfElseFn() {
+  let isFirst = true;
+  return (end = false) => {
+    const elseIf = end ? "else" : "else if";
+    const iF = isFirst ? "if" : elseIf;
+    isFirst = false;
+    return iF;
+  };
+}
+function getJitFnArgCallVarName(parentComp, rt, idFnToCall, argKey) {
+  const fnConfig = getJitFnSettings(idFnToCall);
+  const defaultArgVal = fnConfig.jitDefaultArgs[argKey];
+  if (argKey === "vλl" && fnConfig.noInitialVλl) return "undefined";
+  if (argKey === "vλl") return parentComp.getCurrentStackItem().vλl;
+  const varNameFromContext = parentComp.getChildrenCallArgs(idFnToCall)?.[argKey];
+  if (varNameFromContext) return varNameFromContext;
+  const varNameFromParent = parentComp.args[argKey];
+  if (varNameFromParent) return varNameFromParent;
+  if (!defaultArgVal)
+    throw new Error(
+      `Can not call jit function ${idFnToCall} because it requires argument ${argKey} but it is not provided,
+            neither in the parent function nor in the function context and there is no default value for it.`
+    );
+  const defaultName = fnConfig.jitArgs[argKey];
+  const optsVarName = `${defaultName}_${idFnToCall}0`;
+  parentComp.setContextItem(optsVarName, `const ${optsVarName} = ${defaultArgVal}`);
+  return optsVarName;
+}
+function parentIs(rt, kind) {
+  const parentRT = rt.getParent();
+  if (!parentRT) return false;
+  if (parentRT.src.kind === ReflectionKind.union) return parentIs(parentRT, kind);
+  if (Array.isArray(kind) ? kind.includes(parentRT.src.kind) : parentRT.src.kind === kind) return true;
+  return false;
+}
+function addFullStop(code) {
+  if (!code) return code;
+  const lastChar = code.length - 1;
+  const hasFullStop = code[lastChar] === ";";
+  if (hasFullStop) return code;
+  const hasBlockClose = code[lastChar] === "}";
+  return hasBlockClose ? code : `${code};`;
+}
+export {
+  addFullStop,
+  arrayToArgumentsLiteral,
+  arrayToLiteral,
+  childIsExpression,
+  createIfElseFn,
+  dependencyValueToLiteral,
+  getFormatterHash,
+  getJitFnArgCallVarName,
+  getParamIndex,
+  getPropIndex,
+  getPropLiteral,
+  getPropVarName,
+  getTotalComplexity,
+  isClass,
+  isFunctionKind,
+  isSafePropName,
+  isSameJitCompiler,
+  isSameJitType,
+  memorize,
+  parentIs,
+  sanitizePropName,
+  sortDiscriminatorsFirst,
+  sortRunTypeByComplexity,
+  toLiteral,
+  toLiteralInContext,
+  typeParamsToString,
+  useArrayAccessorForProp
+};
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../src/lib/utils.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} from '@deepkit/type';\nimport type {Type, TypeFunction, TypeParameter, TypeTuple, TypeTupleMember} from '@deepkit/type';\nimport type {CompiledPureFunction, TypeFormatValue} from '@mionjs/core';\nimport type {AnyClass, JitFnID, RunType} from '../types.ts';\nimport type {BaseRunType, CollectionRunType, MemberRunType} from './baseRunTypes.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from './jitFnCompiler.ts';\nimport type {PropertyRunType} from '../nodes/member/property.ts';\nimport {createHashLiteral} from '@mionjs/core';\nimport {validPropertyNameRegExp} from '../constants.ts';\nimport {ReflectionSubKind} from '../constants.kind.ts';\nimport {getJitFnSettings} from './jitFnsRegistry.ts';\nimport type {JitCode} from '../types.ts';\n\nexport function toLiteral(value: number | string | boolean | undefined | null | bigint | RegExp | symbol): string {\n    switch (typeof value) {\n        case 'number':\n            return `${value}`;\n        case 'string':\n            return JSON.stringify(value);\n        case 'boolean':\n            return value ? 'true' : 'false';\n        case 'undefined':\n            return 'undefined';\n        case 'bigint':\n            return `${value}n`;\n        case 'symbol':\n            return `Symbol(${toLiteral(value.description)})`;\n        case 'object':\n            if (value === null) return 'null';\n            if (value instanceof RegExp) return value.toString();\n            throw new Error(`Unsupported literal type ${value}`);\n        default:\n            throw new Error(`Unsupported literal type ${value}`);\n    }\n}\n\nexport function arrayToLiteral(value: any[]): string {\n    return `[${arrayToArgumentsLiteral(value)}]`;\n}\n\nexport function arrayToArgumentsLiteral(value: any[]): string {\n    return value.map((v) => `${toLiteral(v)}`).join(', ');\n}\n\nexport function isFunctionKind(kind: ReflectionKind): boolean {\n    return (\n        kind === ReflectionKind.callSignature ||\n        kind === ReflectionKind.method ||\n        kind === ReflectionKind.function ||\n        kind === ReflectionKind.methodSignature ||\n        kind === ReflectionKind.indexSignature\n    );\n}\n\nexport function isClass(cls: AnyClass | any): cls is AnyClass {\n    return (\n        typeof cls === 'function' &&\n        cls.prototype &&\n        cls.prototype.constructor === cls &&\n        cls.prototype.constructor.name &&\n        cls.toString().startsWith('class')\n    );\n}\n\nexport function isSameJitType(a: RunType, b: RunType): boolean {\n    if (a === b) return true;\n    if (a.src.kind !== b.src.kind) return false;\n    return a.getTypeID() === b.getTypeID();\n}\n\nexport function isSameJitCompiler(a: JitFnCompiler, b: JitFnCompiler): boolean {\n    return a.fnID === b.fnID && isSameJitType(a.rootType, b.rootType);\n}\n\nexport function memorize<Fn extends (...args: any[]) => any>(fn: Fn): Fn {\n    let cached: undefined | any;\n    return ((...args: any[]) => {\n        if (!cached) cached = fn(...args);\n        return cached;\n    }) as Fn;\n}\n\nexport function isSafePropName(name: string | number | symbol): boolean {\n    return (typeof name === 'string' && validPropertyNameRegExp.test(name)) || typeof name === 'number';\n}\n\nexport function sanitizePropName(name: string | number | symbol): string {\n    const sName = typeof name === 'string' ? name : String(name);\n    return sName.replace(/[^a-zA-Z0-9_$]/g, '_');\n}\n\nexport function getPropVarName(name: string | number | symbol): string | number {\n    if (typeof name === 'symbol') return name.toString();\n    return name;\n}\nexport function getPropLiteral(name: string | number | symbol): string | number {\n    return toLiteral(name);\n}\nexport function useArrayAccessorForProp(name: string | number | symbol): boolean {\n    if (typeof name === 'number') return true;\n    return !isSafePropName(name);\n}\n\nexport function getPropIndex(src: Type): number {\n    const parent = src.parent;\n    if (!parent) return -1;\n    const types = (parent as {types: Type[]}).types;\n    if (types) return types.indexOf(src);\n    return 0;\n}\n\nexport function getParamIndex(src: TypeParameter | TypeTupleMember): number {\n    const parent = src.parent as TypeFunction | TypeTuple;\n    if (!parent) return -1;\n    if ((parent as TypeFunction).parameters) return (parent as TypeFunction).parameters.indexOf(src as TypeParameter);\n    if ((parent as TypeTuple).types) return (parent as TypeTuple).types.indexOf(src as TypeTupleMember);\n    return 0;\n}\n\nexport function childIsExpression(childJCode: JitCode, child: BaseRunType): boolean {\n    return childJCode.type === 'E' || !child.isJitInlined();\n}\n\n// ######### To literal with context ########\n\nconst maxStringLength = 10;\n\n/**\n * Transforms values into a literal string to be used in JIT code.\n * ie: {total: 5, name: 'hello'} gets transformed into teh string '{total: 5, name: \"hello\"}' that can be used as JIT code.\n * Some literals are automatically added to the context to reduce code size. in this case the reference to the context variable is returned.\n * Otherwise the literal is returned.\n *\n * Important this is intended for actual immutable literals, if two empty arrays are passed they will be transformed into the same reference.\n * so those object or arrays should never be modified in jit code. //TODO: investigate using object.freeze\n *\n * @param comp\n * @param params\n * @param ignoreProps\n * @param isDependencies\n * @returns\n */\nexport function toLiteralInContext(\n    // if compiled is passed it is assumed that the params are dependencies and will be transformed into code\n    comp: JitFnCompiler | JitErrorsFnCompiler,\n    params: TypeFormatValue | Record<string, string | CompiledPureFunction>,\n    // TODO: somewhere the ignoreProps are not passed and we still outputting 'samples' and 'sampleChars' to jit code were is not needed\n    ignoreProps: string[] = [],\n    isDependencies = false\n): string {\n    switch (true) {\n        case typeof params === 'string': {\n            const literal = toLiteral(params);\n            // if string is longer than 10 chars we add it as a new variable in the context to reduce code size\n            if (params.length > maxStringLength) {\n                const hash = createHashLiteral(params);\n                const strName = hash;\n                if (!comp.hasContextItem(strName)) comp.setContextItem(strName, `const ${strName} = ${literal}`);\n                return strName;\n            }\n            return literal;\n        }\n        case typeof params === 'number':\n            return `${params}`;\n        case typeof params === 'boolean':\n            return params ? 'true' : 'false';\n        case params instanceof RegExp: {\n            // if param is a regexp we add it as a new variable in the context (so we are not creating a new regexp on each call)\n            const regCode = params.toString();\n            const hash = createHashLiteral(regCode);\n            const regName = hash;\n            if (!comp.hasContextItem(regName)) comp.setContextItem(regName, `const ${regName} = ${regCode}`);\n            return regName;\n        }\n        case Array.isArray(params): {\n            // arrays are added to the context as a new variable\n            const arrCode = `[${params.map((v) => toLiteralInContext(comp, v, ignoreProps, isDependencies)).join(',')}]`;\n            const hash = createHashLiteral(arrCode);\n            const arrName = hash;\n            if (!comp.hasContextItem(arrName)) comp.setContextItem(arrName, `const ${arrName} = ${arrCode}`);\n\n            return arrName;\n        }\n        case typeof params === 'object': {\n            // objects are added to the context as a new variable\n            const entriesLiterals = Object.entries(params).map(([k, v]) => {\n                if (ignoreProps.includes(k) || typeof v === 'undefined') return undefined;\n                const propName = isSafePropName(k) ? k : toLiteral(k);\n                if (!isDependencies) return `${propName}:${toLiteralInContext(comp, v, ignoreProps, isDependencies)}`;\n                return `${propName}:${dependencyValueToLiteral(comp, v)}`;\n            });\n            const objCode = `{${entriesLiterals.filter(Boolean).join(',')}}`;\n            const hash = createHashLiteral(objCode);\n            const objName = hash;\n            if (!comp.hasContextItem(objName)) comp.setContextItem(objName, `const ${objName} = ${objCode}`);\n            return objName;\n        }\n        case typeof params === 'bigint':\n            return toLiteral(params);\n        default:\n            throw new Error(`Unsupported type format params ${params}`);\n    }\n}\n\nexport function dependencyValueToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler | undefined, propVal: any): string {\n    if (\n        typeof propVal === 'object' &&\n        propVal !== null &&\n        'createJitFn' in propVal &&\n        'namespace' in propVal &&\n        'fnName' in propVal\n    ) {\n        // propVal is a CompiledPureFunction\n        if (!comp) throw new Error('Dependencies must be pure functions or code');\n        comp.addPureFnDependency(propVal);\n        return `utl.getPureFn(${toLiteral(propVal.namespace)}, ${toLiteral(propVal.fnName)})`;\n    }\n    if (typeof propVal === 'string') return propVal;\n    throw new Error('Dependencies must be CompiledPureFunction objects or code strings');\n}\n\nexport function typeParamsToString(\n    params: TypeFormatValue | Record<string, string | CompiledPureFunction>,\n    ignoreProps: string[]\n): string {\n    switch (true) {\n        case typeof params === 'string':\n            return toLiteral(params);\n        case typeof params === 'number':\n            return `${params}`;\n        case typeof params === 'boolean':\n            return params ? 'true' : 'false';\n        case params instanceof RegExp:\n            return params.toString();\n        case Array.isArray(params):\n            return `[${params.map((v) => typeParamsToString(v, ignoreProps)).join(', ')}]`;\n        case typeof params === 'object': {\n            const entriesLiterals = Object.entries(params).map(([k, v]) => {\n                if (ignoreProps.includes(k) || typeof v === 'undefined') return undefined;\n                return `${k}:${typeParamsToString(v, ignoreProps)}`;\n            });\n            return `{${entriesLiterals.filter(Boolean).join(',')}}`;\n        }\n        case typeof params === 'bigint':\n            return `${params}n`;\n        default:\n            throw new Error(`Unsupported type format params ${params}`);\n    }\n}\nexport function getFormatterHash(rt: BaseRunType): string {\n    const literal = rt.getFormatTypeID();\n    if (!literal) throw new Error('Formatter JIT ID not found');\n    return createHashLiteral(literal);\n}\n\n/** Complexity of each type family, we can add more types and weights here if we want to optimize further */\nconst familyComplexity = {\n    A: 2,\n    M: 20, // member usually involves iteration\n    C: 10, // collection usually involves calling and extra jit function\n    F: 10_000_000,\n}; // function should go always last\nconst typesComplexity = {\n    [ReflectionKind.indexSignature]: 20, // index involves traversing all object keys\n    [ReflectionKind.array]: 30, // array involves iterating all items\n    [ReflectionKind.property]: 0, // property involves just checking a single property\n    [ReflectionKind.propertySignature]: 0, // property involves just checking a single property\n    [ReflectionKind.boolean]: 1, // boolean is fast to check\n    [ReflectionKind.null]: 1, // null is fast to check\n    [ReflectionKind.undefined]: 1, // undefined is fast to check\n    [ReflectionKind.enum]: 20, // enum can involve checking multiple values\n};\nconst subTypesComplexity = {\n    [ReflectionSubKind.date]: 3,\n};\n\n/**\n * Returns an arbitrary complexity number for a runType, this depends on the type family and the complexity of all children.\n * There might be better options to get the type complexity, as this also depends on the runtime operation and the compiled operation.\n * but this is an initial approximation.\n */\nexport function getTotalComplexity(comp: JitFnCompiler, rt: BaseRunType, stack: BaseRunType[] = []): number {\n    if (!rt) return 0;\n    if (stack.includes(rt)) return 0;\n    stack.push(rt);\n    let result = 0;\n    const subKindC = rt.src.subKind ? subTypesComplexity[rt.src.subKind] : undefined;\n    const typeC = subKindC || typesComplexity[rt.src.kind];\n    const familyC = rt.getFamily();\n    if (familyC === 'A') result = typeC || familyComplexity.A;\n    else if (familyC === 'M') {\n        const childRT = (rt as MemberRunType<any>).getJitChild(comp);\n        if (!childRT) return typeC ?? familyComplexity.M;\n        const childC = getTotalComplexity(comp, childRT, stack);\n        result = (typeC ?? familyComplexity.M) + childC;\n    } else if (familyC === 'C') {\n        const childrenC = (rt as CollectionRunType<any>)\n            .getJitChildren(comp)\n            .map((child) => getTotalComplexity(comp, child, stack));\n        const totalChildrenC = childrenC.reduce((acc, childC) => acc + childC, 0);\n        result = (typeC ?? familyComplexity.C) + totalChildrenC;\n    } else {\n        result = typeC ?? familyComplexity.F;\n    }\n    stack.pop();\n    return result;\n}\n\n/**\n * Sort runTypes by complexity, ascending. this way less complex code can be executed first.\n * This could help to fail fast and avoid unnecessary checks.\n */\nexport function sortRunTypeByComplexity(comp: JitFnCompiler, a: BaseRunType, b: BaseRunType): number {\n    if (a.getFamily() === 'M' && b.getFamily() === 'M') {\n        const aIsDiscriminator = (a as PropertyRunType).isUnionDiscriminator;\n        const bIsDiscriminator = (b as PropertyRunType).isUnionDiscriminator;\n        if (aIsDiscriminator && !bIsDiscriminator) return -1;\n        if (!aIsDiscriminator && bIsDiscriminator) return 1;\n    }\n    if (b.getFamily() === 'M' && (b as PropertyRunType).isUnionDiscriminator) return 1;\n    const aTotal = getTotalComplexity(comp, a);\n    const bTotal = getTotalComplexity(comp, b);\n    return aTotal - bTotal;\n}\n\nexport function sortDiscriminatorsFirst(a: BaseRunType, b: BaseRunType): number {\n    if (a.getFamily() === 'M' && b.getFamily() === 'M') {\n        const aIsDiscriminator = (a as PropertyRunType).isUnionDiscriminator;\n        const bIsDiscriminator = (b as PropertyRunType).isUnionDiscriminator;\n        if (aIsDiscriminator && !bIsDiscriminator) return -1;\n        if (!aIsDiscriminator && bIsDiscriminator) return 1;\n    }\n    return 0;\n}\n\nexport function createIfElseFn(): (isEnd?: boolean) => string {\n    let isFirst = true;\n    return (end = false) => {\n        const elseIf = end ? 'else' : 'else if';\n        const iF = isFirst ? 'if' : elseIf;\n        isFirst = false;\n        return iF;\n    };\n}\n\nexport function getJitFnArgCallVarName(parentComp: JitFnCompiler, rt: BaseRunType, idFnToCall: JitFnID, argKey: string): string {\n    const fnConfig = getJitFnSettings(idFnToCall);\n    const defaultArgVal = fnConfig.jitDefaultArgs[argKey];\n    // vλl is a special case because it is the only arg that changes based on the stack\n    if (argKey === 'vλl' && fnConfig.noInitialVλl) return 'undefined'; // when no initial vλl is required, we pass undefined\n    if (argKey === 'vλl') return parentComp.getCurrentStackItem().vλl; // when vλl is required we pass the current stack item\n\n    // first check if the arg is provided by the context\n    const varNameFromContext = parentComp.getChildrenCallArgs(idFnToCall)?.[argKey];\n    if (varNameFromContext) return varNameFromContext;\n    // then check if the arg is provided by the parent function\n    const varNameFromParent = parentComp.args[argKey];\n    if (varNameFromParent) return varNameFromParent;\n    // if neither the parent nor the context has the arg, we create a new default value in the context\n    // if there is no default value, we can't call the function\n    if (!defaultArgVal)\n        throw new Error(\n            `Can not call jit function ${idFnToCall} because it requires argument ${argKey} but it is not provided,\n            neither in the parent function nor in the function context and there is no default value for it.`\n        );\n    const defaultName = fnConfig.jitArgs[argKey];\n    const optsVarName = `${defaultName}_${idFnToCall}0`; // we don't need to use nestLevel as value is the same for all calls\n    parentComp.setContextItem(optsVarName, `const ${optsVarName} = ${defaultArgVal}`);\n    return optsVarName;\n}\n\n/**\n * Returns true if the parent of the runType is of the given kind.\n * handles special case of union types, as we need to check the parent of the union.\n * @param rt\n * @param kind\n * @returns\n */\nexport function parentIs(rt: BaseRunType, kind: ReflectionKind | ReflectionKind[]): boolean {\n    const parentRT = rt.getParent();\n    if (!parentRT) return false;\n    if (parentRT.src.kind === ReflectionKind.union) return parentIs(parentRT, kind);\n    if (Array.isArray(kind) ? kind.includes(parentRT.src.kind) : parentRT.src.kind === kind) return true;\n    return false;\n}\n\n/** Add full stop to code if needed */\nexport function addFullStop(code: string): string {\n    if (!code) return code;\n    const lastChar = code.length - 1;\n    const hasFullStop = code[lastChar] === ';';\n    if (hasFullStop) return code;\n    const hasBlockClose = code[lastChar] === '}';\n    return hasBlockClose ? code : `${code};`;\n}\n"],"names":[],"mappings":";;;;;AAoBO,SAAS,UAAU,OAAwF;AAC9G,UAAQ,OAAO,OAAA;AAAA,IACX,KAAK;AACD,aAAO,GAAG,KAAK;AAAA,IACnB,KAAK;AACD,aAAO,KAAK,UAAU,KAAK;AAAA,IAC/B,KAAK;AACD,aAAO,QAAQ,SAAS;AAAA,IAC5B,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO,GAAG,KAAK;AAAA,IACnB,KAAK;AACD,aAAO,UAAU,UAAU,MAAM,WAAW,CAAC;AAAA,IACjD,KAAK;AACD,UAAI,UAAU,KAAM,QAAO;AAC3B,UAAI,iBAAiB,OAAQ,QAAO,MAAM,SAAA;AAC1C,YAAM,IAAI,MAAM,4BAA4B,KAAK,EAAE;AAAA,IACvD;AACI,YAAM,IAAI,MAAM,4BAA4B,KAAK,EAAE;AAAA,EAAA;AAE/D;AAEO,SAAS,eAAe,OAAsB;AACjD,SAAO,IAAI,wBAAwB,KAAK,CAAC;AAC7C;AAEO,SAAS,wBAAwB,OAAsB;AAC1D,SAAO,MAAM,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC,EAAE,EAAE,KAAK,IAAI;AACxD;AAEO,SAAS,eAAe,MAA+B;AAC1D,SACI,SAAS,eAAe,iBACxB,SAAS,eAAe,UACxB,SAAS,eAAe,YACxB,SAAS,eAAe,mBACxB,SAAS,eAAe;AAEhC;AAEO,SAAS,QAAQ,KAAsC;AAC1D,SACI,OAAO,QAAQ,cACf,IAAI,aACJ,IAAI,UAAU,gBAAgB,OAC9B,IAAI,UAAU,YAAY,QAC1B,IAAI,SAAA,EAAW,WAAW,OAAO;AAEzC;AAEO,SAAS,cAAc,GAAY,GAAqB;AAC3D,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,EAAE,IAAI,SAAS,EAAE,IAAI,KAAM,QAAO;AACtC,SAAO,EAAE,gBAAgB,EAAE,UAAA;AAC/B;AAEO,SAAS,kBAAkB,GAAkB,GAA2B;AAC3E,SAAO,EAAE,SAAS,EAAE,QAAQ,cAAc,EAAE,UAAU,EAAE,QAAQ;AACpE;AAEO,SAAS,SAA6C,IAAY;AACrE,MAAI;AACJ,UAAQ,IAAI,SAAgB;AACxB,QAAI,CAAC,OAAQ,UAAS,GAAG,GAAG,IAAI;AAChC,WAAO;AAAA,EACX;AACJ;AAEO,SAAS,eAAe,MAAyC;AACpE,SAAQ,OAAO,SAAS,YAAY,wBAAwB,KAAK,IAAI,KAAM,OAAO,SAAS;AAC/F;AAEO,SAAS,iBAAiB,MAAwC;AACrE,QAAM,QAAQ,OAAO,SAAS,WAAW,OAAO,OAAO,IAAI;AAC3D,SAAO,MAAM,QAAQ,mBAAmB,GAAG;AAC/C;AAEO,SAAS,eAAe,MAAiD;AAC5E,MAAI,OAAO,SAAS,SAAU,QAAO,KAAK,SAAA;AAC1C,SAAO;AACX;AACO,SAAS,eAAe,MAAiD;AAC5E,SAAO,UAAU,IAAI;AACzB;AACO,SAAS,wBAAwB,MAAyC;AAC7E,MAAI,OAAO,SAAS,SAAU,QAAO;AACrC,SAAO,CAAC,eAAe,IAAI;AAC/B;AAEO,SAAS,aAAa,KAAmB;AAC5C,QAAM,SAAS,IAAI;AACnB,MAAI,CAAC,OAAQ,QAAO;AACpB,QAAM,QAAS,OAA2B;AAC1C,MAAI,MAAO,QAAO,MAAM,QAAQ,GAAG;AACnC,SAAO;AACX;AAEO,SAAS,cAAc,KAA8C;AACxE,QAAM,SAAS,IAAI;AACnB,MAAI,CAAC,OAAQ,QAAO;AACpB,MAAK,OAAwB,WAAY,QAAQ,OAAwB,WAAW,QAAQ,GAAoB;AAChH,MAAK,OAAqB,MAAO,QAAQ,OAAqB,MAAM,QAAQ,GAAsB;AAClG,SAAO;AACX;AAEO,SAAS,kBAAkB,YAAqB,OAA6B;AAChF,SAAO,WAAW,SAAS,OAAO,CAAC,MAAM,aAAA;AAC7C;AAIA,MAAM,kBAAkB;AAiBjB,SAAS,mBAEZ,MACA,QAEA,cAAwB,CAAA,GACxB,iBAAiB,OACX;AACN,UAAQ,MAAA;AAAA,IACJ,KAAK,OAAO,WAAW,UAAU;AAC7B,YAAM,UAAU,UAAU,MAAM;AAEhC,UAAI,OAAO,SAAS,iBAAiB;AACjC,cAAM,OAAO,kBAAkB,MAAM;AACrC,cAAM,UAAU;AAChB,YAAI,CAAC,KAAK,eAAe,OAAO,EAAG,MAAK,eAAe,SAAS,SAAS,OAAO,MAAM,OAAO,EAAE;AAC/F,eAAO;AAAA,MACX;AACA,aAAO;AAAA,IACX;AAAA,IACA,KAAK,OAAO,WAAW;AACnB,aAAO,GAAG,MAAM;AAAA,IACpB,KAAK,OAAO,WAAW;AACnB,aAAO,SAAS,SAAS;AAAA,IAC7B,KAAK,kBAAkB,QAAQ;AAE3B,YAAM,UAAU,OAAO,SAAA;AACvB,YAAM,OAAO,kBAAkB,OAAO;AACtC,YAAM,UAAU;AAChB,UAAI,CAAC,KAAK,eAAe,OAAO,EAAG,MAAK,eAAe,SAAS,SAAS,OAAO,MAAM,OAAO,EAAE;AAC/F,aAAO;AAAA,IACX;AAAA,IACA,KAAK,MAAM,QAAQ,MAAM,GAAG;AAExB,YAAM,UAAU,IAAI,OAAO,IAAI,CAAC,MAAM,mBAAmB,MAAM,GAAG,aAAa,cAAc,CAAC,EAAE,KAAK,GAAG,CAAC;AACzG,YAAM,OAAO,kBAAkB,OAAO;AACtC,YAAM,UAAU;AAChB,UAAI,CAAC,KAAK,eAAe,OAAO,EAAG,MAAK,eAAe,SAAS,SAAS,OAAO,MAAM,OAAO,EAAE;AAE/F,aAAO;AAAA,IACX;AAAA,IACA,KAAK,OAAO,WAAW,UAAU;AAE7B,YAAM,kBAAkB,OAAO,QAAQ,MAAM,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM;AAC3D,YAAI,YAAY,SAAS,CAAC,KAAK,OAAO,MAAM,YAAa,QAAO;AAChE,cAAM,WAAW,eAAe,CAAC,IAAI,IAAI,UAAU,CAAC;AACpD,YAAI,CAAC,eAAgB,QAAO,GAAG,QAAQ,IAAI,mBAAmB,MAAM,GAAG,aAAa,cAAc,CAAC;AACnG,eAAO,GAAG,QAAQ,IAAI,yBAAyB,MAAM,CAAC,CAAC;AAAA,MAC3D,CAAC;AACD,YAAM,UAAU,IAAI,gBAAgB,OAAO,OAAO,EAAE,KAAK,GAAG,CAAC;AAC7D,YAAM,OAAO,kBAAkB,OAAO;AACtC,YAAM,UAAU;AAChB,UAAI,CAAC,KAAK,eAAe,OAAO,EAAG,MAAK,eAAe,SAAS,SAAS,OAAO,MAAM,OAAO,EAAE;AAC/F,aAAO;AAAA,IACX;AAAA,IACA,KAAK,OAAO,WAAW;AACnB,aAAO,UAAU,MAAM;AAAA,IAC3B;AACI,YAAM,IAAI,MAAM,kCAAkC,MAAM,EAAE;AAAA,EAAA;AAEtE;AAEO,SAAS,yBAAyB,MAAuD,SAAsB;AAClH,MACI,OAAO,YAAY,YACnB,YAAY,QACZ,iBAAiB,WACjB,eAAe,WACf,YAAY,SACd;AAEE,QAAI,CAAC,KAAM,OAAM,IAAI,MAAM,6CAA6C;AACxE,SAAK,oBAAoB,OAAO;AAChC,WAAO,iBAAiB,UAAU,QAAQ,SAAS,CAAC,KAAK,UAAU,QAAQ,MAAM,CAAC;AAAA,EACtF;AACA,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,QAAM,IAAI,MAAM,mEAAmE;AACvF;AAEO,SAAS,mBACZ,QACA,aACM;AACN,UAAQ,MAAA;AAAA,IACJ,KAAK,OAAO,WAAW;AACnB,aAAO,UAAU,MAAM;AAAA,IAC3B,KAAK,OAAO,WAAW;AACnB,aAAO,GAAG,MAAM;AAAA,IACpB,KAAK,OAAO,WAAW;AACnB,aAAO,SAAS,SAAS;AAAA,IAC7B,KAAK,kBAAkB;AACnB,aAAO,OAAO,SAAA;AAAA,IAClB,KAAK,MAAM,QAAQ,MAAM;AACrB,aAAO,IAAI,OAAO,IAAI,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC,EAAE,KAAK,IAAI,CAAC;AAAA,IAC/E,KAAK,OAAO,WAAW,UAAU;AAC7B,YAAM,kBAAkB,OAAO,QAAQ,MAAM,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM;AAC3D,YAAI,YAAY,SAAS,CAAC,KAAK,OAAO,MAAM,YAAa,QAAO;AAChE,eAAO,GAAG,CAAC,IAAI,mBAAmB,GAAG,WAAW,CAAC;AAAA,MACrD,CAAC;AACD,aAAO,IAAI,gBAAgB,OAAO,OAAO,EAAE,KAAK,GAAG,CAAC;AAAA,IACxD;AAAA,IACA,KAAK,OAAO,WAAW;AACnB,aAAO,GAAG,MAAM;AAAA,IACpB;AACI,YAAM,IAAI,MAAM,kCAAkC,MAAM,EAAE;AAAA,EAAA;AAEtE;AACO,SAAS,iBAAiB,IAAyB;AACtD,QAAM,UAAU,GAAG,gBAAA;AACnB,MAAI,CAAC,QAAS,OAAM,IAAI,MAAM,4BAA4B;AAC1D,SAAO,kBAAkB,OAAO;AACpC;AAGA,MAAM,mBAAmB;AAAA,EACrB,GAAG;AAAA,EACH,GAAG;AAAA;AAAA,EACH,GAAG;AAAA;AAAA,EACH,GAAG;AACP;AACA,MAAM,kBAAkB;AAAA,EACpB,CAAC,eAAe,cAAc,GAAG;AAAA;AAAA,EACjC,CAAC,eAAe,KAAK,GAAG;AAAA;AAAA,EACxB,CAAC,eAAe,QAAQ,GAAG;AAAA;AAAA,EAC3B,CAAC,eAAe,iBAAiB,GAAG;AAAA;AAAA,EACpC,CAAC,eAAe,OAAO,GAAG;AAAA;AAAA,EAC1B,CAAC,eAAe,IAAI,GAAG;AAAA;AAAA,EACvB,CAAC,eAAe,SAAS,GAAG;AAAA;AAAA,EAC5B,CAAC,eAAe,IAAI,GAAG;AAAA;AAC3B;AACA,MAAM,qBAAqB;AAAA,EACvB,CAAC,kBAAkB,IAAI,GAAG;AAC9B;AAOO,SAAS,mBAAmB,MAAqB,IAAiB,QAAuB,CAAA,GAAY;AACxG,MAAI,CAAC,GAAI,QAAO;AAChB,MAAI,MAAM,SAAS,EAAE,EAAG,QAAO;AAC/B,QAAM,KAAK,EAAE;AACb,MAAI,SAAS;AACb,QAAM,WAAW,GAAG,IAAI,UAAU,mBAAmB,GAAG,IAAI,OAAO,IAAI;AACvE,QAAM,QAAQ,YAAY,gBAAgB,GAAG,IAAI,IAAI;AACrD,QAAM,UAAU,GAAG,UAAA;AACnB,MAAI,YAAY,IAAK,UAAS,SAAS,iBAAiB;AAAA,WAC/C,YAAY,KAAK;AACtB,UAAM,UAAW,GAA0B,YAAY,IAAI;AAC3D,QAAI,CAAC,QAAS,QAAO,SAAS,iBAAiB;AAC/C,UAAM,SAAS,mBAAmB,MAAM,SAAS,KAAK;AACtD,cAAU,SAAS,iBAAiB,KAAK;AAAA,EAC7C,WAAW,YAAY,KAAK;AACxB,UAAM,YAAa,GACd,eAAe,IAAI,EACnB,IAAI,CAAC,UAAU,mBAAmB,MAAM,OAAO,KAAK,CAAC;AAC1D,UAAM,iBAAiB,UAAU,OAAO,CAAC,KAAK,WAAW,MAAM,QAAQ,CAAC;AACxE,cAAU,SAAS,iBAAiB,KAAK;AAAA,EAC7C,OAAO;AACH,aAAS,SAAS,iBAAiB;AAAA,EACvC;AACA,QAAM,IAAA;AACN,SAAO;AACX;AAMO,SAAS,wBAAwB,MAAqB,GAAgB,GAAwB;AACjG,MAAI,EAAE,gBAAgB,OAAO,EAAE,UAAA,MAAgB,KAAK;AAChD,UAAM,mBAAoB,EAAsB;AAChD,UAAM,mBAAoB,EAAsB;AAChD,QAAI,oBAAoB,CAAC,iBAAkB,QAAO;AAClD,QAAI,CAAC,oBAAoB,iBAAkB,QAAO;AAAA,EACtD;AACA,MAAI,EAAE,UAAA,MAAgB,OAAQ,EAAsB,qBAAsB,QAAO;AACjF,QAAM,SAAS,mBAAmB,MAAM,CAAC;AACzC,QAAM,SAAS,mBAAmB,MAAM,CAAC;AACzC,SAAO,SAAS;AACpB;AAEO,SAAS,wBAAwB,GAAgB,GAAwB;AAC5E,MAAI,EAAE,gBAAgB,OAAO,EAAE,UAAA,MAAgB,KAAK;AAChD,UAAM,mBAAoB,EAAsB;AAChD,UAAM,mBAAoB,EAAsB;AAChD,QAAI,oBAAoB,CAAC,iBAAkB,QAAO;AAClD,QAAI,CAAC,oBAAoB,iBAAkB,QAAO;AAAA,EACtD;AACA,SAAO;AACX;AAEO,SAAS,iBAA8C;AAC1D,MAAI,UAAU;AACd,SAAO,CAAC,MAAM,UAAU;AACpB,UAAM,SAAS,MAAM,SAAS;AAC9B,UAAM,KAAK,UAAU,OAAO;AAC5B,cAAU;AACV,WAAO;AAAA,EACX;AACJ;AAEO,SAAS,uBAAuB,YAA2B,IAAiB,YAAqB,QAAwB;AAC5H,QAAM,WAAW,iBAAiB,UAAU;AAC5C,QAAM,gBAAgB,SAAS,eAAe,MAAM;AAEpD,MAAI,WAAW,SAAS,SAAS,aAAc,QAAO;AACtD,MAAI,WAAW,MAAO,QAAO,WAAW,sBAAsB;AAG9D,QAAM,qBAAqB,WAAW,oBAAoB,UAAU,IAAI,MAAM;AAC9E,MAAI,mBAAoB,QAAO;AAE/B,QAAM,oBAAoB,WAAW,KAAK,MAAM;AAChD,MAAI,kBAAmB,QAAO;AAG9B,MAAI,CAAC;AACD,UAAM,IAAI;AAAA,MACN,6BAA6B,UAAU,iCAAiC,MAAM;AAAA;AAAA,IAAA;AAGtF,QAAM,cAAc,SAAS,QAAQ,MAAM;AAC3C,QAAM,cAAc,GAAG,WAAW,IAAI,UAAU;AAChD,aAAW,eAAe,aAAa,SAAS,WAAW,MAAM,aAAa,EAAE;AAChF,SAAO;AACX;AASO,SAAS,SAAS,IAAiB,MAAkD;AACxF,QAAM,WAAW,GAAG,UAAA;AACpB,MAAI,CAAC,SAAU,QAAO;AACtB,MAAI,SAAS,IAAI,SAAS,eAAe,MAAO,QAAO,SAAS,UAAU,IAAI;AAC9E,MAAI,MAAM,QAAQ,IAAI,IAAI,KAAK,SAAS,SAAS,IAAI,IAAI,IAAI,SAAS,IAAI,SAAS,KAAM,QAAO;AAChG,SAAO;AACX;AAGO,SAAS,YAAY,MAAsB;AAC9C,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,WAAW,KAAK,SAAS;AAC/B,QAAM,cAAc,KAAK,QAAQ,MAAM;AACvC,MAAI,YAAa,QAAO;AACxB,QAAM,gBAAgB,KAAK,QAAQ,MAAM;AACzC,SAAO,gBAAgB,OAAO,GAAG,IAAI;AACzC;"}

package/.dist/esm/src/mocking/constants.mock.d.ts

@@ -0,0 +1,85 @@
+export declare const mockRegExpsList: RegExp[];
+export declare const stringCharSet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 .>?<~!@#$%^&*()_+-=[]{}|;:,";
+export declare const emailLocalPartSymbols = "._%-";
+export declare const anyValuesList: (string | number | bigint | boolean | symbol | RegExp | (string | number)[] | Set<string | number> | Date | Map<string, number> | {
+    hello?: undefined;
+} | {
+    hello: string;
+} | null | undefined)[];
+export declare const mockObjectList: ({
+    a?: undefined;
+    b?: undefined;
+    c?: undefined;
+    d?: undefined;
+} | {
+    a: number;
+    b?: undefined;
+    c?: undefined;
+    d?: undefined;
+} | {
+    b: number;
+    a?: undefined;
+    c?: undefined;
+    d?: undefined;
+} | {
+    a: number;
+    b: string;
+    c?: undefined;
+    d?: undefined;
+} | {
+    a: number;
+    b: number;
+    c: number;
+    d?: undefined;
+} | {
+    a: string;
+    b: number;
+    c: string;
+    d: number;
+})[];
+export declare const defaultMockOptions: {
+    anyValuesList: (string | number | bigint | boolean | symbol | RegExp | (string | number)[] | Set<string | number> | Date | Map<string, number> | {
+        hello?: undefined;
+    } | {
+        hello: string;
+    } | null | undefined)[];
+    promiseTimeOut: number;
+    regexpList: RegExp[];
+    maxRandomStringLength: number;
+    stringCharSet: string;
+    maxRandomItemsLength: number;
+    optionalProbability: number;
+    objectList: ({
+        a?: undefined;
+        b?: undefined;
+        c?: undefined;
+        d?: undefined;
+    } | {
+        a: number;
+        b?: undefined;
+        c?: undefined;
+        d?: undefined;
+    } | {
+        b: number;
+        a?: undefined;
+        c?: undefined;
+        d?: undefined;
+    } | {
+        a: number;
+        b: string;
+        c?: undefined;
+        d?: undefined;
+    } | {
+        a: number;
+        b: number;
+        c: number;
+        d?: undefined;
+    } | {
+        a: string;
+        b: number;
+        c: string;
+        d: number;
+    })[];
+    maxStackDepth: number;
+    maxMockRecursion: number;
+};

package/.dist/esm/src/mocking/constants.mock.js

@@ -0,0 +1,108 @@
+const mockRegExpsList = [
+  /abc/,
+  // Matches the string 'abc'
+  /def/,
+  // Matches the string 'def'
+  /123/,
+  // Matches the string '123'
+  /xyz/,
+  // Matches the string 'xyz'
+  /[\w]+/,
+  // Matches one or more word characters
+  /\d{3}-\d{3}-\d{4}/,
+  // Matches a phone number in the format XXX-XXX-XXXX
+  /[A-Z]/,
+  // Matches a single uppercase letter
+  /[a-z]/,
+  // Matches a single lowercase letter
+  /\d+/,
+  // Matches one or more digits
+  /\s+/,
+  // Matches one or more whitespace characters
+  /^https:\/\/[\w.-]+\.[a-zA-Z]{2,}$/i,
+  // Matches a URL starting with http:// or https://
+  /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i,
+  // Matches an email address
+  /\b\d{2}\/\d{2}\/\d{4}\b/,
+  // Matches a date in the format MM/DD/YYYY
+  /\b\d{1,2}:\d{2}\b/,
+  // Matches a time in the format HH:MM
+  /\b\d{1,2}:\d{2}:\d{2}\b/,
+  // Matches a time in the format HH:MM:SS
+  /\b\d{1,2}\/\d{1,2}\/\d{2}\b/,
+  // Matches a date in the format M/D/YY
+  /\b\d{1,2}\/\d{1,2}\/\d{4}\b/,
+  // Matches a date in the format M/D/YYYY
+  /\b\d{1,2}:\d{2}:\d{2} [AP]M\b/,
+  // Matches a time in the format HH:MM:SS AM/PM
+  /\b\d{1,2}:\d{2} [AP]M\b/,
+  // Matches a time in the format HH:MM AM/PM
+  /abc/gi,
+  // Matches the string 'abc' with the global and case-insensitive flags
+  /['"]/,
+  // regexp that contains single and double quotes
+  /\/(.*)\/(.*)?/,
+  // regexp that contains a slash
+  /\/\//,
+  // regexp that contains two slashes
+  /`/,
+  // regexp that contains backticks
+  /\/\\\//
+  // regexp double scaped \\
+];
+const stringCharSet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 .>?<~!@#$%^&*()_+-=[]{}|;:,";
+const emailLocalPartSymbols = "._%-";
+const anyValuesList = [
+  {},
+  { hello: "world" },
+  [],
+  [1, 3, "hello"],
+  "hello",
+  1234,
+  BigInt(1),
+  true,
+  false,
+  null,
+  void 0,
+  /* @__PURE__ */ Symbol("hello"),
+  -124,
+  0,
+  124,
+  0.1,
+  -0.1,
+  Infinity,
+  NaN,
+  /* @__PURE__ */ new Date(),
+  /abc/,
+  /* @__PURE__ */ new Map([
+    ["zero", 0],
+    ["one", 1],
+    ["two", 2],
+    ["three", 3],
+    ["four", 4]
+  ]),
+  /* @__PURE__ */ new Set(["zero", 1, 2, 3, "four"])
+];
+const mockObjectList = [{}, { a: 1 }, { b: 2 }, { a: 1, b: "hello" }, { a: 1, b: 2, c: 3 }, { a: "hello", b: 2, c: "wold", d: 4 }];
+const defaultMockOptions = {
+  anyValuesList,
+  promiseTimeOut: 1,
+  regexpList: mockRegExpsList,
+  maxRandomStringLength: 100,
+  stringCharSet,
+  maxRandomItemsLength: 60,
+  /** probability to generate options types, number between 0 and 1 */
+  optionalProbability: 0.5,
+  objectList: mockObjectList,
+  maxStackDepth: 50,
+  maxMockRecursion: 10
+};
+export {
+  anyValuesList,
+  defaultMockOptions,
+  emailLocalPartSymbols,
+  mockObjectList,
+  mockRegExpsList,
+  stringCharSet
+};
+//# sourceMappingURL=constants.mock.js.map

package/.dist/esm/src/mocking/constants.mock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mock.js","sources":["../../../../src/mocking/constants.mock.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 {MockOptions} from '../types.ts';\n\nexport const mockRegExpsList = [\n    /abc/, // Matches the string 'abc'\n    /def/, // Matches the string 'def'\n    /123/, // Matches the string '123'\n    /xyz/, // Matches the string 'xyz'\n    /[\\w]+/, // Matches one or more word characters\n    /\\d{3}-\\d{3}-\\d{4}/, // Matches a phone number in the format XXX-XXX-XXXX\n    /[A-Z]/, // Matches a single uppercase letter\n    /[a-z]/, // Matches a single lowercase letter\n    /\\d+/, // Matches one or more digits\n    /\\s+/, // Matches one or more whitespace characters\n    /^https:\\/\\/[\\w.-]+\\.[a-zA-Z]{2,}$/i, // Matches a URL starting with http:// or https://\n    /\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}\\b/i, // Matches an email address\n    /\\b\\d{2}\\/\\d{2}\\/\\d{4}\\b/, // Matches a date in the format MM/DD/YYYY\n    /\\b\\d{1,2}:\\d{2}\\b/, // Matches a time in the format HH:MM\n    /\\b\\d{1,2}:\\d{2}:\\d{2}\\b/, // Matches a time in the format HH:MM:SS\n    /\\b\\d{1,2}\\/\\d{1,2}\\/\\d{2}\\b/, // Matches a date in the format M/D/YY\n    /\\b\\d{1,2}\\/\\d{1,2}\\/\\d{4}\\b/, // Matches a date in the format M/D/YYYY\n    /\\b\\d{1,2}:\\d{2}:\\d{2} [AP]M\\b/, // Matches a time in the format HH:MM:SS AM/PM\n    /\\b\\d{1,2}:\\d{2} [AP]M\\b/, // Matches a time in the format HH:MM AM/PM\n    /abc/gi, // Matches the string 'abc' with the global and case-insensitive flags\n    /['\"]/, // regexp that contains single and double quotes\n    /\\/(.*)\\/(.*)?/, // regexp that contains a slash\n    /\\/\\//, // regexp that contains two slashes\n    /`/, // regexp that contains backticks\n    /\\/\\\\\\//, // regexp double scaped \\\\\n];\n\nexport const stringCharSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 .>?<~!@#$%^&*()_+-=[]{}|;:,';\nexport const emailLocalPartSymbols = '._%-';\n\nexport const anyValuesList = [\n    {},\n    {hello: 'world'},\n    [],\n    [1, 3, 'hello'],\n    'hello',\n    1234,\n    BigInt(1),\n    true,\n    false,\n    null,\n    undefined,\n    Symbol('hello'),\n    -124,\n    0,\n    124,\n    0.1,\n    -0.1,\n    Infinity,\n    NaN,\n    new Date(),\n    /abc/,\n    new Map([\n        ['zero', 0],\n        ['one', 1],\n        ['two', 2],\n        ['three', 3],\n        ['four', 4],\n    ]),\n    new Set(['zero', 1, 2, 3, 'four']),\n];\n\nexport const mockObjectList = [{}, {a: 1}, {b: 2}, {a: 1, b: 'hello'}, {a: 1, b: 2, c: 3}, {a: 'hello', b: 2, c: 'wold', d: 4}];\n\nexport const defaultMockOptions = {\n    anyValuesList,\n    promiseTimeOut: 1,\n    regexpList: mockRegExpsList,\n    maxRandomStringLength: 100,\n    stringCharSet,\n    maxRandomItemsLength: 60,\n    /** probability to generate options types, number between 0 and 1 */\n    optionalProbability: 0.5,\n    objectList: mockObjectList,\n    maxStackDepth: 50,\n    maxMockRecursion: 10,\n} satisfies MockOptions;\n"],"names":[],"mappings":"AASO,MAAM,kBAAkB;AAAA,EAC3B;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AACJ;AAEO,MAAM,gBAAgB;AACtB,MAAM,wBAAwB;AAE9B,MAAM,gBAAgB;AAAA,EACzB,CAAA;AAAA,EACA,EAAC,OAAO,QAAA;AAAA,EACR,CAAA;AAAA,EACA,CAAC,GAAG,GAAG,OAAO;AAAA,EACd;AAAA,EACA;AAAA,EACA,OAAO,CAAC;AAAA,EACR;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,yBACO,OAAO;AAAA,EACd;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,sBACI,KAAA;AAAA,EACJ;AAAA,sBACI,IAAI;AAAA,IACJ,CAAC,QAAQ,CAAC;AAAA,IACV,CAAC,OAAO,CAAC;AAAA,IACT,CAAC,OAAO,CAAC;AAAA,IACT,CAAC,SAAS,CAAC;AAAA,IACX,CAAC,QAAQ,CAAC;AAAA,EAAA,CACb;AAAA,EACD,oBAAI,IAAI,CAAC,QAAQ,GAAG,GAAG,GAAG,MAAM,CAAC;AACrC;AAEO,MAAM,iBAAiB,CAAC,CAAA,GAAI,EAAC,GAAG,EAAA,GAAI,EAAC,GAAG,EAAA,GAAI,EAAC,GAAG,GAAG,GAAG,QAAA,GAAU,EAAC,GAAG,GAAG,GAAG,GAAG,GAAG,KAAI,EAAC,GAAG,SAAS,GAAG,GAAG,GAAG,QAAQ,GAAG,GAAE;AAEvH,MAAM,qBAAqB;AAAA,EAC9B;AAAA,EACA,gBAAgB;AAAA,EAChB,YAAY;AAAA,EACZ,uBAAuB;AAAA,EACvB;AAAA,EACA,sBAAsB;AAAA;AAAA,EAEtB,qBAAqB;AAAA,EACrB,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,kBAAkB;AACtB;"}

package/.dist/esm/src/mocking/mockRegistry.d.ts

@@ -0,0 +1,3 @@
+import { JitFnCompiler } from '../lib/jitFnCompiler.ts';
+export declare function getMockCompiler(fnHash: string): JitFnCompiler;
+export declare function setMockCompiler(fnHash: string, comp: JitFnCompiler): void;

package/.dist/esm/src/mocking/mockRegistry.js

@@ -0,0 +1,12 @@
+const mockCompCache = /* @__PURE__ */ new Map();
+function getMockCompiler(fnHash) {
+  return mockCompCache.get(fnHash);
+}
+function setMockCompiler(fnHash, comp) {
+  mockCompCache.set(fnHash, comp);
+}
+export {
+  getMockCompiler,
+  setMockCompiler
+};
+//# sourceMappingURL=mockRegistry.js.map

package/.dist/esm/src/mocking/mockRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockRegistry.js","sources":["../../../../src/mocking/mockRegistry.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {JitFnCompiler} from '../lib/jitFnCompiler.ts';\n\n// TODO, as mock could return results async with mock promises\n// we might need an unique JitCompiler, for each mock to avoid problems with the stack\nconst mockCompCache = new Map<string, JitFnCompiler>();\n\nexport function getMockCompiler(fnHash: string): JitFnCompiler {\n    return mockCompCache.get(fnHash)!;\n}\n\nexport function setMockCompiler(fnHash: string, comp: JitFnCompiler): void {\n    mockCompCache.set(fnHash, comp);\n}\n"],"names":[],"mappings":"AAWA,MAAM,oCAAoB,IAAA;AAEnB,SAAS,gBAAgB,QAA+B;AAC3D,SAAO,cAAc,IAAI,MAAM;AACnC;AAEO,SAAS,gBAAgB,QAAgB,MAA2B;AACvE,gBAAc,IAAI,QAAQ,IAAI;AAClC;"}

package/.dist/esm/src/mocking/mockType.d.ts

@@ -0,0 +1,3 @@
+import { BaseRunType } from '../lib/baseRunTypes.ts';
+import { JitFnCompiler } from '../lib/jitFnCompiler.ts';
+export declare function mockType(runType: BaseRunType, comp: JitFnCompiler, stack?: BaseRunType[]): any;