sveld 0.25.0 → 0.25.2

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.
@@ -137,6 +139,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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const comment_parser_1 = require("comment-parser");
 const compiler_1 = require("svelte/compiler");
 const element_tag_map_1 = require("./element-tag-map");
+const COMMENT_BLOCK_DESCRIPTION_REGEX = /^-\s*/;
 const VAR_DECLARATION_REGEX = /(?:const|let|function)\s+(\w+)\s*[=(]/;
 const DEFAULT_SLOT_NAME = null;
 const TYPEDEF_END_REGEX = /(\}|\};)$/;
@@ -34,6 +35,7 @@ class ComponentParser {
     bindings = new Map();
     contexts = new Map();
     variableInfoCache = new Map();
+    sourceLinesCache;
     constructor(options) {
         this.options = options;
     }
@@ -53,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.
@@ -137,7 +178,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, {
@@ -166,7 +209,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, {
@@ -185,7 +228,9 @@ class ComponentParser {
         }
     }
     parseCustomTypes() {
-        for (const { tags, description: commentDescription } of (0, comment_parser_1.parse)(this.source, { spacing: "preserve" })) {
+        for (const { tags, description: commentDescription, source: blockSource } of (0, comment_parser_1.parse)(this.source, {
+            spacing: "preserve",
+        })) {
             let currentEventName;
             let currentEventType;
             let currentEventDescription;
@@ -193,8 +238,65 @@ class ComponentParser {
             let currentTypedefName;
             let currentTypedefType;
             let currentTypedefDescription;
-            let commentDescriptionUsed = false;
             const typedefProperties = [];
+            // Track if we've used the comment block description for any tag in this block
+            // Only the first tag (that needs a description) should use the comment block description
+            let commentDescriptionUsed = false;
+            let isFirstTag = true;
+            // Build a map of line numbers to their description content (for lines without tags)
+            const lineDescriptions = new Map();
+            // Track line numbers that contain tags
+            const tagLineNumbers = new Set();
+            for (const tagInfo of tags) {
+                if (tagInfo.source && tagInfo.source.length > 0) {
+                    tagLineNumbers.add(tagInfo.source[0].number);
+                }
+            }
+            for (const line of blockSource) {
+                // Only track lines that have a description but no tag
+                // Also filter out lines that are just "}" (artifact from some comment formats)
+                if (!line.tokens.tag && line.tokens.description && line.tokens.description.trim() !== "}") {
+                    lineDescriptions.set(line.number, line.tokens.description);
+                }
+            }
+            // Helper to get the description from lines preceding a tag
+            // Look backwards from the tag until we hit another tag, collecting description lines
+            // Stop after finding the first contiguous block of description lines
+            const getPrecedingDescription = (tagSource) => {
+                if (!tagSource || tagSource.length === 0)
+                    return undefined;
+                const tagLineNumber = tagSource[0].number;
+                // Look backwards from the tag line to find the immediately preceding description
+                const descLines = [];
+                let foundDescriptionBlock = false;
+                for (let lineNum = tagLineNumber - 1; lineNum >= 1; lineNum--) {
+                    // Stop if we hit a tag line
+                    if (tagLineNumbers.has(lineNum)) {
+                        break;
+                    }
+                    // Check if this line has a description
+                    const desc = lineDescriptions.get(lineNum);
+                    if (desc) {
+                        descLines.unshift(desc); // Add to beginning to maintain order
+                        foundDescriptionBlock = true;
+                    }
+                    else if (foundDescriptionBlock) {
+                        // We've already found description lines and now hit a non-description line
+                        // Check if it's blank - if so, continue; if not, stop
+                        const sourceLine = blockSource.find((l) => l.number === lineNum);
+                        const isBlank = !sourceLine ||
+                            (!sourceLine.tokens.tag &&
+                                (!sourceLine.tokens.description || sourceLine.tokens.description.trim() === ""));
+                        if (!isBlank) {
+                            // Non-blank non-description line - stop here
+                            break;
+                        }
+                        // Blank line - continue (blank lines can separate descriptions from tags)
+                    }
+                    // If we haven't found any description yet, continue looking backwards
+                }
+                return descLines.length > 0 ? descLines.join("\n").trim() : undefined;
+            };
             const finalizeEvent = () => {
                 if (currentEventName !== undefined) {
                     let detailType;
@@ -250,37 +352,63 @@ class ComponentParser {
                     currentTypedefDescription = undefined;
                 }
             };
-            for (const { tag, type: tagType, name, description, optional, default: defaultValue } of tags) {
+            for (const { tag, type: tagType, name, description, optional, default: defaultValue, source: tagSource, } of tags) {
                 const type = this.aliasType(tagType);
+                // Get the description from the line immediately before this tag
+                const precedingDescription = getPrecedingDescription(tagSource);
                 switch (tag) {
                     case "extends":
                         this.extends = {
                             interface: name,
                             import: type,
                         };
+                        if (isFirstTag)
+                            isFirstTag = false;
                         break;
                     case "restProps":
                         this.rest_props = {
                             type: "Element",
                             name: type,
                         };
+                        if (isFirstTag)
+                            isFirstTag = false;
                         break;
-                    case "slot":
+                    case "slot": {
+                        // Prefer inline description, fall back to preceding line description,
+                        // then fall back to the comment block description (only for first tag if not already used)
+                        const inlineSlotDesc = description?.replace(COMMENT_BLOCK_DESCRIPTION_REGEX, "").trim();
+                        let slotDesc = inlineSlotDesc || precedingDescription;
+                        if (!slotDesc && isFirstTag && !commentDescriptionUsed && commentDescription) {
+                            slotDesc = commentDescription;
+                            commentDescriptionUsed = true;
+                        }
+                        if (isFirstTag)
+                            isFirstTag = false;
                         this.addSlot({
                             slot_name: name,
                             slot_props: type,
-                            slot_description: description ? description : undefined,
+                            slot_description: slotDesc || undefined,
                         });
                         break;
-                    case "event":
+                    }
+                    case "event": {
                         // Finalize any previous event being built
                         finalizeEvent();
                         // Start tracking new event
                         currentEventName = name;
                         currentEventType = type;
-                        // Use the main comment description if available, otherwise use inline description
-                        currentEventDescription = commentDescription?.trim() || description || undefined;
+                        // Prefer inline description (e.g., "@event {type} name - description"),
+                        // fall back to preceding line, then fall back to comment block description (only for first tag if not already used)
+                        const inlineEventDesc = description?.replace(COMMENT_BLOCK_DESCRIPTION_REGEX, "").trim();
+                        currentEventDescription = inlineEventDesc || precedingDescription;
+                        if (!currentEventDescription && isFirstTag && !commentDescriptionUsed && commentDescription) {
+                            currentEventDescription = commentDescription;
+                            commentDescriptionUsed = true;
+                        }
+                        if (isFirstTag)
+                            isFirstTag = false;
                         break;
+                    }
                     case "type":
                         // Track the @type tag for the current event
                         if (currentEventName !== undefined) {
@@ -310,22 +438,22 @@ class ComponentParser {
                         // Start tracking new typedef
                         currentTypedefName = name;
                         currentTypedefType = type;
-                        // Use inline description if present, otherwise use comment description only if not already used
-                        const trimmedCommentDesc = commentDescription?.trim();
-                        if (description) {
-                            currentTypedefDescription = description;
-                        }
-                        else if (!commentDescriptionUsed && trimmedCommentDesc && trimmedCommentDesc !== "}") {
-                            currentTypedefDescription = trimmedCommentDesc;
+                        // Prefer inline description, fall back to preceding line description,
+                        // then fall back to comment block description (only for first tag if not already used)
+                        const inlineTypedefDesc = description?.replace(COMMENT_BLOCK_DESCRIPTION_REGEX, "").trim();
+                        currentTypedefDescription = inlineTypedefDesc || precedingDescription;
+                        if (!currentTypedefDescription && isFirstTag && !commentDescriptionUsed && commentDescription) {
+                            currentTypedefDescription = commentDescription;
                             commentDescriptionUsed = true;
                         }
-                        else {
-                            currentTypedefDescription = undefined;
-                        }
+                        if (isFirstTag)
+                            isFirstTag = false;
                         break;
                     }
                     case "generics":
                         this.generics = [name, type];
+                        if (isFirstTag)
+                            isFirstTag = false;
                         break;
                 }
             }
@@ -367,7 +495,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
@@ -391,14 +522,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;
                     }
@@ -406,6 +535,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) {
@@ -414,15 +557,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--) {
@@ -441,14 +587,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;
                     }
@@ -599,6 +743,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;
@@ -632,6 +777,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) {
@@ -712,12 +858,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"
@@ -729,27 +874,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");
                                 }
                             }
                         }
@@ -908,12 +1046,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"
@@ -925,27 +1062,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");
                             }
                         }
                     }
@@ -1027,7 +1157,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, {
@@ -1097,7 +1229,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,
@@ -1113,56 +1247,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.0",
+  "version": "0.25.2",
   "license": "Apache-2.0",
   "description": "Generate TypeScript definitions for your Svelte components.",
   "main": "./lib/index.js",