@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/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/cjs/src/constants.kind.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_types = require("./types.cjs");
+const ReflectionKindName = {
+  0: "never",
+  1: "any",
+  2: "unknown",
+  3: "void",
+  4: "objectLiteral",
+  // name was changed from deepkit's 'object' to 'objectLiteral'
+  5: "string",
+  6: "number",
+  7: "boolean",
+  8: "symbol",
+  9: "bigint",
+  10: "null",
+  11: "undefined",
+  12: "regexp",
+  13: "literal",
+  14: "templateLiteral",
+  15: "property",
+  16: "method",
+  17: "function",
+  18: "parameter",
+  19: "promise",
+  20: "class",
+  21: "typeParameter",
+  22: "enum",
+  23: "union",
+  24: "intersection",
+  25: "array",
+  26: "tuple",
+  27: "tupleMember",
+  28: "enumMember",
+  29: "rest",
+  30: "object",
+  // name was changed from deepkit's 'objectLiteral' to 'object' for better error messages
+  31: "indexSignature",
+  32: "propertySignature",
+  33: "methodSignature",
+  34: "infer",
+  35: "callSignature"
+};
+const ReflectionSubKind = {
+  // group of sub-kinds that extends ReflectionKind.class
+  date: 2001,
+  map: 2002,
+  set: 2003,
+  nonSerializable: 2004,
+  params: 1701,
+  mapKey: 1801,
+  mapValue: 1802,
+  setItem: 1803
+};
+const ReflectionSubNames = {
+  2001: "date",
+  2002: "map",
+  2003: "set",
+  1701: "params"
+};
+const __ΩAnyKindName = [() => type.ReflectionKind, () => ReflectionSubKind, "AnyKindName", 'Pi!gi"gJw#y'];
+function getReflectionName(rt) {
+  if (rt.src.subKind)
+    return ReflectionSubNames[rt.src.subKind];
+  return ReflectionKindName[rt.src.kind];
+}
+getReflectionName.__type = [() => src_types.__ΩRunType, "rt", () => __ΩAnyKindName, "getReflectionName", 'Pn!2"n#/$'];
+exports.ReflectionKindName = ReflectionKindName;
+exports.ReflectionSubKind = ReflectionSubKind;
+exports.ReflectionSubNames = ReflectionSubNames;
+exports.__ΩAnyKindName = __ΩAnyKindName;
+exports.getReflectionName = getReflectionName;
+//# sourceMappingURL=constants.kind.cjs.map

package/.dist/cjs/src/constants.kind.cjs.map

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

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