@mionjs/run-types 0.8.7 → 0.8.8

package/src/nodes/collection/unionDiscriminator.ts

@@ -0,0 +1,259 @@
+import type {BaseRunType, CollectionRunType, MemberRunType} from '../../lib/baseRunTypes.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {UnionRunType} from './union.ts';
+import type {PropertyRunType} from '../member/property.ts';
+import {getTotalComplexity, sortRunTypeByComplexity} from '../../lib/utils.ts';
+import {isAnyRunType, isUnknownRunType} from '../../lib/guards.ts';
+
+export type FlattenedProp = {
+    /** union item, parent of the property */
+    unionItem: CollectionRunType<any>;
+    /** index of the union item in the union */
+    unionIndex: string | number;
+    /** one property of the union item  */
+    prop: PropertyRunType;
+    /** typeID of the property */
+    typeID: string | number;
+    /** name of the property as it should be used in the code */
+    compiledName: string;
+};
+
+export type SplitUnionResult = {
+    simpleItems: BaseRunType[];
+    objectTypes: CollectionRunType<any>[];
+    /** any or unknown type if present in the union, should be checked last */
+    anyItem?: BaseRunType;
+};
+
+/**
+ * Split the union types in two groups: interface types and simple types
+ * interface types are types that have properties, simple types are the rest (atomic types, tuples, etc)
+ * If any or unknown types are present, they are extracted and returned separately as anyItem
+ * so they can be checked last (any/unknown would match anything, so must be last resort)
+ */
+export function splitUnionItems(comp: JitFnCompiler, urt: UnionRunType, unionChildren?: BaseRunType[]): SplitUnionResult {
+    const unionItems = unionChildren || urt.getJitChildren(comp);
+    const objectTypes: CollectionRunType<any>[] = [];
+    const simpleItems: BaseRunType[] = [];
+    let anyItem: BaseRunType | undefined;
+
+    unionItems.forEach((unionItem) => {
+        // Extract any/unknown types to be checked last
+        if (isAnyRunType(unionItem) || isUnknownRunType(unionItem)) {
+            // Only keep the first any/unknown type (having multiple is redundant)
+            if (!anyItem) anyItem = unionItem;
+            return;
+        }
+        const isObj = urt.isTypeWithProperties(unionItem);
+        if (!isObj) return simpleItems.push(unionItem);
+        return objectTypes.push(unionItem as CollectionRunType<any>);
+    });
+
+    // Sort object types to prevent unreachable types (objects with more props should come first when they share same prop types)
+    const sortedObjectTypes = sortUnreachableTypes(comp, objectTypes);
+
+    return {simpleItems, objectTypes: sortedObjectTypes, anyItem};
+}
+
+/**
+ * Sorts object types to prevent unreachable union types.
+ * When two objects share the same properties (by typeID), the one with more properties must come first.
+ * This ensures that at runtime, the more specific type is checked before the less specific one.
+ * Objects that don't share properties with others maintain their relative order.
+ */
+export function sortUnreachableTypes(comp: JitFnCompiler, objectTypes: CollectionRunType<any>[]): CollectionRunType<any>[] {
+    if (objectTypes.length <= 1) return objectTypes;
+
+    // Get property typeIDs for each object type
+    const typePropsMap = new Map<CollectionRunType<any>, Set<string | number>>();
+    objectTypes.forEach((objType) => {
+        const props = objType.getJitChildren(comp) as PropertyRunType[];
+        const propTypeIDs = new Set<string | number>();
+        props.forEach((prop) => propTypeIDs.add(prop.getTypeID()));
+        typePropsMap.set(objType, propTypeIDs);
+    });
+
+    // Check if one object's props are a subset of another's (all props have same typeIDs)
+    const isSubsetOf = (smaller: CollectionRunType<any>, larger: CollectionRunType<any>): boolean => {
+        const smallerProps = typePropsMap.get(smaller)!;
+        const largerProps = typePropsMap.get(larger)!;
+        if (smallerProps.size >= largerProps.size) return false;
+        for (const typeID of smallerProps) {
+            if (!largerProps.has(typeID)) return false;
+        }
+        return true;
+    };
+
+    // Find groups of objects that share properties (one is subset of another)
+    const processed = new Set<CollectionRunType<any>>();
+    const result: CollectionRunType<any>[] = [];
+
+    for (let i = 0; i < objectTypes.length; i++) {
+        const current = objectTypes[i];
+        if (processed.has(current)) continue;
+
+        // Find all objects that are related (subset/superset) to current
+        const relatedGroup: CollectionRunType<any>[] = [current];
+        processed.add(current);
+
+        for (let j = 0; j < objectTypes.length; j++) {
+            if (i === j) continue;
+            const other = objectTypes[j];
+            if (processed.has(other)) continue;
+
+            // Check if current and other are related (one is subset of the other)
+            if (isSubsetOf(current, other) || isSubsetOf(other, current)) {
+                relatedGroup.push(other);
+                processed.add(other);
+            }
+        }
+
+        // Sort related group by number of properties (more props first)
+        if (relatedGroup.length > 1) {
+            relatedGroup.sort((a, b) => {
+                const aSize = typePropsMap.get(a)!.size;
+                const bSize = typePropsMap.get(b)!.size;
+                return bSize - aSize; // descending order (more props first)
+            });
+        }
+
+        result.push(...relatedGroup);
+    }
+
+    return result;
+}
+
+/**
+ * Mark discriminator properties so they can be sorted and validate union more efficiently.
+ * @param comp
+ * @param urt
+ */
+export function markDiscriminators(comp: JitFnCompiler, urt: UnionRunType, unionItems: BaseRunType[]) {
+    if (urt.hasDiscriminators !== undefined && urt.hasObjectTypes !== undefined) return;
+    const objectTypes = unionItems.filter((item) => urt.isTypeWithProperties(item)) as CollectionRunType<any>[];
+    const namedDiscriminators = getDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
+    const uniqueDiscriminators = getUniqueDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
+    urt.hasObjectTypes = !!objectTypes.length;
+    urt.hasDiscriminators = !!namedDiscriminators.length || !!uniqueDiscriminators.length;
+}
+
+type PropUnionItemPair = {prop: PropertyRunType; unionItem: CollectionRunType<any>};
+
+/**
+ * Find a property with the same name in all the types of the union and that has different types.
+ * It also marks those properties as discriminator properties so can be sorted later
+ */
+function getDiscriminatorProperties(
+    comp: JitFnCompiler,
+    urt: UnionRunType,
+    unionTypes: CollectionRunType<any>[],
+    getCompiledName: (comp: JitFnCompiler, urt: UnionRunType, propTypeID: string | number) => string
+): FlattenedProp[] {
+    if (!unionTypes.length) return [];
+    const propByName = new Map<string | number, PropUnionItemPair[]>();
+    unionTypes.forEach((unionItem) => {
+        const props = unionItem.getJitChildren(comp) as PropertyRunType[];
+        props.forEach((prop) => {
+            const name = prop.getChildVarName(comp);
+            const existing = propByName.get(name) || [];
+            // index no needed now
+            propByName.set(name, [...existing, {prop, unionItem}]);
+        });
+    });
+    const propsOnAllTypes = Array.from(propByName.entries())
+        // filter all properties that are in all types
+        .filter(([, props]) => props.length === unionTypes.length)
+        // calculate complexity and check if all types are different in all props
+        .map(([key, props]) => ({
+            name: key,
+            props,
+            complexity: props.reduce((acc, item) => acc + getTotalComplexity(comp, item.prop), 0),
+            isUniqueType: props.every((item) => {
+                const child = item;
+                const typeID = child.prop.getTypeID();
+                const isDiff = props.every((otherItem) => child.prop === otherItem.prop || otherItem.prop.getTypeID() !== typeID);
+                return isDiff;
+            }),
+        }))
+        .filter((item) => item.isUniqueType);
+    const lessComplexProps = propsOnAllTypes.toSorted((a, b) => a.complexity - b.complexity);
+    const lessComplex = lessComplexProps[0];
+    if (!lessComplex) return [];
+    // we need to marks the property as discriminator so they can be sorted and checked first later
+    return lessComplex.props.map((item) => {
+        item.prop.isUnionDiscriminator = true;
+        const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
+        const typeID = item.prop.getTypeID();
+        return {
+            unionItem: item.unionItem,
+            unionIndex,
+            prop: item.prop,
+            typeID,
+            compiledName: getCompiledName(comp, urt, typeID),
+        };
+    });
+}
+
+/**
+ * Get unique properties in the union as discriminators.
+ * These properties can be of different name but are unique in the union so can act as discriminators.
+ * It also marks those properties as discriminator properties so can be sorted later.
+ * */
+function getUniqueDiscriminatorProperties(
+    comp: JitFnCompiler,
+    urt: UnionRunType,
+    unionTypes: CollectionRunType<any>[],
+    getCompiledName: (comp: JitFnCompiler, urt: UnionRunType, propTypeID: string | number) => string
+): FlattenedProp[] {
+    if (!unionTypes.length) return [];
+    const uniquePropByUnionItem = new Map<CollectionRunType<any>, PropUnionItemPair>();
+    unionTypes.forEach((unionItem) => {
+        const props = unionItem.getJitChildren(comp) as PropertyRunType[];
+        props.forEach((prop) => {
+            const typeID = prop.getTypeID();
+            const isUnique = unionTypes.every((otherUnionItem) => {
+                if (otherUnionItem === unionItem) return true;
+                const otherProps = otherUnionItem.getJitChildren(comp) as MemberRunType<any>[];
+                return otherProps.every((otherProp) => otherProp.getTypeID() !== typeID);
+            });
+            if (isUnique) {
+                const existing = uniquePropByUnionItem.get(unionItem);
+                if (!existing) {
+                    uniquePropByUnionItem.set(unionItem, {
+                        prop,
+                        unionItem,
+                    });
+                    return;
+                }
+                const newItem = {prop, unionItem};
+                const lessComplex = [newItem, existing].toSorted((a, b) => sortRunTypeByComplexity(comp, a.prop, b.prop))[0];
+                uniquePropByUnionItem.set(unionItem, lessComplex);
+            }
+        });
+    });
+    if (!uniquePropByUnionItem.size) return [];
+    const uniqueProps = Array.from(uniquePropByUnionItem.values());
+    return uniqueProps.map((item) => {
+        item.prop.isUnionDiscriminator = true;
+        const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
+        const typeID = item.prop.getTypeID();
+        return {
+            unionItem: item.unionItem,
+            unionIndex,
+            prop: item.prop,
+            typeID,
+            compiledName: getCompiledName(comp, urt, typeID),
+        };
+    });
+}
+
+function initGetCompiledName() {
+    const typeIDs = new Map<string | number, number>();
+    return function getCompiledName(comp: JitFnCompiler, urt: UnionRunType, typeID: string | number): string {
+        const existingIndex = typeIDs.get(typeID);
+        if (existingIndex) return comp.getLocalVarName('prop', urt) + `_${existingIndex}`;
+        const newIndex = typeIDs.size;
+        typeIDs.set(typeID, newIndex);
+        return comp.getLocalVarName('prop', urt) + `_${newIndex}`;
+    };
+}

package/src/nodes/function/function.ts

@@ -0,0 +1,166 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import type {AnyFunction, SrcType, JitFn, JitCode, RunTypeOptions} from '../../types.ts';
+import {ReflectionKind, TypeFunction} from '@deepkit/type';
+import {BaseRunType} from '../../lib/baseRunTypes.ts';
+import {isAnyFunctionRunType, isFunctionRunType, isPromiseRunType} from '../../lib/guards.ts';
+import {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {PromiseRunType} from '../native/promise.ts';
+import {ReflectionSubKind} from '../../constants.kind.ts';
+import {FunctionParamsRunType} from '../collection/functionParams.ts';
+import {JitCompiledFn} from '@mionjs/core';
+import {registerJitFunctionCompiler} from '../../lib/jitFnsRegistry.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+
+export class FunctionRunType<CallType extends AnyFunction = TypeFunction> extends BaseRunType<CallType> {
+    // parameterRunTypes.src must be set after FunctionRunType creation
+    parameterRunTypes: FunctionParamsRunType = new FunctionParamsRunType();
+    skipJit(comp: JitFnCompiler): boolean {
+        if (!comp) return true;
+        return comp.fnID !== JitFunctions.toJSCode.id;
+    }
+    onCreated(deepkitType: SrcType): void {
+        // here we are mapping parameters from TypeParameter[] to TypeTuple as TupleRunType() is the same functionality as ParameterRunType[]
+        super.onCreated(deepkitType);
+        // Create a synthetic type for parameters with its own subKind
+        // Explicitly exclude _typeId and _formatId so the params type gets its own cached IDs
+        const paramsType = {...deepkitType, subKind: ReflectionSubKind.params} as any;
+        delete paramsType._typeId;
+        delete paramsType._formatId;
+        this.parameterRunTypes.onCreated(paramsType);
+    }
+    getFamily(): 'F' {
+        return 'F';
+    }
+    getFnName(): string | number {
+        const name = (this.src as TypeFunction).name;
+        if (!name) return '';
+        if (typeof name === 'symbol') return name.toString();
+        return name;
+    }
+    createJitParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any {
+        return this.createJitCompiledParamsFunction(jitFn, opts).fn;
+    }
+    createJitCompiledParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn {
+        const start = opts?.paramsSlice?.start;
+        const end = opts?.paramsSlice?.end;
+        if (start && end) {
+            if (start < 0 || end > this.parameterRunTypes.getChildRunTypes().length)
+                throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}.`);
+            if (end <= start) throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}`);
+        }
+        return this.parameterRunTypes.createJitCompiledFunction(jitFn.id, undefined, opts);
+    }
+    createJitReturnFunction(jitFn: JitFn): (...args: any[]) => any {
+        return this.createJitCompiledReturnFunction(jitFn).fn;
+    }
+
+    createJitCompiledReturnFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn {
+        return this.getResolvedReturnType().createJitCompiledFunction(jitFn.id, undefined, opts);
+    }
+
+    // ######## JIT functions (all throw error) ########
+
+    // can't know the types of the run type function parameters, neither the return type, so only compare function name and length
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const minLength = this.parameterRunTypes.totalRequiredParams(comp);
+        const totalParams = this.parameterRunTypes.getParamRunTypes(comp).length;
+        const hasOptional = totalParams > minLength;
+        const maxLength =
+            this.parameterRunTypes.hasRestParameter(comp) || !hasOptional ? '' : ` && ${comp.vλl}.length <= ${totalParams}`;
+        return {code: `(typeof ${comp.vλl} === 'function' && ${comp.vλl}.length >= ${minLength} ${maxLength})`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (!(${this.emitIsType(comp).code})) ${comp.callJitErr(this)};`, type: 'S'};
+    }
+    /**
+     * json encode a function
+     */
+    emitPrepareForJson(): JitCode {
+        throw new Error(`Compile function PrepareForJson not supported, call compileParams or compileReturn instead.`);
+    }
+    emitRestoreFromJson(): JitCode {
+        throw new Error(`Compile function RestoreFromJson not supported, call compileParams or compileReturn instead.`);
+    }
+    emitHasUnknownKeys(): JitCode {
+        return {code: '', type: 'E'};
+    }
+    emitUnknownKeyErrors(): JitCode {
+        return {code: '', type: 'S'};
+    }
+    emitStripUnknownKeys(): JitCode {
+        return {code: '', type: 'S'};
+    }
+    emitUnknownKeysToUndefined(): JitCode {
+        return {code: '', type: 'S'};
+    }
+
+    // TODO: paramsSlice has been removed as options are not jet passed when building the run type. maybe we can pass it to the JitCompileOperation instead
+    // constructor() {
+    //     const start = opts?.paramsSlice?.start;
+    //     const end = opts?.paramsSlice?.end;
+    //     parameterRunTypes = src.parameters.slice(start, end).map((p) => visitor(p, parents, opts)) as ParameterRunType[];
+    // }
+    getReturnType(): BaseRunType {
+        return (this.src.return as SrcType)._rt as BaseRunType;
+    }
+    /** returns the inner run-type when the handler returns Promise<T> (or nested Promise/function-return chains), or the plain return type otherwise */
+    getResolvedReturnType(): BaseRunType {
+        let currentType: PromiseRunType | FunctionRunType<any> = this; // eslint-disable-line @typescript-eslint/no-this-alias
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            if (isAnyFunctionRunType(currentType)) {
+                const returnType = currentType.getReturnType();
+                if (isPromiseRunType(returnType) || isFunctionRunType(returnType)) {
+                    currentType = returnType;
+                    continue;
+                }
+                return returnType;
+            }
+            const memberType = currentType.getMemberType();
+            if (isPromiseRunType(memberType) || isFunctionRunType(memberType)) {
+                currentType = memberType;
+                continue;
+            }
+            return memberType;
+        }
+    }
+    getParameters(): FunctionParamsRunType {
+        return this.parameterRunTypes;
+    }
+    getParameterNames(opts?: RunTypeOptions): string[] {
+        const start = opts?.paramsSlice?.start;
+        const end = opts?.paramsSlice?.end;
+        if (start || end) {
+            return this.src.parameters.slice(start, end).map((p) => p.name);
+        }
+        return this.src.parameters.map((p) => p.name);
+    }
+    hasReturnData(): boolean {
+        const returnKind = this.getReturnType().src.kind;
+        return (
+            returnKind !== ReflectionKind.void && returnKind !== ReflectionKind.never && returnKind !== ReflectionKind.undefined
+        );
+    }
+    isAsync(): boolean {
+        const returnKind = this.getReturnType().src.kind;
+        return (
+            returnKind === ReflectionKind.promise || returnKind === ReflectionKind.any || returnKind === ReflectionKind.unknown
+        );
+    }
+    returnIsPromise(): boolean {
+        return isPromiseRunType(this.getReturnType());
+    }
+    async mockReturn(ctx?: RunTypeOptions): Promise<any> {
+        await registerJitFunctionCompiler(JitFunctions.mock);
+        return this.getReturnType().mockType(ctx);
+    }
+    async mockParams(ctx?: RunTypeOptions): Promise<any[]> {
+        await registerJitFunctionCompiler(JitFunctions.mock);
+        return this.parameterRunTypes.mockType(ctx);
+    }
+}

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'};
+    }
+}