sveld 0.25.1 → 0.25.3

package/README.md

@@ -332,6 +332,21 @@ export let kind = "primary";
 // inferred type: "string"
 ```
 
+For template literal default values, `sveld` automatically infers [template literal types](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html) when possible:
+
+```js
+export let id = `ccs-${Math.random().toString(36)}`;
+// inferred type: `ccs-${string}` & {}
+
+export let prefix = `prefix-`;
+// inferred type: `prefix-` & {}
+
+export let suffix = `-suffix`;
+// inferred type: `-suffix` & {}
+```
+
+The `& {}` intersection type makes the template literal type more permissive, allowing regular strings to be assigned while preserving the template literal type for better autocomplete and type hints. This provides more precise type checking than a generic `string` type while remaining flexible. For complex expressions in template literals, the type defaults to `string` for safety.
+
 Use the `@type` tag to explicitly document the type. In the following example, the `kind` property has an enumerated (enum) type.
 
 Signature:

package/lib/ComponentParser.d.ts

@@ -112,10 +112,12 @@ export default class ComponentParser {
     private readonly bindings;
     private readonly contexts;
     private variableInfoCache;
+    private sourceLinesCache?;
     constructor(options?: ComponentParserOptions);
     private static mapToArray;
     private static assignValue;
     private static formatComment;
+    private getCommentTags;
     /**
      * Finds the last comment from an array of leading comments.
      * TypeScript directives are stripped before parsing, so we can safely take the last comment.
@@ -126,6 +128,16 @@ export default class ComponentParser {
      * (e.g., Number.POSITIVE_INFINITY, Math.PI, etc.)
      */
     private isNumericConstant;
+    /**
+     * Infers the TypeScript type for an expression in a template literal.
+     * Returns a type string that can be used in a template literal type.
+     */
+    private inferExpressionType;
+    /**
+     * Infers a template literal type from a TemplateLiteral AST node.
+     * Returns a TypeScript template literal type string like `prefix-${string}`.
+     */
+    private inferTemplateLiteralType;
     private sourceAtPos;
     private collectReactiveVars;
     private addProp;
@@ -137,6 +149,8 @@ export default class ComponentParser {
     private buildEventDetailFromProperties;
     private generateContextTypeName;
     private buildVariableInfoCache;
+    private static readonly VAR_NAME_REGEX_CACHE;
+    private static getVarNameRegexes;
     private findVariableTypeAndDescription;
     private parseContextValue;
     private parseSetContextCall;

package/lib/ComponentParser.js

@@ -35,6 +35,7 @@ class ComponentParser {
     bindings = new Map();
     contexts = new Map();
     variableInfoCache = new Map();
+    sourceLinesCache;
     constructor(options) {
         this.options = options;
     }
@@ -54,6 +55,45 @@ class ComponentParser {
         }
         return formatted_comment;
     }
+    getCommentTags(parsed) {
+        const tags = parsed[0]?.tags ?? [];
+        const excludedTags = new Set([
+            "type",
+            "param",
+            "returns",
+            "return",
+            "extends",
+            "restProps",
+            "slot",
+            "event",
+            "typedef",
+        ]);
+        let typeTag;
+        const paramTags = [];
+        let returnsTag;
+        const additionalTags = [];
+        for (const tag of tags) {
+            if (tag.tag === "type") {
+                typeTag = tag;
+            }
+            else if (tag.tag === "param") {
+                paramTags.push(tag);
+            }
+            else if (tag.tag === "returns" || tag.tag === "return") {
+                returnsTag = tag;
+            }
+            else if (!excludedTags.has(tag.tag)) {
+                additionalTags.push(tag);
+            }
+        }
+        return {
+            type: typeTag,
+            param: paramTags,
+            returns: returnsTag,
+            additional: additionalTags,
+            description: parsed[0]?.description,
+        };
+    }
     /**
      * Finds the last comment from an array of leading comments.
      * TypeScript directives are stripped before parsing, so we can safely take the last comment.
@@ -91,6 +131,119 @@ class ComponentParser {
         }
         return false;
     }
+    /**
+     * Infers the TypeScript type for an expression in a template literal.
+     * Returns a type string that can be used in a template literal type.
+     */
+    inferExpressionType(expr) {
+        if (!expr || typeof expr !== "object" || !("type" in expr)) {
+            return "string";
+        }
+        /**
+         * @example `"hello"` → `"hello"`
+         * @example `42` → `42`
+         * @example `true` → `true`
+         */
+        if (expr.type === "Literal") {
+            if (typeof expr.value === "string") {
+                return `"${expr.value}"`;
+            }
+            if (typeof expr.value === "number") {
+                return `${expr.value}`;
+            }
+            if (typeof expr.value === "boolean") {
+                return `${expr.value}`;
+            }
+            return "string";
+        }
+        /**
+         * @example `someVar` → `string`
+         */
+        if (expr.type === "Identifier") {
+            // For variables, we can't know the exact type, so default to string
+            // Users can add explicit @type annotations if they need more precision
+            return "string";
+        }
+        /**
+         * @example `Math.PI` → `number`
+         * @example `Number.MAX_VALUE` → `number`
+         * @example `Math.random().toString` → `string`
+         */
+        if (expr.type === "MemberExpression") {
+            // Check if it's a well-known numeric constant
+            if (this.isNumericConstant(expr)) {
+                return "number";
+            }
+            // For other member expressions, default to string
+            // Common cases like Math.random().toString(36) will be string
+            return "string";
+        }
+        /**
+         * @example `Math.random().toString(36)` → `string`
+         * @example `someFunction()` → `string`
+         */
+        if (expr.type === "CallExpression") {
+            // Most call expressions in template literals return strings or numbers
+            // Default to string for safety
+            return "string";
+        }
+        /**
+         * @example `a + b` → `string`
+         * @example `x * y` → `string`
+         */
+        if (expr.type === "BinaryExpression") {
+            // For string concatenation or arithmetic, default to string
+            return "string";
+        }
+        return "string";
+    }
+    /**
+     * Infers a template literal type from a TemplateLiteral AST node.
+     * Returns a TypeScript template literal type string like `prefix-${string}`.
+     */
+    inferTemplateLiteralType(templateLiteral) {
+        if (!templateLiteral || typeof templateLiteral !== "object" || templateLiteral.type !== "TemplateLiteral") {
+            return "string";
+        }
+        const quasis = templateLiteral.quasis || [];
+        const expressions = templateLiteral.expressions || [];
+        // If there are no expressions, it's a static string
+        if (expressions.length === 0) {
+            if (quasis.length === 1) {
+                const staticValue = quasis[0].value?.cooked || quasis[0].value?.raw || "";
+                // Escape backticks and backslashes in the static string
+                const escaped = staticValue.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+                const templateLiteralType = `\`${escaped}\``;
+                // Use the (template-literal & {}) trick to make the type more permissive
+                return `(${templateLiteralType} & {})`;
+            }
+            return "string";
+        }
+        // Build the template literal type
+        const parts = [];
+        for (let i = 0; i < quasis.length; i++) {
+            const quasi = quasis[i];
+            const staticValue = quasi.value?.cooked || quasi.value?.raw || "";
+            // Escape backticks and backslashes in static parts
+            const escaped = staticValue.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+            if (escaped) {
+                parts.push(escaped);
+            }
+            // Add the expression type if there's a corresponding expression
+            if (i < expressions.length) {
+                const exprType = this.inferExpressionType(expressions[i]);
+                parts.push(`\${${exprType}}`);
+            }
+        }
+        // If we couldn't build a meaningful template literal type, fall back to string
+        if (parts.length === 0) {
+            return "string";
+        }
+        const templateLiteralType = `\`${parts.join("")}\``;
+        // Use the (template-literal & {}) trick to make the type more permissive
+        // This allows regular strings to be assigned while preserving template literal type for autocomplete
+        return `(${templateLiteralType} & {})`;
+    }
     sourceAtPos(start, end) {
         return this.source?.slice(start, end);
     }
@@ -138,7 +291,9 @@ class ComponentParser {
         const name = default_slot ? DEFAULT_SLOT_NAME : (slot_name ?? "");
         const fallback = ComponentParser.assignValue(slot_fallback);
         const props = ComponentParser.assignValue(slot_props);
-        const description = slot_description?.split("-").pop()?.trim();
+        const description = slot_description
+            ? slot_description.substring(slot_description.lastIndexOf("-") + 1).trim()
+            : undefined;
         if (this.slots.has(name)) {
             const existing_slot = this.slots.get(name);
             this.slots.set(name, {
@@ -167,7 +322,7 @@ class ComponentParser {
          * `@event` is not specified.
          */
         const default_detail = !has_argument && !detail ? "null" : ComponentParser.assignValue(detail);
-        const event_description = description?.split("-").pop()?.trim();
+        const event_description = description ? description.substring(description.lastIndexOf("-") + 1).trim() : undefined;
         if (this.events.has(name)) {
             const existing_event = this.events.get(name);
             this.events.set(name, {
@@ -453,7 +608,10 @@ class ComponentParser {
     buildVariableInfoCache() {
         if (!this.source)
             return;
-        const lines = this.source.split("\n");
+        if (!this.sourceLinesCache) {
+            this.sourceLinesCache = this.source.split("\n");
+        }
+        const lines = this.sourceLinesCache;
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i].trim();
             // Match variable declarations
@@ -477,14 +635,12 @@ class ComponentParser {
                         const commentBlock = commentLines.join("\n");
                         // Parse the JSDoc
                         const parsed = (0, comment_parser_1.parse)(commentBlock, { spacing: "preserve" });
-                        if (parsed[0]?.tags) {
-                            const typeTag = parsed[0].tags.find((t) => t.tag === "type");
-                            if (typeTag) {
-                                this.variableInfoCache.set(varName, {
-                                    type: this.aliasType(typeTag.type),
-                                    description: parsed[0].description || typeTag.description,
-                                });
-                            }
+                        const { type: typeTag, description } = this.getCommentTags(parsed);
+                        if (typeTag) {
+                            this.variableInfoCache.set(varName, {
+                                type: this.aliasType(typeTag.type),
+                                description: description || typeTag.description,
+                            });
                         }
                         break;
                     }
@@ -492,6 +648,20 @@ class ComponentParser {
             }
         }
     }
+    static VAR_NAME_REGEX_CACHE = new Map();
+    static getVarNameRegexes(varName) {
+        let cached = ComponentParser.VAR_NAME_REGEX_CACHE.get(varName);
+        if (!cached) {
+            const escaped = varName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            cached = [
+                new RegExp(`const\\s+${escaped}\\s*=`),
+                new RegExp(`let\\s+${escaped}\\s*=`),
+                new RegExp(`function\\s+${escaped}\\s*\\(`),
+            ];
+            ComponentParser.VAR_NAME_REGEX_CACHE.set(varName, cached);
+        }
+        return cached;
+    }
     findVariableTypeAndDescription(varName) {
         const cached = this.variableInfoCache.get(varName);
         if (cached) {
@@ -500,15 +670,18 @@ class ComponentParser {
         // Search through the source code directly for JSDoc comments
         if (!this.source)
             return null;
-        // Build a map of variable names to their types by looking at the source
-        const lines = this.source.split("\n");
+        if (!this.sourceLinesCache) {
+            this.sourceLinesCache = this.source.split("\n");
+        }
+        const lines = this.sourceLinesCache;
+        const [constRegex, letRegex, funcRegex] = ComponentParser.getVarNameRegexes(varName);
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i].trim();
             // Check if this line declares our variable
             // Match patterns like: const varName = ..., let varName = ..., function varName
-            const constMatch = line.match(new RegExp(`const\\s+${varName}\\s*=`));
-            const letMatch = line.match(new RegExp(`let\\s+${varName}\\s*=`));
-            const funcMatch = line.match(new RegExp(`function\\s+${varName}\\s*\\(`));
+            const constMatch = line.match(constRegex);
+            const letMatch = line.match(letRegex);
+            const funcMatch = line.match(funcRegex);
             if (constMatch || letMatch || funcMatch) {
                 // Look backwards for JSDoc comment
                 for (let j = i - 1; j >= 0; j--) {
@@ -527,14 +700,12 @@ class ComponentParser {
                         const commentBlock = commentLines.join("\n");
                         // Parse the JSDoc
                         const parsed = (0, comment_parser_1.parse)(commentBlock, { spacing: "preserve" });
-                        if (parsed[0]?.tags) {
-                            const typeTag = parsed[0].tags.find((t) => t.tag === "type");
-                            if (typeTag) {
-                                return {
-                                    type: this.aliasType(typeTag.type),
-                                    description: parsed[0].description || typeTag.description,
-                                };
-                            }
+                        const { type: typeTag, description } = this.getCommentTags(parsed);
+                        if (typeTag) {
+                            return {
+                                type: this.aliasType(typeTag.type),
+                                description: description || typeTag.description,
+                            };
                         }
                         break;
                     }
@@ -685,6 +856,7 @@ class ComponentParser {
         this.bindings.clear();
         this.contexts.clear();
         this.variableInfoCache.clear();
+        this.sourceLinesCache = undefined;
     }
     // Pre-compiled regexes for better performance
     static SCRIPT_BLOCK_REGEX = /(<script[^>]*>)([\s\S]*?)(<\/script>)/gi;
@@ -718,6 +890,7 @@ class ComponentParser {
         // The compile result includes the parsed AST
         this.parsed = compiled.ast || (0, compiler_1.parse)(cleanedSource);
         this.collectReactiveVars();
+        this.sourceLinesCache = this.source.split("\n");
         this.buildVariableInfoCache();
         this.parseCustomTypes();
         if (this.parsed?.module) {
@@ -775,6 +948,11 @@ class ComponentParser {
                                     }
                                     // Otherwise, don't infer type, just preserve existing type annotation.
                                 }
+                                else if (init.type === "TemplateLiteral") {
+                                    // Handle template literals - infer template literal type when possible
+                                    value = this.sourceAtPos(init.start, init.end);
+                                    type = this.inferTemplateLiteralType(init);
+                                }
                                 else {
                                     value = init.raw;
                                     type = init.value == null ? undefined : typeof init.value;
@@ -798,12 +976,11 @@ class ComponentParser {
                                 const comment = (0, comment_parser_1.parse)(ComponentParser.formatComment(jsdoc_comment.value), {
                                     spacing: "preserve",
                                 });
+                                const { type: typeTag, param: paramTags, returns: returnsTag, additional: additionalTags, description: commentDescription, } = this.getCommentTags(comment);
                                 // Extract @type tag
-                                const typeTag = comment[0]?.tags.find((t) => t.tag === "type");
                                 if (typeTag)
                                     type = this.aliasType(typeTag.type);
                                 // Extract @param tags
-                                const paramTags = comment[0]?.tags.filter((t) => t.tag === "param") ?? [];
                                 if (paramTags.length > 0) {
                                     params = paramTags
                                         .filter((tag) => !tag.name.includes(".")) // Exclude nested params like "options.expand"
@@ -815,27 +992,20 @@ class ComponentParser {
                                     }));
                                 }
                                 // Extract @returns/@return tag
-                                const returnsTag = comment[0]?.tags.find((t) => t.tag === "returns" || t.tag === "return");
                                 if (returnsTag)
                                     returnType = this.aliasType(returnsTag.type);
                                 // Build description from comment description and non-param/non-type tags
-                                const commentDescription = ComponentParser.assignValue(comment[0]?.description?.trim());
-                                const additionalTags = comment[0]?.tags.filter((tag) => ![
-                                    "type",
-                                    "param",
-                                    "returns",
-                                    "return",
-                                    "extends",
-                                    "restProps",
-                                    "slot",
-                                    "event",
-                                    "typedef",
-                                ].includes(tag.tag)) ?? [];
-                                if (commentDescription || additionalTags.length > 0) {
-                                    description = commentDescription || "";
+                                const formattedDescription = ComponentParser.assignValue(commentDescription?.trim());
+                                if (formattedDescription || additionalTags.length > 0) {
+                                    const descriptionParts = [];
+                                    if (formattedDescription) {
+                                        descriptionParts.push(formattedDescription);
+                                    }
                                     for (const tag of additionalTags) {
-                                        description += `${description ? "\n" : ""}@${tag.tag}${tag.name ? ` ${tag.name}` : ""}${tag.description ? ` ${tag.description}` : ""}`;
+                                        const tagStr = `@${tag.tag}${tag.name ? ` ${tag.name}` : ""}${tag.description ? ` ${tag.description}` : ""}`;
+                                        descriptionParts.push(tagStr);
                                     }
+                                    description = descriptionParts.join("\n");
                                 }
                             }
                         }
@@ -971,6 +1141,11 @@ class ComponentParser {
                                 }
                                 // Otherwise, don't infer type, just preserve existing type annotation.
                             }
+                            else if (init.type === "TemplateLiteral") {
+                                // Handle template literals - infer template literal type when possible
+                                value = this.sourceAtPos(init.start, init.end);
+                                type = this.inferTemplateLiteralType(init);
+                            }
                             else {
                                 value = init.raw;
                                 type = init.value == null ? undefined : typeof init.value;
@@ -994,12 +1169,11 @@ class ComponentParser {
                             const comment = (0, comment_parser_1.parse)(ComponentParser.formatComment(jsdoc_comment.value), {
                                 spacing: "preserve",
                             });
+                            const { type: typeTag, param: paramTags, returns: returnsTag, additional: additional_tags, description: commentDescription, } = this.getCommentTags(comment);
                             // Extract @type tag
-                            const typeTag = comment[0]?.tags.find((t) => t.tag === "type");
                             if (typeTag)
                                 type = this.aliasType(typeTag.type);
                             // Extract @param tags
-                            const paramTags = comment[0]?.tags.filter((t) => t.tag === "param") ?? [];
                             if (paramTags.length > 0) {
                                 params = paramTags
                                     .filter((tag) => !tag.name.includes(".")) // Exclude nested params like "options.expand"
@@ -1011,27 +1185,20 @@ class ComponentParser {
                                 }));
                             }
                             // Extract @returns/@return tag
-                            const returnsTag = comment[0]?.tags.find((t) => t.tag === "returns" || t.tag === "return");
                             if (returnsTag)
                                 returnType = this.aliasType(returnsTag.type);
                             // Build description from comment description and non-param/non-type tags
-                            const commentDescription = ComponentParser.assignValue(comment[0]?.description?.trim());
-                            const additional_tags = comment[0]?.tags.filter((tag) => ![
-                                "type",
-                                "param",
-                                "returns",
-                                "return",
-                                "extends",
-                                "restProps",
-                                "slot",
-                                "event",
-                                "typedef",
-                            ].includes(tag.tag)) ?? [];
-                            if (commentDescription || additional_tags.length > 0) {
-                                description = commentDescription || "";
+                            const formattedDescription = ComponentParser.assignValue(commentDescription?.trim());
+                            if (formattedDescription || additional_tags.length > 0) {
+                                const descriptionParts = [];
+                                if (formattedDescription) {
+                                    descriptionParts.push(formattedDescription);
+                                }
                                 for (const tag of additional_tags) {
-                                    description += `${description ? "\n" : ""}@${tag.tag}${tag.name ? ` ${tag.name}` : ""}${tag.description ? ` ${tag.description}` : ""}`;
+                                    const tagStr = `@${tag.tag}${tag.name ? ` ${tag.name}` : ""}${tag.description ? ` ${tag.description}` : ""}`;
+                                    descriptionParts.push(tagStr);
                                 }
+                                description = descriptionParts.join("\n");
                             }
                         }
                     }
@@ -1113,7 +1280,9 @@ class ComponentParser {
                         const existing_event = this.events.get(node.name);
                         // Check if this event has a JSDoc description
                         const description = this.eventDescriptions.get(node.name);
-                        const event_description = description?.split("-").pop()?.trim();
+                        const event_description = description
+                            ? description.substring(description.lastIndexOf("-") + 1).trim()
+                            : undefined;
                         if (!existing_event) {
                             // Add new forwarded event
                             this.events.set(node.name, {
@@ -1183,7 +1352,9 @@ class ComponentParser {
             // If event is marked as dispatched but is NOT actually dispatched, convert it to forwarded
             if (event && event.type === "dispatched" && !actuallyDispatchedEvents.has(eventName)) {
                 const description = this.eventDescriptions.get(eventName);
-                const event_description = description?.split("-").pop()?.trim();
+                const event_description = description
+                    ? description.substring(description.lastIndexOf("-") + 1).trim()
+                    : undefined;
                 const forwardedEvent = {
                     type: "forwarded",
                     name: eventName,
@@ -1199,56 +1370,62 @@ class ComponentParser {
                 this.events.set(eventName, forwardedEvent);
             }
         });
-        return {
-            props: ComponentParser.mapToArray(this.props).map((prop) => {
-                if (this.bindings.has(prop.name)) {
-                    return {
-                        ...prop,
-                        type: "null | " +
-                            this.bindings
-                                .get(prop.name)
-                                ?.elements.sort()
-                                .map((element) => (0, element_tag_map_1.getElementByTag)(element))
-                                .join(" | "),
-                    };
-                }
-                return prop;
-            }),
-            moduleExports: ComponentParser.mapToArray(this.moduleExports),
-            slots: ComponentParser.mapToArray(this.slots)
-                .map((slot) => {
-                try {
-                    const slot_props = JSON.parse(slot.slot_props);
-                    const new_props = [];
-                    for (const key of Object.keys(slot_props)) {
-                        if (slot_props[key].replace && slot_props[key].value !== undefined) {
-                            slot_props[key].value = this.props.get(slot_props[key].value)?.type;
-                        }
-                        if (slot_props[key].value === undefined)
-                            slot_props[key].value = "any";
-                        new_props.push(`${key}: ${slot_props[key].value}`);
+        const processedProps = ComponentParser.mapToArray(this.props).map((prop) => {
+            if (this.bindings.has(prop.name)) {
+                const elementTypes = this.bindings
+                    .get(prop.name)
+                    ?.elements.sort()
+                    .map((element) => (0, element_tag_map_1.getElementByTag)(element))
+                    .join(" | ");
+                return {
+                    ...prop,
+                    type: `null | ${elementTypes}`,
+                };
+            }
+            return prop;
+        });
+        const processedSlots = ComponentParser.mapToArray(this.slots)
+            .map((slot) => {
+            try {
+                const slot_props = JSON.parse(slot.slot_props);
+                const new_props = [];
+                for (const key of Object.keys(slot_props)) {
+                    if (slot_props[key].replace && slot_props[key].value !== undefined) {
+                        slot_props[key].value = this.props.get(slot_props[key].value)?.type;
                     }
-                    const formatted_slot_props = new_props.length === 0 ? "Record<string, never>" : `{ ${new_props.join(", ")} }`;
-                    return { ...slot, slot_props: formatted_slot_props };
+                    if (slot_props[key].value === undefined)
+                        slot_props[key].value = "any";
+                    new_props.push(`${key}: ${slot_props[key].value}`);
                 }
-                catch (_e) {
-                    return slot;
-                }
-            })
-                .sort((a, b) => {
-                if (a.name < b.name)
-                    return -1;
-                if (a.name > b.name)
-                    return 1;
-                return 0;
-            }),
-            events: ComponentParser.mapToArray(this.events),
-            typedefs: ComponentParser.mapToArray(this.typedefs),
+                const formatted_slot_props = new_props.length === 0 ? "Record<string, never>" : `{ ${new_props.join(", ")} }`;
+                return { ...slot, slot_props: formatted_slot_props };
+            }
+            catch (_e) {
+                return slot;
+            }
+        })
+            .sort((a, b) => {
+            if (a.name < b.name)
+                return -1;
+            if (a.name > b.name)
+                return 1;
+            return 0;
+        });
+        const moduleExportsArray = ComponentParser.mapToArray(this.moduleExports);
+        const eventsArray = ComponentParser.mapToArray(this.events);
+        const typedefsArray = ComponentParser.mapToArray(this.typedefs);
+        const contextsArray = ComponentParser.mapToArray(this.contexts);
+        return {
+            props: processedProps,
+            moduleExports: moduleExportsArray,
+            slots: processedSlots,
+            events: eventsArray,
+            typedefs: typedefsArray,
             generics: this.generics,
             rest_props: this.rest_props,
             extends: this.extends,
             componentComment: this.componentComment,
-            contexts: ComponentParser.mapToArray(this.contexts),
+            contexts: contextsArray,
         };
     }
 }

package/lib/resolve-alias.js

@@ -7,6 +7,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const path_1 = require("./path");
 const configCache = new Map();
+const pathPatternRegexCache = new Map();
 const COMMENT_PATTERN = /\/\*[\s\S]*?\*\/|\/\/.*/g;
 const REGEX_SPECIAL_CHARS = /[.+?^${}()|[\]\\]/g;
 function clearConfigCache() {
@@ -83,12 +84,16 @@ function resolvePathAliasAbsolute(importPath, fromDir) {
         // e.g., "$lib/*" -> /^\$lib\/(.*)$/
         // e.g., "$lib" -> /^\$lib$/
         // e.g., "@components/*" -> /^@components\/(.*)$/
-        // Escape special regex chars but keep * for replacement
-        const escapedPattern = pattern
-            .split("*")
-            .map((part) => part.replace(REGEX_SPECIAL_CHARS, "\\$&"))
-            .join("(.*)");
-        const regex = new RegExp(`^${escapedPattern}$`);
+        let regex = pathPatternRegexCache.get(pattern);
+        if (!regex) {
+            // Escape special regex chars but keep * for replacement
+            const escapedPattern = pattern
+                .split("*")
+                .map((part) => part.replace(REGEX_SPECIAL_CHARS, "\\$&"))
+                .join("(.*)");
+            regex = new RegExp(`^${escapedPattern}$`);
+            pathPatternRegexCache.set(pattern, regex);
+        }
         const match = importPath.match(regex);
         if (match) {
             // Use the first mapping (TypeScript uses the first match)

package/lib/rollup-plugin.js

@@ -69,42 +69,47 @@ async function generateBundle(input, glob) {
     const allComponentsForTypes = new Map();
     const exportEntries = Object.entries(exports);
     const allComponentEntries = Object.entries(allComponents);
-    // Process exported components (for metadata/JSON/Markdown)
-    const componentPromises = exportEntries.map(async ([exportName, entry]) => {
+    const uniqueFilePaths = new Set();
+    for (const [, entry] of exportEntries) {
         const filePath = entry.source;
-        const { ext, name } = (0, node_path_1.parse)(filePath);
-        let moduleName = exportName;
-        if (exportEntries.length === 1 && exportName === "default") {
-            moduleName = name;
+        const { ext } = (0, node_path_1.parse)(filePath);
+        if (ext === ".svelte") {
+            uniqueFilePaths.add((0, node_path_1.resolve)(dir, filePath));
         }
+    }
+    for (const [, entry] of allComponentEntries) {
+        const filePath = entry.source;
+        const { ext } = (0, node_path_1.parse)(filePath);
         if (ext === ".svelte") {
-            const source = await (0, promises_1.readFile)((0, node_path_1.resolve)(dir, filePath), "utf-8");
-            const { code: processed } = await (0, compiler_1.preprocess)(source, [(0, svelte_preprocess_1.typescript)(), (0, svelte_preprocess_1.replace)([[STYLE_TAG_REGEX, ""]])], {
-                filename: (0, node_path_1.basename)(filePath),
-            });
-            const parser = new ComponentParser_1.default();
-            const parsed = parser.parseSvelteComponent(processed, {
-                moduleName,
-                filePath,
-            });
-            return {
-                moduleName,
-                filePath,
-                ...parsed,
-            };
+            uniqueFilePaths.add((0, node_path_1.resolve)(dir, filePath));
         }
-        return null;
-    });
-    // Process all components (for .d.ts generation)
-    const allComponentPromises = allComponentEntries.map(async ([exportName, entry]) => {
+    }
+    const fileContents = await Promise.all(Array.from(uniqueFilePaths).map(async (filePath) => {
+        try {
+            const content = await (0, promises_1.readFile)(filePath, "utf-8");
+            return { path: filePath, content };
+        }
+        catch (error) {
+            console.warn(`Warning: Failed to read file ${filePath}:`, error);
+            return { path: filePath, content: null };
+        }
+    }));
+    const fileMap = new Map(fileContents.map(({ path, content }) => [path, content]));
+    // Helper function to process a single component
+    const processComponent = async ([exportName, entry], entries, fileMap) => {
         const filePath = entry.source;
         const { ext, name } = (0, node_path_1.parse)(filePath);
         let moduleName = exportName;
-        if (allComponentEntries.length === 1 && exportName === "default") {
+        if (entries.length === 1 && exportName === "default") {
             moduleName = name;
         }
         if (ext === ".svelte") {
-            const source = await (0, promises_1.readFile)((0, node_path_1.resolve)(dir, filePath), "utf-8");
+            const resolvedPath = (0, node_path_1.resolve)(dir, filePath);
+            const source = fileMap.get(resolvedPath);
+            if (source === null || source === undefined) {
+                // File was not found or failed to read, skip this component
+                return null;
+            }
             const { code: processed } = await (0, compiler_1.preprocess)(source, [(0, svelte_preprocess_1.typescript)(), (0, svelte_preprocess_1.replace)([[STYLE_TAG_REGEX, ""]])], {
                 filename: (0, node_path_1.basename)(filePath),
             });
@@ -120,7 +125,11 @@ async function generateBundle(input, glob) {
             };
         }
         return null;
-    });
+    };
+    // Process exported components (for metadata/JSON/Markdown)
+    const componentPromises = exportEntries.map((entry) => processComponent(entry, exportEntries, fileMap));
+    // Process all components (for .d.ts generation)
+    const allComponentPromises = allComponentEntries.map((entry) => processComponent(entry, allComponentEntries, fileMap));
     const [results, allResults] = await Promise.all([Promise.all(componentPromises), Promise.all(allComponentPromises)]);
     for (const result of results) {
         if (result) {

package/lib/writer/WriterMarkdown.d.ts

@@ -10,10 +10,11 @@ interface TocLine {
 }
 export default class WriterMarkdown extends Writer {
     onAppend?: OnAppend;
-    source: string;
+    private sourceParts;
     hasToC: boolean;
     toc: TocLine[];
     constructor(options: MarkdownOptions);
+    get source(): string;
     appendLineBreaks(): this;
     append(type: AppendType, raw?: string): this;
     tableOfContents(): this;

package/lib/writer/WriterMarkdown.js

@@ -8,15 +8,18 @@ const BACKTICK_REGEX = /`/g;
 const WHITESPACE_REGEX = /\s+/g;
 class WriterMarkdown extends Writer_1.default {
     onAppend;
-    source = "";
+    sourceParts = [];
     hasToC = false;
     toc = [];
     constructor(options) {
         super({ parser: "markdown", printWidth: 80 });
         this.onAppend = options.onAppend;
     }
+    get source() {
+        return this.sourceParts.join("");
+    }
     appendLineBreaks() {
-        this.source += "\n\n";
+        this.sourceParts.push("\n\n");
         return this;
     }
     append(type, raw) {
@@ -28,9 +31,7 @@ class WriterMarkdown extends Writer_1.default {
             case "h5":
             case "h6": {
                 const length = Number(type.slice(-1));
-                this.source += `${Array.from({ length })
-                    .map((_) => "#")
-                    .join("")} ${raw}`;
+                this.sourceParts.push(`${"#".repeat(length)} ${raw}`);
                 if (this.hasToC && type === "h2") {
                     this.toc.push({
                         array: Array.from({ length: (length - 1) * 2 }),
@@ -40,16 +41,16 @@ class WriterMarkdown extends Writer_1.default {
                 break;
             }
             case "quote":
-                this.source += `> ${raw}`;
+                this.sourceParts.push(`> ${raw}`);
                 break;
             case "p":
-                this.source += raw;
+                this.sourceParts.push(raw ?? "");
                 break;
             case "divider":
-                this.source += "---";
+                this.sourceParts.push("---");
                 break;
             case "raw":
-                this.source += raw;
+                this.sourceParts.push(raw ?? "");
                 break;
         }
         if (type !== "raw")
@@ -58,18 +59,18 @@ class WriterMarkdown extends Writer_1.default {
         return this;
     }
     tableOfContents() {
-        this.source += "<!-- __TOC__ -->";
+        this.sourceParts.push("<!-- __TOC__ -->");
         this.hasToC = true;
         this.appendLineBreaks();
         return this;
     }
     end() {
-        this.source = this.source.replace("<!-- __TOC__ -->", this.toc
+        const source = this.sourceParts.join("");
+        return source.replace("<!-- __TOC__ -->", this.toc
             .map(({ array, raw }) => {
             return `${array.join(" ")} - [${raw}](#${raw.toLowerCase().replace(BACKTICK_REGEX, "").replace(WHITESPACE_REGEX, "-")})`;
         })
             .join("\n"));
-        return this.source;
     }
 }
 exports.default = WriterMarkdown;

package/lib/writer/writer-markdown-core.d.ts

@@ -10,10 +10,11 @@ interface TocLine {
 }
 export declare class BrowserWriterMarkdown {
     onAppend?: OnAppend;
-    source: string;
+    private sourceParts;
     hasToC: boolean;
     toc: TocLine[];
     constructor(options: MarkdownOptions);
+    get source(): string;
     appendLineBreaks(): this;
     append(type: AppendType, raw?: string): this;
     tableOfContents(): this;

package/lib/writer/writer-markdown-core.js

@@ -8,14 +8,17 @@ const WHITESPACE_REGEX = /\s+/g;
 // Browser-compatible WriterMarkdown that doesn't extend Writer
 class BrowserWriterMarkdown {
     onAppend;
-    source = "";
+    sourceParts = [];
     hasToC = false;
     toc = [];
     constructor(options) {
         this.onAppend = options.onAppend;
     }
+    get source() {
+        return this.sourceParts.join("");
+    }
     appendLineBreaks() {
-        this.source += "\n\n";
+        this.sourceParts.push("\n\n");
         return this;
     }
     append(type, raw) {
@@ -27,9 +30,7 @@ class BrowserWriterMarkdown {
             case "h5":
             case "h6": {
                 const length = Number(type.slice(-1));
-                this.source += `${Array.from({ length })
-                    .map((_) => "#")
-                    .join("")} ${raw}`;
+                this.sourceParts.push(`${"#".repeat(length)} ${raw}`);
                 if (this.hasToC && type === "h2") {
                     this.toc.push({
                         array: Array.from({ length: (length - 1) * 2 }),
@@ -39,16 +40,16 @@ class BrowserWriterMarkdown {
                 break;
             }
             case "quote":
-                this.source += `> ${raw}`;
+                this.sourceParts.push(`> ${raw}`);
                 break;
             case "p":
-                this.source += raw;
+                this.sourceParts.push(raw ?? "");
                 break;
             case "divider":
-                this.source += "---";
+                this.sourceParts.push("---");
                 break;
             case "raw":
-                this.source += raw;
+                this.sourceParts.push(raw ?? "");
                 break;
         }
         if (type !== "raw")
@@ -57,18 +58,18 @@ class BrowserWriterMarkdown {
         return this;
     }
     tableOfContents() {
-        this.source += "<!-- __TOC__ -->";
+        this.sourceParts.push("<!-- __TOC__ -->");
         this.hasToC = true;
         this.appendLineBreaks();
         return this;
     }
     end() {
-        this.source = this.source.replace("<!-- __TOC__ -->", this.toc
+        const source = this.sourceParts.join("");
+        return source.replace("<!-- __TOC__ -->", this.toc
             .map(({ array, raw }) => {
             return `${array.join(" ")} - [${raw}](#${raw.toLowerCase().replace(BACKTICK_REGEX, "").replace(WHITESPACE_REGEX, "-")})`;
         })
             .join("\n"));
-        return this.source;
     }
 }
 exports.BrowserWriterMarkdown = BrowserWriterMarkdown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sveld",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "license": "Apache-2.0",
   "description": "Generate TypeScript definitions for your Svelte components.",
   "main": "./lib/index.js",