@mionjs/run-types 0.8.8 → 0.8.10

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/member/indexProperty.ts

@@ -1,10 +1,11 @@
-import {ReflectionKind, TypeIndexSignature} from '@deepkit/type';
+import {ReflectionKind, type TypeIndexSignature, type TypeTemplateLiteral} from '@deepkit/type';
 import {MemberRunType} from '../../lib/baseRunTypes.ts';
 import {type JitCode} from '../../types.ts';
 import {JitFunctions} from '../../constants.functions.ts';
 import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
 import {InterfaceRunType} from '../collection/interface.ts';
 import {childIsExpression} from '../../lib/utils.ts';
+import {buildAnchoredTemplateRegexSource} from '../collection/templateLiteral.ts';
 
 /* ########
  * 2024 mion
@@ -34,21 +35,44 @@ export class IndexSignatureRunType extends MemberRunType<TypeIndexSignature> {
         return false;
     }
 
+    /** if the index key is a template literal type, return the JIT context var holding the compiled key-pattern regex */
+    private getKeyPatternVar(comp: JitFnCompiler): string | undefined {
+        const idx = this.src.index;
+        if (idx?.kind !== ReflectionKind.templateLiteral) return undefined;
+        const varName = comp.getLocalVarName('reIdx', this);
+        if (!comp.hasContextItem(varName)) {
+            const src = buildAnchoredTemplateRegexSource((idx as TypeTemplateLiteral).types || []);
+            comp.setContextItem(varName, `const ${varName} = new RegExp(${JSON.stringify(src)})`);
+        }
+        return varName;
+    }
+
     // #### jit code ####
     emitIsType(comp: JitFnCompiler): JitCode {
         const child = this.getJitChild(comp);
         const childJit = comp.compileIsType(child, 'E');
-        if (!childJit?.code) return {code: undefined, type: 'E'};
+        const prop = this.getChildVarName(comp);
+        const reVar = this.getKeyPatternVar(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const keyCheck = reVar ? `if (!${reVar}.test(${prop})) return false;` : '';
+        if (!childJit?.code && !keyCheck) return {code: undefined, type: 'E'};
+        const valueCheck = childJit?.code ? `if (!(${childJit.code})) return false;` : '';
         return {
-            code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}){if (!(${childJit.code})) return false;} return true;`,
+            code: `for (const ${prop} in ${comp.vλl}){${skipCode} ${keyCheck} ${valueCheck}} return true;`,
             type: 'RB',
         };
     }
     emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
         const child = this.getJitChild(comp);
         const childJit = comp.compileTypeErrors(child, 'S');
-        if (!childJit?.code) return {code: undefined, type: 'S'};
-        return {code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}) {${childJit.code}}`, type: 'S'};
+        const prop = this.getChildVarName(comp);
+        const reVar = this.getKeyPatternVar(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        // when the key fails the template literal pattern, report it (with the offending key in the path)
+        // and skip the value check to avoid compounding errors on values whose key was already invalid
+        const keyErr = reVar ? `if (!${reVar}.test(${prop})) {${comp.callJitErrWithPath(this, prop)}; continue;}` : '';
+        if (!childJit?.code && !keyErr) return {code: undefined, type: 'S'};
+        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${keyErr} ${childJit?.code || ''}}`, type: 'S'};
     }
     emitPrepareForJson(comp: JitFnCompiler): JitCode {
         const child = this.getJitChild(comp);
@@ -57,9 +81,11 @@ export class IndexSignatureRunType extends MemberRunType<TypeIndexSignature> {
         const varName = comp.vλl;
         const prop = this.getChildVarName(comp);
         const skipCode = this.getSkipCode(comp, prop);
+        const reVar = this.getKeyPatternVar(comp);
+        const patternSkip = reVar ? `if (!${reVar}.test(${prop})) continue;` : '';
         const isExpression = childIsExpression(childJit, child);
         const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
-        return {code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: 'S'};
+        return {code: `for (const ${prop} in ${varName}){${skipCode} ${patternSkip} ${code}}`, type: 'S'};
     }
     emitRestoreFromJson(comp: JitFnCompiler): JitCode {
         const child = this.getJitChild(comp);
@@ -68,40 +94,63 @@ export class IndexSignatureRunType extends MemberRunType<TypeIndexSignature> {
         const varName = comp.vλl;
         const prop = this.getChildVarName(comp);
         const skipCode = this.getSkipCode(comp, prop);
+        const reVar = this.getKeyPatternVar(comp);
+        const patternSkip = reVar ? `if (!${reVar}.test(${prop})) continue;` : '';
         const isExpression = childIsExpression(childJit, child);
         const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
-        return {code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: 'S'};
+        return {code: `for (const ${prop} in ${varName}){${skipCode} ${patternSkip} ${code}}`, type: 'S'};
     }
     emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
-        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'E'};
+        const reVar = this.getKeyPatternVar(comp);
         const child = this.getJitChild(comp);
         const childJit = comp.compileHasUnknownKeys(child, 'E');
-        if (!childJit?.code) return {code: '', type: 'E'};
+        // when the value is atomic and there's no key pattern, every key is "known" -> no check needed
+        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'E'};
         const varName = comp.vλl;
         const prop = this.getChildVarName(comp);
-        const resultVal = comp.getLocalVarName('res', this);
+        const skipCode = this.getSkipCode(comp, prop);
+        const patternCheck = reVar ? `if (!${reVar}.test(${prop})) return true;` : '';
+        const childCheck = childJit?.code
+            ? `const ${comp.getLocalVarName('res', this)} = ${childJit.code};if (${comp.getLocalVarName('res', this)}) return true;`
+            : '';
+        if (!patternCheck && !childCheck) return {code: '', type: 'E'};
         return {
-            code: `for (const ${prop} in ${varName}) {const ${resultVal} = ${childJit.code};if (${resultVal}) return true;}return false;`,
+            code: `for (const ${prop} in ${varName}) {${skipCode} ${patternCheck} ${childCheck}}return false;`,
             type: 'RB',
         };
     }
     emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
-        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};
+        const reVar = this.getKeyPatternVar(comp);
         const child = this.getJitChild(comp);
         const childJit = comp.compileUnknownKeyErrors(child, 'S');
-        return this.traverseCode(comp, childJit);
+        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const patternErr = reVar ? `if (!${reVar}.test(${prop})) {${comp.callJitErrWithPath('never', prop)}; continue;}` : '';
+        if (!patternErr && !childJit?.code) return {code: undefined, type: 'S'};
+        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternErr} ${childJit?.code || ''}}`, type: 'S'};
     }
     emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
-        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};
+        const reVar = this.getKeyPatternVar(comp);
         const child = this.getJitChild(comp);
         const childJit = comp.compileStripUnknownKeys(child, 'S');
-        return this.traverseCode(comp, childJit);
+        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const patternStrip = reVar ? `if (!${reVar}.test(${prop})) {delete ${comp.vλl}[${prop}]; continue;}` : '';
+        if (!patternStrip && !childJit?.code) return {code: undefined, type: 'S'};
+        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternStrip} ${childJit?.code || ''}}`, type: 'S'};
     }
     emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
-        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};
+        const reVar = this.getKeyPatternVar(comp);
         const child = this.getJitChild(comp);
         const childJit = comp.compileUnknownKeysToUndefined(child, 'S');
-        return this.traverseCode(comp, childJit);
+        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};
+        const prop = this.getChildVarName(comp);
+        const skipCode = this.getSkipCode(comp, prop);
+        const patternUndef = reVar ? `if (!${reVar}.test(${prop})) {${comp.vλl}[${prop}] = undefined; continue;}` : '';
+        if (!patternUndef && !childJit?.code) return {code: undefined, type: 'S'};
+        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternUndef} ${childJit?.code || ''}}`, type: 'S'};
     }
     traverseCode(comp: JitFnCompiler, childJit: JitCode | undefined): JitCode {
         if (!childJit?.code) return {code: undefined, type: 'S'};