@mionjs/run-types 0.8.8 → 0.13.0

package/src/nodes/collection/unionDiscriminator.ts

@@ -1,259 +0,0 @@
-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

@@ -1,166 +0,0 @@
-/* ########
- * 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

@@ -1,150 +0,0 @@
-/* ########
- * 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

@@ -1,34 +0,0 @@
-/* ########
- * 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

@@ -1,63 +0,0 @@
-/* ########
- * 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'};
-    }
-}