@mionjs/run-types 0.8.8 → 0.13.0

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

@@ -1,310 +0,0 @@
-import { ReflectionKind } from "@deepkit/type";
-import { random, mockSymbol, mockRegExp, mockBigInt, mockBoolean, mockNumber, mockString, mockAny, mockDate } from "./mockUtils.js";
-import { stringCharSet } from "./constants.mock.js";
-import { ClassRunType } from "../nodes/collection/class.js";
-import { ReflectionSubKind } from "../constants.kind.js";
-import { NonSerializableRunType } from "../nodes/native/nonSerializable.js";
-import { IndexSignatureRunType } from "../nodes/member/indexProperty.js";
-import { getRunTypeFormat, getRunTypeTransformer } from "../lib/formats.js";
-import { JIT_STACK_TRACE_MESSAGE } from "../constants.js";
-import { JitFunctions } from "../constants.functions.js";
-import { getJitUtils } from "@mionjs/core";
-import { MockJitCompiler } from "../lib/jitFnCompiler.js";
-function mockType(runType, comp, stack = []) {
-  stack.push(runType);
-  const mockNestLevel = stack.filter((rt) => rt === runType).length;
-  const rtOpts = comp.opts;
-  const updatedOps = mockNestLevel ? getMockOptionsForNestedElements(rtOpts, mockNestLevel) : comp.opts;
-  comp.opts = updatedOps;
-  const typeValidator = getRunTypeFormat(runType);
-  let mocked = typeValidator ? typeValidator.mock(updatedOps, runType) : _mockType(runType, comp, stack);
-  comp.opts = rtOpts;
-  const typeTransformer = getRunTypeTransformer(runType);
-  if (typeTransformer) {
-    const compiledFormatter = runType.createJitCompiledFunction(JitFunctions.format.id);
-    mocked = compiledFormatter.isNoop ? mocked : compiledFormatter.fn(mocked);
-  }
-  stack.pop();
-  return mocked;
-}
-function getMockOptionsForNestedElements(opts, nestLevel) {
-  const mOps = opts.mock;
-  const maxDepth = mOps.maxMockRecursion;
-  const divisor = nestLevel;
-  const { optionalProbability, maxRandomItemsLength: maxRandomArrayLength, optionalPropertyProbability, arrayLength } = mOps;
-  const newProv = nestLevel >= maxDepth ? 0 : optionalProbability / divisor;
-  const newMaxLength = nestLevel >= maxDepth ? 0 : Math.round(maxRandomArrayLength / divisor);
-  const ret = {
-    mock: {
-      ...mOps,
-      optionalProbability: newProv,
-      maxRandomItemsLength: newMaxLength
-    }
-  };
-  if (optionalPropertyProbability) {
-    const entries = Object.entries(optionalPropertyProbability).map(([key, value]) => {
-      const newProv2 = nestLevel > maxDepth ? 0 : value / divisor;
-      return [key, value / newProv2];
-    });
-    ret.mock.optionalPropertyProbability = Object.fromEntries(entries);
-  }
-  if (arrayLength) {
-    const newLength = nestLevel >= maxDepth ? 0 : Math.round(arrayLength / divisor);
-    ret.mock.arrayLength = newLength;
-  }
-  if (ret.mock.parentObj) ret.mock.parentObj = {};
-  return ret;
-}
-function _mockType(runType, comp, stack) {
-  const mOps = comp.opts.mock;
-  const recursionLevel = stack.filter((rt) => rt === runType).length;
-  const src = runType.src;
-  const kind = src.kind;
-  if (recursionLevel > mOps.maxMockRecursion) return void 0;
-  switch (kind) {
-    case ReflectionKind.never:
-      throw new Error("Cannot mock never type." + printStackTrace(comp, stack));
-    case ReflectionKind.any:
-    case ReflectionKind.unknown:
-      return mockAny(mOps.anyValuesList);
-    // Atomic types
-    case ReflectionKind.string:
-      return mockString(mOps.stringLength || random(1, mOps.maxRandomStringLength), mOps.stringCharSet || stringCharSet);
-    case ReflectionKind.number:
-      return mockNumber(mOps.minNumber, mOps.maxNumber);
-    case ReflectionKind.boolean:
-      return mockBoolean();
-    case ReflectionKind.bigint:
-      return mockBigInt(mOps.minNumber, mOps.maxNumber);
-    case ReflectionKind.null:
-      return null;
-    case ReflectionKind.undefined:
-      return void 0;
-    case ReflectionKind.void:
-      return void 0;
-    case ReflectionKind.regexp:
-      return mockRegExp(mOps.regexpList);
-    case ReflectionKind.symbol:
-      return mockSymbol(mOps.symbolName, mOps.symbolLength, mOps.symbolCharSet);
-    case ReflectionKind.literal:
-      return src.literal;
-    case ReflectionKind.object:
-      return mOps.objectList[random(0, mOps.objectList.length - 1)];
-    case ReflectionKind.enum: {
-      const rt = runType;
-      const i = mOps.enumIndex || random(0, rt.src.values.length - 1);
-      return rt.src.values[i];
-    }
-    case ReflectionKind.enumMember:
-      throw new Error("Mock enum member is not supported." + printStackTrace(comp, stack));
-    // Collection types
-    case ReflectionKind.array: {
-      const rt = runType;
-      const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);
-      if (length === 0) return [];
-      return Array.from({ length }, () => mockType(rt.getMemberType(), comp, stack));
-    }
-    case ReflectionKind.tuple: {
-      const rt = runType;
-      const options = mOps.tupleOptions;
-      const params = rt.getChildRunTypes().map((p, i) => mockType(p, getChildOpts(comp, options?.[i]), stack));
-      if (rt.hasRestParameter(comp)) {
-        return [...params.slice(0, -1), ...params[params.length - 1]];
-      }
-      return params;
-    }
-    case ReflectionKind.intersection:
-    case ReflectionKind.objectLiteral: {
-      if (runType instanceof NonSerializableRunType) {
-        throw new Error(`Mock is disabled for Non Serializable types.` + printStackTrace(comp, stack));
-      } else {
-        const rt = runType;
-        if (rt.isCallable()) return mockType(rt.getCallSignature(), comp, stack);
-        let obj = mOps.parentObj || {};
-        rt.getChildRunTypes().forEach((prop) => {
-          if (prop instanceof IndexSignatureRunType) {
-            obj = { ...obj, ...mockType(prop, comp, stack) };
-            return;
-          }
-          const name = prop.getChildVarName(comp);
-          const isMethod = prop.src.kind === ReflectionKind.method || prop.src.kind === ReflectionKind.methodSignature;
-          if (isMethod) return;
-          obj[name] = mockType(prop, comp, stack);
-        });
-        return obj;
-      }
-    }
-    case ReflectionKind.class:
-      return _mockClass(runType, comp, stack);
-    case ReflectionKind.union: {
-      const rt = runType;
-      if (mOps.unionIndex && (mOps.unionIndex < 0 || mOps.unionIndex >= rt.getChildRunTypes().length)) {
-        throw new Error(
-          "unionIndex must be between 0 and the number of types in the union." + printStackTrace(comp, stack)
-        );
-      }
-      const index = mOps?.unionIndex ?? random(0, rt.getChildRunTypes().length - 1);
-      return mockType(rt.getChildRunTypes()[index], comp, stack);
-    }
-    case ReflectionKind.function:
-    case ReflectionKind.callSignature:
-    case ReflectionKind.method:
-    case ReflectionKind.methodSignature:
-      if (runType.src.subKind === ReflectionSubKind.params) {
-        const rt = runType;
-        const options = mOps.tupleOptions;
-        const params = rt.getParamRunTypes(comp).map((p, i) => mockType(p, getChildOpts(comp, options?.[i]), stack));
-        if (rt.hasRestParameter(comp)) {
-          return [...params.slice(0, -1), ...params[params.length - 1]];
-        }
-        return params;
-      } else if (runType.src.kind === ReflectionKind.method || runType.src.kind === ReflectionKind.methodSignature) {
-        return void 0;
-      } else {
-        throw new Error("Mock is not allowed, call mockParams or mockReturn instead." + printStackTrace(comp, stack));
-      }
-    case ReflectionKind.promise: {
-      const rt = runType;
-      const timeOut = mOps.promiseTimeOut || 1;
-      return new Promise((resolve, reject) => {
-        if (timeOut > 0) {
-          setTimeout(() => {
-            if (mOps.promiseReject) reject(mOps.promiseReject);
-            else resolve(mockType(rt.getMemberType(), comp, stack));
-          }, timeOut);
-          return;
-        }
-        if (mOps.promiseReject) reject(mOps.promiseReject);
-        else resolve(mockType(rt.getMemberType(), comp, stack));
-      });
-    }
-    // Member types
-    case ReflectionKind.tupleMember:
-    case ReflectionKind.parameter: {
-      const rt = runType;
-      if (!rt.getJitChild(comp)) return void 0;
-      if (rt.isOptional() && !rt.isRest()) {
-        const probability = mOps.optionalProbability;
-        if (probability < 0 || probability > 1)
-          throw new Error("optionalProbability must be between 0 and 1" + printStackTrace(comp, stack));
-        if (Math.random() > probability) {
-          return void 0;
-        }
-      }
-      return mockType(rt.getMemberType(), comp, stack);
-    }
-    case ReflectionKind.propertySignature:
-    case ReflectionKind.property: {
-      const rt = runType;
-      const probability = mOps.optionalPropertyProbability?.[rt.getChildVarName(comp)] ?? mOps.optionalProbability;
-      if (probability < 0 || probability > 1)
-        throw new Error("optionalProbability must be between 0 and 1" + printStackTrace(comp, stack));
-      if (rt.src.optional && Math.random() > probability) return void 0;
-      return mockType(rt.getMemberType(), comp, stack);
-    }
-    case ReflectionKind.rest: {
-      const rt = runType;
-      const length = random(0, mOps.maxRandomItemsLength);
-      const items = [];
-      for (let i = 0; i < length; i++) {
-        items.push(mockType(rt.getMemberType(), comp, stack));
-      }
-      return items;
-    }
-    case ReflectionKind.indexSignature: {
-      const rt = runType;
-      const length = random(0, mOps.maxRandomItemsLength);
-      const parentObj = mOps.parentObj || {};
-      for (let i = 0; i < length; i++) {
-        let propName;
-        switch (true) {
-          case !!(rt.src.index.kind === ReflectionKind.number):
-            propName = i;
-            break;
-          case !!(rt.src.index.kind === ReflectionKind.string):
-            propName = `key${i}`;
-            break;
-          case !!(rt.src.index.kind === ReflectionKind.symbol):
-            propName = /* @__PURE__ */ Symbol.for(`key${i}`);
-            break;
-          default:
-            throw new Error("Invalid index signature type.");
-        }
-        parentObj[propName] = mockType(rt.getMemberType(), comp, stack);
-      }
-      return parentObj;
-    }
-    case ReflectionKind.infer:
-    case ReflectionKind.templateLiteral:
-    case ReflectionKind.typeParameter:
-    default:
-      throw new Error(`Cant mock Unsupported RunType: ${runType.getTypeName()}` + printStackTrace(comp, stack));
-  }
-}
-function _mockClass(runType, comp, stack) {
-  const mOps = comp.opts.mock;
-  switch (runType.src.subKind) {
-    case ReflectionSubKind.date:
-      return mockDate(mOps.minDate, mOps.maxDate);
-    case ReflectionSubKind.map: {
-      const rt = runType;
-      const mockMap = /* @__PURE__ */ new Map();
-      const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);
-      for (let i = 0; i < length; i++) {
-        const keyType = mockType(rt.keyRT, comp, stack);
-        const valueType = mockType(rt.valueRT, comp, stack);
-        mockMap.set(keyType, valueType);
-      }
-      return mockMap;
-    }
-    case ReflectionSubKind.set: {
-      const rt = runType;
-      const mockSet = /* @__PURE__ */ new Set();
-      const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);
-      for (let i = 0; i < length; i++) {
-        const value = mockType(rt.keyRT, comp, stack);
-        mockSet.add(value);
-      }
-      return mockSet;
-    }
-    case ReflectionSubKind.nonSerializable:
-      throw new Error(`Mock is disabled for Non Serializable types.` + printStackTrace(comp, stack));
-    default: {
-      if (!(runType instanceof ClassRunType)) {
-        throw new Error(`Cant mock Unsupported RunType: ${runType.getTypeName()}` + printStackTrace(comp, stack));
-      }
-      const rt = runType;
-      const isSerializable = rt.isClassWithEmptyConstructor();
-      const deserializeFn = getJitUtils().getDeserializeFn(rt.getClassName());
-      if (!deserializeFn && !isSerializable) {
-        throw new Error(
-          `Class ${rt.getClassName()} can not be mocked. Be sure to register a deserialize function first with jiUtils.${getJitUtils().setDeserializeFn.name}` + printStackTrace(comp, stack)
-        );
-      }
-      const instance = deserializeFn ? {} : new rt.src.classType();
-      rt.getJitChildren(comp).forEach((prop) => {
-        const name = prop.getChildVarName(comp);
-        if (prop instanceof IndexSignatureRunType) mockType(prop, comp, stack);
-        const mocked = mockType(prop, comp, stack);
-        if (prop.src.optional && mocked === void 0) return;
-        instance[name] = mockType(prop, comp, stack);
-      });
-      if (deserializeFn) return deserializeFn(instance);
-      if (isSerializable) return instance;
-      throw new Error(`Class ${rt.getClassName()} can not be mocked.` + printStackTrace(comp, stack));
-    }
-  }
-}
-function getChildOpts(comp, mockOpts) {
-  if (!mockOpts) return comp;
-  const newOpts = { ...comp.opts, mock: mockOpts };
-  return new MockJitCompiler(comp.rootType, newOpts, comp, comp.jitFnHash, comp.typeID);
-}
-function printStackTrace(comp, stack) {
-  const separator = ".";
-  return JIT_STACK_TRACE_MESSAGE + stack.map((rt) => comp.getTypeTraceInfo(rt)).join(separator);
-}
-export {
-  mockType
-};
-//# sourceMappingURL=mockType.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mockType.js","sources":["../../../../src/mocking/mockType.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 {ReflectionKind} from '@deepkit/type';\nimport type {MockOptions, Mutable, RunTypeOptions} from '../types.ts';\nimport type {BaseRunType} from '../lib/baseRunTypes.ts';\nimport {mockString, mockNumber, mockBoolean, mockBigInt, mockDate, random, mockRegExp, mockSymbol, mockAny} from './mockUtils.ts';\nimport {stringCharSet} from './constants.mock.ts';\nimport {ClassRunType} from '../nodes/collection/class.ts';\nimport type {PropertyRunType} from '../nodes/member/property.ts';\nimport type {MapRunType} from '../nodes/native/map.ts';\nimport type {SetRunType} from '../nodes/native/set.ts';\nimport type {InterfaceRunType} from '../nodes/collection/interface.ts';\nimport type {TupleRunType} from '../nodes/collection/tuple.ts';\nimport type {FunctionParamsRunType} from '../nodes/collection/functionParams.ts';\nimport type {UnionRunType} from '../nodes/collection/union.ts';\nimport type {EnumRunType} from '../nodes/atomic/enum.ts';\nimport type {PromiseRunType} from '../nodes/native/promise.ts';\nimport type {ParameterRunType} from '../nodes/member/param.ts';\nimport type {RestParamsRunType} from '../nodes/member/restParams.ts';\nimport {ReflectionSubKind} from '../constants.kind.ts';\nimport {NonSerializableRunType} from '../nodes/native/nonSerializable.ts';\nimport {IndexSignatureRunType} from '../nodes/member/indexProperty.ts';\nimport {getRunTypeFormat, getRunTypeTransformer} from '../lib/formats.ts';\nimport {JIT_STACK_TRACE_MESSAGE} from '../constants.ts';\nimport {JitFunctions} from '../constants.functions.ts';\nimport type {ArrayRunType} from '../nodes/member/array.ts';\nimport {getJitUtils} from '@mionjs/core';\nimport {MockJitCompiler, type JitFnCompiler} from '../lib/jitFnCompiler.ts';\n\nexport function mockType(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[] = []): any {\n    // TODO: we could use JitCompiler functionality here to controls the stack etc\n    stack.push(runType);\n    const mockNestLevel = stack.filter((rt) => rt === runType).length;\n    const rtOpts = comp.opts;\n    const updatedOps = mockNestLevel ? getMockOptionsForNestedElements(rtOpts, mockNestLevel) : comp.opts;\n    (comp as Mutable<JitFnCompiler>).opts = updatedOps;\n    // Just one type validator allowed per type, and is responsible to mock the value,\n    // ie: email and uuid should contain the logic to generate a valid value\n    const typeValidator = getRunTypeFormat(runType);\n    let mocked = typeValidator ? typeValidator.mock(updatedOps, runType) : _mockType(runType, comp, stack);\n    (comp as Mutable<JitFnCompiler>).opts = rtOpts;\n    // once mocked multiple type transformers can be applied to the mocked value\n    const typeTransformer = getRunTypeTransformer(runType);\n    if (typeTransformer) {\n        const compiledFormatter = runType.createJitCompiledFunction(JitFunctions.format.id);\n        mocked = compiledFormatter.isNoop ? mocked : compiledFormatter.fn(mocked);\n    }\n    stack.pop();\n    return mocked;\n}\n\n// reduces all probabilities within the MockOptions to prevent infinite loops\n// each time mocking is a level deeper, the probabilities to generate an optional property should be reduced\n// this does not prevent infinite loops on types with circular references that are non optional,\n// we probably should throw an error in this case but these kind of types are technically not possible in real world so we can ignore them for now\nfunction getMockOptionsForNestedElements(opts: RunTypeOptions, nestLevel: number): RunTypeOptions {\n    const mOps = opts.mock as MockOptions;\n    const maxDepth = mOps.maxMockRecursion;\n    const divisor = nestLevel;\n    const {optionalProbability, maxRandomItemsLength: maxRandomArrayLength, optionalPropertyProbability, arrayLength} = mOps;\n    const newProv = nestLevel >= maxDepth ? 0 : optionalProbability / divisor;\n    const newMaxLength = nestLevel >= maxDepth ? 0 : Math.round(maxRandomArrayLength / divisor);\n    // console.log(`divisor: ${divisor} | newMaxLength: ${newMaxLength} | newProv: ${newProv}`);\n    const ret = {\n        mock: {\n            ...mOps,\n            optionalProbability: newProv,\n            maxRandomItemsLength: newMaxLength,\n        },\n    } satisfies RunTypeOptions;\n    if (optionalPropertyProbability) {\n        const entries = Object.entries(optionalPropertyProbability).map(([key, value]) => {\n            const newProv = nestLevel > maxDepth ? 0 : value / divisor;\n            return [key, value / newProv];\n        });\n        ret.mock.optionalPropertyProbability = Object.fromEntries(entries);\n    }\n    if (arrayLength) {\n        const newLength = nestLevel >= maxDepth ? 0 : Math.round(arrayLength / divisor);\n        ret.mock.arrayLength = newLength;\n    }\n    if (ret.mock.parentObj) ret.mock.parentObj = {}; // prevents mocking objects with circular references\n    return ret;\n}\n\n/**\n * Centralized mock function with a giant switch statement that handles all node types.\n * This function is similar to createRunType in runType.ts but for mocking.\n */\nfunction _mockType(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[]): any {\n    // Handle circular references\n    const mOps = comp.opts.mock as MockOptions;\n    const recursionLevel = stack.filter((rt) => rt === runType).length;\n    const src = runType.src;\n    const kind = src.kind;\n    if (recursionLevel > mOps.maxMockRecursion) return undefined;\n\n    switch (kind) {\n        case ReflectionKind.never:\n            throw new Error('Cannot mock never type.' + printStackTrace(comp, stack));\n        case ReflectionKind.any:\n        case ReflectionKind.unknown:\n            return mockAny(mOps.anyValuesList);\n        // Atomic types\n        case ReflectionKind.string:\n            return mockString(mOps.stringLength || random(1, mOps.maxRandomStringLength), mOps.stringCharSet || stringCharSet);\n        case ReflectionKind.number:\n            return mockNumber(mOps.minNumber, mOps.maxNumber);\n        case ReflectionKind.boolean:\n            return mockBoolean();\n        case ReflectionKind.bigint:\n            return mockBigInt(mOps.minNumber, mOps.maxNumber);\n        case ReflectionKind.null:\n            return null;\n        case ReflectionKind.undefined:\n            return undefined;\n        case ReflectionKind.void:\n            return undefined;\n        case ReflectionKind.regexp:\n            return mockRegExp(mOps.regexpList);\n        case ReflectionKind.symbol:\n            return mockSymbol(mOps.symbolName, mOps.symbolLength, mOps.symbolCharSet);\n        case ReflectionKind.literal:\n            return src.literal;\n        case ReflectionKind.object:\n            return mOps.objectList[random(0, mOps.objectList.length - 1)];\n        case ReflectionKind.enum: {\n            const rt = runType as EnumRunType;\n            const i = mOps.enumIndex || random(0, rt.src.values.length - 1);\n            return rt.src.values[i];\n        }\n        case ReflectionKind.enumMember:\n            throw new Error('Mock enum member is not supported.' + printStackTrace(comp, stack));\n        // Collection types\n        case ReflectionKind.array: {\n            const rt = runType as ArrayRunType;\n            const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);\n            if (length === 0) return [];\n            return Array.from({length}, () => mockType(rt.getMemberType(), comp, stack));\n        }\n\n        case ReflectionKind.tuple: {\n            const rt = runType as TupleRunType;\n            const options = mOps.tupleOptions;\n            const params = rt.getChildRunTypes().map((p, i) => mockType(p, getChildOpts(comp, options?.[i]), stack));\n            if (rt.hasRestParameter(comp)) {\n                return [...params.slice(0, -1), ...params[params.length - 1]];\n            }\n            return params;\n        }\n        case ReflectionKind.intersection:\n        case ReflectionKind.objectLiteral: {\n            if (runType instanceof NonSerializableRunType) {\n                throw new Error(`Mock is disabled for Non Serializable types.` + printStackTrace(comp, stack));\n            } else {\n                const rt = runType as InterfaceRunType;\n                if (rt.isCallable()) return mockType(rt.getCallSignature()!, comp, stack);\n                let obj: Record<string | number, any> = mOps.parentObj || {};\n                rt.getChildRunTypes().forEach((prop) => {\n                    if (prop instanceof IndexSignatureRunType) {\n                        obj = {...obj, ...mockType(prop, comp, stack)};\n                        return;\n                    }\n                    const name = (prop as PropertyRunType).getChildVarName(comp);\n                    const isMethod = prop.src.kind === ReflectionKind.method || prop.src.kind === ReflectionKind.methodSignature;\n                    if (isMethod) return; // skip mocking methods\n                    obj[name] = mockType(prop, comp, stack);\n                });\n                return obj;\n            }\n        }\n        case ReflectionKind.class:\n            return _mockClass(runType, comp, stack);\n        case ReflectionKind.union: {\n            const rt = runType as UnionRunType;\n            if (mOps.unionIndex && (mOps.unionIndex < 0 || mOps.unionIndex >= rt.getChildRunTypes().length)) {\n                throw new Error(\n                    'unionIndex must be between 0 and the number of types in the union.' + printStackTrace(comp, stack)\n                );\n            }\n            const index = mOps?.unionIndex ?? random(0, rt.getChildRunTypes().length - 1);\n            return mockType(rt.getChildRunTypes()[index], comp, stack);\n        }\n\n        case ReflectionKind.function:\n        case ReflectionKind.callSignature:\n        case ReflectionKind.method:\n        case ReflectionKind.methodSignature:\n            if (runType.src.subKind === ReflectionSubKind.params) {\n                const rt = runType as FunctionParamsRunType;\n                const options = mOps.tupleOptions;\n                const params = rt.getParamRunTypes(comp).map((p, i) => mockType(p, getChildOpts(comp, options?.[i]), stack));\n                if (rt.hasRestParameter(comp)) {\n                    return [...params.slice(0, -1), ...params[params.length - 1]];\n                }\n                return params;\n            } else if (runType.src.kind === ReflectionKind.method || runType.src.kind === ReflectionKind.methodSignature) {\n                return undefined; // Skip methods silently\n            } else {\n                throw new Error('Mock is not allowed, call mockParams or mockReturn instead.' + printStackTrace(comp, stack));\n            }\n        case ReflectionKind.promise: {\n            const rt = runType as PromiseRunType;\n            const timeOut = mOps.promiseTimeOut || 1;\n            return new Promise((resolve, reject) => {\n                if (timeOut > 0) {\n                    setTimeout(() => {\n                        if (mOps.promiseReject) reject(mOps.promiseReject);\n                        else resolve(mockType(rt.getMemberType(), comp, stack));\n                    }, timeOut);\n                    return;\n                }\n                if (mOps.promiseReject) reject(mOps.promiseReject);\n                else resolve(mockType(rt.getMemberType(), comp, stack));\n            });\n        }\n        // Member types\n        case ReflectionKind.tupleMember:\n        case ReflectionKind.parameter: {\n            const rt = runType as ParameterRunType;\n            if (!rt.getJitChild(comp)) return undefined; // non serializable types are set to undefined\n            if (rt.isOptional() && !rt.isRest()) {\n                const probability = mOps.optionalProbability;\n                if (probability < 0 || probability > 1)\n                    throw new Error('optionalProbability must be between 0 and 1' + printStackTrace(comp, stack));\n                if (Math.random() > probability) {\n                    return undefined;\n                }\n            }\n            return mockType(rt.getMemberType(), comp, stack);\n        }\n        case ReflectionKind.propertySignature:\n        case ReflectionKind.property: {\n            const rt = runType as PropertyRunType;\n            const probability = mOps.optionalPropertyProbability?.[rt.getChildVarName(comp)] ?? mOps.optionalProbability;\n            if (probability < 0 || probability > 1)\n                throw new Error('optionalProbability must be between 0 and 1' + printStackTrace(comp, stack));\n            if (rt.src.optional && Math.random() > probability) return undefined;\n            return mockType(rt.getMemberType(), comp, stack);\n        }\n\n        case ReflectionKind.rest: {\n            const rt = runType as RestParamsRunType;\n            const length = random(0, mOps.maxRandomItemsLength);\n            const items: any[] = [];\n            for (let i = 0; i < length; i++) {\n                items.push(mockType(rt.getMemberType(), comp, stack));\n            }\n            return items;\n        }\n        case ReflectionKind.indexSignature: {\n            const rt = runType as IndexSignatureRunType;\n            const length = random(0, mOps.maxRandomItemsLength);\n            const parentObj = mOps.parentObj || {};\n            for (let i = 0; i < length; i++) {\n                let propName: number | string | symbol;\n                switch (true) {\n                    case !!(rt.src.index.kind === ReflectionKind.number):\n                        propName = i;\n                        break;\n                    case !!(rt.src.index.kind === ReflectionKind.string):\n                        propName = `key${i}`;\n                        break;\n                    case !!(rt.src.index.kind === ReflectionKind.symbol):\n                        propName = Symbol.for(`key${i}`);\n                        break;\n                    default:\n                        throw new Error('Invalid index signature type.');\n                }\n                parentObj[propName] = mockType(rt.getMemberType(), comp, stack);\n            }\n            return parentObj;\n        }\n\n        case ReflectionKind.infer:\n        case ReflectionKind.templateLiteral:\n        case ReflectionKind.typeParameter:\n        default:\n            throw new Error(`Cant mock Unsupported RunType: ${runType.getTypeName()}` + printStackTrace(comp, stack));\n    }\n}\n\nfunction _mockClass(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[]) {\n    const mOps = comp.opts.mock as MockOptions;\n    switch (runType.src.subKind) {\n        case ReflectionSubKind.date:\n            return mockDate(mOps.minDate, mOps.maxDate);\n        case ReflectionSubKind.map: {\n            const rt = runType as MapRunType;\n            const mockMap = new Map();\n            const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);\n            for (let i = 0; i < length; i++) {\n                const keyType = mockType(rt.keyRT, comp, stack);\n                const valueType = mockType(rt.valueRT, comp, stack);\n                mockMap.set(keyType, valueType);\n            }\n            return mockMap;\n        }\n        case ReflectionSubKind.set: {\n            const rt = runType as SetRunType;\n            const mockSet = new Set();\n            const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);\n            for (let i = 0; i < length; i++) {\n                const value = mockType(rt.keyRT, comp, stack);\n                mockSet.add(value);\n            }\n            return mockSet;\n        }\n        case ReflectionSubKind.nonSerializable:\n            throw new Error(`Mock is disabled for Non Serializable types.` + printStackTrace(comp, stack));\n        default: {\n            if (!(runType instanceof ClassRunType)) {\n                throw new Error(`Cant mock Unsupported RunType: ${runType.getTypeName()}` + printStackTrace(comp, stack));\n            }\n            const rt = runType as ClassRunType;\n            const isSerializable = rt.isClassWithEmptyConstructor();\n            const deserializeFn = getJitUtils().getDeserializeFn(rt.getClassName());\n            if (!deserializeFn && !isSerializable) {\n                throw new Error(\n                    `Class ${rt.getClassName()} can not be mocked. Be sure to register a deserialize function first with jiUtils.${getJitUtils().setDeserializeFn.name}` +\n                        printStackTrace(comp, stack)\n                );\n            }\n            const instance = deserializeFn ? {} : new rt.src.classType();\n            // only properties that are used in jit operations are mocked, there properties should be initialized in the constructor\n            rt.getJitChildren(comp).forEach((prop) => {\n                const name = (prop as PropertyRunType).getChildVarName(comp);\n                if (prop instanceof IndexSignatureRunType) mockType(prop, comp, stack);\n                const mocked = mockType(prop, comp, stack);\n                if ((prop as PropertyRunType).src.optional && mocked === undefined) return;\n                instance[name] = mockType(prop, comp, stack);\n            });\n            if (deserializeFn) return deserializeFn(instance);\n            if (isSerializable) return instance;\n            throw new Error(`Class ${rt.getClassName()} can not be mocked.` + printStackTrace(comp, stack));\n        }\n    }\n}\n\nfunction getChildOpts(comp: JitFnCompiler, mockOpts?: MockOptions): JitFnCompiler {\n    if (!mockOpts) return comp;\n    const newOpts = {...comp.opts, mock: mockOpts};\n    return new MockJitCompiler(comp.rootType, newOpts, comp, comp.jitFnHash, comp.typeID);\n}\n\nfunction printStackTrace(comp: JitFnCompiler, stack: BaseRunType[]) {\n    const separator = '.';\n    return JIT_STACK_TRACE_MESSAGE + stack.map((rt) => comp.getTypeTraceInfo(rt)).join(separator);\n}\n"],"names":["newProv"],"mappings":"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"}

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

@@ -1,16 +0,0 @@
-export declare function mockBoolean(): boolean;
-export declare function mockBigInt(min?: number, max?: number): bigint;
-export declare function mockString(length?: number, allowedChars?: string, disallowedChars?: string): string;
-export declare function mockSymbol(name?: string, length?: number, charsSet?: string): symbol;
-export declare function mockRegExp(list?: RegExp[]): RegExp;
-export declare function mockNumber(min?: number, max?: number): number;
-export declare function mockDate(minDate?: Date | number, maxDate?: Date | number): Date;
-export declare function mockAny(anyList?: (string | number | bigint | boolean | symbol | RegExp | (string | number)[] | Set<string | number> | Date | Map<string, number> | {
-    hello?: undefined;
-} | {
-    hello: string;
-} | null | undefined)[]): any;
-export declare function random(min?: number, max?: number): number;
-export declare function randomItem<T>(list: T[]): T;
-export declare function mockRecursiveEmptyArray(depth: number, length: number): any;
-//# sourceMappingURL=mockUtils.d.ts.map

package/.dist/esm/src/mocking/mockUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mockUtils.d.ts","sourceRoot":"","sources":["../../../../src/mocking/mockUtils.ts"],"names":[],"mappings":"AAUA,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED,wBAAgB,UAAU,CAAC,GAAG,SAAI,EAAE,GAAG,SAAQ,GAAG,MAAM,CAEvD;AAED,wBAAgB,UAAU,CAAC,MAAM,SAAgB,EAAE,YAAY,SAAgB,EAAE,eAAe,GAAE,MAAW,GAAG,MAAM,CASrH;AAED,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAGpF;AAED,wBAAgB,UAAU,CAAC,IAAI,WAAkB,GAAG,MAAM,CAEzD;AAQD,wBAAgB,UAAU,CAAC,GAAG,SAAI,EAAE,GAAG,SAAQ,GAAG,MAAM,CAKvD;AAOD,wBAAgB,QAAQ,CAAC,OAAO,GAAE,IAAI,GAAG,MAAoB,EAAE,OAAO,GAAE,IAAI,GAAG,MAAmB,GAAG,IAAI,CAOxG;AAED,wBAAgB,OAAO,CAAC,OAAO;;;;uBAAgB,GAAG,GAAG,CAEpD;AAGD,wBAAgB,MAAM,CAAC,GAAG,GAAE,MAAU,EAAE,GAAG,SAAQ,GAAG,MAAM,CAE3D;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,CAE1C;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,OAGpE"}

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

@@ -1,62 +0,0 @@
-import { mockRegExpsList, stringCharSet, anyValuesList } from "./constants.mock.js";
-function mockBoolean() {
-  return Math.random() < 0.5;
-}
-function mockBigInt(min = 0, max = 1e4) {
-  return BigInt(random(min, max));
-}
-function mockString(length = random(0, 30), allowedChars = stringCharSet, disallowedChars = "") {
-  if (allowedChars.length === 0) throw new Error("Can not generate random string as allowedChars cannot be empty");
-  const allowedCharSet = allowedChars.split("").filter((char) => !disallowedChars.includes(char)).join("");
-  if (allowedCharSet.length === 0)
-    throw new Error("Can not generate random string as allowedChars and disallowedChars are mutually exclusive");
-  return Array.from({ length }, () => allowedCharSet[random(0, allowedCharSet.length - 1)]).join("");
-}
-function mockSymbol(name, length, charsSet) {
-  const symbolName = name ?? mockString(length, charsSet);
-  return Symbol(symbolName);
-}
-function mockRegExp(list = mockRegExpsList) {
-  return list[random(0, list.length - 1)];
-}
-function mockNumber(min = 0, max = 1e4) {
-  if (min > max) {
-    throw new Error("min cannot be greater than max");
-  }
-  return random(min, max);
-}
-function mockDate(minDate = /* @__PURE__ */ new Date(0), maxDate = /* @__PURE__ */ new Date()) {
-  const min = typeof minDate === "number" ? minDate : minDate.getTime();
-  const max = typeof maxDate === "number" ? maxDate : maxDate.getTime();
-  if (min > max) {
-    throw new Error("minDate cannot be greater than maxDate");
-  }
-  return new Date(random(min, max));
-}
-function mockAny(anyList = anyValuesList) {
-  return anyList[random(0, anyList.length - 1)];
-}
-function random(min = 0, max = 1e4) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-function randomItem(list) {
-  return list[random(0, list.length - 1)];
-}
-function mockRecursiveEmptyArray(depth, length) {
-  if (depth === 0) return [];
-  return Array.from({ length }, () => mockRecursiveEmptyArray(depth - 1, length));
-}
-export {
-  mockAny,
-  mockBigInt,
-  mockBoolean,
-  mockDate,
-  mockNumber,
-  mockRecursiveEmptyArray,
-  mockRegExp,
-  mockString,
-  mockSymbol,
-  random,
-  randomItem
-};
-//# sourceMappingURL=mockUtils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mockUtils.js","sources":["../../../../src/mocking/mockUtils.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 {anyValuesList, stringCharSet} from './constants.mock.ts';\nimport {mockRegExpsList} from './constants.mock.ts';\n\nexport function mockBoolean(): boolean {\n    return Math.random() < 0.5;\n}\n\nexport function mockBigInt(min = 0, max = 10000): bigint {\n    return BigInt(random(min, max));\n}\n\nexport function mockString(length = random(0, 30), allowedChars = stringCharSet, disallowedChars: string = ''): string {\n    if (allowedChars.length === 0) throw new Error('Can not generate random string as allowedChars cannot be empty');\n    const allowedCharSet = allowedChars\n        .split('')\n        .filter((char) => !disallowedChars.includes(char))\n        .join('');\n    if (allowedCharSet.length === 0)\n        throw new Error('Can not generate random string as allowedChars and disallowedChars are mutually exclusive');\n    return Array.from({length}, () => allowedCharSet[random(0, allowedCharSet.length - 1)]).join('');\n}\n\nexport function mockSymbol(name?: string, length?: number, charsSet?: string): symbol {\n    const symbolName = name ?? mockString(length, charsSet);\n    return Symbol(symbolName);\n}\n\nexport function mockRegExp(list = mockRegExpsList): RegExp {\n    return list[random(0, list.length - 1)];\n}\n\n/**\n * Generates a random number between min and max, both inclusive.\n * @param min 0 by default\n * @param max 10000 by default\n * @returns random number\n */\nexport function mockNumber(min = 0, max = 10000): number {\n    if (min > max) {\n        throw new Error('min cannot be greater than max');\n    }\n    return random(min, max);\n}\n\n/**\n * Generates a random date between minDate and maxDate, both inclusive.\n * @param minDate 0 by default\n * @param maxDate Date.now() by default\n */\nexport function mockDate(minDate: Date | number = new Date(0), maxDate: Date | number = new Date()): Date {\n    const min = typeof minDate === 'number' ? minDate : minDate.getTime();\n    const max = typeof maxDate === 'number' ? maxDate : maxDate.getTime();\n    if (min > max) {\n        throw new Error('minDate cannot be greater than maxDate');\n    }\n    return new Date(random(min, max));\n}\n\nexport function mockAny(anyList = anyValuesList): any {\n    return anyList[random(0, anyList.length - 1)];\n}\n\n/** Generates a random number between min and max, both inclusive */\nexport function random(min: number = 0, max = 10000): number {\n    return Math.floor(Math.random() * (max - min + 1)) + min;\n}\n\nexport function randomItem<T>(list: T[]): T {\n    return list[random(0, list.length - 1)];\n}\n\nexport function mockRecursiveEmptyArray(depth: number, length: number) {\n    if (depth === 0) return [];\n    return Array.from({length}, () => mockRecursiveEmptyArray(depth - 1, length));\n}\n"],"names":[],"mappings":";AAUO,SAAS,cAAuB;AACnC,SAAO,KAAK,WAAW;AAC3B;AAEO,SAAS,WAAW,MAAM,GAAG,MAAM,KAAe;AACrD,SAAO,OAAO,OAAO,KAAK,GAAG,CAAC;AAClC;AAEO,SAAS,WAAW,SAAS,OAAO,GAAG,EAAE,GAAG,eAAe,eAAe,kBAA0B,IAAY;AACnH,MAAI,aAAa,WAAW,EAAG,OAAM,IAAI,MAAM,gEAAgE;AAC/G,QAAM,iBAAiB,aAClB,MAAM,EAAE,EACR,OAAO,CAAC,SAAS,CAAC,gBAAgB,SAAS,IAAI,CAAC,EAChD,KAAK,EAAE;AACZ,MAAI,eAAe,WAAW;AAC1B,UAAM,IAAI,MAAM,2FAA2F;AAC/G,SAAO,MAAM,KAAK,EAAC,OAAA,GAAS,MAAM,eAAe,OAAO,GAAG,eAAe,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE;AACnG;AAEO,SAAS,WAAW,MAAe,QAAiB,UAA2B;AAClF,QAAM,aAAa,QAAQ,WAAW,QAAQ,QAAQ;AACtD,SAAO,OAAO,UAAU;AAC5B;AAEO,SAAS,WAAW,OAAO,iBAAyB;AACvD,SAAO,KAAK,OAAO,GAAG,KAAK,SAAS,CAAC,CAAC;AAC1C;AAQO,SAAS,WAAW,MAAM,GAAG,MAAM,KAAe;AACrD,MAAI,MAAM,KAAK;AACX,UAAM,IAAI,MAAM,gCAAgC;AAAA,EACpD;AACA,SAAO,OAAO,KAAK,GAAG;AAC1B;AAOO,SAAS,SAAS,UAAyB,oBAAI,KAAK,CAAC,GAAG,UAAyB,oBAAI,QAAc;AACtG,QAAM,MAAM,OAAO,YAAY,WAAW,UAAU,QAAQ,QAAA;AAC5D,QAAM,MAAM,OAAO,YAAY,WAAW,UAAU,QAAQ,QAAA;AAC5D,MAAI,MAAM,KAAK;AACX,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC5D;AACA,SAAO,IAAI,KAAK,OAAO,KAAK,GAAG,CAAC;AACpC;AAEO,SAAS,QAAQ,UAAU,eAAoB;AAClD,SAAO,QAAQ,OAAO,GAAG,QAAQ,SAAS,CAAC,CAAC;AAChD;AAGO,SAAS,OAAO,MAAc,GAAG,MAAM,KAAe;AACzD,SAAO,KAAK,MAAM,KAAK,OAAA,KAAY,MAAM,MAAM,EAAE,IAAI;AACzD;AAEO,SAAS,WAAc,MAAc;AACxC,SAAO,KAAK,OAAO,GAAG,KAAK,SAAS,CAAC,CAAC;AAC1C;AAEO,SAAS,wBAAwB,OAAe,QAAgB;AACnE,MAAI,UAAU,EAAG,QAAO,CAAA;AACxB,SAAO,MAAM,KAAK,EAAC,OAAA,GAAS,MAAM,wBAAwB,QAAQ,GAAG,MAAM,CAAC;AAChF;"}

package/.dist/esm/src/nodes/atomic/any.d.ts

@@ -1,9 +0,0 @@
-import { TypeAny, TypeUnknown } from '@deepkit/type';
-import { AtomicRunType } from '../../lib/baseRunTypes.ts';
-import { JitCode } from '../../types.ts';
-import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
-export declare class AnyRunType extends AtomicRunType<TypeAny | TypeUnknown> {
-    emitIsType(comp: JitFnCompiler): JitCode;
-    emitTypeErrors(): JitCode;
-}
-//# sourceMappingURL=any.d.ts.map

package/.dist/esm/src/nodes/atomic/any.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"any.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/atomic/any.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,OAAO,EAAE,KAAK,WAAW,EAAC,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAEzD,qBAAa,UAAW,SAAQ,aAAa,CAAC,OAAO,GAAG,WAAW,CAAC;IAChE,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAKxC,cAAc,IAAI,OAAO;CAG5B"}

package/.dist/esm/src/nodes/atomic/any.js

@@ -1,18 +0,0 @@
-import { AtomicRunType } from "../../lib/baseRunTypes.js";
-import { JitFnCompiler } from "../../lib/jitFnCompiler.js";
-class AnyRunType extends AtomicRunType {
-  emitIsType(comp) {
-    const isRoot = comp.getNestLevel(this) === 0;
-    if (isRoot)
-      return { code: void 0, type: "E" };
-    return { code: "true", type: "E" };
-  }
-  emitTypeErrors() {
-    return { code: void 0, type: "S" };
-  }
-  static __type = ["TypeAny", "TypeUnknown", () => AtomicRunType, () => JitFnCompiler, "comp", "JitCode", "emitIsType", "emitTypeErrors", "AnyRunType", `PP"w!"w"J7#PP7$2%"w&0'P"w&0(5P"w!"w"J6"w)`];
-}
-export {
-  AnyRunType
-};
-//# sourceMappingURL=any.js.map

package/.dist/esm/src/nodes/atomic/any.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"any.js","sources":["../../../../../src/nodes/atomic/any.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type TypeAny, type TypeUnknown} from '@deepkit/type';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport type {JitCode} from '../../types.ts';\nimport {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\n\nexport class AnyRunType extends AtomicRunType<TypeAny | TypeUnknown> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const isRoot = comp.getNestLevel(this) === 0;\n        if (isRoot) return {code: undefined, type: 'E'};\n        return {code: 'true', type: 'E'};\n    }\n    emitTypeErrors(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n}\n"],"names":[],"mappings":";;AAYM,MAAO,mBAAmB,cAAoC;AAAA,EAChE,WAAW,MAAmB;AAC1B,UAAM,SAAS,KAAK,aAAa,IAAI,MAAM;AAC3C,QAAI;AAAQ,aAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAC3C,WAAO,EAAC,MAAM,QAAQ,MAAM,IAAA;AAAA,EAChC;AAAA,EACA,iBAAc;AACV,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA;;"}

package/.dist/esm/src/nodes/atomic/bigInt.d.ts

@@ -1,11 +0,0 @@
-import { TypeBigInt } from '@deepkit/type';
-import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
-import { JitCode } from '../../types.ts';
-import { AtomicRunType } from '../../lib/baseRunTypes.ts';
-export declare class BigIntRunType extends AtomicRunType<TypeBigInt> {
-    emitIsType(comp: JitFnCompiler): JitCode;
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
-    emitPrepareForJson(comp: JitFnCompiler): JitCode;
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
-}
-//# sourceMappingURL=bigInt.d.ts.map

package/.dist/esm/src/nodes/atomic/bigInt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bigInt.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/atomic/bigInt.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AACnF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAExD,qBAAa,aAAc,SAAQ,aAAa,CAAC,UAAU,CAAC;IACxD,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAGlD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGhD,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGpD"}

package/.dist/esm/src/nodes/atomic/bigInt.js

@@ -1,20 +0,0 @@
-import { AtomicRunType } from "../../lib/baseRunTypes.js";
-class BigIntRunType extends AtomicRunType {
-  emitIsType(comp) {
-    return { code: `typeof ${comp.vλl} === 'bigint'`, type: "E" };
-  }
-  emitTypeErrors(comp) {
-    return { code: `if (typeof ${comp.vλl} !== 'bigint') ${comp.callJitErr(this)}`, type: "S" };
-  }
-  emitPrepareForJson(comp) {
-    return { code: `${comp.vλl}.toString()`, type: "E" };
-  }
-  emitRestoreFromJson(comp) {
-    return { code: `BigInt(${comp.vλl})`, type: "E" };
-  }
-  static __type = ["TypeBigInt", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "BigIntRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(P"w#2$"w%0)P"w#2$"w%0*5"w!6"w+`];
-}
-export {
-  BigIntRunType
-};
-//# sourceMappingURL=bigInt.js.map

package/.dist/esm/src/nodes/atomic/bigInt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bigInt.js","sources":["../../../../../src/nodes/atomic/bigInt.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeBigInt} from '@deepkit/type';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {JitCode} from '../../types.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class BigIntRunType extends AtomicRunType<TypeBigInt> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `typeof ${comp.vλl} === 'bigint'`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (typeof ${comp.vλl} !== 'bigint') ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        return {code: `${comp.vλl}.toString()`, type: 'E'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {code: `BigInt(${comp.vλl})`, type: 'E'};\n    }\n}\n"],"names":[],"mappings":";AAYM,MAAO,sBAAsB,cAAyB;AAAA,EACxD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,iBAAiB,MAAM,IAAA;AAAA,EAC3D;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,cAAc,KAAK,GAAG,kBAAkB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACzF;AAAA,EACA,mBAAmB,MAAmB;AAClC,WAAO,EAAC,MAAM,GAAG,KAAK,GAAG,eAAe,MAAM,IAAA;AAAA,EAClD;AAAA,EACA,oBAAoB,MAAmB;AACnC,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,KAAK,MAAM,IAAA;AAAA,EAC/C;AAAA;;"}

package/.dist/esm/src/nodes/atomic/boolean.d.ts

@@ -1,11 +0,0 @@
-import { TypeBoolean } from '@deepkit/type';
-import { JitCode } from '../../types.ts';
-import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
-import { AtomicRunType } from '../../lib/baseRunTypes.ts';
-export declare class BooleanRunType extends AtomicRunType<TypeBoolean> {
-    emitIsType(comp: JitFnCompiler): JitCode;
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
-    emitPrepareForJson(): JitCode;
-    emitRestoreFromJson(): JitCode;
-}
-//# sourceMappingURL=boolean.d.ts.map

package/.dist/esm/src/nodes/atomic/boolean.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/atomic/boolean.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AACnF,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAExD,qBAAa,cAAe,SAAQ,aAAa,CAAC,WAAW,CAAC;IAC1D,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAGlD,kBAAkB,IAAI,OAAO;IAG7B,mBAAmB,IAAI,OAAO;CAGjC"}

package/.dist/esm/src/nodes/atomic/boolean.js

@@ -1,20 +0,0 @@
-import { AtomicRunType } from "../../lib/baseRunTypes.js";
-class BooleanRunType extends AtomicRunType {
-  emitIsType(comp) {
-    return { code: `typeof ${comp.vλl} === 'boolean'`, type: "E" };
-  }
-  emitTypeErrors(comp) {
-    return { code: `if (typeof ${comp.vλl} !== 'boolean') ${comp.callJitErr(this)}`, type: "S" };
-  }
-  emitPrepareForJson() {
-    return { code: void 0, type: "S" };
-  }
-  emitRestoreFromJson() {
-    return { code: void 0, type: "S" };
-  }
-  static __type = ["TypeBoolean", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "BooleanRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(P"w%0)P"w%0*5"w!6"w+`];
-}
-export {
-  BooleanRunType
-};
-//# sourceMappingURL=boolean.js.map

package/.dist/esm/src/nodes/atomic/boolean.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean.js","sources":["../../../../../src/nodes/atomic/boolean.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeBoolean} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class BooleanRunType extends AtomicRunType<TypeBoolean> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `typeof ${comp.vλl} === 'boolean'`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (typeof ${comp.vλl} !== 'boolean') ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n    emitRestoreFromJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n}\n"],"names":[],"mappings":";AAYM,MAAO,uBAAuB,cAA0B;AAAA,EAC1D,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,kBAAkB,MAAM,IAAA;AAAA,EAC5D;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,cAAc,KAAK,GAAG,mBAAmB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EAC1F;AAAA,EACA,qBAAkB;AACd,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA,EACA,sBAAmB;AACf,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA;;"}

package/.dist/esm/src/nodes/atomic/date.d.ts

@@ -1,11 +0,0 @@
-import { TypeClass } from '@deepkit/type';
-import { JitCode } from '../../types.ts';
-import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
-import { AtomicRunType } from '../../lib/baseRunTypes.ts';
-export declare class DateRunType extends AtomicRunType<TypeClass> {
-    emitIsType(comp: JitFnCompiler): JitCode;
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
-    emitPrepareForJson(): JitCode;
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
-}
-//# sourceMappingURL=date.d.ts.map

package/.dist/esm/src/nodes/atomic/date.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/atomic/date.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,SAAS,EAAC,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AACnF,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAExD,qBAAa,WAAY,SAAQ,aAAa,CAAC,SAAS,CAAC;IACrD,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAGlD,kBAAkB,IAAI,OAAO;IAG7B,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGpD"}

package/.dist/esm/src/nodes/atomic/date.js

@@ -1,20 +0,0 @@
-import { AtomicRunType } from "../../lib/baseRunTypes.js";
-class DateRunType extends AtomicRunType {
-  emitIsType(comp) {
-    return { code: `(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))`, type: "E" };
-  }
-  emitTypeErrors(comp) {
-    return { code: `if (!(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))) ${comp.callJitErr(this)}`, type: "S" };
-  }
-  emitPrepareForJson() {
-    return { code: void 0, type: "S" };
-  }
-  emitRestoreFromJson(comp) {
-    return { code: `new Date(${comp.vλl})`, type: "E" };
-  }
-  static __type = ["TypeClass", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "DateRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(P"w%0)P"w#2$"w%0*5"w!6"w+`];
-}
-export {
-  DateRunType
-};
-//# sourceMappingURL=date.js.map

package/.dist/esm/src/nodes/atomic/date.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"date.js","sources":["../../../../../src/nodes/atomic/date.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type TypeClass} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class DateRunType extends AtomicRunType<TypeClass> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (!(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))) ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {code: `new Date(${comp.vλl})`, type: 'E'};\n    }\n}\n"],"names":[],"mappings":";AAYM,MAAO,oBAAoB,cAAwB;AAAA,EACrD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,IAAI,KAAK,GAAG,8BAA8B,KAAK,GAAG,gBAAgB,MAAM,IAAA;AAAA,EAC1F;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,SAAS,KAAK,GAAG,8BAA8B,KAAK,GAAG,iBAAiB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACzH;AAAA,EACA,qBAAkB;AACd,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA,EACA,oBAAoB,MAAmB;AACnC,WAAO,EAAC,MAAM,YAAY,KAAK,GAAG,KAAK,MAAM,IAAA;AAAA,EACjD;AAAA;;"}