@mionjs/run-types 0.8.7 → 0.8.10

package/src/nodes/collection/interface.ts

@@ -0,0 +1,300 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import {TypeObjectLiteral, TypeClass, TypeIntersection, ReflectionKind} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {arrayToLiteral, getJitFnArgCallVarName, memorize, sortDiscriminatorsFirst} from '../../lib/utils.ts';
+import {PropertyRunType} from '../member/property.ts';
+import {BaseRunType, CollectionRunType, MemberRunType} from '../../lib/baseRunTypes.ts';
+import {MethodSignatureRunType} from '../member/methodSignature.ts';
+import {IndexSignatureRunType} from '../member/indexProperty.ts';
+import {MethodRunType} from '../member/method.ts';
+import {CallSignatureRunType} from '../member/callSignature.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+import {isIndexSignatureRunType} from '../../lib/guards.ts';
+import {cpf_getUnknownKeysFromArray, cpf_hasUnknownKeysFromArray} from '../../run-types-pure-fns.ts';
+
+export type InterfaceMember =
+    | PropertyRunType
+    | MethodSignatureRunType
+    | IndexSignatureRunType
+    | MethodRunType
+    | CallSignatureRunType;
+
+export class InterfaceRunType<
+    T extends TypeObjectLiteral | TypeClass | TypeIntersection = TypeObjectLiteral,
+> extends CollectionRunType<T> {
+    getNamedChildren(comp: JitFnCompiler): InterfaceMember[] {
+        return this.getJitChildren(comp).filter((prop) => !!(prop.src as any).name) as InterfaceMember[];
+    }
+
+    isCallable(): boolean {
+        return this.getCallSignature() !== undefined;
+    }
+
+    getCallSignature = memorize((): CallSignatureRunType | undefined => {
+        return this.getChildRunTypes().find((prop) => prop.src.kind === ReflectionKind.callSignature) as CallSignatureRunType;
+    });
+
+    getJitChildren(comp: JitFnCompiler): InterfaceMember[] {
+        const children = super.getJitChildren(comp) as InterfaceMember[];
+        return children.toSorted((a, b) => sortDiscriminatorsFirst(a, b)) as InterfaceMember[];
+    }
+    /** Split children in two groups: required and optional */
+    splitJitSplitChildren(comp: JitFnCompiler): {
+        /** all required properties */
+        required: PropertyRunType[];
+        /** all optional properties */
+        optional: PropertyRunType[];
+        /** all index signatures */
+        indexSignatures: IndexSignatureRunType[];
+    } {
+        const children = super.getJitChildren(comp) as InterfaceMember[];
+        const required = children.filter((prop) => !prop.isOptional()) as PropertyRunType[];
+        const optional = children.filter((prop) => prop.isOptional() && !isIndexSignatureRunType(prop)) as PropertyRunType[];
+        const indexSignatures = children.filter((prop) => isIndexSignatureRunType(prop)) as IndexSignatureRunType[];
+        return {required, optional, indexSignatures};
+    }
+    isPartOfUnion(): boolean {
+        return this.getParent()?.src.kind === ReflectionKind.union;
+    }
+    hasIndexSignature(comp: JitFnCompiler): boolean {
+        return this.getJitChildren(comp).some((prop) => isIndexSignatureRunType(prop));
+    }
+
+    // #### collection's jit code ####
+
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const varName = comp.vλl;
+        const children = this.getJitChildren(comp);
+        const childrenCode = children
+            .map((prop) => comp.compileIsType(prop, 'E').code)
+            .filter(Boolean)
+            .join(' && ');
+        if (this.isCallable())
+            return {
+                code: [this.getCallSignature()!.emitIsType(comp).code, childrenCode].filter(Boolean).join(' && '),
+                type: 'E',
+            };
+        let propsCode = '';
+        if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {
+            const unknownCheck = callCheckUnknownProperties(this, comp, children, false, false);
+            if (unknownCheck) propsCode = `!${unknownCheck}`;
+        }
+        const objectCheck = this.isPartOfUnion() ? '' : `typeof ${varName} === 'object' && ${varName} !== null`;
+        const itemsCode = [objectCheck, this.allOptionalCode(comp), childrenCode, propsCode].filter(Boolean).join(' && ');
+        return {code: `(${itemsCode})`, type: 'E'};
+    }
+
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const varName = comp.vλl;
+        const children = this.getJitChildren(comp);
+        const childrenCode = children
+            .map((prop) => comp.compileTypeErrors(prop, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        if (this.isCallable()) {
+            return {code: `${this.getCallSignature()!.emitTypeErrors(comp).code} else {${childrenCode}}`, type: 'S'};
+        }
+        let propsCode = '';
+        if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {
+            const unknownVar = comp.getLocalVarName('unk', this);
+            const keyVar = comp.getLocalVarName('ky', this);
+            const unknownValue = callCheckUnknownProperties(this, comp, children, true, false);
+            if (unknownValue) {
+                propsCode = `
+                    const ${unknownVar} = ${unknownValue};
+                    if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath('never', keyVar)}}}
+                `;
+            }
+        }
+        const objectCheck = this.isPartOfUnion() ? '' : `typeof ${varName} === 'object' && ${varName} !== null`;
+        const isObjectCode = [objectCheck, this.allOptionalCode(comp)].filter(Boolean).join(' && ');
+        return {
+            code: `
+            if (!(${isObjectCode})) {
+                ${comp.callJitErr(this)};
+            } else {
+                ${childrenCode}
+                ${propsCode}
+            }
+        `,
+            type: 'S',
+        };
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        if (this.isCallable()) return this.getCallSignature()!.emitPrepareForJson();
+        const children = this.getJitChildren(comp);
+        const childrenCode = children
+            .map((prop) => comp.compilePrepareForJson(prop, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        return {code: childrenCode, type: 'S'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        if (this.isCallable()) return this.getCallSignature()!.emitRestoreFromJson();
+        const children = this.getJitChildren(comp);
+        const childrenCode = children
+            .map((prop) => comp.compileRestoreFromJson(prop, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        return {code: childrenCode, type: 'S'};
+    }
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        const allChildren = this.getChildRunTypes().filter((prop) => !isIndexSignatureRunType(prop));
+        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
+        const parentCode = hasIndexProp
+            ? ''
+            : callCheckUnknownProperties(this, comp, children, false, !this.isPartOfUnion(), allChildren);
+        const childrenCode = super.emitHasUnknownKeys(comp).code;
+        return {code: [parentCode, childrenCode].filter(Boolean).join(' || '), type: 'E'};
+    }
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        const allChildren = this.getChildRunTypes().filter((prop) => !isIndexSignatureRunType(prop));
+        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
+        const unknownVar = comp.getLocalVarName('unk', this);
+        const keyVar = comp.getLocalVarName('ky', this);
+        const unknownValue = hasIndexProp
+            ? undefined
+            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion(), allChildren);
+        const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath('never', keyVar)}}}
+        `;
+        const childrenCode = super.emitUnknownKeyErrors(comp).code;
+        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
+    }
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        const unknownVar = comp.getLocalVarName('unk', this);
+        const keyVar = comp.getLocalVarName('ky', this);
+        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
+        const unknownValue = hasIndexProp
+            ? undefined
+            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());
+        const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){delete ${comp.vλl}[${keyVar}]}}
+        `;
+        const childrenCode = super.emitStripUnknownKeys(comp).code;
+        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
+    }
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        const unknownVar = comp.getLocalVarName('unk', this);
+        const keyVar = comp.getLocalVarName('ky', this);
+        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
+        const unknownValue = hasIndexProp
+            ? undefined
+            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());
+        const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){${comp.vλl}[${keyVar}] = undefined}}
+        `;
+        const childrenCode = super.emitUnknownKeysToUndefined(comp).code;
+        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
+    }
+
+    // In order to json stringify to work properly optional properties must come first
+    getJsonStringifySortedChildren(comp: JitFnCompiler): MemberRunType<any>[] {
+        return this.getJitChildren(comp).toSorted((a, b) => {
+            const aOptional = a instanceof MemberRunType && a.isOptional();
+            const bOptional = b instanceof MemberRunType && b.isOptional();
+            if (aOptional && !bOptional) return -1;
+            if (!aOptional && bOptional) return 1;
+            return 0;
+        }) as MemberRunType<any>[];
+    }
+
+    // extra check to prevent empty array passing as object where all properties are optional
+    // when this check is disabled empty array will pass as object but fail when checking for properties
+    allOptionalCode(comp: JitFnCompiler): string {
+        const children = this.getJitChildren(comp);
+        if (children.length !== 0 && !this.areAllChildrenOptional(children)) return '';
+        const isNotArray = `!Array.isArray(${comp.vλl})`;
+        const ifNoNative = `Object.prototype.toString.call(${comp.vλl}) === '[object Object]'`;
+        return `(${isNotArray} && ${ifNoNative})`;
+    }
+
+    addObjectPropsToContext(comp: JitFnCompiler, jitChildrenRunTypes?: BaseRunType[], allChildrenRuntypes?: BaseRunType[]) {
+        const children = jitChildrenRunTypes || this.getJitChildren(comp);
+        const allChildren = allChildrenRuntypes || this.getChildRunTypes();
+        return addObjectPropsToContext(this, comp, children, allChildren);
+    }
+}
+
+export interface ObjectPropsContextResult {
+    keysName: string;
+    allKeysName: string;
+    hasNonJitChildren: boolean;
+    jitChildrenNames: string[];
+    allChildrenNames: string[];
+}
+
+/**
+ * Extracts object property names and adds them to the JIT compiler context.
+ */
+function addObjectPropsToContext(
+    rt: InterfaceRunType<any>,
+    comp: JitFnCompiler,
+    jitChildrenRunTypes: BaseRunType[],
+    allChildrenRuntypes?: BaseRunType[]
+): ObjectPropsContextResult {
+    const jitArrNames = jitChildrenRunTypes.filter((prop) => !!(prop.src as any).name).map((prop) => (prop.src as any).name);
+    const AllArrNames = allChildrenRuntypes?.filter((prop) => !!(prop.src as any).name).map((prop) => (prop.src as any).name);
+    const jitChildrenNames = Array.from(new Set(jitArrNames));
+    const allChildrenNames = Array.from(new Set(AllArrNames));
+    const isSameLength = jitChildrenNames.length === allChildrenNames.length;
+    const isSameSet = isSameLength && jitChildrenNames.every((v) => allChildrenNames.includes(v));
+    const hasNonJitChildren = !(isSameLength && isSameSet);
+    const keysName = `k_${rt.getJitHash(comp.opts)}`;
+    const allKeysName = `kA_${rt.getJitHash(comp.opts)}`;
+
+    comp.setContextItem(keysName, `const ${keysName} = ${arrayToLiteral(jitChildrenNames)}`);
+    if (hasNonJitChildren) comp.setContextItem(allKeysName, `const ${allKeysName} = ${arrayToLiteral(allChildrenNames)}`);
+
+    return {
+        keysName,
+        allKeysName,
+        hasNonJitChildren,
+        jitChildrenNames,
+        allChildrenNames,
+    };
+}
+
+// TODO: look like some of this logic should be moved to index prop ? Also the runtime
+function callCheckUnknownProperties(
+    rt: InterfaceRunType<any>,
+    comp: JitFnCompiler,
+    jitChildrenRunTypes: BaseRunType[],
+    returnKeys: boolean,
+    checkObject = true,
+    allChildrenRuntypes?: BaseRunType[]
+): string {
+    const result = addObjectPropsToContext(rt, comp, jitChildrenRunTypes, allChildrenRuntypes);
+
+    if (result.jitChildrenNames.length === 0 && result.allChildrenNames.length === 0) return '';
+
+    const objectCheckCode = checkObject ? [`typeof ${comp.vλl} === 'object'`, `${comp.vλl} !== null`] : [];
+    const checkPropName = JitFunctions.hasUnknownKeys.runTimeOptions.checkNonJitProps.keyName;
+    const optsVarName = getJitFnArgCallVarName(comp, rt, JitFunctions.hasUnknownKeys.id, 'θpts');
+    const conditional =
+        allChildrenRuntypes?.length && result.hasNonJitChildren
+            ? `${optsVarName}.${checkPropName} ? ${result.allKeysName} : ${result.keysName}`
+            : result.keysName;
+    if (returnKeys) {
+        const getUnknownKeysFn = comp.addPureFunction(cpf_getUnknownKeysFromArray);
+        return `${getUnknownKeysFn}(${comp.vλl}, ${conditional})`;
+    }
+    const hasUnknownKeysFn = comp.addPureFunction(cpf_hasUnknownKeysFromArray);
+    objectCheckCode.push(`${hasUnknownKeysFn}(${comp.vλl}, ${conditional})`);
+    const filtered = objectCheckCode.filter(Boolean);
+    if (filtered.length > 1) return `(${filtered.join(' && ')})`;
+    return filtered[0];
+}

package/src/nodes/collection/intersection.ts

@@ -0,0 +1,30 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {TypeIntersection} from '@deepkit/type';
+import {InterfaceRunType} from './interface.ts';
+import {type JitCode} from '../../types.ts';
+
+/** IMPORTANT:
+ * Intersection are already resolved by deepkit so seems like this runType wont ever be called
+ * ie: type A = {a: string} & {b: number} will be resolved to ObjectLiteral {a: string, b: number}
+ * ie: type NeVer = string & number will be resolved to never
+ * */
+export class IntersectionRunType extends InterfaceRunType<TypeIntersection> {
+    compileIsType(): JitCode {
+        throw new Error('Intersection validation not supported, should be resolve to other RunTypes');
+    }
+    compileTypeErrors(): JitCode {
+        throw new Error('Intersection validation not supported, should be resolve to other RunTypes');
+    }
+    compilePrepareForJson(): JitCode {
+        throw new Error('Intersection serialization not supported, should be resolve to other RunTypes');
+    }
+    compileRestoreFromJson(): JitCode {
+        throw new Error('Intersection serialization not supported, should be resolve to other RunTypes');
+    }
+}

package/src/nodes/collection/templateLiteral.ts

@@ -0,0 +1,87 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {ReflectionKind, type TypeTemplateLiteral, type TypeLiteral} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {JitCode} from '../../types.ts';
+import {CollectionRunType} from '../../lib/baseRunTypes.ts';
+
+/**
+ * RunType for TypeScript template literal types, ie: `type T = \`api/user/${number}\``.
+ * The runtime value is a string. Validation is done by compiling the template literal type
+ * to a single anchored regex at JIT-build time and then calling `regex.test(v)` at runtime.
+ * Mocking walks the children directly (literal => verbatim, string/any => mockString, number => mockNumber)
+ * and concatenates the spans, which guarantees the result satisfies the validation regex.
+ */
+export class TemplateLiteralRunType extends CollectionRunType<TypeTemplateLiteral> {
+    private _regexSource: string | undefined;
+
+    /** Builds the anchored regex source from src.types. Memoized. */
+    getRegexSource(): string {
+        if (this._regexSource !== undefined) return this._regexSource;
+        this._regexSource = buildAnchoredTemplateRegexSource(this.src.types || []);
+        return this._regexSource;
+    }
+
+    /** Returns a context-bound variable name holding the RegExp; emits the const into the compiler context. */
+    private getRegexVar(comp: JitFnCompiler): string {
+        const varName = comp.getLocalVarName('reTL', this);
+        if (!comp.hasContextItem(varName)) {
+            comp.setContextItem(varName, `const ${varName} = new RegExp(${JSON.stringify(this.getRegexSource())})`);
+        }
+        return varName;
+    }
+
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const re = this.getRegexVar(comp);
+        return {code: `(typeof ${comp.vλl} === 'string' && ${re}.test(${comp.vλl}))`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const re = this.getRegexVar(comp);
+        return {
+            code: `if (typeof ${comp.vλl} !== 'string' || !${re}.test(${comp.vλl})) ${comp.callJitErr(this)}`,
+            type: 'S',
+        };
+    }
+    /** value is already a JSON-safe string, no transform required */
+    emitPrepareForJson(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+    /** value is already a JSON-safe string, no transform required */
+    emitRestoreFromJson(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+}
+
+/** Build the full ^...$ regex source for a template literal type's spans */
+export function buildAnchoredTemplateRegexSource(types: TypeTemplateLiteral['types']): string {
+    return `^${types.map((t) => spanToRegex(t)).join('')}$`;
+}
+
+/** Translate a single template-literal span (TypeString | TypeAny | TypeNumber | TypeLiteral | TypeInfer) into regex source */
+export function spanToRegex(t: TypeTemplateLiteral['types'][number]): string {
+    switch (t.kind) {
+        case ReflectionKind.literal:
+            return escapeForRegex(String((t as TypeLiteral).literal));
+        case ReflectionKind.number:
+            // matches signed integers and floats (including leading dot like '.5'), mirroring TS's `${number}` semantics
+            return '-?(?:\\d+\\.?\\d*|\\.\\d+)';
+        case ReflectionKind.string:
+        case ReflectionKind.any:
+        case ReflectionKind.infer:
+            // `${string}` accepts the empty string, so use * not +
+            return '[\\s\\S]*';
+        default:
+            // unreachable per deepkit's TypeTemplateLiteral.types definition
+            throw new Error(`Unsupported template literal span kind: ${(t as {kind: number}).kind}`);
+    }
+}
+
+/** Escape regex metacharacters so a literal substring is matched verbatim */
+function escapeForRegex(s: string): string {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/nodes/collection/tuple.ts

@@ -0,0 +1,80 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeFunction, TypeTuple} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {AnyParameterListRunType, SrcType, JitCode} from '../../types.ts';
+import {ParameterRunType} from '../member/param.ts';
+import {CollectionRunType} from '../../lib/baseRunTypes.ts';
+import {TupleMemberRunType} from '../member/tupleMember.ts';
+
+type AnyParamRunType = ParameterRunType | TupleMemberRunType;
+
+export class TupleRunType<
+    ParamList extends AnyParameterListRunType = TypeTuple,
+    ParamType extends AnyParamRunType = TupleMemberRunType,
+> extends CollectionRunType<ParamList> {
+    getChildRunTypes = (): ParamType[] => {
+        const childTypes = ((this.src as TypeFunction).parameters || (this.src as TypeTuple).types || []) as SrcType[];
+        return childTypes.map((t) => t._rt as ParamType);
+    };
+    getParamRunTypes(comp: JitFnCompiler): ParamType[] {
+        const start = comp.opts?.paramsSlice?.start;
+        const end = comp.opts?.paramsSlice?.end;
+        const children = this.getChildRunTypes();
+        if (!start && !end) return children;
+        // Get all child run types first without using comp to avoid recursion
+        return children.slice(start, end);
+    }
+    hasRestParameter(comp: JitFnCompiler): boolean {
+        return (
+            !!this.getParamRunTypes(comp).length && this.getParamRunTypes(comp)[this.getParamRunTypes(comp).length - 1].isRest()
+        );
+    }
+    totalRequiredParams(comp: JitFnCompiler): number {
+        return this.getParamRunTypes(comp).filter((p) => !p.isOptional() && !p.isRest()).length;
+    }
+    // ####### params #######
+
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (children.length === 0 && comp.opts.noIsArrayCheck) return {code: undefined, type: 'E'};
+        if (children.length === 0) return {code: `Array.isArray(${comp.vλl}) && ${comp.vλl}.length === 0`, type: 'E'};
+        const lengthCode = this.hasRestParameter(comp) ? '' : `&& ${comp.vλl}.length <= ${this.getParamRunTypes(comp).length}`;
+        const paramsCode = children.map((p) => `(${comp.compileIsType(p, 'E').code})`).join(' && ');
+        const checkIsArrayCode = comp.opts.noIsArrayCheck ? '' : `Array.isArray(${comp.vλl})${lengthCode} && `;
+        return {code: `(${checkIsArrayCode} ${paramsCode})`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (children.length === 0 && comp.opts.noIsArrayCheck) return {code: undefined, type: 'S'};
+        if (children.length === 0)
+            return {code: `if (!Array.isArray(${comp.vλl}) || && ${comp.vλl}.length === 0) ${comp.callJitErr(this)}`, type: 'S'};
+        const lengthCode = this.hasRestParameter(comp) ? '' : `|| ${comp.vλl}.length > ${this.getParamRunTypes(comp).length}`;
+        const paramsCode = children.map((p) => comp.compileTypeErrors(p, 'S').code).join(';');
+        if (comp.opts.noIsArrayCheck) return {code: paramsCode, type: 'S'};
+        return {code: `if (!Array.isArray(${comp.vλl})${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode}}`, type: 'S'};
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (!children.length) return {code: undefined, type: 'S'};
+        const code = children
+            .map((p) => comp.compilePrepareForJson(p, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        return {code: code, type: 'S'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (!children.length) return {code: undefined, type: 'S'};
+        const code = children
+            .map((p) => comp.compileRestoreFromJson(p, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        return {code: code, type: 'S'};
+    }
+}