@mionjs/run-types 0.8.0-alpha.0

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

@@ -0,0 +1,385 @@
+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[];

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

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+import { ReflectionKind } from '@deepkit/type';
+import { RunType } from './types.ts';
+export declare const ReflectionKindName: {
+    [key: number]: keyof typeof ReflectionKind;
+};
+export declare const ReflectionSubKind: {
+    readonly date: 2001;
+    readonly map: 2002;
+    readonly set: 2003;
+    readonly nonSerializable: 2004;
+    readonly params: 1701;
+    readonly mapKey: 1801;
+    readonly mapValue: 1802;
+    readonly setItem: 1803;
+};
+export declare const ReflectionSubNames: {
+    [key: number]: keyof typeof ReflectionSubKind;
+};
+export type AnyKindName = keyof typeof ReflectionKind | keyof typeof ReflectionSubKind;
+export declare function getReflectionName(rt: RunType): AnyKindName;
+export declare type __ΩAnyKindName = any[];