@mionjs/run-types 0.8.6 → 0.8.8

package/src/nodes/atomic/enumMember.ts

@@ -0,0 +1,29 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {type TypeEnum} from '@deepkit/type';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+import {JitCode} from '../../types.ts';
+
+// TODO: not sure when run type will be generated but doesn't seem to be used when using reflection on enums
+export class EnumMemberRunType extends AtomicRunType<TypeEnum> {
+    skipJit() {
+        return true;
+    }
+    emitIsType(): JitCode {
+        throw new Error('Enum member operations are not supported');
+    }
+    emitTypeErrors(): JitCode {
+        throw new Error('Enum member operations are not supported');
+    }
+    emitPrepareForJson(): JitCode {
+        throw new Error('Enum member operations are not supported');
+    }
+    emitRestoreFromJson(): JitCode {
+        throw new Error('Enum member operations are not supported');
+    }
+}

package/src/nodes/atomic/literal.ts

@@ -0,0 +1,125 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {ReflectionKind, type TypeLiteral} from '@deepkit/type';
+import type {JitCode, RunType} from '../../types.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {Mutable} from '@mionjs/core';
+import {toLiteral} from '../../lib/utils.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+import {BigIntRunType} from './bigInt.ts';
+import {RegexpRunType} from './regexp.ts';
+import {SymbolRunType} from './symbol.ts';
+import {AnyKindName} from '../../constants.kind.ts';
+import {StringRunType} from './string.ts';
+import {NumberRunType} from './number.ts';
+import {BooleanRunType} from './boolean.ts';
+
+const stringRt = new StringRunType();
+const numberRt = new NumberRunType();
+const booleanRt = new BooleanRunType();
+const symbolRt = new SymbolRunType();
+const regexpRt = new RegexpRunType();
+const bigIntRt = new BigIntRunType();
+
+type AnyLiteralRunType = StringRunType | NumberRunType | BooleanRunType | SymbolRunType | RegexpRunType | BigIntRunType;
+
+export class LiteralRunType extends AtomicRunType<TypeLiteral> {
+    getRunTypeForLiteral(comp: JitFnCompiler): AnyLiteralRunType {
+        const noLiterals = comp.opts.noLiterals;
+        const lit = this.src.literal;
+        let rt: AnyLiteralRunType;
+        if (lit instanceof RegExp) {
+            rt = regexpRt;
+            (rt as Mutable<RunType>).src = this.src;
+            if (noLiterals) (this.src as any).kind = ReflectionKind.regexp;
+            return rt;
+        }
+        switch (typeof lit) {
+            case 'string':
+                rt = stringRt;
+                if (noLiterals) (this.src as any).kind = ReflectionKind.string;
+                break;
+            case 'number':
+                rt = numberRt;
+                if (noLiterals) (this.src as any).kind = ReflectionKind.number;
+                break;
+            case 'boolean':
+                rt = booleanRt;
+                if (noLiterals) (this.src as any).kind = ReflectionKind.boolean;
+                break;
+            case 'bigint':
+                rt = bigIntRt;
+                if (noLiterals) (this.src as any).kind = ReflectionKind.bigint;
+                break;
+            case 'symbol':
+                rt = symbolRt;
+                if (noLiterals) (this.src as any).kind = ReflectionKind.symbol;
+                break;
+            default:
+                throw new Error(`Unsupported literal type ${typeof lit}`);
+        }
+        (rt as Mutable<RunType>).src = this.src;
+        return rt;
+    }
+    emitIsType(comp: JitFnCompiler): JitCode {
+        if (comp.opts.noLiterals) return this.getRunTypeForLiteral(comp).emitIsType(comp);
+        return {code: compileIsLiteral(comp, this.src.literal), type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        if (comp.opts.noLiterals) return this.getRunTypeForLiteral(comp).emitTypeErrors(comp);
+        return {code: compileTypeErrorsLiteral(comp, this.src.literal, this.getKindName()), type: 'S'};
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        return this.getRunTypeForLiteral(comp).emitPrepareForJson(comp);
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        return this.getRunTypeForLiteral(comp).emitRestoreFromJson(comp);
+    }
+    getLiteralValue() {
+        return this.src.literal;
+    }
+}
+
+function compileIsLiteral(comp: JitFnCompiler, lit: TypeLiteral['literal']): string {
+    const literalType = typeof lit;
+    if (lit instanceof RegExp) return `${comp.vλl} instanceof RegExp && String(${comp.vλl}) === String(${lit})`;
+    switch (literalType) {
+        case 'string':
+            return `${comp.vλl} === ${toLiteral(lit)}`;
+        case 'number':
+            return `${comp.vλl} === ${toLiteral(lit)}`;
+        case 'boolean':
+            return `${comp.vλl} === ${toLiteral(lit)}`;
+        case 'bigint':
+            return `${comp.vλl} === ${toLiteral(lit)}`;
+        case 'symbol':
+            return `typeof ${comp.vλl} === 'symbol' && ${comp.vλl}.description === ${toLiteral((lit as symbol).description)}`;
+        default:
+            throw new Error(`Unsupported literal type ${literalType}`);
+    }
+}
+
+function compileTypeErrorsLiteral(comp: JitErrorsFnCompiler, lit: TypeLiteral['literal'], name: AnyKindName): string {
+    const literalType = typeof lit;
+    if (lit instanceof RegExp)
+        return `if (!(${comp.vλl} instanceof RegExp) || String(${comp.vλl}) !== String(${lit})) ${comp.callJitErr(name)}`;
+    switch (literalType) {
+        case 'string':
+            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
+        case 'number':
+            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
+        case 'boolean':
+            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
+        case 'bigint':
+            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
+        case 'symbol':
+            return `if (typeof ${comp.vλl} !== 'symbol' || ${comp.vλl}.description !== ${toLiteral((lit as symbol).description)}) {${comp.callJitErr(name)}}`;
+        default:
+            throw new Error(`Unsupported literal type ${literalType}`);
+    }
+}

package/src/nodes/atomic/never.ts

@@ -0,0 +1,26 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeNever} from '@deepkit/type';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+import {JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {JitCode} from '../../types.ts';
+
+export class NeverRunType extends AtomicRunType<TypeNever> {
+    emitIsType(): JitCode {
+        return {code: 'false', type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitPrepareForJson(): JitCode {
+        throw new Error('Never type cannot be encoded to JSON.');
+    }
+    emitRestoreFromJson(): JitCode {
+        throw new Error('Never type cannot be decoded from JSON.');
+    }
+}

package/src/nodes/atomic/null.ts

@@ -0,0 +1,26 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeNull} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {JitCode} from '../../types.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+
+export class NullRunType extends AtomicRunType<TypeNull> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `${comp.vλl} === null`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (${comp.vλl} !== null) ${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitPrepareForJson(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+    emitRestoreFromJson(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+}

package/src/nodes/atomic/number.ts

@@ -0,0 +1,26 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeNumber} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+
+export class NumberRunType extends AtomicRunType<TypeNumber> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `Number.isFinite(${comp.vλl})`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if(!(Number.isFinite(${comp.vλl}))) ${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitPrepareForJson(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+    emitRestoreFromJson(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+}

package/src/nodes/atomic/object.ts

@@ -0,0 +1,20 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeAny, TypeUnknown} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+export class ObjectRunType extends AtomicRunType<TypeAny | TypeUnknown> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null)`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (!(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null)) ${comp.callJitErr(this)}`, type: 'S'};
+    }
+}

package/src/nodes/atomic/regexp.ts

@@ -0,0 +1,29 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeRegexp} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+
+export class RegexpRunType extends AtomicRunType<TypeRegexp> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `(${comp.vλl} instanceof RegExp)`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (!(${comp.vλl} instanceof RegExp)) ${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        return {code: `${comp.vλl}.toString()`, type: 'E'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        return {
+            code: `(function(){const parts = ${comp.vλl}.match(/\\/(.*)\\/(.*)?/) ;return new RegExp(parts[1], parts[2] || '')})()`,
+            type: 'E',
+        };
+    }
+}

package/src/nodes/atomic/string.ts

@@ -0,0 +1,20 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeString} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+export class StringRunType extends AtomicRunType<TypeString> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `typeof ${comp.vλl} === 'string'`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (typeof ${comp.vλl} !== 'string') ${comp.callJitErr(this)}`, type: 'S'};
+    }
+}

package/src/nodes/atomic/symbol.ts

@@ -0,0 +1,31 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeSymbol} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+
+export class SymbolRunType extends AtomicRunType<TypeSymbol> {
+    skipJit(comp: JitFnCompiler): boolean {
+        if (!comp) return true;
+        return comp.fnID !== JitFunctions.toJSCode.id;
+    }
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `typeof ${comp.vλl} === 'symbol'`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (typeof ${comp.vλl} !== 'symbol') ${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        return {code: `'Symbol:' + (${comp.vλl}.description || '')`, type: 'E'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        return {code: `Symbol(${comp.vλl}.substring(7))`, type: 'E'};
+    }
+}

package/src/nodes/atomic/undefined.ts

@@ -0,0 +1,23 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeUndefined} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {JitCode} from '../../types.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+
+export class UndefinedRunType extends AtomicRunType<TypeUndefined> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `typeof ${comp.vλl} === 'undefined'`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (typeof ${comp.vλl} !== 'undefined') ${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitRestoreFromJson(): JitCode {
+        return {code: `undefined`, type: 'E'};
+    }
+}

package/src/nodes/atomic/unknown.ts

@@ -0,0 +1,10 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {AnyRunType} from './any.ts';
+
+export class UnknownRunType extends AnyRunType {}

package/src/nodes/atomic/void.ts

@@ -0,0 +1,26 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeVoid} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+export class VoidRunType extends AtomicRunType<TypeVoid> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `${comp.vλl} === undefined`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (${comp.vλl} !== undefined) ${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        return {code: `${comp.vλl} = undefined`, type: 'E'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        return {code: `${comp.vλl} = undefined`, type: 'E'};
+    }
+}

package/src/nodes/collection/class.ts

@@ -0,0 +1,36 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import {TypeClass} from '@deepkit/type';
+import {InterfaceMember, InterfaceRunType} from './interface.ts';
+import {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {getJitUtils} from '@mionjs/core';
+import {toLiteral} from '../../lib/utils.ts';
+import {isConstructor} from '../../lib/guards.ts';
+import {JitCode} from '../../types.ts';
+
+export class ClassRunType extends InterfaceRunType<TypeClass> {
+    getClassName(): string {
+        return this.src.classType.name;
+    }
+    isClassWithEmptyConstructor(): boolean {
+        const children = this.getChildRunTypes() as InterfaceMember[];
+        const isEmpty = children.every((prop) => !isConstructor(prop) || prop.getParameters().getChildRunTypes().length === 0);
+        return isEmpty;
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        const objJit = super.emitRestoreFromJson(comp);
+        const desFnVarName = comp.getLocalVarName('desFn', this);
+        const classLiteral = toLiteral(this.getClassName());
+        const code = `
+            ${objJit.code};
+            let ${desFnVarName} = utl.${getJitUtils().getDeserializeFn.name}(${classLiteral});
+            if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}
+            else if (${desFnVarName} = utl.${getJitUtils().getSerializeClass.name}(${classLiteral})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}
+        `;
+        return {code, type: 'S'};
+    }
+}

package/src/nodes/collection/functionParams.ts

@@ -0,0 +1,42 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeFunction} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {AnyParameterListRunType, JitCode} from '../../types.ts';
+import {TupleRunType} from './tuple.ts';
+import {ParameterRunType} from '../member/param.ts';
+
+export class FunctionParamsRunType<ParamList extends AnyParameterListRunType = TypeFunction> extends TupleRunType<
+    ParamList,
+    ParameterRunType
+> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (children.length === 0) return {code: `${comp.vλl}.length === 0`, type: 'E'};
+        const lengthCode = this.hasRestParameter(comp) ? '' : `${comp.vλl}.length <= ${children.length}`;
+        // Only include parameters that require validation
+        const paramsCode = children.map((p) => comp.compileIsType(p, 'E').code).filter(Boolean);
+        if (paramsCode.length === 0) return lengthCode ? {code: `(${lengthCode})`, type: 'E'} : {code: undefined, type: 'E'};
+        return lengthCode
+            ? {code: `(${lengthCode} && ${paramsCode.join(' && ')})`, type: 'E'}
+            : {code: `(${paramsCode.join(' && ')})`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (children.length === 0) return {code: `if (${comp.vλl}.length !== 0) ${comp.callJitErr(this)}`, type: 'S'};
+        const lengthCode = this.hasRestParameter(comp) ? '' : `${comp.vλl}.length > ${children.length}`;
+
+        // Only include parameters that require validation
+        const paramsCode = children.map((p) => comp.compileTypeErrors(p, 'S').code).filter(Boolean);
+        if (paramsCode.length === 0)
+            return lengthCode ? {code: `if (${lengthCode}) ${comp.callJitErr(this)}`, type: 'S'} : {code: undefined, type: 'S'};
+        return lengthCode
+            ? {code: `if (${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode.join(';')}}`, type: 'S'}
+            : {code: paramsCode.join(';'), type: 'S'};
+    }
+}