@mionjs/run-types 0.8.0-alpha.0

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

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

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

@@ -0,0 +1,59 @@
+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", "RunTypeOptions", `PP'4!8'4"8M4#8n$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

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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90-dark.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png">
+    <img alt='mion, a mikro kit for Typescript Serverless APIs' src='https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png'>
+  </picture>
+</p>
+<p align="center">
+  <strong>Common RunTypes.
+  </strong>
+</p>
+<p align=center>
+  <img src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+  <img src="https://img.shields.io/badge/license-MIT-97ca00.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+</p>
+
+# `@mionjs/run-types`
+
+Runtime Types support for mion apps!
+
+## Description
+
+This library provides support for runtime types based on [@deepkit/type].  
+Having runtime types enables a full new set of features when using typescript/javascript.
+
+## Check Out The [Website And Documentation](http://mion.io) 📚
+
+[![mion-website-banner](https://raw.githubusercontent.com/MionKit/mion/master/assets/public/mion-website-banner.png)](http://mion.io)
+
+---
+
+[MIT LICENSE](../../LICENSE)

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@mionjs/run-types",
+  "version": "0.8.0-alpha.0",
+  "type": "module",
+  "description": "Run time functionality directly from typescript types",
+  "keywords": [
+    "typescript",
+    "API",
+    "RPC",
+    "json",
+    "schema",
+    "generate",
+    "server",
+    "serverless",
+    "framework",
+    "node",
+    "runtime types",
+    "deepkit"
+  ],
+  "author": "ma jerez",
+  "homepage": "https://mion.io/",
+  "license": "MIT",
+  "browser": {
+    "./persist/jitFnCacheCompiler": false
+  },
+  "exports": {
+    ".": {
+      "source": "./index.ts",
+      "types": "./.dist/esm/index.d.ts",
+      "require": "./.dist/cjs/index.cjs",
+      "default": "./.dist/esm/index.js"
+    }
+  },
+  "directories": {
+    "lib": ".dist"
+  },
+  "files": [
+    ".dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MionKit/mion.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "dev": "vite build --watch",
+    "dev:test": "vitest watch",
+    "lint": "npx eslint src",
+    "format": "prettier --write src/**/*.ts",
+    "build": "vite build",
+    "clean": "rimraf .dist & rimraf .coverage",
+    "fresh-start": "npm run clean && rimraf node_modules"
+  },
+  "bugs": {
+    "url": "https://github.com/MionKit/mion/issues"
+  },
+  "dependencies": {
+    "@deepkit/core": "1.0.19",
+    "@deepkit/type": "1.0.19",
+    "@mionjs/core": "^0.8.0-alpha.0"
+  },
+  "gitHead": "5d2ec524ba39d040338ce8946d8edf78aa7291a3"
+}