Support for infer in template literals, intrinsic types and more

factory/parser.ts

@@ -42,7 +42,7 @@ import { PrefixUnaryExpressionNodeParser } from "../src/NodeParser/PrefixUnaryEx
 import { PropertyAccessExpressionParser } from "../src/NodeParser/PropertyAccessExpressionParser.js";
 import { RestTypeNodeParser } from "../src/NodeParser/RestTypeNodeParser.js";
 import { StringLiteralNodeParser } from "../src/NodeParser/StringLiteralNodeParser.js";
-import { StringTemplateLiteralNodeParser } from "../src/NodeParser/StringTemplateLiteralNodeParser.js";
+import { TemplateLiteralNodeParser } from "../src/NodeParser/TemplateLiteralNodeParser.js";
 import { StringTypeNodeParser } from "../src/NodeParser/StringTypeNodeParser.js";
 import { SymbolTypeNodeParser } from "../src/NodeParser/SymbolTypeNodeParser.js";
 import { TupleNodeParser } from "../src/NodeParser/TupleNodeParser.js";
@@ -109,7 +109,7 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         .addNodeParser(new SatisfiesNodeParser(chainNodeParser))
         .addNodeParser(withJsDoc(new ParameterParser(chainNodeParser)))
         .addNodeParser(new StringLiteralNodeParser())
-        .addNodeParser(new StringTemplateLiteralNodeParser(chainNodeParser))
+        .addNodeParser(new TemplateLiteralNodeParser(chainNodeParser))
         .addNodeParser(new IntrinsicNodeParser())
         .addNodeParser(new NumberLiteralNodeParser())
         .addNodeParser(new BooleanLiteralNodeParser())

index.ts

@@ -54,6 +54,7 @@ export * from "./src/Type/ReferenceType.js";
 export * from "./src/Type/RestType.js";
 export * from "./src/Type/StringType.js";
 export * from "./src/Type/SymbolType.js";
+export * from "./src/Type/TemplateLiteralType.js";
 export * from "./src/Type/TupleType.js";
 export * from "./src/Type/UndefinedType.js";
 export * from "./src/Type/UnionType.js";
@@ -135,7 +136,7 @@ export * from "./src/NodeParser/PrefixUnaryExpressionNodeParser.js";
 export * from "./src/NodeParser/PropertyAccessExpressionParser.js";
 export * from "./src/NodeParser/RestTypeNodeParser.js";
 export * from "./src/NodeParser/StringLiteralNodeParser.js";
-export * from "./src/NodeParser/StringTemplateLiteralNodeParser.js";
+export * from "./src/NodeParser/TemplateLiteralNodeParser.js";
 export * from "./src/NodeParser/StringTypeNodeParser.js";
 export * from "./src/NodeParser/SymbolTypeNodeParser.js";
 export * from "./src/NodeParser/TupleNodeParser.js";

src/NodeParser/ConditionalTypeNodeParser.ts

@@ -29,14 +29,14 @@ export class ConditionalTypeNodeParser implements SubNodeParser {
         const extendsType = this.childNodeParser.createType(node.extendsType, context);
         const checkTypeParameterName = this.getTypeParameterName(node.checkType);
 
-        const inferMap = new Map();
+        const inferMap = new Map<string, BaseType>();
 
         // If check-type is not a type parameter then condition is very simple, no type narrowing needed
         if (checkTypeParameterName == null) {
             const result = isAssignableTo(extendsType, checkType, inferMap);
             return this.childNodeParser.createType(
                 result ? node.trueType : node.falseType,
-                this.createSubContext(node, context, undefined, result ? inferMap : new Map()),
+                this.createSubContext(node, context, undefined, result ? inferMap : new Map<string, BaseType>()),
             );
         }
 

src/NodeParser/IntrinsicNodeParser.ts

@@ -6,33 +6,51 @@ import type { BaseType } from "../Type/BaseType.js";
 import { LiteralType } from "../Type/LiteralType.js";
 import { UnionType } from "../Type/UnionType.js";
 import { extractLiterals } from "../Utils/extractLiterals.js";
+import { isExtendsType } from "../Utils/isExtendsType.js";
+import { IntrinsicType } from "../Type/IntrinsicType.js";
+import { StringType } from "../Type/StringType.js";
 
-export const intrinsicMethods: Record<string, ((v: string) => string) | undefined> = {
+export const intrinsicMethods = {
     Uppercase: (v) => v.toUpperCase(),
     Lowercase: (v) => v.toLowerCase(),
     Capitalize: (v) => v[0].toUpperCase() + v.slice(1),
     Uncapitalize: (v) => v[0].toLowerCase() + v.slice(1),
-};
+} as const satisfies Record<string, ((v: string) => string) | undefined>;
+
+function isIntrinsicMethod(methodName: string): methodName is keyof typeof intrinsicMethods {
+    return methodName in intrinsicMethods;
+}
 
 export class IntrinsicNodeParser implements SubNodeParser {
     public supportsNode(node: ts.KeywordTypeNode): boolean {
         return node.kind === ts.SyntaxKind.IntrinsicKeyword;
     }
     public createType(node: ts.KeywordTypeNode, context: Context): BaseType {
         const methodName = getParentName(node);
-        const method = intrinsicMethods[methodName];
-
-        if (!method) {
+        if (!isIntrinsicMethod(methodName)) {
             throw new LogicError(node, `Unknown intrinsic method: ${methodName}`);
         }
 
-        const literals = extractLiterals(context.getArguments()[0])
-            .map(method)
-            .map((literal) => new LiteralType(literal));
-        if (literals.length === 1) {
-            return literals[0];
+        const method = intrinsicMethods[methodName];
+        const argument = context.getArguments()[0];
+
+        try {
+            const literals = extractLiterals(argument)
+                .map(method)
+                .map((literal) => new LiteralType(literal));
+
+            if (literals.length === 1) {
+                return literals[0];
+            }
+
+            return new UnionType(literals);
+        } catch (error) {
+            if (isExtendsType(context.getReference())) {
+                return new IntrinsicType(method, argument);
+            }
+
+            return new StringType();
         }
-        return new UnionType(literals);
     }
 }
 

src/NodeParser/TemplateLiteralNodeParser.ts

@@ -0,0 +1,73 @@
+import ts from "typescript";
+import type { Context, NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { LiteralType } from "../Type/LiteralType.js";
+import { TemplateLiteralType } from "../Type/TemplateLiteralType.js"; // New type
+import { NeverType } from "../Type/NeverType.js";
+import { extractLiterals } from "../Utils/extractLiterals.js";
+import { StringType } from "../Type/StringType.js";
+import { UnionType } from "../Type/UnionType.js";
+import { isExtendsType } from "../Utils/isExtendsType.js";
+
+export class TemplateLiteralNodeParser implements SubNodeParser {
+    public constructor(protected childNodeParser: NodeParser) {}
+
+    public supportsNode(node: ts.NoSubstitutionTemplateLiteral | ts.TemplateLiteralTypeNode): boolean {
+        return (
+            node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === ts.SyntaxKind.TemplateLiteralType
+        );
+    }
+
+    public createType(node: ts.NoSubstitutionTemplateLiteral | ts.TemplateLiteralTypeNode, context: Context): BaseType {
+        if (node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral) {
+            return new LiteralType(node.text);
+        }
+
+        const types: BaseType[] = [];
+
+        const prefix = node.head.text;
+        if (prefix) {
+            types.push(new LiteralType(prefix));
+        }
+
+        for (const span of node.templateSpans) {
+            types.push(this.childNodeParser.createType(span.type, context));
+
+            const suffix = span.literal.text;
+            if (suffix) {
+                types.push(new LiteralType(suffix));
+            }
+        }
+
+        if (isExtendsType(node)) {
+            return new TemplateLiteralType(types);
+        }
+
+        return this.expandTypes(types);
+    }
+
+    protected expandTypes(types: BaseType[]): BaseType {
+        let expanded: string[] = [""];
+
+        for (const type of types) {
+            // Any `never` type in the template literal will make the whole type `never`
+            if (type instanceof NeverType) {
+                return new NeverType();
+            }
+
+            try {
+                const literals = extractLiterals(type);
+                expanded = expanded.flatMap((prefix) => literals.map((suffix) => prefix + suffix));
+            } catch {
+                return new StringType();
+            }
+        }
+
+        if (expanded.length === 1) {
+            return new LiteralType(expanded[0]);
+        }
+
+        return new UnionType(expanded.map((literal) => new LiteralType(literal)));
+    }
+}

src/Type/IntrinsicType.ts

@@ -0,0 +1,23 @@
+import type { BaseType } from "./BaseType.js";
+import { PrimitiveType } from "./PrimitiveType.js";
+
+export class IntrinsicType extends PrimitiveType {
+    constructor(
+        protected method: (v: string) => string,
+        protected argument: BaseType,
+    ) {
+        super();
+    }
+
+    public getId(): string {
+        return `${this.getMethod().name}<${this.getArgument().getId()}>`;
+    }
+
+    public getMethod(): (v: string) => string {
+        return this.method;
+    }
+
+    public getArgument(): BaseType {
+        return this.argument;
+    }
+}

src/Type/TemplateLiteralType.ts

@@ -0,0 +1,17 @@
+import { BaseType } from "./BaseType.js";
+
+export class TemplateLiteralType extends BaseType {
+    public constructor(private types: readonly BaseType[]) {
+        super();
+    }
+
+    public getId(): string {
+        return `template-literal-${this.getParts()
+            .map((part) => part.getId())
+            .join("-")}`;
+    }
+
+    public getParts(): readonly BaseType[] {
+        return this.types;
+    }
+}