@mionjs/run-types 0.8.7 → 0.8.10

package/src/nodes/member/array.ts

@@ -0,0 +1,150 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {Type, TypeArray} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {MemberRunType} from '../../lib/baseRunTypes.ts';
+import {childIsExpression} from '../../lib/utils.ts';
+
+export class ArrayRunType<T extends Type = TypeArray> extends MemberRunType<T> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    startIndex(comp: JitFnCompiler): number {
+        return 0;
+    }
+    getChildVarName(comp: JitFnCompiler): string {
+        return comp.getLocalVarName('i', this);
+    }
+    getChildLiteral(comp: JitFnCompiler): string {
+        return this.getChildVarName(comp);
+    }
+    useArrayAccessor(): true {
+        return true;
+    }
+    isOptional(): boolean {
+        return false;
+    }
+
+    // #### jit code ####
+    emitIsType(comp: JitFnCompiler): JitCode {
+        this.checkNonSkipTypes(comp);
+        const resultVal = comp.getLocalVarName('res', this);
+        const index = this.getChildVarName(comp);
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileIsType(child, 'E');
+        if (!childJit?.code && comp.opts.noIsArrayCheck) return {code: undefined, type: 'E'};
+        if (!childJit?.code) return {code: `Array.isArray(${comp.vλl})`, type: 'E'};
+        const isArrayCheckCode = comp.opts.noIsArrayCheck ? '' : `if (!Array.isArray(${comp.vλl})) return false;`;
+        return {
+            code: `
+            ${isArrayCheckCode}
+            for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
+                const ${resultVal} = ${childJit.code};
+                if (!(${resultVal})) return false;
+            }
+            return true;
+        `,
+            type: 'RB',
+        };
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        this.checkNonSkipTypes(comp);
+        const index = this.getChildVarName(comp);
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileTypeErrors(child, 'S');
+        if (!childJit?.code && comp.opts.noIsArrayCheck) return {code: undefined, type: 'E'};
+        if (!childJit?.code) return {code: `if (!Array.isArray(${comp.vλl})) ${comp.callJitErr(this)};`, type: 'S'};
+        const itemsCode = `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${childJit.code}}`;
+        if (comp.opts.noIsArrayCheck) return {code: itemsCode, type: 'S'};
+        return {
+            code: `if (!Array.isArray(${comp.vλl})) {${comp.callJitErr(this)}} else {${itemsCode}}`,
+            type: 'S',
+        };
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        this.checkNonSkipTypes(comp);
+        const index = this.getChildVarName(comp);
+        const child = this.getJitChild(comp);
+        const childJit = comp.compilePrepareForJson(child, 'S');
+        if (!childJit?.code || !child) return {code: undefined, type: 'S'};
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        return {
+            code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${code}}`,
+            type: 'S',
+        };
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        this.checkNonSkipTypes(comp);
+        const index = this.getChildVarName(comp);
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileRestoreFromJson(child, 'S');
+        if (!childJit?.code || !child) return {code: undefined, type: 'S'};
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        return {
+            code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${code}}`,
+            type: 'S',
+        };
+    }
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        this.checkNonSkipTypes(comp);
+        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'E'};
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileHasUnknownKeys(child, 'E');
+        if (!childJit?.code) return {code: undefined, type: 'E'};
+        const resultVal = comp.getLocalVarName('res', this);
+        const index = this.getChildVarName(comp);
+
+        return {
+            code: `
+            if (!Array.isArray(${comp.vλl})) return false;
+            for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
+                const ${resultVal} = ${childJit.code};
+                if (${resultVal}) return true;
+            }
+            return false;
+        `,
+            type: 'RB',
+        };
+    }
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
+        this.checkNonSkipTypes(comp);
+        if (this.getMemberType().getFamily() === 'A') return {code: '', type: 'E'};
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileUnknownKeyErrors(child, 'S');
+        return this.traverseCode(comp, childJit);
+    }
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        this.checkNonSkipTypes(comp);
+        if (this.getMemberType().getFamily() === 'A') return {code: '', type: 'E'};
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileStripUnknownKeys(child, 'S');
+        return this.traverseCode(comp, childJit);
+    }
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        this.checkNonSkipTypes(comp);
+        if (this.getMemberType().getFamily() === 'A') return {code: '', type: 'E'};
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileUnknownKeysToUndefined(child, 'S');
+        return this.traverseCode(comp, childJit);
+    }
+
+    traverseCode(comp: JitFnCompiler, childJit: JitCode | undefined): {code: string | undefined; type: 'S'} {
+        if (!childJit?.code) return {code: undefined, type: 'S'};
+        const index = this.getChildVarName(comp);
+        return {
+            code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${childJit.code}}`,
+            type: 'S',
+        };
+    }
+
+    checkNonSkipTypes(comp: JitFnCompiler) {
+        const child = this.getMemberType();
+        if (child.skipJit(comp)) throw new Error(`Arrays can not have non serializable types, ie: Symbol[], Function[], etc.`);
+    }
+}

package/src/nodes/member/callSignature.ts

@@ -0,0 +1,34 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import {TypeCallSignature} from '@deepkit/type';
+import {RunTypeChildAccessor} from '../../types.ts';
+import {getPropIndex} from '../../lib/utils.ts';
+import {FunctionRunType} from '../function/function.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+/**
+ * Represents a call signature.
+ * Call signature is an special node within in interface or object literal that represents a function signature but can have extra properties.
+ * ie:
+ * type  = {
+ *  (a: number, b: boolean): string; // call signature node
+ *  popA: number;
+ * }
+ *
+ * So when a call signature is present the parent object literal or interface is considered a function.
+ */
+export class CallSignatureRunType extends FunctionRunType<TypeCallSignature> implements RunTypeChildAccessor {
+    getChildIndex = (comp: JitFnCompiler) => {
+        const start = comp?.opts?.paramsSlice?.start;
+        if (start) return getPropIndex(this.src) - start;
+        return getPropIndex(this.src);
+    };
+    getChildVarName = () => '';
+    getChildLiteral = () => '""';
+    useArrayAccessor = () => false;
+    isOptional = () => false;
+}

package/src/nodes/member/genericMember.ts

@@ -0,0 +1,63 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {MemberRunType} from '../../lib/baseRunTypes.ts';
+import type {JitCode, SrcMember} from '../../types.ts';
+import {childIsExpression} from '../../lib/utils.ts';
+
+// TODO: investigate is other member types cloud extend this class instead of MemberRunType
+export class GenericMemberRunType<T extends SrcMember> extends MemberRunType<T> {
+    index = 0;
+    getChildIndex() {
+        return this.index;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getChildVarName(comp: JitFnCompiler): string | number {
+        return this.index;
+    }
+    getChildLiteral(comp: JitFnCompiler) {
+        return this.getChildVarName(comp);
+    }
+    useArrayAccessor() {
+        return true;
+    }
+    isOptional() {
+        return false;
+    }
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileIsType(child, 'E');
+        if (!childJit?.code) return {code: undefined, type: 'E'};
+        if (this.isOptional()) return {code: `${comp.getChildVλl()} === undefined || (${childJit.code})`, type: 'E'};
+        return childJit;
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileTypeErrors(child, 'S');
+        if (!childJit?.code) return {code: undefined, type: 'S'};
+        if (this.isOptional()) return {code: `if (${comp.getChildVλl()} !== undefined) {${childJit.code}}`, type: 'S'};
+        return childJit;
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compilePrepareForJson(child, 'S');
+        if (!childJit?.code || !child) return {code: undefined, type: 'S'};
+        const isExpression = childIsExpression(childJit, child); // expressions must be assigned to a variable
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code}` : childJit.code || '';
+        if (this.isOptional()) return {code: `if (${comp.getChildVλl()} !== undefined) {${code}}`, type: 'S'};
+        return {code, type: 'S'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileRestoreFromJson(child, 'S');
+        if (!childJit?.code || !child) return {code: undefined, type: 'S'};
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        if (this.isOptional()) return {code: `if (${comp.getChildVλl()} !== undefined) {${code}}`, type: 'S'};
+        return {code, type: 'S'};
+    }
+}

package/src/nodes/member/indexProperty.ts

@@ -0,0 +1,174 @@
+import {ReflectionKind, type TypeIndexSignature, type TypeTemplateLiteral} from '@deepkit/type';
+import {MemberRunType} from '../../lib/baseRunTypes.ts';
+import {type JitCode} from '../../types.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {InterfaceRunType} from '../collection/interface.ts';
+import {childIsExpression} from '../../lib/utils.ts';
+import {buildAnchoredTemplateRegexSource} from '../collection/templateLiteral.ts';
+
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+export class IndexSignatureRunType extends MemberRunType<TypeIndexSignature> {
+    isOptional(): boolean {
+        return true;
+    }
+    getChildVarName(comp: JitFnCompiler): string {
+        return comp.getLocalVarName('p', this);
+    }
+    getChildLiteral(comp: JitFnCompiler): string {
+        return this.getChildVarName(comp);
+    }
+    useArrayAccessor(): true {
+        return true;
+    }
+    skipJit(comp: JitFnCompiler): boolean {
+        const index = (this.src as TypeIndexSignature).index?.kind;
+        if (index === ReflectionKind.symbol) {
+            return comp?.fnID !== JitFunctions.toJSCode.id;
+        }
+        return false;
+    }
+
+    /** if the index key is a template literal type, return the JIT context var holding the compiled key-pattern regex */
+    private getKeyPatternVar(comp: JitFnCompiler): string | undefined {
+        const idx = this.src.index;
+        if (idx?.kind !== ReflectionKind.templateLiteral) return undefined;
+        const varName = comp.getLocalVarName('reIdx', this);
+        if (!comp.hasContextItem(varName)) {
+            const src = buildAnchoredTemplateRegexSource((idx as TypeTemplateLiteral).types || []);
+            comp.setContextItem(varName, `const ${varName} = new RegExp(${JSON.stringify(src)})`);
+        }
+        return varName;
+    }
+
+    // #### jit code ####
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileIsType(child, 'E');
+        const prop = this.getChildVarName(comp);
+        const reVar = this.getKeyPatternVar(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const keyCheck = reVar ? `if (!${reVar}.test(${prop})) return false;` : '';
+        if (!childJit?.code && !keyCheck) return {code: undefined, type: 'E'};
+        const valueCheck = childJit?.code ? `if (!(${childJit.code})) return false;` : '';
+        return {
+            code: `for (const ${prop} in ${comp.vλl}){${skipCode} ${keyCheck} ${valueCheck}} return true;`,
+            type: 'RB',
+        };
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileTypeErrors(child, 'S');
+        const prop = this.getChildVarName(comp);
+        const reVar = this.getKeyPatternVar(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        // when the key fails the template literal pattern, report it (with the offending key in the path)
+        // and skip the value check to avoid compounding errors on values whose key was already invalid
+        const keyErr = reVar ? `if (!${reVar}.test(${prop})) {${comp.callJitErrWithPath(this, prop)}; continue;}` : '';
+        if (!childJit?.code && !keyErr) return {code: undefined, type: 'S'};
+        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${keyErr} ${childJit?.code || ''}}`, type: 'S'};
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compilePrepareForJson(child, 'S');
+        if (!child || !childJit?.code) return {code: undefined, type: 'S'};
+        const varName = comp.vλl;
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const reVar = this.getKeyPatternVar(comp);
+        const patternSkip = reVar ? `if (!${reVar}.test(${prop})) continue;` : '';
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        return {code: `for (const ${prop} in ${varName}){${skipCode} ${patternSkip} ${code}}`, type: 'S'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileRestoreFromJson(child, 'S');
+        if (!child || !childJit?.code) return {code: undefined, type: 'S'};
+        const varName = comp.vλl;
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const reVar = this.getKeyPatternVar(comp);
+        const patternSkip = reVar ? `if (!${reVar}.test(${prop})) continue;` : '';
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        return {code: `for (const ${prop} in ${varName}){${skipCode} ${patternSkip} ${code}}`, type: 'S'};
+    }
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        const reVar = this.getKeyPatternVar(comp);
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileHasUnknownKeys(child, 'E');
+        // when the value is atomic and there's no key pattern, every key is "known" -> no check needed
+        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'E'};
+        const varName = comp.vλl;
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const patternCheck = reVar ? `if (!${reVar}.test(${prop})) return true;` : '';
+        const childCheck = childJit?.code
+            ? `const ${comp.getLocalVarName('res', this)} = ${childJit.code};if (${comp.getLocalVarName('res', this)}) return true;`
+            : '';
+        if (!patternCheck && !childCheck) return {code: '', type: 'E'};
+        return {
+            code: `for (const ${prop} in ${varName}) {${skipCode} ${patternCheck} ${childCheck}}return false;`,
+            type: 'RB',
+        };
+    }
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
+        const reVar = this.getKeyPatternVar(comp);
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileUnknownKeyErrors(child, 'S');
+        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const patternErr = reVar ? `if (!${reVar}.test(${prop})) {${comp.callJitErrWithPath('never', prop)}; continue;}` : '';
+        if (!patternErr && !childJit?.code) return {code: undefined, type: 'S'};
+        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternErr} ${childJit?.code || ''}}`, type: 'S'};
+    }
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        const reVar = this.getKeyPatternVar(comp);
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileStripUnknownKeys(child, 'S');
+        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const patternStrip = reVar ? `if (!${reVar}.test(${prop})) {delete ${comp.vλl}[${prop}]; continue;}` : '';
+        if (!patternStrip && !childJit?.code) return {code: undefined, type: 'S'};
+        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternStrip} ${childJit?.code || ''}}`, type: 'S'};
+    }
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        const reVar = this.getKeyPatternVar(comp);
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileUnknownKeysToUndefined(child, 'S');
+        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const patternUndef = reVar ? `if (!${reVar}.test(${prop})) {${comp.vλl}[${prop}] = undefined; continue;}` : '';
+        if (!patternUndef && !childJit?.code) return {code: undefined, type: 'S'};
+        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternUndef} ${childJit?.code || ''}}`, type: 'S'};
+    }
+    traverseCode(comp: JitFnCompiler, childJit: JitCode | undefined): JitCode {
+        if (!childJit?.code) return {code: undefined, type: 'S'};
+        const prop = this.getChildVarName(comp);
+        return {code: `for (const ${prop} in ${comp.vλl}) {${childJit.code}}`, type: 'S'};
+    }
+    /**
+     * if index property should be skipped then it output some code to skip it,
+     * this happen when an object/interface has an index property but also has named properties
+     * that might collide with the index property. ie {[key: string]: string, a: string}
+     * when executing the logic for the index property we need to skip the named properties.
+     */
+    getSkipCode(comp: JitFnCompiler, prop: string): string {
+        const parent = this.getParent() as InterfaceRunType;
+        const namedChildren = parent.getNamedChildren(comp);
+        const skipNames = namedChildren.length
+            ? namedChildren.map((child) => `${child.getChildLiteral(comp)} === ${prop}`).join(' || ')
+            : '';
+        return namedChildren.length ? `if (${skipNames}) continue;` : '';
+    }
+}

package/src/nodes/member/method.ts

@@ -0,0 +1,30 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import {TypeMethod} from '@deepkit/type';
+import {FunctionRunType} from '../function/function.ts';
+import {RunTypeChildAccessor} from '../../types.ts';
+import {getPropIndex, getPropLiteral, getPropVarName, useArrayAccessorForProp} from '../../lib/utils.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+export class MethodRunType extends FunctionRunType<TypeMethod> implements RunTypeChildAccessor {
+    getChildIndex = (comp: JitFnCompiler) => {
+        const start = comp?.opts?.paramsSlice?.start;
+        if (start) return getPropIndex(this.src) - start;
+        return getPropIndex(this.src);
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getChildVarName(comp: JitFnCompiler) {
+        return getPropVarName(this.src.name);
+    }
+    getChildLiteral(comp: JitFnCompiler) {
+        return getPropLiteral(this.getChildVarName(comp));
+    }
+    useArrayAccessor() {
+        return useArrayAccessorForProp(this.src.name);
+    }
+    isOptional = () => !!this.src.optional;
+}

package/src/nodes/member/methodSignature.ts

@@ -0,0 +1,31 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import {TypeMethodSignature} from '@deepkit/type';
+import {RunTypeChildAccessor} from '../../types.ts';
+import {FunctionRunType} from '../function/function.ts';
+import {getPropIndex, getPropLiteral, getPropVarName, useArrayAccessorForProp} from '../../lib/utils.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+export class MethodSignatureRunType extends FunctionRunType<TypeMethodSignature> implements RunTypeChildAccessor {
+    getChildIndex = (comp: JitFnCompiler) => {
+        const start = comp?.opts?.paramsSlice?.start;
+        if (start) return getPropIndex(this.src) - start;
+        return getPropIndex(this.src);
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getChildVarName(comp: JitFnCompiler) {
+        return getPropVarName(this.src.name);
+    }
+    getChildLiteral(comp: JitFnCompiler) {
+        return getPropLiteral(this.getChildVarName(comp));
+    }
+    useArrayAccessor() {
+        return useArrayAccessorForProp(this.src.name);
+    }
+    isOptional = () => !!this.src.optional;
+    skipCommas = false;
+}

package/src/nodes/member/param.ts

@@ -0,0 +1,22 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeParameter} from '@deepkit/type';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {TupleMemberRunType} from './tupleMember.ts';
+
+export class ParameterRunType<T extends TypeParameter = TypeParameter> extends TupleMemberRunType<T> {
+    getParamName() {
+        return this.src.name;
+    }
+    getChildVarName(comp: JitFnCompiler): number {
+        return this.getChildIndex(comp);
+    }
+    getChildLiteral(comp: JitFnCompiler): number {
+        return this.getChildIndex(comp);
+    }
+}

package/src/nodes/member/property.ts

@@ -0,0 +1,75 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeProperty, TypePropertySignature} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {JitCode} from '../../types.ts';
+import {childIsExpression, getPropLiteral, getPropVarName, useArrayAccessorForProp} from '../../lib/utils.ts';
+import {MemberRunType} from '../../lib/baseRunTypes.ts';
+import {InterfaceRunType} from '../collection/interface.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+
+export class PropertyRunType extends MemberRunType<TypePropertySignature | TypeProperty> {
+    isUnionDiscriminator = false;
+    /** this is set by the parent interface if prop is optional, when optional properties are sorted */
+    optionalIndex = -1;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getPropertyName() {
+        return getPropVarName(this.src.name);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getChildVarName(comp: JitFnCompiler) {
+        return getPropVarName(this.src.name);
+    }
+    getChildLiteral(comp: JitFnCompiler) {
+        return getPropLiteral(this.getChildVarName(comp));
+    }
+    useArrayAccessor() {
+        return useArrayAccessorForProp(this.src.name);
+    }
+    getJitChildIndex = (comp: JitFnCompiler) => (this.getParent() as InterfaceRunType).getJitChildren(comp).indexOf(this);
+    isOptional = () => !!this.src.optional;
+    skipJit(comp: JitFnCompiler): boolean {
+        const name = (this.src as TypeProperty).name;
+        if (typeof name === 'symbol') {
+            return comp?.fnID !== JitFunctions.toJSCode.id;
+        }
+        return false;
+    }
+    // #### jit code ####
+
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileIsType(child, 'E');
+        if (!childJit?.code) return {code: undefined, type: 'E'};
+        return this.src.optional ? {code: `(${comp.getChildVλl()} === undefined || ${childJit.code})`, type: 'E'} : childJit;
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileTypeErrors(child, 'S');
+        if (!childJit?.code) return {code: undefined, type: 'S'};
+        return this.src.optional ? {code: `if (${comp.getChildVλl()} !== undefined) {${childJit.code}}`, type: 'S'} : childJit;
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compilePrepareForJson(child, 'S');
+        if (!child || !childJit?.code) return {code: undefined, type: 'S'};
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        if (this.src.optional) return {code: `if (${comp.getChildVλl()} !== undefined) {${code}}`, type: 'S'};
+        return {code, type: 'S'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileRestoreFromJson(child, 'S');
+        if (!child || !childJit?.code) return {code: undefined, type: 'S'};
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        if (this.src.optional) return {code: `if (${comp.getChildVλl()} !== undefined) {${code}}`, type: 'S'};
+        return {code, type: 'S'};
+    }
+}

package/src/nodes/member/restParams.ts

@@ -0,0 +1,22 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeRest} from '@deepkit/type';
+import type {ParameterRunType} from './param.ts';
+import type {TupleMemberRunType} from './tupleMember.ts';
+import {ArrayRunType} from './array.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+export class RestParamsRunType extends ArrayRunType<TypeRest> {
+    getChildIndex(comp: JitFnCompiler): number {
+        const parent = this.getParent() as ParameterRunType | TupleMemberRunType;
+        return parent.getChildIndex(comp);
+    }
+    startIndex(comp: JitFnCompiler): number {
+        return this.getChildIndex(comp);
+    }
+}