@mionjs/run-types 0.8.8 → 0.13.0

package/src/mocking/constants.mock.ts

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

package/src/mocking/mockRegistry.ts

@@ -1,20 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {JitFnCompiler} from '../lib/jitFnCompiler.ts';
-
-// TODO, as mock could return results async with mock promises
-// we might need an unique JitCompiler, for each mock to avoid problems with the stack
-const mockCompCache = new Map<string, JitFnCompiler>();
-
-export function getMockCompiler(fnHash: string): JitFnCompiler {
-    return mockCompCache.get(fnHash)!;
-}
-
-export function setMockCompiler(fnHash: string, comp: JitFnCompiler): void {
-    mockCompCache.set(fnHash, comp);
-}

package/src/mocking/mockType.ts

@@ -1,354 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {ReflectionKind} from '@deepkit/type';
-import type {MockOptions, Mutable, RunTypeOptions} from '../types.ts';
-import type {BaseRunType} from '../lib/baseRunTypes.ts';
-import {mockString, mockNumber, mockBoolean, mockBigInt, mockDate, random, mockRegExp, mockSymbol, mockAny} from './mockUtils.ts';
-import {stringCharSet} from './constants.mock.ts';
-import {ClassRunType} from '../nodes/collection/class.ts';
-import type {PropertyRunType} from '../nodes/member/property.ts';
-import type {MapRunType} from '../nodes/native/map.ts';
-import type {SetRunType} from '../nodes/native/set.ts';
-import type {InterfaceRunType} from '../nodes/collection/interface.ts';
-import type {TupleRunType} from '../nodes/collection/tuple.ts';
-import type {FunctionParamsRunType} from '../nodes/collection/functionParams.ts';
-import type {UnionRunType} from '../nodes/collection/union.ts';
-import type {EnumRunType} from '../nodes/atomic/enum.ts';
-import type {PromiseRunType} from '../nodes/native/promise.ts';
-import type {ParameterRunType} from '../nodes/member/param.ts';
-import type {RestParamsRunType} from '../nodes/member/restParams.ts';
-import {ReflectionSubKind} from '../constants.kind.ts';
-import {NonSerializableRunType} from '../nodes/native/nonSerializable.ts';
-import {IndexSignatureRunType} from '../nodes/member/indexProperty.ts';
-import {getRunTypeFormat, getRunTypeTransformer} from '../lib/formats.ts';
-import {JIT_STACK_TRACE_MESSAGE} from '../constants.ts';
-import {JitFunctions} from '../constants.functions.ts';
-import type {ArrayRunType} from '../nodes/member/array.ts';
-import {getJitUtils} from '@mionjs/core';
-import {MockJitCompiler, type JitFnCompiler} from '../lib/jitFnCompiler.ts';
-
-export function mockType(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[] = []): any {
-    // TODO: we could use JitCompiler functionality here to controls the stack etc
-    stack.push(runType);
-    const mockNestLevel = stack.filter((rt) => rt === runType).length;
-    const rtOpts = comp.opts;
-    const updatedOps = mockNestLevel ? getMockOptionsForNestedElements(rtOpts, mockNestLevel) : comp.opts;
-    (comp as Mutable<JitFnCompiler>).opts = updatedOps;
-    // Just one type validator allowed per type, and is responsible to mock the value,
-    // ie: email and uuid should contain the logic to generate a valid value
-    const typeValidator = getRunTypeFormat(runType);
-    let mocked = typeValidator ? typeValidator.mock(updatedOps, runType) : _mockType(runType, comp, stack);
-    (comp as Mutable<JitFnCompiler>).opts = rtOpts;
-    // once mocked multiple type transformers can be applied to the mocked value
-    const typeTransformer = getRunTypeTransformer(runType);
-    if (typeTransformer) {
-        const compiledFormatter = runType.createJitCompiledFunction(JitFunctions.format.id);
-        mocked = compiledFormatter.isNoop ? mocked : compiledFormatter.fn(mocked);
-    }
-    stack.pop();
-    return mocked;
-}
-
-// reduces all probabilities within the MockOptions to prevent infinite loops
-// each time mocking is a level deeper, the probabilities to generate an optional property should be reduced
-// this does not prevent infinite loops on types with circular references that are non optional,
-// 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
-function getMockOptionsForNestedElements(opts: RunTypeOptions, nestLevel: number): RunTypeOptions {
-    const mOps = opts.mock as MockOptions;
-    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);
-    // console.log(`divisor: ${divisor} | newMaxLength: ${newMaxLength} | newProv: ${newProv}`);
-    const ret = {
-        mock: {
-            ...mOps,
-            optionalProbability: newProv,
-            maxRandomItemsLength: newMaxLength,
-        },
-    } satisfies RunTypeOptions;
-    if (optionalPropertyProbability) {
-        const entries = Object.entries(optionalPropertyProbability).map(([key, value]) => {
-            const newProv = nestLevel > maxDepth ? 0 : value / divisor;
-            return [key, value / newProv];
-        });
-        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 = {}; // prevents mocking objects with circular references
-    return ret;
-}
-
-/**
- * Centralized mock function with a giant switch statement that handles all node types.
- * This function is similar to createRunType in runType.ts but for mocking.
- */
-function _mockType(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[]): any {
-    // Handle circular references
-    const mOps = comp.opts.mock as MockOptions;
-    const recursionLevel = stack.filter((rt) => rt === runType).length;
-    const src = runType.src;
-    const kind = src.kind;
-    if (recursionLevel > mOps.maxMockRecursion) return undefined;
-
-    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 undefined;
-        case ReflectionKind.void:
-            return undefined;
-        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 as EnumRunType;
-            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 as ArrayRunType;
-            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 as TupleRunType;
-            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 as InterfaceRunType;
-                if (rt.isCallable()) return mockType(rt.getCallSignature()!, comp, stack);
-                let obj: Record<string | number, any> = mOps.parentObj || {};
-                rt.getChildRunTypes().forEach((prop) => {
-                    if (prop instanceof IndexSignatureRunType) {
-                        obj = {...obj, ...mockType(prop, comp, stack)};
-                        return;
-                    }
-                    const name = (prop as PropertyRunType).getChildVarName(comp);
-                    const isMethod = prop.src.kind === ReflectionKind.method || prop.src.kind === ReflectionKind.methodSignature;
-                    if (isMethod) return; // skip mocking methods
-                    obj[name] = mockType(prop, comp, stack);
-                });
-                return obj;
-            }
-        }
-        case ReflectionKind.class:
-            return _mockClass(runType, comp, stack);
-        case ReflectionKind.union: {
-            const rt = runType as UnionRunType;
-            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 as FunctionParamsRunType;
-                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 undefined; // Skip methods silently
-            } else {
-                throw new Error('Mock is not allowed, call mockParams or mockReturn instead.' + printStackTrace(comp, stack));
-            }
-        case ReflectionKind.promise: {
-            const rt = runType as PromiseRunType;
-            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 as ParameterRunType;
-            if (!rt.getJitChild(comp)) return undefined; // non serializable types are set to undefined
-            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 undefined;
-                }
-            }
-            return mockType(rt.getMemberType(), comp, stack);
-        }
-        case ReflectionKind.propertySignature:
-        case ReflectionKind.property: {
-            const rt = runType as PropertyRunType;
-            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 undefined;
-            return mockType(rt.getMemberType(), comp, stack);
-        }
-
-        case ReflectionKind.rest: {
-            const rt = runType as RestParamsRunType;
-            const length = random(0, mOps.maxRandomItemsLength);
-            const items: any[] = [];
-            for (let i = 0; i < length; i++) {
-                items.push(mockType(rt.getMemberType(), comp, stack));
-            }
-            return items;
-        }
-        case ReflectionKind.indexSignature: {
-            const rt = runType as IndexSignatureRunType;
-            const length = random(0, mOps.maxRandomItemsLength);
-            const parentObj = mOps.parentObj || {};
-            for (let i = 0; i < length; i++) {
-                let propName: number | string | symbol;
-                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 = 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: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[]) {
-    const mOps = comp.opts.mock as MockOptions;
-    switch (runType.src.subKind) {
-        case ReflectionSubKind.date:
-            return mockDate(mOps.minDate, mOps.maxDate);
-        case ReflectionSubKind.map: {
-            const rt = runType as MapRunType;
-            const mockMap = 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 as SetRunType;
-            const mockSet = 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 as ClassRunType;
-            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();
-            // only properties that are used in jit operations are mocked, there properties should be initialized in the constructor
-            rt.getJitChildren(comp).forEach((prop) => {
-                const name = (prop as PropertyRunType).getChildVarName(comp);
-                if (prop instanceof IndexSignatureRunType) mockType(prop, comp, stack);
-                const mocked = mockType(prop, comp, stack);
-                if ((prop as PropertyRunType).src.optional && mocked === undefined) 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: JitFnCompiler, mockOpts?: MockOptions): JitFnCompiler {
-    if (!mockOpts) return comp;
-    const newOpts = {...comp.opts, mock: mockOpts};
-    return new MockJitCompiler(comp.rootType, newOpts, comp, comp.jitFnHash, comp.typeID);
-}
-
-function printStackTrace(comp: JitFnCompiler, stack: BaseRunType[]) {
-    const separator = '.';
-    return JIT_STACK_TRACE_MESSAGE + stack.map((rt) => comp.getTypeTraceInfo(rt)).join(separator);
-}

package/src/mocking/mockUtils.ts

@@ -1,82 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {anyValuesList, stringCharSet} from './constants.mock.ts';
-import {mockRegExpsList} from './constants.mock.ts';
-
-export function mockBoolean(): boolean {
-    return Math.random() < 0.5;
-}
-
-export function mockBigInt(min = 0, max = 10000): bigint {
-    return BigInt(random(min, max));
-}
-
-export function mockString(length = random(0, 30), allowedChars = stringCharSet, disallowedChars: string = ''): string {
-    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('');
-}
-
-export function mockSymbol(name?: string, length?: number, charsSet?: string): symbol {
-    const symbolName = name ?? mockString(length, charsSet);
-    return Symbol(symbolName);
-}
-
-export function mockRegExp(list = mockRegExpsList): RegExp {
-    return list[random(0, list.length - 1)];
-}
-
-/**
- * Generates a random number between min and max, both inclusive.
- * @param min 0 by default
- * @param max 10000 by default
- * @returns random number
- */
-export function mockNumber(min = 0, max = 10000): number {
-    if (min > max) {
-        throw new Error('min cannot be greater than max');
-    }
-    return random(min, max);
-}
-
-/**
- * Generates a random date between minDate and maxDate, both inclusive.
- * @param minDate 0 by default
- * @param maxDate Date.now() by default
- */
-export function mockDate(minDate: Date | number = new Date(0), maxDate: Date | number = new Date()): 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));
-}
-
-export function mockAny(anyList = anyValuesList): any {
-    return anyList[random(0, anyList.length - 1)];
-}
-
-/** Generates a random number between min and max, both inclusive */
-export function random(min: number = 0, max = 10000): number {
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-export function randomItem<T>(list: T[]): T {
-    return list[random(0, list.length - 1)];
-}
-
-export function mockRecursiveEmptyArray(depth: number, length: number) {
-    if (depth === 0) return [];
-    return Array.from({length}, () => mockRecursiveEmptyArray(depth - 1, length));
-}

package/src/nodes/atomic/any.ts

@@ -1,22 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {type TypeAny, type TypeUnknown} from '@deepkit/type';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import type {JitCode} from '../../types.ts';
-import {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
-
-export class AnyRunType extends AtomicRunType<TypeAny | TypeUnknown> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const isRoot = comp.getNestLevel(this) === 0;
-        if (isRoot) return {code: undefined, type: 'E'};
-        return {code: 'true', type: 'E'};
-    }
-    emitTypeErrors(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-}

package/src/nodes/atomic/bigInt.ts

@@ -1,26 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeBigInt} from '@deepkit/type';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import type {JitCode} from '../../types.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-
-export class BigIntRunType extends AtomicRunType<TypeBigInt> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `typeof ${comp.vλl} === 'bigint'`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (typeof ${comp.vλl} !== 'bigint') ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        return {code: `${comp.vλl}.toString()`, type: 'E'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        return {code: `BigInt(${comp.vλl})`, type: 'E'};
-    }
-}

package/src/nodes/atomic/boolean.ts

@@ -1,26 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeBoolean} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-
-export class BooleanRunType extends AtomicRunType<TypeBoolean> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `typeof ${comp.vλl} === 'boolean'`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (typeof ${comp.vλl} !== 'boolean') ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-    emitRestoreFromJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-}

package/src/nodes/atomic/date.ts

@@ -1,26 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {type TypeClass} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-
-export class DateRunType extends AtomicRunType<TypeClass> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (!(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        return {code: `new Date(${comp.vλl})`, type: 'E'};
-    }
-}

package/src/nodes/atomic/enum.ts

@@ -1,23 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {TypeEnum} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import {toLiteral} from '../../lib/utils.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-
-export class EnumRunType extends AtomicRunType<TypeEnum> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const items = this.src.values.map((v) => `${comp.vλl} === ${toLiteral(v)}`);
-        return {code: `(${items.join(' || ')})`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        const items = this.src.values.map((v) => `${comp.vλl} === ${toLiteral(v)}`);
-        return {code: `if (!(${items.join(' || ')})) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-}