@mionjs/run-types 0.8.6 → 0.8.8

package/src/nodes/member/indexProperty.ts

@@ -0,0 +1,125 @@
+import {ReflectionKind, TypeIndexSignature} 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';
+
+/* ########
+ * 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;
+    }
+
+    // #### 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 {
+            code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}){if (!(${childJit.code})) return false;} return true;`,
+            type: 'RB',
+        };
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileTypeErrors(child, 'S');
+        if (!childJit?.code) return {code: undefined, type: 'S'};
+        return {code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}) {${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 isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        return {code: `for (const ${prop} in ${varName}){${skipCode} ${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 isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        return {code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: 'S'};
+    }
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        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: '', type: 'E'};
+        const varName = comp.vλl;
+        const prop = this.getChildVarName(comp);
+        const resultVal = comp.getLocalVarName('res', this);
+        return {
+            code: `for (const ${prop} in ${varName}) {const ${resultVal} = ${childJit.code};if (${resultVal}) return true;}return false;`,
+            type: 'RB',
+        };
+    }
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
+        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileUnknownKeyErrors(child, 'S');
+        return this.traverseCode(comp, childJit);
+    }
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileStripUnknownKeys(child, 'S');
+        return this.traverseCode(comp, childJit);
+    }
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileUnknownKeysToUndefined(child, 'S');
+        return this.traverseCode(comp, childJit);
+    }
+    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);
+    }
+}

package/src/nodes/member/tupleMember.ts

@@ -0,0 +1,93 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {ReflectionKind, TypeTupleMember, type TypeParameter} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {MemberRunType} from '../../lib/baseRunTypes.ts';
+import {JitCode} from '../../types.ts';
+import {childIsExpression, getParamIndex} from '../../lib/utils.ts';
+
+type TupleMemberT = TypeParameter | TypeTupleMember;
+export class TupleMemberRunType<T extends TupleMemberT = TypeTupleMember> extends MemberRunType<T> {
+    isOptional(): boolean {
+        return !!this.src.optional || this.isRest() || this.hasDefaultValue();
+    }
+    getChildIndex(comp: JitFnCompiler): number {
+        const start = comp?.opts?.paramsSlice?.start;
+        if (start) return getParamIndex(this.src as TypeParameter) - start;
+        return getParamIndex(this.src as TypeParameter);
+    }
+    getChildVarName(comp: JitFnCompiler): number {
+        // For tuple members, use the index in the parent tuple
+        const src = this.src as any;
+        if (src.parent?.types) {
+            return src.parent.types.indexOf(this.src);
+        }
+        // Fallback to parameter index for non-tuple members
+        return this.getChildIndex(comp);
+    }
+    getChildLiteral(comp: JitFnCompiler): number {
+        return this.getChildVarName(comp);
+    }
+    useArrayAccessor(): true {
+        return true;
+    }
+    isRest(): boolean {
+        return this.getMemberType().src.kind === ReflectionKind.rest;
+    }
+    skipSettingAccessor() {
+        return this.isRest();
+    }
+    hasDefaultValue(): boolean {
+        return !!(this.src as TypeParameter).default;
+    }
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const skipChild = child?.skipJit(comp);
+        const childJit = comp.compileIsType(child, 'E');
+        const isNonSerializable = skipChild || (!childJit?.code && !child);
+        if (isNonSerializable) return {code: `${comp.getChildVλl()} === undefined`, type: 'E'}; // non serializable types must be undefined
+        if (!childJit?.code) return {code: undefined, type: 'E'};
+        if (this.isRest()) return childJit;
+        return this.isOptional() ? {code: `(${comp.getChildVλl()} === undefined || (${childJit.code}))`, type: 'E'} : childJit;
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const skipChild = child?.skipJit(comp);
+        const childJit = comp.compileTypeErrors(child, 'S');
+        const isNonSerializable = skipChild || (!childJit?.code && !child);
+        if (isNonSerializable)
+            return {
+                code: `if (${comp.getChildVλl()} !== undefined) ${comp.callJitErrWithPath('undefined', this.getChildIndex(comp))}`,
+                type: 'S',
+            }; // non serializable types must be undefined
+        if (!childJit?.code) return {code: undefined, type: 'S'};
+        if (this.isRest()) return childJit;
+        return this.isOptional() ? {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');
+        const optionalCode = `if (${comp.getChildVλl()} === undefined ) {if (${comp.vλl}.length > ${this.getChildIndex(comp)}) ${comp.getChildVλl()} = null}`;
+        if (!child || !childJit?.code) return this.isOptional() ? {code: optionalCode, type: 'S'} : {code: undefined, type: 'S'};
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        return this.isOptional() ? {code: `${optionalCode} else {${code}}`, type: 'S'} : {code, type: 'S'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        if (!this.getJitChild(comp)) return {code: `${comp.getChildVλl()} = undefined;`, type: 'S'}; // non serializable are restored to undefined
+        const child = this.getJitChild(comp);
+        const childJit = comp.compileRestoreFromJson(child, 'S');
+        const optionalCOde = `if (${comp.getChildVλl()} === null ) {${comp.getChildVλl()} = undefined}`;
+        if (!child || !childJit?.code) return this.isOptional() ? {code: optionalCOde, type: 'S'} : {code: undefined, type: 'S'};
+        const isExpression = childIsExpression(childJit, child);
+        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
+        return this.isOptional()
+            ? {code: `${optionalCOde} else if (${comp.getChildVλl()} !== undefined) {${code}}`, type: 'S'}
+            : {code, type: 'S'};
+    }
+}

package/src/nodes/native/Iterable.ts

@@ -0,0 +1,153 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import type {JitCode} from '../../types.ts';
+import {ClassRunType} from '../collection/class.ts';
+import {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {BaseRunType} from '../../lib/baseRunTypes.ts';
+
+// This is the base class for all iterable run types, like SetRunType and MapRunType
+export abstract class IterableRunType extends ClassRunType {
+    abstract children: BaseRunType[];
+    abstract constructorName: string;
+    getIndexVarName(comp: JitFnCompiler): string {
+        return comp.getLocalVarName('e', this);
+    }
+    getChildRunTypes = (): BaseRunType[] => {
+        return this.children;
+    };
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+        const childrenCode = this.getJitChildren(comp)
+            .map((c) => `if (!(${comp.compileIsType(c, 'E').code})) return false`)
+            .join(';');
+        return {
+            code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return false;
+            for (const ${entry} of ${comp.vλl}) {${childrenCode}} return true;
+        `,
+            type: 'RB',
+        };
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+        const childrenCode = this.getJitChildren(comp)
+            .map((c) => comp.compileTypeErrors(c, 'S').code)
+            .join(';');
+        const index = this.getIndexVarName(comp);
+        return {
+            code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})){${comp.callJitErr(this)}}
+            else {let ${index} = 0;for (const ${entry} of ${comp.vλl}) {${childrenCode}; ${index}++}}
+        `,
+            type: 'S',
+        };
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+        const resName = comp.getLocalVarName('ml', this);
+        const childrenCode = this.getJitChildren(comp)
+            .map((c) => comp.compilePrepareForJson(c, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        if (!childrenCode) return {code: `${comp.vλl} = Array.from(${comp.vλl})`, type: 'S'};
+        return {
+            code: `
+            const ${resName} = [];
+            for (let ${entry} of ${comp.vλl}) {${childrenCode} ${resName}.push(${entry})}
+            ${comp.vλl} = ${resName};
+        `,
+            type: 'S',
+        };
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        if (!children.length) return {code: `${comp.vλl} = new Map(${comp.vλl})`, type: 'S'};
+        const index = this.getCustomVλl(comp)?.vλl || comp.vλl;
+        const childrenCode = children
+            .map((c) => comp.compileRestoreFromJson(c, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        if (!childrenCode) return {code: `${comp.vλl} = new ${this.constructorName}(${comp.vλl})`, type: 'S'};
+        return {
+            code: `
+            for (let ${index} = 0; ${index} < ${comp.vλl}.length; ${index}++) {${childrenCode}}
+            ${comp.vλl} = new ${this.constructorName}(${comp.vλl})
+        `,
+            type: 'S',
+        };
+    }
+
+    // TODO: Implement the following methods, should just call same compile method for children, look into to array run type
+
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        const childrenCode = this.getJitChildren(comp)
+            .map((child) => {
+                const itemJit = comp.compileHasUnknownKeys(child, 'E');
+                return itemJit?.code ? `if (${itemJit.code}) return true;` : '';
+            })
+            .filter(Boolean)
+            .join('');
+        if (!childrenCode) return {code: 'return false', type: 'RB'};
+        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+        return {
+            code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return false;
+            for (const ${entry} of ${comp.vλl}) {${childrenCode}} return false;
+        `,
+            type: 'RB',
+        };
+    }
+
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
+        const childrenCode = this.getJitChildren(comp)
+            .map((child) => comp.compileUnknownKeyErrors(child, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        if (!childrenCode) return {code: undefined, type: 'S'};
+        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+        const index = this.getIndexVarName(comp);
+        return {
+            code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
+            let ${index} = 0; for (const ${entry} of ${comp.vλl}) {${childrenCode}; ${index}++}
+        `,
+            type: 'S',
+        };
+    }
+
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        const childrenCode = this.getJitChildren(comp)
+            .map((child) => comp.compileStripUnknownKeys(child, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        if (!childrenCode) return {code: undefined, type: 'S'};
+        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+        return {
+            code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
+            for (const ${entry} of ${comp.vλl}) {${childrenCode}}
+        `,
+            type: 'S',
+        };
+    }
+
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        const childrenCode = this.getJitChildren(comp)
+            .map((child) => comp.compileUnknownKeysToUndefined(child, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        if (!childrenCode) return {code: undefined, type: 'S'};
+        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+        return {
+            code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
+            for (const ${entry} of ${comp.vλl}) {${childrenCode}}
+        `,
+            type: 'S',
+        };
+    }
+}

package/src/nodes/native/map.ts

@@ -0,0 +1,91 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import type {SrcType} from '../../types.ts';
+import {GenericMemberRunType} from '../member/genericMember.ts';
+import {ReflectionSubKind} from '../../constants.kind.ts';
+import {ReflectionKind, TypeClass} from '@deepkit/type';
+import {IterableRunType} from './Iterable.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {cpf_safeIterableKey} from '../../run-types-pure-fns.ts';
+
+export class MapRunType extends IterableRunType {
+    keyRT = new MapKeyRunType();
+    valueRT = new MapValueRunType();
+    children = [this.keyRT, this.valueRT];
+    constructorName = 'Map';
+    onCreated(src: SrcType<TypeClass>): void {
+        const types = src.arguments;
+        if (!types || types.length !== 2) throw new Error(`Map expects 2 type arguments: ie: Map<string, number>`);
+        super.onCreated(src);
+        this.keyRT.onCreated({
+            kind: ReflectionKind.parameter,
+            parent: src,
+            type: types[0],
+            subKind: ReflectionSubKind.mapKey,
+        });
+        this.valueRT.onCreated({
+            kind: ReflectionKind.parameter,
+            parent: src,
+            type: types[1],
+            subKind: ReflectionSubKind.mapValue,
+        });
+    }
+    getCustomVλl(comp: JitFnCompiler) {
+        // restoreFromJson is decoding a regular array so no need to use an special case for vλl as other operations
+        if (comp.fnID === JitFunctions.restoreFromJson.id)
+            return {vλl: comp.getLocalVarName('it', this), isStandalone: false, useArrayAccessor: true};
+        // other operations use an special case for vλl where all parents are skipped
+        return {vλl: comp.getLocalVarName('it', this), isStandalone: true};
+    }
+    getMapKeyVλl(comp: JitFnCompiler) {
+        return comp.getLocalVarName('mpk', this);
+    }
+    getMapValueVλl(comp: JitFnCompiler) {
+        return comp.getLocalVarName('mpV', this);
+    }
+}
+
+class MapKeyRunType extends GenericMemberRunType<any> {
+    index = 0;
+    getStaticPathLiteral(comp: JitFnCompiler): string | number {
+        const parent = this.getParent()! as MapRunType;
+        const custom = parent.getCustomVλl(comp)!;
+        const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
+        return `{key:${safeKeyFn}(${custom.vλl}[0]),index:${parent.getIndexVarName(comp)},failed:'mapKey'}`;
+    }
+    getCustomVλl(comp: JitFnCompiler) {
+        // temp variable to assign mapKey
+        if (comp.fnID === JitFunctions.fromBinary.id)
+            return {
+                vλl: (this.getParent()! as MapRunType).getMapKeyVλl(comp),
+                isStandalone: true,
+                useArrayAccessor: false,
+            };
+        return undefined;
+    }
+}
+
+class MapValueRunType extends GenericMemberRunType<any> {
+    index = 1;
+    getStaticPathLiteral(comp: JitFnCompiler): string | number {
+        const parent = this.getParent()! as MapRunType;
+        const custom = parent.getCustomVλl(comp)!;
+        const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
+        return `{key:${safeKeyFn}(${custom.vλl}[0]),index:${parent.getIndexVarName(comp)},failed:'mapVal'}`;
+    }
+    getCustomVλl(comp: JitFnCompiler) {
+        // temp variable to assign mapKey
+        if (comp.fnID === JitFunctions.fromBinary.id)
+            return {
+                vλl: (this.getParent()! as MapRunType).getMapValueVλl(comp),
+                isStandalone: true,
+                useArrayAccessor: false,
+            };
+        return undefined;
+    }
+}