@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/src/mocking/mockType.cjs

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_mocking_mockUtils = require("./mockUtils.cjs");
+const src_mocking_constants_mock = require("./constants.mock.cjs");
+const src_nodes_collection_class = require("../nodes/collection/class.cjs");
+const src_constants_kind = require("../constants.kind.cjs");
+const src_nodes_native_nonSerializable = require("../nodes/native/nonSerializable.cjs");
+const src_nodes_member_indexProperty = require("../nodes/member/indexProperty.cjs");
+const src_lib_formats = require("../lib/formats.cjs");
+const src_constants = require("../constants.cjs");
+const src_constants_functions = require("../constants.functions.cjs");
+const core = require("@mionjs/core");
+const src_lib_jitFnCompiler = require("../lib/jitFnCompiler.cjs");
+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 = src_lib_formats.getRunTypeFormat(runType);
+  let mocked = typeValidator ? typeValidator.mock(updatedOps, runType) : _mockType(runType, comp, stack);
+  comp.opts = rtOpts;
+  const typeTransformer = src_lib_formats.getRunTypeTransformer(runType);
+  if (typeTransformer) {
+    const compiledFormatter = runType.createJitCompiledFunction(src_constants_functions.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 type.ReflectionKind.never:
+      throw new Error("Cannot mock never type." + printStackTrace(comp, stack));
+    case type.ReflectionKind.any:
+    case type.ReflectionKind.unknown:
+      return src_mocking_mockUtils.mockAny(mOps.anyValuesList);
+    // Atomic types
+    case type.ReflectionKind.string:
+      return src_mocking_mockUtils.mockString(mOps.stringLength || src_mocking_mockUtils.random(1, mOps.maxRandomStringLength), mOps.stringCharSet || src_mocking_constants_mock.stringCharSet);
+    case type.ReflectionKind.number:
+      return src_mocking_mockUtils.mockNumber(mOps.minNumber, mOps.maxNumber);
+    case type.ReflectionKind.boolean:
+      return src_mocking_mockUtils.mockBoolean();
+    case type.ReflectionKind.bigint:
+      return src_mocking_mockUtils.mockBigInt(mOps.minNumber, mOps.maxNumber);
+    case type.ReflectionKind.null:
+      return null;
+    case type.ReflectionKind.undefined:
+      return void 0;
+    case type.ReflectionKind.void:
+      return void 0;
+    case type.ReflectionKind.regexp:
+      return src_mocking_mockUtils.mockRegExp(mOps.regexpList);
+    case type.ReflectionKind.symbol:
+      return src_mocking_mockUtils.mockSymbol(mOps.symbolName, mOps.symbolLength, mOps.symbolCharSet);
+    case type.ReflectionKind.literal:
+      return src.literal;
+    case type.ReflectionKind.object:
+      return mOps.objectList[src_mocking_mockUtils.random(0, mOps.objectList.length - 1)];
+    case type.ReflectionKind.enum: {
+      const rt = runType;
+      const i = mOps.enumIndex || src_mocking_mockUtils.random(0, rt.src.values.length - 1);
+      return rt.src.values[i];
+    }
+    case type.ReflectionKind.enumMember:
+      throw new Error("Mock enum member is not supported." + printStackTrace(comp, stack));
+    // Collection types
+    case type.ReflectionKind.array: {
+      const rt = runType;
+      const length = mOps.arrayLength ?? src_mocking_mockUtils.random(0, mOps.maxRandomItemsLength);
+      if (length === 0) return [];
+      return Array.from({ length }, () => mockType(rt.getMemberType(), comp, stack));
+    }
+    case type.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 type.ReflectionKind.intersection:
+    case type.ReflectionKind.objectLiteral: {
+      if (runType instanceof src_nodes_native_nonSerializable.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 src_nodes_member_indexProperty.IndexSignatureRunType) {
+            obj = { ...obj, ...mockType(prop, comp, stack) };
+            return;
+          }
+          const name = prop.getChildVarName(comp);
+          const isMethod = prop.src.kind === type.ReflectionKind.method || prop.src.kind === type.ReflectionKind.methodSignature;
+          if (isMethod) return;
+          obj[name] = mockType(prop, comp, stack);
+        });
+        return obj;
+      }
+    }
+    case type.ReflectionKind.class:
+      return _mockClass(runType, comp, stack);
+    case type.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 ?? src_mocking_mockUtils.random(0, rt.getChildRunTypes().length - 1);
+      return mockType(rt.getChildRunTypes()[index], comp, stack);
+    }
+    case type.ReflectionKind.function:
+    case type.ReflectionKind.callSignature:
+    case type.ReflectionKind.method:
+    case type.ReflectionKind.methodSignature:
+      if (runType.src.subKind === src_constants_kind.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 === type.ReflectionKind.method || runType.src.kind === type.ReflectionKind.methodSignature) {
+        return void 0;
+      } else {
+        throw new Error("Mock is not allowed, call mockParams or mockReturn instead." + printStackTrace(comp, stack));
+      }
+    case type.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 type.ReflectionKind.tupleMember:
+    case type.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 type.ReflectionKind.propertySignature:
+    case type.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 type.ReflectionKind.rest: {
+      const rt = runType;
+      const length = src_mocking_mockUtils.random(0, mOps.maxRandomItemsLength);
+      const items = [];
+      for (let i = 0; i < length; i++) {
+        items.push(mockType(rt.getMemberType(), comp, stack));
+      }
+      return items;
+    }
+    case type.ReflectionKind.indexSignature: {
+      const rt = runType;
+      const length = src_mocking_mockUtils.random(0, mOps.maxRandomItemsLength);
+      const parentObj = mOps.parentObj || {};
+      for (let i = 0; i < length; i++) {
+        let propName;
+        switch (true) {
+          case !!(rt.src.index.kind === type.ReflectionKind.number):
+            propName = i;
+            break;
+          case !!(rt.src.index.kind === type.ReflectionKind.string):
+            propName = `key${i}`;
+            break;
+          case !!(rt.src.index.kind === type.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 type.ReflectionKind.infer:
+    case type.ReflectionKind.templateLiteral:
+    case type.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 src_constants_kind.ReflectionSubKind.date:
+      return src_mocking_mockUtils.mockDate(mOps.minDate, mOps.maxDate);
+    case src_constants_kind.ReflectionSubKind.map: {
+      const rt = runType;
+      const mockMap = /* @__PURE__ */ new Map();
+      const length = mOps.arrayLength ?? src_mocking_mockUtils.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 src_constants_kind.ReflectionSubKind.set: {
+      const rt = runType;
+      const mockSet = /* @__PURE__ */ new Set();
+      const length = mOps.arrayLength ?? src_mocking_mockUtils.random(0, mOps.maxRandomItemsLength);
+      for (let i = 0; i < length; i++) {
+        const value = mockType(rt.keyRT, comp, stack);
+        mockSet.add(value);
+      }
+      return mockSet;
+    }
+    case src_constants_kind.ReflectionSubKind.nonSerializable:
+      throw new Error(`Mock is disabled for Non Serializable types.` + printStackTrace(comp, stack));
+    default: {
+      if (!(runType instanceof src_nodes_collection_class.ClassRunType)) {
+        throw new Error(`Cant mock Unsupported RunType: ${runType.getTypeName()}` + printStackTrace(comp, stack));
+      }
+      const rt = runType;
+      const isSerializable = rt.isClassWithEmptyConstructor();
+      const deserializeFn = core.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.${core.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 src_nodes_member_indexProperty.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 src_lib_jitFnCompiler.MockJitCompiler(comp.rootType, newOpts, comp, comp.jitFnHash, comp.typeID);
+}
+function printStackTrace(comp, stack) {
+  const separator = ".";
+  return src_constants.JIT_STACK_TRACE_MESSAGE + stack.map((rt) => comp.getTypeTraceInfo(rt)).join(separator);
+}
+exports.mockType = mockType;
+//# sourceMappingURL=mockType.cjs.map

package/.dist/cjs/src/mocking/mockType.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockType.cjs","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":["getRunTypeFormat","getRunTypeTransformer","JitFunctions","newProv","ReflectionKind","mockAny","mockString","random","stringCharSet","mockNumber","mockBoolean","mockBigInt","mockRegExp","mockSymbol","NonSerializableRunType","IndexSignatureRunType","ReflectionSubKind","mockDate","ClassRunType","getJitUtils","MockJitCompiler","JIT_STACK_TRACE_MESSAGE"],"mappings":"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"}

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

package/.dist/cjs/src/mocking/mockUtils.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_mocking_constants_mock = require("./constants.mock.cjs");
+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 = src_mocking_constants_mock.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 = src_mocking_constants_mock.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 = src_mocking_constants_mock.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));
+}
+exports.mockAny = mockAny;
+exports.mockBigInt = mockBigInt;
+exports.mockBoolean = mockBoolean;
+exports.mockDate = mockDate;
+exports.mockNumber = mockNumber;
+exports.mockRecursiveEmptyArray = mockRecursiveEmptyArray;
+exports.mockRegExp = mockRegExp;
+exports.mockString = mockString;
+exports.mockSymbol = mockSymbol;
+exports.random = random;
+exports.randomItem = randomItem;
+//# sourceMappingURL=mockUtils.cjs.map

package/.dist/cjs/src/mocking/mockUtils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockUtils.cjs","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":["stringCharSet","mockRegExpsList","anyValuesList"],"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,eAAeA,2BAAAA,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,OAAOC,4CAAyB;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,UAAUC,0CAAoB;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/cjs/src/mocking/mockUtils.d.ts

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

package/.dist/cjs/src/nodes/atomic/any.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_lib_jitFnCompiler = require("../../lib/jitFnCompiler.cjs");
+class AnyRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.AtomicRunType, () => src_lib_jitFnCompiler.JitFnCompiler, "comp", "JitCode", "emitIsType", "emitTypeErrors", "AnyRunType", `PP"w!"w"J7#PP7$2%"w&0'P"w&0(5P"w!"w"J6"w)`];
+}
+exports.AnyRunType = AnyRunType;
+//# sourceMappingURL=any.cjs.map

package/.dist/cjs/src/nodes/atomic/any.cjs.map

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

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

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

package/.dist/cjs/src/nodes/atomic/bigInt.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class BigIntRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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+`];
+}
+exports.BigIntRunType = BigIntRunType;
+//# sourceMappingURL=bigInt.cjs.map

package/.dist/cjs/src/nodes/atomic/bigInt.cjs.map

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

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

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

package/.dist/cjs/src/nodes/atomic/boolean.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class BooleanRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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+`];
+}
+exports.BooleanRunType = BooleanRunType;
+//# sourceMappingURL=boolean.cjs.map

package/.dist/cjs/src/nodes/atomic/boolean.cjs.map

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

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

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

package/.dist/cjs/src/nodes/atomic/date.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class DateRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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+`];
+}
+exports.DateRunType = DateRunType;
+//# sourceMappingURL=date.cjs.map

package/.dist/cjs/src/nodes/atomic/date.cjs.map

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

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

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

package/.dist/cjs/src/nodes/atomic/enum.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_lib_utils = require("../../lib/utils.cjs");
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class EnumRunType extends src_lib_baseRunTypes.AtomicRunType {
+  emitIsType(comp) {
+    const items = this.src.values.map(__assignType((v) => `${comp.vλl} === ${src_lib_utils.toLiteral(v)}`, ["v", "", 'P"2!"/"']));
+    return { code: `(${items.join(" || ")})`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    const items = this.src.values.map(__assignType((v) => `${comp.vλl} === ${src_lib_utils.toLiteral(v)}`, ["v", "", 'P"2!"/"']));
+    return { code: `if (!(${items.join(" || ")})) ${comp.callJitErr(this)}`, type: "S" };
+  }
+  static __type = [() => type.__ΩTypeEnum, () => src_lib_baseRunTypes.AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", () => type.__ΩTypeEnum, "EnumRunType", `Pn!7"P"w#2$"w%0&P"w'2$"w%0(5n)6"w*`];
+}
+exports.EnumRunType = EnumRunType;
+//# sourceMappingURL=enum.cjs.map

package/.dist/cjs/src/nodes/atomic/enum.cjs.map

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