@mionjs/run-types 0.8.10 → 0.13.0

package/.dist/esm/src/constants.functions.d.ts

@@ -1,386 +0,0 @@
-import { JitFnArgs } from '@mionjs/core';
-export declare const CodeTypes: {
-    readonly expression: "E";
-    readonly statement: "S";
-    readonly returnBlock: "RB";
-};
-export type CodeType = (typeof CodeTypes)[keyof typeof CodeTypes];
-export interface JitFnSettings {
-    id: string;
-    name: string;
-    import?: () => Promise<(...args: any[]) => any>;
-    jitArgs: JitFnArgs;
-    jitDefaultArgs: JitFnArgs;
-    returnName: string;
-    noInitialVλl?: true;
-    runTimeOptions?: Record<string, {
-        keyName: string;
-        type: 'boolean' | 'number' | 'string';
-        defaultValue: any;
-    }>;
-    formatShouldReplaceJitCode?: true;
-}
-export declare const jitArgs: {
-    readonly vλl: "v";
-};
-export declare const jitDefaultArgs: {
-    readonly vλl: "";
-};
-export declare const jitErrorArgs: {
-    readonly vλl: "v";
-    readonly pλth: "pth";
-    readonly εrr: "er";
-};
-export declare const jitDefaultErrorArgs: {
-    readonly vλl: "";
-    readonly pλth: "[]";
-    readonly εrr: "[]";
-};
-export declare const jitArgsWithOptions: {
-    readonly vλl: "v";
-    readonly θpts: "opts";
-};
-export declare const jitDefaultArgsWithOptions: {
-    readonly vλl: "";
-    readonly θpts: "{}";
-};
-export declare const jitBinarySerializerArgs: {
-    readonly vλl: "v";
-    readonly sεr: "Ser";
-};
-export declare const jitBinaryDeserializerArgs: {
-    readonly vλl: "ret";
-    readonly dεs: "Des";
-};
-export declare const jitDefaultBinarySerializerArgs: {
-    readonly vλl: "";
-    readonly sεr: "";
-};
-export declare const jitDefaultBinaryDeserializerArgs: {
-    readonly vλl: "";
-    readonly dεs: "";
-};
-export declare const jitValidationFunctions: {
-    readonly isType: {
-        readonly id: "is";
-        readonly name: "isType";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly typeErrors: {
-        readonly id: "te";
-        readonly name: "typeErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-};
-export declare const jitSerializationFunctions: {
-    readonly prepareForJson: {
-        readonly id: "tj";
-        readonly name: "prepareForJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly restoreFromJson: {
-        readonly id: "fj";
-        readonly name: "restoreFromJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly stringifyJson: {
-        readonly id: "sj";
-        readonly name: "stringifyJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toJSCode: {
-        readonly id: "tc";
-        readonly name: "toJSCode";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toBinary: {
-        readonly id: "tBi";
-        readonly name: "toBinary";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly sεr: "Ser";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly sεr: "";
-        };
-        readonly returnName: "Ser";
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly fromBinary: {
-        readonly id: "fBi";
-        readonly name: "fromBinary";
-        readonly jitArgs: {
-            readonly vλl: "ret";
-            readonly dεs: "Des";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly dεs: "";
-        };
-        readonly returnName: "ret";
-        readonly noInitialVλl: true;
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly format: {
-        readonly id: "fmt";
-        readonly name: "format";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-};
-export declare const JitFunctions: {
-    readonly unknownKeyErrors: {
-        readonly id: "uk";
-        readonly name: "unknownKeyErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-    readonly hasUnknownKeys: {
-        readonly id: "hk";
-        readonly name: "hasUnknownKeys";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly θpts: "opts";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly θpts: "{}";
-        };
-        readonly runTimeOptions: {
-            readonly checkNonJitProps: {
-                readonly keyName: "checkNonJitProps";
-                readonly type: "boolean";
-                readonly defaultValue: false;
-            };
-        };
-        readonly returnName: "v";
-    };
-    readonly stripUnknownKeys: {
-        readonly id: "sk";
-        readonly name: "stripUnknownKeys";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly unknownKeysToUndefined: {
-        readonly id: "ku";
-        readonly name: "unknownKeysToUndefined";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly aux: {
-        readonly id: "aux";
-        readonly name: "aux";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly mock: {
-        readonly id: "mock";
-        readonly name: "mockType";
-        readonly import: () => Promise<((...args: any[]) => any) | typeof import('./mocking/mockType.ts').mockType>;
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly pureFunction: {
-        readonly id: "pf";
-        readonly name: "pureFunction";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly prepareForJson: {
-        readonly id: "tj";
-        readonly name: "prepareForJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly restoreFromJson: {
-        readonly id: "fj";
-        readonly name: "restoreFromJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly stringifyJson: {
-        readonly id: "sj";
-        readonly name: "stringifyJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toJSCode: {
-        readonly id: "tc";
-        readonly name: "toJSCode";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toBinary: {
-        readonly id: "tBi";
-        readonly name: "toBinary";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly sεr: "Ser";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly sεr: "";
-        };
-        readonly returnName: "Ser";
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly fromBinary: {
-        readonly id: "fBi";
-        readonly name: "fromBinary";
-        readonly jitArgs: {
-            readonly vλl: "ret";
-            readonly dεs: "Des";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly dεs: "";
-        };
-        readonly returnName: "ret";
-        readonly noInitialVλl: true;
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly format: {
-        readonly id: "fmt";
-        readonly name: "format";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly isType: {
-        readonly id: "is";
-        readonly name: "isType";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly typeErrors: {
-        readonly id: "te";
-        readonly name: "typeErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-};
-export declare const jitFunctionList: JitFnSettings[];
-export declare const jitFunctionsById: {
-    [k: string]: JitFnSettings;
-};
-export declare type __ΩCodeType = any[];
-export declare type __ΩJitFnSettings = any[];
-//# sourceMappingURL=constants.functions.d.ts.map

package/.dist/esm/src/constants.functions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.functions.d.ts","sourceRoot":"","sources":["../../../src/constants.functions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,SAAS,EAAmB,MAAM,cAAc,CAAC;AAG9D,eAAO,MAAM,SAAS;;;;CAIZ,CAAC;AACX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAElE,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IAIb,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,CAAC;IAChD,OAAO,EAAE,SAAS,CAAC;IACnB,cAAc,EAAE,SAAS,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IAOnB,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;QAAC,YAAY,EAAE,GAAG,CAAA;KAAC,CAAC,CAAC;IAK7G,0BAA0B,CAAC,EAAE,IAAI,CAAC;CACrC;AAID,eAAO,MAAM,OAAO;;CAAsB,CAAC;AAC3C,eAAO,MAAM,cAAc;;CAAqB,CAAC;AACjD,eAAO,MAAM,YAAY;;;;CAA8C,CAAC;AACxE,eAAO,MAAM,mBAAmB;;;;CAA4C,CAAC;AAC7E,eAAO,MAAM,kBAAkB;;;CAAoC,CAAC;AACpE,eAAO,MAAM,yBAAyB;;;CAAiC,CAAC;AACxE,eAAO,MAAM,uBAAuB;;;CAAkC,CAAC;AACvE,eAAO,MAAM,yBAAyB;;;CAAoC,CAAC;AAC3E,eAAO,MAAM,8BAA8B;;;CAA8B,CAAC;AAC1E,eAAO,MAAM,gCAAgC;;;CAA8B,CAAC;AAM5E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeG,CAAC;AAEvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DA,CAAC;AAEvC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAjHY,GAAG,EAAE,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyKZ,CAAC;AAEvC,eAAO,MAAM,eAAe,EAAE,aAAa,EAAgC,CAAC;AAC5E,eAAO,MAAM,gBAAgB;;CAA4D,CAAC"}

package/.dist/esm/src/constants.functions.js

@@ -1,181 +0,0 @@
-import { JIT_FUNCTION_IDS } 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 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
-};
-const __ΩCodeType = [() => CodeTypes, () => CodeTypes, "CodeType", 'i!i"gfw#y'];
-const __ΩJitFnSettings = ["id", "name", "args", "", "import", "JitFnArgs", "jitArgs", "jitDefaultArgs", "returnName", true, "noInitialVλl", () => __ΩRecord, "keyName", "boolean", "number", "string", "type", "defaultValue", "runTimeOptions", true, "formatShouldReplaceJitCode", "JitFnSettings", 'P&4!&4"PP"@2#"/$`/$4%8"w&4\'"w&4(&4).*4+8&P&4-P.../.0J41"42Mo,#438.4458Mw6y'];
-const jitArgs = { vλl: "v" };
-const jitDefaultArgs = { vλl: "" };
-const jitErrorArgs = { vλl: "v", pλth: "pth", εrr: "er" };
-const jitDefaultErrorArgs = { vλl: "", pλth: "[]", εrr: "[]" };
-const jitArgsWithOptions = { vλl: "v", θpts: "opts" };
-const jitDefaultArgsWithOptions = { vλl: "", θpts: "{}" };
-const jitBinarySerializerArgs = { vλl: "v", sεr: "Ser" };
-const jitBinaryDeserializerArgs = { vλl: "ret", dεs: "Des" };
-const jitDefaultBinarySerializerArgs = { vλl: "", sεr: "" };
-const jitDefaultBinaryDeserializerArgs = { vλl: "", dεs: "" };
-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
-  }
-};
-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
-  }
-};
-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.js").then(__assignType((m) => m.mockType, ["m", "", 'P"2!"/"'])),
-    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
-  }
-};
-const jitFunctionList = Object.values(JitFunctions);
-const jitFunctionsById = Object.fromEntries(jitFunctionList.map(__assignType((f) => [f.id, f], ["f", "", 'P"2!"/"'])));
-export {
-  CodeTypes,
-  JitFunctions,
-  __ΩCodeType,
-  __ΩJitFnSettings,
-  jitArgs,
-  jitArgsWithOptions,
-  jitBinaryDeserializerArgs,
-  jitBinarySerializerArgs,
-  jitDefaultArgs,
-  jitDefaultArgsWithOptions,
-  jitDefaultBinaryDeserializerArgs,
-  jitDefaultBinarySerializerArgs,
-  jitDefaultErrorArgs,
-  jitErrorArgs,
-  jitFunctionList,
-  jitFunctionsById,
-  jitSerializationFunctions,
-  jitValidationFunctions
-};
-//# sourceMappingURL=constants.functions.js.map

package/.dist/esm/src/constants.functions.js.map

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

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

@@ -1,79 +0,0 @@
-const nonSerializableClasses = [
-  // TODO: decide what to do with native errors, they should be easily serializable
-  Error,
-  EvalError,
-  RangeError,
-  ReferenceError,
-  SyntaxError,
-  TypeError,
-  URIError,
-  AggregateError,
-  // Promise, // Promise has it's own RunType
-  // data types
-  WeakMap,
-  WeakSet,
-  DataView,
-  ArrayBuffer,
-  SharedArrayBuffer,
-  Float32Array,
-  Float64Array,
-  Int8Array,
-  Int16Array,
-  Int32Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Uint16Array,
-  Uint32Array,
-  BigInt64Array,
-  BigUint64Array
-];
-const nonSerializableGlobals = [
-  // TODO: decide what to do with native errors, they should be easily serializable
-  "Error",
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError",
-  "AggregateError",
-  // data types
-  "WeakMap",
-  "WeakSet",
-  "DataView",
-  "ArrayBuffer",
-  "SharedArrayBuffer",
-  "Float32Array",
-  "Float64Array",
-  "Int8Array",
-  "Int16Array",
-  "Int32Array",
-  "Uint8Array",
-  "Uint8ClampedArray",
-  "Uint16Array",
-  "Uint32Array",
-  "BigInt64Array",
-  "BigUint64Array",
-  // bellow are common interface names from standard libraries, they added here but not tested
-  "Generator",
-  "GeneratorFunction",
-  "AsyncGenerator",
-  "Iterator",
-  "AsyncGeneratorFunction",
-  "AsyncIterator"
-];
-const nativeUtilityStringTypes = ["Uppercase", "Lowercase", "Capitalize", "Uncapitalize"];
-const validPropertyNameRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-const maxStackErrorMessage = "Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.";
-const JIT_STACK_TRACE_MESSAGE = "\nJIT runType trace => ";
-const MAX_UNION_ITEMS = 2 ** 16 - 1;
-export {
-  JIT_STACK_TRACE_MESSAGE,
-  MAX_UNION_ITEMS,
-  maxStackErrorMessage,
-  nativeUtilityStringTypes,
-  nonSerializableClasses,
-  nonSerializableGlobals,
-  validPropertyNameRegExp
-};
-//# sourceMappingURL=constants.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sources":["../../../src/constants.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\n// native javascript objects that are not serializable\nexport const nonSerializableClasses = [\n    // TODO: decide what to do with native errors, they should be easily serializable\n    Error,\n    EvalError,\n    RangeError,\n    ReferenceError,\n    SyntaxError,\n    TypeError,\n    URIError,\n    AggregateError,\n    // Promise, // Promise has it's own RunType\n    // data types\n    WeakMap,\n    WeakSet,\n    DataView,\n    ArrayBuffer,\n    SharedArrayBuffer,\n    Float32Array,\n    Float64Array,\n    Int8Array,\n    Int16Array,\n    Int32Array,\n    Uint8Array,\n    Uint8ClampedArray,\n    Uint16Array,\n    Uint32Array,\n    BigInt64Array,\n    BigUint64Array,\n];\n\n// these are global objects that are not serializable.\n// values are repeated from nonSerializableClasses, as if they are classes or global object depends in typescript stn lib types and these can change\nexport const nonSerializableGlobals = [\n    // TODO: decide what to do with native errors, they should be easily serializable\n    'Error',\n    'EvalError',\n    'RangeError',\n    'ReferenceError',\n    'SyntaxError',\n    'TypeError',\n    'URIError',\n    'AggregateError',\n    // data types\n    'WeakMap',\n    'WeakSet',\n    'DataView',\n    'ArrayBuffer',\n    'SharedArrayBuffer',\n    'Float32Array',\n    'Float64Array',\n    'Int8Array',\n    'Int16Array',\n    'Int32Array',\n    'Uint8Array',\n    'Uint8ClampedArray',\n    'Uint16Array',\n    'Uint32Array',\n    'BigInt64Array',\n    'BigUint64Array',\n    // bellow are common interface names from standard libraries, they added here but not tested\n    'Generator',\n    'GeneratorFunction',\n    'AsyncGenerator',\n    'Iterator',\n    'AsyncGeneratorFunction',\n    'AsyncIterator',\n];\n\n// typescript utility types\nexport const nativeUtilityStringTypes = ['Uppercase', 'Lowercase', 'Capitalize', 'Uncapitalize'];\n\n// other constants\nexport const validPropertyNameRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;\nexport const maxStackErrorMessage =\n    'Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.';\nexport const JIT_STACK_TRACE_MESSAGE = '\\nJIT runType trace => ';\nexport const MAX_UNION_ITEMS = 2 ** 16 - 1;\n"],"names":[],"mappings":"AAQO,MAAM,yBAAyB;AAAA;AAAA,EAElC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;;AAKG,MAAM,yBAAyB;AAAA;AAAA,EAElC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;;AAIG,MAAM,2BAA2B,CAAC,aAAa,aAAa,cAAc,cAAc;AAGxF,MAAM,0BAA0B;AAChC,MAAM,uBACT;AACG,MAAM,0BAA0B;AAChC,MAAM,kBAAkB,KAAK,KAAK;"}