@mionjs/run-types 0.8.8 → 0.13.0

package/.dist/esm/src/run-types-pure-fns.js

@@ -1,112 +0,0 @@
-import { registerPureFnFactory } from "@mionjs/core";
-const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-const cpf_asJSONString = registerPureFnFactory("mion", "asJSONString", function() {
-  if (typeof Bun !== "undefined")
-    return JSON.stringify;
-  const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
-  const MAX_SCAPE_TEST_LENGTH = 1e3;
-  return __assignType(function _asJSONStringRegexOnly(str) {
-    if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
-      return '"' + str + '"';
-    } else {
-      return JSON.stringify(str);
-    }
-  }, ["str", "_asJSONStringRegexOnly", 'P"2!"/"']);
-}, { bodyHash: "4WYkR03dXOzAUe", paramNames: [], code: `if (typeof Bun !== "undefined") return JSON.stringify;
-  const STR_ESCAPE = /[\\u0000-\\u001f\\u0022\\u005c\\ud800-\\udfff]/;
-  const MAX_SCAPE_TEST_LENGTH = 1e3;
-  return function _asJSONStringRegexOnly(str) {
-    if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
-      return '"' + str + '"';
-    } else {
-      return JSON.stringify(str);
-    }
-  };` });
-const cpf_getUnknownKeysFromArray = registerPureFnFactory("mion", "getUnknownKeysFromArray", function() {
-  const MAX_UNKNOWN_KEYS = 10;
-  return __assignType(function _getUnknownKeysFromArray(obj, keys) {
-    const unknownKeys = [];
-    for (const prop in obj) {
-      let found = false;
-      for (let j = 0; j < keys.length; j++) {
-        if (keys[j] === prop) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        unknownKeys.push(prop);
-        if (unknownKeys.length >= MAX_UNKNOWN_KEYS)
-          throw new Error("Too many unknown keys");
-      }
-    }
-    return unknownKeys;
-  }, [() => __ΩRecord, "StrNumber", "obj", "keys", "_getUnknownKeysFromArray", 'P"w""o!#2#"w"F2$"w"F/%']);
-}, { bodyHash: "D2CDXI8OoGLGyW", paramNames: [], code: 'const MAX_UNKNOWN_KEYS = 10;\n  return function _getUnknownKeysFromArray(obj, keys) {\n    const unknownKeys = [];\n    for (const prop in obj) {\n      let found = false;\n      for (let j = 0; j < keys.length; j++) {\n        if (keys[j] === prop) {\n          found = true;\n          break;\n        }\n      }\n      if (!found) {\n        unknownKeys.push(prop);\n        if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error("Too many unknown keys");\n      }\n    }\n    return unknownKeys;\n  };' });
-const cpf_hasUnknownKeysFromArray = registerPureFnFactory("mion", "hasUnknownKeysFromArray", function() {
-  return __assignType(function _hasUnknownKeysFromArray(obj, keys) {
-    for (const prop in obj) {
-      let found = false;
-      for (let j = 0; j < keys.length; j++) {
-        if (keys[j] === prop) {
-          found = true;
-          break;
-        }
-      }
-      if (!found)
-        return true;
-    }
-    return false;
-  }, [() => __ΩRecord, "StrNumber", "obj", "keys", "_hasUnknownKeysFromArray", 'P"w""o!#2#"w"F2$)/%']);
-}, { bodyHash: "K7uzDGNnPwcqQ9", paramNames: [], code: "return function _hasUnknownKeysFromArray(obj, keys) {\n    for (const prop in obj) {\n      let found = false;\n      for (let j = 0; j < keys.length; j++) {\n        if (keys[j] === prop) {\n          found = true;\n          break;\n        }\n      }\n      if (!found) return true;\n    }\n    return false;\n  };" });
-const cpf_newRunTypeErr = registerPureFnFactory("mion", "newRunTypeErr", function() {
-  return __assignType(function _err(pλth, εrr, expected, accessPath) {
-    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
-    const runTypeErr = { expected, path };
-    εrr.push(runTypeErr);
-  }, ["StrNumber", "pλth", "RunTypeError", "εrr", "expected", "accessPath", "_err", `P"w!F92""w#F2$&2%"w!F92&8$/'`]);
-}, { bodyHash: "eCwDrS1nuSv7ge", paramNames: [], code: "return function _err(p\\u03BBth, \\u03B5rr, expected, accessPath) {\n    const path = accessPath?.length ? [...p\\u03BBth, ...accessPath] : [...p\\u03BBth];\n    const runTypeErr = { expected, path };\n    \\u03B5rr.push(runTypeErr);\n  };" });
-const cpf_formatErr = registerPureFnFactory("mion", "formatErr", function() {
-  return __assignType(function _formatErr(pλth, εrr, expected, fmtName, paramName, paramVal, fmtPath, accessPath, fmtAccessPath) {
-    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
-    const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];
-    const format = { name: fmtName, formatPath, val: paramVal };
-    const runTypeErr = { expected, path, format };
-    εrr.push(runTypeErr);
-  }, ["StrNumber", "pλth", "RunTypeError", "εrr", "expected", "fmtName", "paramName", "paramVal", "fmtPath", "accessPath", "fmtAccessPath", "_formatErr", `P"w!F2""w#F2$&2%&2&&2'P&')*J2("w!F2)"w!F2*8"w!F2+8$/,`]);
-}, { bodyHash: "2isPiuLWPtohVR", paramNames: [], code: "return function _formatErr(p\\u03BBth, \\u03B5rr, expected, fmtName, paramName, paramVal, fmtPath, accessPath, fmtAccessPath) {\n    const path = accessPath?.length ? [...p\\u03BBth, ...accessPath] : [...p\\u03BBth];\n    const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];\n    const format = { name: fmtName, formatPath, val: paramVal };\n    const runTypeErr = { expected, path, format };\n    \\u03B5rr.push(runTypeErr);\n  };" });
-const cpf_safeIterableKey = registerPureFnFactory("mion", "safeIterableKey", function() {
-  return __assignType(function _safeKey(value) {
-    if (value === void 0)
-      return null;
-    if (value === null)
-      return null;
-    const type = typeof value;
-    if (type === "number" || type === "string" || type === "boolean")
-      return value;
-    return null;
-  }, ["value", "_safeKey", 'P"2!"/"']);
-}, { bodyHash: "BrjL47E-GRjUpQ", paramNames: [], code: 'return function _safeKey(value) {\n    if (value === void 0) return null;\n    if (value === null) return null;\n    const type = typeof value;\n    if (type === "number" || type === "string" || type === "boolean") return value;\n    return null;\n  };' });
-const cpf_sanitizeCompiledFn = registerPureFnFactory("mion", "sanitizeCompiledFn", function() {
-  const anonymousRegex = /^\s*function\s+anonymous\s*\(/;
-  return function sanitizeCompiled(fnCode) {
-    if (anonymousRegex.test(fnCode)) {
-      return fnCode.replace(anonymousRegex, "function (");
-    }
-    return fnCode;
-  };
-}, { bodyHash: "UjTRflEOSgqLPC", paramNames: [], code: 'const anonymousRegex = /^\\s*function\\s+anonymous\\s*\\(/;\n  return function sanitizeCompiled(fnCode) {\n    if (anonymousRegex.test(fnCode)) {\n      return fnCode.replace(anonymousRegex, "function (");\n    }\n    return fnCode;\n  };' });
-export {
-  cpf_asJSONString,
-  cpf_formatErr,
-  cpf_getUnknownKeysFromArray,
-  cpf_hasUnknownKeysFromArray,
-  cpf_newRunTypeErr,
-  cpf_safeIterableKey,
-  cpf_sanitizeCompiledFn
-};
-//# sourceMappingURL=run-types-pure-fns.js.map

package/.dist/esm/src/run-types-pure-fns.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-types-pure-fns.js","sources":["../../../src/run-types-pure-fns.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 * ######## */\nimport type {TypeFormatError, StrNumber, RunTypeError} from '@mionjs/core';\nimport {registerPureFnFactory} from '@mionjs/core';\n\nexport const cpf_asJSONString = registerPureFnFactory('mion', 'asJSONString', function () {\n    // @ts-expect-error 2867\n    if (typeof Bun !== 'undefined') return JSON.stringify; // bun has a faster JSON.stringify\n    // eslint-disable-next-line no-control-regex\n    const STR_ESCAPE = /[\\u0000-\\u001f\\u0022\\u005c\\ud800-\\udfff]/;\n    const MAX_SCAPE_TEST_LENGTH = 1000;\n    return function _asJSONStringRegexOnly(str) {\n        // Always use regex test for strings >= 42 chars (n o for loop)\n        if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {\n            return '\"' + str + '\"';\n        } else {\n            return JSON.stringify(str);\n        }\n    };\n});\n\nexport const cpf_getUnknownKeysFromArray = registerPureFnFactory('mion', 'getUnknownKeysFromArray', function () {\n    const MAX_UNKNOWN_KEYS = 10;\n    return function _getUnknownKeysFromArray(obj: Record<StrNumber, any>, keys: StrNumber[]): StrNumber[] {\n        const unknownKeys: StrNumber[] = [];\n        for (const prop in obj) {\n            let found = false;\n            for (let j = 0; j < keys.length; j++) {\n                if (keys[j] === prop) {\n                    found = true;\n                    break;\n                }\n            }\n            if (!found) {\n                unknownKeys.push(prop as string);\n                if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error('Too many unknown keys');\n            }\n        }\n        return unknownKeys;\n    };\n});\n\nexport const cpf_hasUnknownKeysFromArray = registerPureFnFactory('mion', 'hasUnknownKeysFromArray', function () {\n    return function _hasUnknownKeysFromArray(obj: Record<StrNumber, any>, keys: StrNumber[]): boolean {\n        for (const prop in obj) {\n            // iterates over the object keys and if not found prop adds to unknownKeys\n            let found = false;\n            for (let j = 0; j < keys.length; j++) {\n                if (keys[j] === prop) {\n                    found = true;\n                    break;\n                }\n            }\n            if (!found) return true;\n        }\n        return false;\n    };\n});\n\nexport const cpf_newRunTypeErr = registerPureFnFactory('mion', 'newRunTypeErr', function () {\n    return function _err(\n        pλth: readonly StrNumber[],\n        εrr: RunTypeError[],\n        expected: string,\n        accessPath?: readonly StrNumber[]\n    ): void {\n        const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];\n        const runTypeErr: RunTypeError = {expected, path};\n        εrr.push(runTypeErr);\n    };\n});\n\nexport const cpf_formatErr = registerPureFnFactory('mion', 'formatErr', function () {\n    return function _formatErr(\n        pλth: StrNumber[],\n        εrr: RunTypeError[],\n        expected: string,\n        fmtName: string,\n        paramName: string,\n        paramVal: string | number | boolean | bigint,\n        fmtPath: StrNumber[],\n        accessPath?: StrNumber[],\n        fmtAccessPath?: StrNumber[]\n    ): void {\n        const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];\n        const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];\n        const format: TypeFormatError = {name: fmtName, formatPath: formatPath, val: paramVal};\n        const runTypeErr: Required<RunTypeError> = {expected, path, format};\n        εrr.push(runTypeErr);\n    };\n});\n\nexport const cpf_safeIterableKey = registerPureFnFactory('mion', 'safeIterableKey', function () {\n    return function _safeKey(value: any): any {\n        if (value === undefined) return null;\n        if (value === null) return null;\n        const type = typeof value;\n        if (type === 'number' || type === 'string' || type === 'boolean') return value;\n        return null;\n    };\n});\n\n/** @reflection never */\nexport const cpf_sanitizeCompiledFn = registerPureFnFactory('mion', 'sanitizeCompiledFn', function () {\n    const anonymousRegex = /^\\s*function\\s+anonymous\\s*\\(/;\n    return function sanitizeCompiled(fnCode: string): string {\n        if (anonymousRegex.test(fnCode)) {\n            return fnCode.replace(anonymousRegex, 'function (');\n        }\n        return fnCode;\n    };\n});\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/types.d.ts

@@ -1,154 +0,0 @@
-import { Type, TypeCallSignature, TypeFunction, TypeMethod, TypeMethodSignature, TypeTuple } from '@deepkit/type';
-import { TypeFormatParams } from '@mionjs/core';
-import { JitFunctions, CodeType } from './constants.functions.ts';
-import { ReflectionSubKind } from './constants.kind.ts';
-import { BaseRunTypeFormat } from './lib/baseRunTypeFormat.ts';
-import { JitFnCompiler } from './lib/jitFnCompiler.ts';
-export type StrNumber = string | number;
-export type JitCode = {
-    code: string | undefined;
-    type: CodeType;
-};
-export type SrcType<T extends Type = Type> = T & {
-    readonly _rt: RunType;
-    readonly _typeId?: StrNumber;
-    readonly _formatId?: string;
-    readonly subKind?: SubKind;
-};
-export type RunTypeFamily = 'A' | 'C' | 'M' | 'F';
-export interface RunType {
-    readonly src: SrcType<any>;
-    getKindName(): string;
-    getFamily(): RunTypeFamily;
-    mock: (options?: DeepPartial<RunTypeOptions>) => Promise<any>;
-    getTypeID(): StrNumber;
-    getJitHash(opts: RunTypeOptions): string;
-    createJitFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any;
-}
-export type SubKind = (typeof ReflectionSubKind)[keyof typeof ReflectionSubKind];
-export type RunTypeVisitor = (deepkitType: Type, parents: RunType[], opts: RunTypeOptions) => RunType;
-export type SrcCollection = Type & {
-    types: Type[];
-};
-export type SrcMember = Type & {
-    type: Type;
-};
-export interface JitCompilerOpts {
-    readonly fnID: string;
-    readonly typeID: StrNumber;
-    readonly jitFnHash: string;
-    readonly opts: RunTypeOptions;
-}
-export interface RunTypeChildAccessor extends RunType {
-    getChildIndex(comp: JitFnCompiler): number;
-    getChildVarName(comp: JitFnCompiler): StrNumber;
-    getChildLiteral(comp: JitFnCompiler): StrNumber;
-    useArrayAccessor(): boolean;
-    isOptional(): boolean;
-    skipSettingAccessor?(): boolean;
-    skipCommas?: boolean;
-}
-export interface CustomVλl {
-    vλl: string;
-    isStandalone?: boolean;
-    useArrayAccessor?: boolean;
-}
-export interface RunTypeOptions {
-    paramsSlice?: {
-        start?: number;
-        end?: number;
-    };
-    mock?: MockOptions;
-    noLiterals?: boolean;
-    noIsArrayCheck?: boolean;
-    strictTypes?: boolean;
-}
-export type PartialRunTypeOptions = DeepPartial<RunTypeOptions>;
-export type JitFn = (typeof JitFunctions)[keyof typeof JitFunctions];
-export type JitFnID = JitFn['id'];
-export type AnyFunction = TypeMethodSignature | TypeCallSignature | TypeFunction | TypeMethod;
-export type AnyParameterListRunType = AnyFunction | TypeTuple;
-export interface MockOptions {
-    anyValuesList: any[];
-    minNumber?: number;
-    maxNumber?: number;
-    minDate?: number;
-    maxDate?: number;
-    enumIndex?: number;
-    objectList: object[];
-    promiseTimeOut: number;
-    promiseReject?: string | Error | any;
-    regexpList: RegExp[];
-    maxRandomStringLength: number;
-    stringLength?: number;
-    stringCharSet: string;
-    symbolLength?: number;
-    symbolCharSet?: string;
-    symbolName?: string;
-    maxRandomItemsLength: number;
-    arrayLength?: number;
-    optionalProbability: number;
-    optionalPropertyProbability?: Record<StrNumber, number>;
-    parentObj?: Record<StrNumber | symbol, any>;
-    unionIndex?: number;
-    tupleOptions?: MockOptions[];
-    paramsOptions?: MockOptions[];
-    maxStackDepth: number;
-    maxMockRecursion: number;
-}
-export interface MockOperation extends MockOptions {
-    stack: RunType[];
-    fnID: JitFnID;
-}
-export type DKAnnotation = {
-    name: string;
-    options: SrcType;
-};
-export type FormatAnnotation = DKAnnotation & {
-    params?: TypeFormatParams;
-    formatter: BaseRunTypeFormat;
-};
-export type RunTypeAnnotation = {
-    name: string;
-    options: RunType;
-};
-export interface AnyClass<T = any> {
-    new (...args: any[]): T;
-}
-export type Mutable<T> = {
-    -readonly [K in keyof T]: T[K];
-};
-export type DeepRequired<T> = T extends object ? {
-    [P in keyof T]?: DeepRequired<T[P]>;
-} : T;
-export type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-export declare type __ΩStrNumber = any[];
-export declare type __ΩJitCode = any[];
-export declare type __ΩSrcType = any[];
-export declare type __ΩRunTypeFamily = any[];
-export declare type __ΩRunType = any[];
-export declare type __ΩSubKind = any[];
-export declare type __ΩRunTypeVisitor = any[];
-export declare type __ΩSrcCollection = any[];
-export declare type __ΩSrcMember = any[];
-export declare type __ΩJitCompilerOpts = any[];
-export declare type __ΩRunTypeChildAccessor = any[];
-export declare type __ΩCustomVλl = any[];
-export declare type __ΩRunTypeOptions = any[];
-export declare type __ΩPartialRunTypeOptions = any[];
-export declare type __ΩJitFn = any[];
-export declare type __ΩJitFnID = any[];
-export declare type __ΩAnyFunction = any[];
-export declare type __ΩAnyParameterListRunType = any[];
-export declare type __ΩMockOptions = any[];
-export declare type __ΩMockOperation = any[];
-export declare type __ΩDKAnnotation = any[];
-export declare type __ΩFormatAnnotation = any[];
-export declare type __ΩRunTypeAnnotation = any[];
-export declare type __ΩAnyClass = any[];
-export declare type __ΩMutable = any[];
-export declare type __ΩDeepRequired = any[];
-export declare type __ΩDeepPartial = any[];
-//# sourceMappingURL=types.d.ts.map

package/.dist/esm/src/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"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"}

package/.dist/esm/src/types.js

@@ -1,59 +0,0 @@
-const __ΩError = ["name", "message", "stack", "Error", 'P&4!&4"&4#8Mw$y'];
-const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
-const __ΩStrNumber = ["StrNumber", "P&'Jw!y"];
-const __ΩJitCode = ["code", "CodeType", "type", "JitCode", 'PP&-J4!"w"4#Mw$y'];
-const __ΩSrcType = ["Type", "T", () => __ΩRunType, "_rt", () => __ΩStrNumber, "_typeId", "_formatId", () => __ΩSubKind, "subKind", "SrcType", `"w!c"Pe"!Pn#4$9n%4&89&4'89n(4)89MKw*y`];
-const __ΩRunTypeFamily = ["A", "C", "M", "F", "RunTypeFamily", 'P.!.".#.$Jw%y'];
-const __ΩRunType = [() => __ΩSrcType, "src", "getKindName", () => __ΩRunTypeFamily, "getFamily", () => __ΩDeepPartial, () => __ΩRunTypeOptions, "options", "", "mock", () => __ΩStrNumber, "getTypeID", () => __ΩRunTypeOptions, "opts", "getJitHash", () => __ΩJitFn, "jitFn", () => __ΩRunTypeOptions, "args", "createJitFunction", "RunType", 'P"o!"4"9P&1#Pn$1%Pn\'o&"2(8"`/)4*Pn+1,Pn-2.&1/Pn021n22.8P"@23"/)14Mw5y'];
-const __ΩSubKind = [() => ReflectionSubKind, () => ReflectionSubKind, "SubKind", 'i!i"gfw#y'];
-const __ΩRunTypeVisitor = ["Type", "deepkitType", () => __ΩRunType, "parents", () => __ΩRunTypeOptions, "opts", () => __ΩRunType, "", "RunTypeVisitor", `P"w!2"n#F2$n%2&n'/(w)y`];
-const __ΩSrcCollection = ["Type", "types", "SrcCollection", 'P"w!P"w!F4"MKw#y'];
-const __ΩSrcMember = ["Type", "type", "SrcMember", 'P"w!P"w!4"MKw#y'];
-const __ΩJitCompilerOpts = ["fnID", () => __ΩStrNumber, "typeID", "jitFnHash", () => __ΩRunTypeOptions, "opts", "JitCompilerOpts", `P&4!9n"4#9&4$9n%4&9Mw'y`];
-const __ΩRunTypeChildAccessor = [() => __ΩRunType, "JitFnCompiler", "comp", "getChildIndex", () => __ΩStrNumber, "getChildVarName", () => __ΩStrNumber, "getChildLiteral", "useArrayAccessor", "isOptional", "skipSettingAccessor", "skipCommas", "RunTypeChildAccessor", `Pn!P"w"2#'1$P"w"2#n%1&P"w"2#n'1(P)1)P)1*P)1+8)4,8Mw-y`];
-const __ΩCustomVλl = ["vλl", "isStandalone", "useArrayAccessor", "CustomVλl", 'P&4!)4"8)4#8Mw$y'];
-const __ΩRunTypeOptions = ["start", "end", "paramsSlice", () => __ΩMockOptions, "mock", "noLiterals", "noIsArrayCheck", "strictTypes", "RunTypeOptions", `PP'4!8'4"8M4#8n$4%8)4&8)4'8)4(8Mw)y`];
-const __ΩPartialRunTypeOptions = [() => __ΩDeepPartial, () => __ΩRunTypeOptions, "PartialRunTypeOptions", 'n"o!"w#y'];
-const __ΩJitFn = [() => JitFunctions, () => JitFunctions, "JitFn", 'i!i"gfw#y'];
-const __ΩJitFnID = [() => __ΩJitFn, "id", "JitFnID", 'n!."fw#y'];
-const __ΩAnyFunction = ["TypeMethodSignature", "TypeCallSignature", "TypeFunction", "TypeMethod", "AnyFunction", 'P"w!"w""w#"w$Jw%y'];
-const __ΩAnyParameterListRunType = [() => __ΩAnyFunction, "TypeTuple", "AnyParameterListRunType", 'Pn!"w"Jw#y'];
-const __ΩMockOptions = ["anyValuesList", "minNumber", "maxNumber", "minDate", "maxDate", "enumIndex", "objectList", "promiseTimeOut", () => __ΩError, "promiseReject", "regexpList", "maxRandomStringLength", "stringLength", "stringCharSet", "symbolLength", "symbolCharSet", "symbolName", "maxRandomItemsLength", "arrayLength", "optionalProbability", () => __ΩRecord, () => __ΩStrNumber, "optionalPropertyProbability", () => __ΩRecord, () => __ΩStrNumber, "parentObj", "unionIndex", 0, "tupleOptions", 0, "paramsOptions", "maxStackDepth", "maxMockRecursion", "MockOptions", `P"F4!'4"8'4#8'4$8'4%8'4&8%F4''4(P&n)"J4*8AF4+'4,'4-8&4.'4/8&408&418'42'438'44n6'o5#478Pn9+J"o8#4:8'4;8n<F4=8n>F4?8'4@'4AMwBy`];
-const __ΩMockOperation = [() => __ΩMockOptions, () => __ΩRunType, "stack", () => __ΩJitFnID, "fnID", "MockOperation", 'Pn!n"F4#n$4%Mw&y'];
-const __ΩDKAnnotation = ["name", () => __ΩSrcType, "options", "DKAnnotation", 'P&4!n"4#Mw$y'];
-const __ΩFormatAnnotation = [() => __ΩDKAnnotation, "TypeFormatParams", "params", "BaseRunTypeFormat", "formatter", "FormatAnnotation", 'Pn!P"w"4#8"w$4%MKw&y'];
-const __ΩRunTypeAnnotation = ["name", () => __ΩRunType, "options", "RunTypeAnnotation", 'P&4!n"4#Mw$y'];
-const __ΩAnyClass = ["T", "args", "new", "AnyClass", '"c!PP"@2"e#!1#Mw$y'];
-const __ΩMutable = ["T", "Mutable", 'l+e#!e"!fRb!Pde"!gN#)w"y'];
-const __ΩDeepRequired = ["T", 0, "DeepRequired", 'lGe&!e"!fo""RPde%!gN#"Re$!RPe#!%qk.8QRb!Pde"!p<w#y'];
-const __ΩDeepPartial = ["T", 0, "DeepPartial", 'lGe&!e"!fo""RPde%!gN#"Re$!RPe#!%qk.8QRb!Pde"!p<w#y'];
-export {
-  __ΩAnyClass,
-  __ΩAnyFunction,
-  __ΩAnyParameterListRunType,
-  __ΩCustomVλl,
-  __ΩDKAnnotation,
-  __ΩDeepPartial,
-  __ΩDeepRequired,
-  __ΩFormatAnnotation,
-  __ΩJitCode,
-  __ΩJitCompilerOpts,
-  __ΩJitFn,
-  __ΩJitFnID,
-  __ΩMockOperation,
-  __ΩMockOptions,
-  __ΩMutable,
-  __ΩPartialRunTypeOptions,
-  __ΩRunType,
-  __ΩRunTypeAnnotation,
-  __ΩRunTypeChildAccessor,
-  __ΩRunTypeFamily,
-  __ΩRunTypeOptions,
-  __ΩRunTypeVisitor,
-  __ΩSrcCollection,
-  __ΩSrcMember,
-  __ΩSrcType,
-  __ΩStrNumber,
-  __ΩSubKind
-};
-//# sourceMappingURL=types.js.map

package/.dist/esm/src/types.js.map

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

package/index.ts

@@ -1,70 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-// Re-export all modules from the package.json exports field
-export * from './src/types.ts';
-export * from './src/constants.functions.ts';
-export * from './src/constants.kind.ts';
-export * from './src/constants.ts';
-export * from './src/createRunType.ts';
-export * from './src/createRunTypeFunctions.ts';
-export * from './src/formats.runtype.ts';
-export * from './src/lib/typeId.ts';
-export * from './src/lib/dkProxy.ts';
-export * from './src/lib/baseRunTypeFormat.ts';
-export * from './src/lib/baseRunTypes.ts';
-export * from './src/lib/formats.ts';
-export * from './src/lib/guards.ts';
-export * from './src/lib/jitFnCompiler.ts';
-export * from './src/lib/jitFnsRegistry.ts';
-export * from './src/mocking/constants.mock.ts';
-export * from './src/mocking/mockRegistry.ts';
-export * from './src/mocking/mockType.ts';
-export * from './src/mocking/mockUtils.ts';
-export * from './src/run-types-pure-fns.ts';
-
-// TODO: decide if we want to export all nodes or not
-export type * from './src/nodes/atomic/any.ts';
-export type * from './src/nodes/atomic/bigInt.ts';
-export type * from './src/nodes/atomic/boolean.ts';
-export type * from './src/nodes/atomic/date.ts';
-export type * from './src/nodes/atomic/enum.ts';
-export type * from './src/nodes/atomic/enumMember.ts';
-export type * from './src/nodes/atomic/literal.ts';
-export type * from './src/nodes/atomic/never.ts';
-export type * from './src/nodes/atomic/null.ts';
-export type * from './src/nodes/atomic/number.ts';
-export type * from './src/nodes/atomic/object.ts';
-export type * from './src/nodes/atomic/regexp.ts';
-export type * from './src/nodes/atomic/string.ts';
-export type * from './src/nodes/atomic/symbol.ts';
-export type * from './src/nodes/atomic/undefined.ts';
-export type * from './src/nodes/atomic/unknown.ts';
-export type * from './src/nodes/atomic/void.ts';
-export type * from './src/nodes/collection/class.ts';
-export type * from './src/nodes/collection/functionParams.ts';
-export type * from './src/nodes/collection/interface.ts';
-export type * from './src/nodes/collection/intersection.ts';
-export type * from './src/nodes/collection/tuple.ts';
-export type * from './src/nodes/collection/union.ts';
-export type * from './src/nodes/collection/unionDiscriminator.ts';
-export type * from './src/nodes/function/function.ts';
-export type * from './src/nodes/member/array.ts';
-export type * from './src/nodes/member/callSignature.ts';
-export type * from './src/nodes/member/genericMember.ts';
-export type * from './src/nodes/member/indexProperty.ts';
-export type * from './src/nodes/member/method.ts';
-export type * from './src/nodes/member/methodSignature.ts';
-export type * from './src/nodes/member/param.ts';
-export type * from './src/nodes/member/property.ts';
-export type * from './src/nodes/member/restParams.ts';
-export type * from './src/nodes/member/tupleMember.ts';
-export type * from './src/nodes/native/Iterable.ts';
-export type * from './src/nodes/native/map.ts';
-export type * from './src/nodes/native/nonSerializable.ts';
-export type * from './src/nodes/native/promise.ts';
-export type * from './src/nodes/native/set.ts';

package/src/constants.functions.ts

@@ -1,196 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {type JitFnArgs, JIT_FUNCTION_IDS} from '@mionjs/core';
-
-/** Javascript code types */
-export const CodeTypes = {
-    expression: 'E', // single expression, that could be concatenated using js operators like + - * && || etc...
-    statement: 'S', // one or multiple statements, that could be concatenated using ; to ensure correct syntax
-    returnBlock: 'RB', // code block, it can not be concatenated with other code, it has an explicit return statement and needs to be wrapped in a function
-} as const;
-export type CodeType = (typeof CodeTypes)[keyof typeof CodeTypes];
-
-export interface JitFnSettings {
-    id: string;
-    name: string;
-    /** dynamically imports a single compiler function that is capable of compiling any node
-     * @see {@link ./jitCompilers/stringifyJson.ts#visitJsonStringify} as example of compiler function
-     */
-    import?: () => Promise<(...args: any[]) => any>;
-    jitArgs: JitFnArgs;
-    jitDefaultArgs: JitFnArgs;
-    returnName: string;
-    /**
-     * When no initial vλl is required by the function.
-     * This is typically used by deserializers, that do not transform the input value but create a new one from other params.
-     * an the initial vλl is used as a variable initialization for the returned values.
-     * ie binary deserialization
-     */
-    noInitialVλl?: true;
-    runTimeOptions?: Record<string, {keyName: string; type: 'boolean' | 'number' | 'string'; defaultValue: any}>;
-    /**
-     * When set to true, the format code should replace the jit code for the function.
-     * This is used when the format code is more efficient than the default code.
-     */
-    formatShouldReplaceJitCode?: true;
-} // list of available jit functions
-
-// variable names used in jit functions
-// JitUtils is passed with the name 'utl'. it is hardcoded in all jit code to avoid string interpolation
-export const jitArgs = {vλl: 'v'} as const;
-export const jitDefaultArgs = {vλl: ''} as const;
-export const jitErrorArgs = {vλl: 'v', pλth: 'pth', εrr: 'er'} as const;
-export const jitDefaultErrorArgs = {vλl: '', pλth: '[]', εrr: '[]'} as const;
-export const jitArgsWithOptions = {vλl: 'v', θpts: 'opts'} as const;
-export const jitDefaultArgsWithOptions = {vλl: '', θpts: '{}'} as const;
-export const jitBinarySerializerArgs = {vλl: 'v', sεr: 'Ser'} as const; // vλl = js value to serialize ser = serializer,
-export const jitBinaryDeserializerArgs = {vλl: 'ret', dεs: 'Des'} as const; // vλl is used as return variable ans is assigned the deserialized value, des = deserializer
-export const jitDefaultBinarySerializerArgs = {vλl: '', sεr: ''} as const;
-export const jitDefaultBinaryDeserializerArgs = {vλl: '', dεs: ''} as const;
-
-// ######## !IMPORTANT: ALL JIT FUNCTIONS IDs MUST BE UNIQUE and short ########
-
-type JitFunctionsGroup = {[key: string]: JitFnSettings};
-
-export const jitValidationFunctions = {
-    isType: {
-        id: JIT_FUNCTION_IDS.isType,
-        name: 'isType',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    typeErrors: {
-        id: JIT_FUNCTION_IDS.typeErrors,
-        name: 'typeErrors',
-        jitArgs: jitErrorArgs,
-        jitDefaultArgs: jitDefaultErrorArgs,
-        returnName: jitErrorArgs.εrr,
-    },
-} as const satisfies JitFunctionsGroup;
-
-export const jitSerializationFunctions = {
-    prepareForJson: {
-        id: JIT_FUNCTION_IDS.prepareForJson,
-        name: 'prepareForJson',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    restoreFromJson: {
-        id: JIT_FUNCTION_IDS.restoreFromJson,
-        name: 'restoreFromJson',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    stringifyJson: {
-        id: JIT_FUNCTION_IDS.stringifyJson,
-        name: 'stringifyJson',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    // similar to json stringify but outputs js code, including pure functions, already imported as size is quite small
-    toJSCode: {
-        id: JIT_FUNCTION_IDS.toJSCode,
-        name: 'toJSCode',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    // Binary serialization functions
-    toBinary: {
-        id: JIT_FUNCTION_IDS.toBinary,
-        name: 'toBinary',
-        jitArgs: jitBinarySerializerArgs,
-        jitDefaultArgs: jitDefaultBinarySerializerArgs,
-        // returns the serializer buffer
-        returnName: jitBinarySerializerArgs.sεr,
-        formatShouldReplaceJitCode: true,
-    },
-    fromBinary: {
-        id: JIT_FUNCTION_IDS.fromBinary,
-        name: 'fromBinary',
-        jitArgs: jitBinaryDeserializerArgs,
-        jitDefaultArgs: jitDefaultBinaryDeserializerArgs,
-        // deserialized value is stored in vλl that is initially undefined
-        returnName: jitBinaryDeserializerArgs.vλl,
-        noInitialVλl: true,
-        formatShouldReplaceJitCode: true,
-    },
-    // apply type formatters, ie: lowercase, uppercase, trim, etc
-    format: {
-        id: JIT_FUNCTION_IDS.format,
-        name: 'format',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-} as const satisfies JitFunctionsGroup;
-
-export const JitFunctions = {
-    ...jitValidationFunctions,
-    ...jitSerializationFunctions,
-    unknownKeyErrors: {
-        id: JIT_FUNCTION_IDS.unknownKeyErrors,
-        name: 'unknownKeyErrors',
-        jitArgs: jitErrorArgs,
-        jitDefaultArgs: jitDefaultErrorArgs,
-        returnName: jitErrorArgs.εrr,
-    },
-    hasUnknownKeys: {
-        id: JIT_FUNCTION_IDS.hasUnknownKeys,
-        name: 'hasUnknownKeys',
-        jitArgs: jitArgsWithOptions,
-        jitDefaultArgs: jitDefaultArgsWithOptions,
-        runTimeOptions: {checkNonJitProps: {keyName: 'checkNonJitProps', type: 'boolean', defaultValue: false}},
-        returnName: jitArgsWithOptions.vλl,
-    },
-    stripUnknownKeys: {
-        id: JIT_FUNCTION_IDS.stripUnknownKeys,
-        name: 'stripUnknownKeys',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    unknownKeysToUndefined: {
-        id: JIT_FUNCTION_IDS.unknownKeysToUndefined,
-        name: 'unknownKeysToUndefined',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    aux: {
-        id: JIT_FUNCTION_IDS.aux,
-        name: 'aux',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    // mock is not really a jit function but is used in a similar way, main difference is that it is not compiled
-    mock: {
-        id: JIT_FUNCTION_IDS.mock,
-        name: 'mockType',
-        import: () => import('./mocking/mockType.ts').then((m) => m.mockType),
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-    // pure function are not jit compiled but we ensure we reserve a prefix to avoid collisions
-    pureFunction: {
-        id: JIT_FUNCTION_IDS.pureFunction,
-        name: 'pureFunction',
-        jitArgs,
-        jitDefaultArgs,
-        returnName: jitArgs.vλl,
-    },
-} as const satisfies JitFunctionsGroup;
-
-export const jitFunctionList: JitFnSettings[] = Object.values(JitFunctions);
-export const jitFunctionsById = Object.fromEntries(jitFunctionList.map((f) => [f.id, f]));