sveld 0.25.11 → 0.25.12

package/README.md

@@ -8,11 +8,11 @@
 
 The purpose of this project is to make third party Svelte component libraries compatible with the Svelte Language Server and TypeScript with minimal effort required by the author. For example, TypeScript definitions may be used during development via intelligent code completion in Integrated Development Environments (IDE) like VSCode.
 
-[Carbon Components Svelte](https://github.com/IBM/carbon-components-svelte) uses this library to auto-generate component types and API metadata:
+[Carbon Components Svelte](https://github.com/carbon-design-system/carbon-components-svelte) uses this library to auto-generate component types and API metadata:
 
-- [TypeScript definitions](https://github.com/IBM/carbon-components-svelte/blob/master/types): Component TypeScript definitions
-- [Component Index](https://github.com/IBM/carbon-components-svelte/blob/master/COMPONENT_INDEX.md): Markdown file documenting component props, slots, and events
-- [Component API](https://github.com/IBM/carbon-components-svelte/blob/master/docs/src/COMPONENT_API.json): Component API metadata in JSON format
+- [TypeScript definitions](https://github.com/carbon-design-system/carbon-components-svelte/blob/master/types): Component TypeScript definitions
+- [Component Index](https://github.com/carbon-design-system/carbon-components-svelte/blob/master/COMPONENT_INDEX.md): Markdown file documenting component props, slots, and events
+- [Component API](https://github.com/carbon-design-system/carbon-components-svelte/blob/master/docs/src/COMPONENT_API.json): Component API metadata in JSON format
 
 **Note:** `sveld` supports Svelte 3, 4, and 5, but does not support Svelte 5-specific syntax or runes-only usage. Components must use traditional Svelte syntax (e.g., `export let` for props, not `$props()`).
 
@@ -430,9 +430,12 @@ Output:
 
 ```ts
 export type User = {
-  /** The user's full name */ name: string;
-  /** The user's email address */ email: string;
-  /** The user's age in years */ age: number;
+  /** The user's full name */
+  name: string;
+  /** The user's email address */
+  email: string;
+  /** The user's age in years */
+  age: number;
 };
 
 export type ComponentProps = {
@@ -478,10 +481,14 @@ Output:
 
 ```ts
 export type ComponentConfig = {
-  /** Whether the component is enabled */ enabled: boolean;
-  /** The component theme */ theme: string;
-  /** Optional timeout in milliseconds @default 5000 */ timeout?: number;
-  /** Optional debug mode flag */ debug?: boolean;
+  /** Whether the component is enabled */
+  enabled: boolean;
+  /** The component theme */
+  theme: string;
+  /** Optional timeout in milliseconds @default 5000 */
+  timeout?: number;
+  /** Optional debug mode flag */
+  debug?: boolean;
 };
 
 export type ComponentProps = {
@@ -735,9 +742,12 @@ export default class Component extends SvelteComponentTyped<
   {
     /** Fired when the user submits the form */
     submit: CustomEvent<{
-      /** The user's name */ name: string;
-      /** The user's email address */ email: string;
-      /** Whether the user opted into the newsletter */ newsletter: boolean;
+      /** The user's name */
+      name: string;
+      /** The user's email address */
+      email: string;
+      /** Whether the user opted into the newsletter */
+      newsletter: boolean;
     }>;
   },
   Record<string, never>
@@ -782,10 +792,14 @@ export default class Component extends SvelteComponentTyped<
   {
     /** Snowball event fired when throwing a snowball */
     snowball: CustomEvent<{
-      /** Indicates whether the snowball is tightly packed */ isPacked: boolean;
-      /** The speed of the snowball in mph */ speed: number;
-      /** Optional color of the snowball */ color?: string;
-      /** Optional density with default value @default 0.9 */ density?: number;
+      /** Indicates whether the snowball is tightly packed */
+      isPacked: boolean;
+      /** The speed of the snowball in mph */
+      speed: number;
+      /** Optional color of the snowball */
+      color?: string;
+      /** Optional density with default value @default 0.9 */
+      density?: number;
     }>;
   },
   Record<string, never>
@@ -1171,7 +1185,8 @@ Output:
 
 ```ts
 export type NotificationData = {
-  /** Optional id for deduplication */ id?: string;
+  /** Optional id for deduplication */
+  id?: string;
   kind?: "error" | "info" | "success";
 };
 

package/lib/ComponentParser.js

@@ -526,8 +526,72 @@ class ComponentParser {
                 typeof unaryExpr.end === "number") {
                 value = this.sourceAtPos(unaryExpr.start, unaryExpr.end);
             }
-            if (unaryExpr.argument && typeof unaryExpr.argument === "object" && "value" in unaryExpr.argument) {
-                type = typeof unaryExpr.argument.value;
+            if (unaryExpr.argument) {
+                // If the argument is another UnaryExpression, recursively resolve the type
+                if (typeof unaryExpr.argument === "object" &&
+                    "type" in unaryExpr.argument &&
+                    unaryExpr.argument.type === "UnaryExpression") {
+                    const nestedResult = this.processInitializer(unaryExpr.argument);
+                    type = nestedResult.type;
+                }
+                else if (typeof unaryExpr.argument === "object" && "value" in unaryExpr.argument) {
+                    // Direct literal argument
+                    type = typeof unaryExpr.argument.value;
+                }
+            }
+        }
+        else if (init.type === "NewExpression") {
+            const newExpr = init;
+            if ("start" in newExpr &&
+                "end" in newExpr &&
+                typeof newExpr.start === "number" &&
+                typeof newExpr.end === "number") {
+                value = this.sourceAtPos(newExpr.start, newExpr.end);
+            }
+            // Infer type from callee if it's an Identifier (e.g., new Date() -> Date)
+            if (newExpr.callee &&
+                typeof newExpr.callee === "object" &&
+                "type" in newExpr.callee &&
+                newExpr.callee.type === "Identifier") {
+                const calleeName = newExpr.callee.name;
+                // Common built-in constructors
+                if (calleeName === "Date") {
+                    type = "Date";
+                }
+                else if (calleeName === "Map") {
+                    type = "Map<any, any>";
+                }
+                else if (calleeName === "Set") {
+                    type = "Set<any>";
+                }
+                else if (calleeName === "WeakMap") {
+                    type = "WeakMap<object, any>";
+                }
+                else if (calleeName === "WeakSet") {
+                    type = "WeakSet<object>";
+                }
+                else if (calleeName === "Array") {
+                    type = "any[]";
+                }
+                else if (calleeName === "RegExp" || calleeName === "Regexp") {
+                    type = "RegExp";
+                }
+                else if (calleeName === "Error") {
+                    type = "Error";
+                }
+                else {
+                    // For other constructors, use the constructor name as the type
+                    type = calleeName;
+                }
+            }
+        }
+        else if (init.type === "CallExpression") {
+            const callExpr = init;
+            if ("start" in callExpr &&
+                "end" in callExpr &&
+                typeof callExpr.start === "number" &&
+                typeof callExpr.end === "number") {
+                value = this.sourceAtPos(callExpr.start, callExpr.end);
             }
         }
         else if (init.type === "Identifier") {
@@ -958,7 +1022,7 @@ class ComponentParser {
                 if (currentEventName !== undefined) {
                     let detailType;
                     if (eventProperties.length > 0) {
-                        detailType = this.buildEventDetailFromProperties(eventProperties, currentEventName);
+                        detailType = this.buildEventDetailFromProperties(eventProperties, currentEventName, true);
                     }
                     else {
                         detailType = currentEventType || "";
@@ -1008,8 +1072,9 @@ class ComponentParser {
                     if (typedefProperties.length > 0) {
                         /**
                          * Build type alias with property descriptions from `@property` tags.
+                         * Use multiline formatting for better readability.
                          */
-                        typedefType = this.buildEventDetailFromProperties(typedefProperties);
+                        typedefType = this.buildEventDetailFromProperties(typedefProperties, undefined, true);
                         typedefTs = `type ${currentTypedefName} = ${typedefType}`;
                     }
                     else if (currentTypedefType) {
@@ -1199,7 +1264,7 @@ class ComponentParser {
      * "{ /** The new value *\/ value: string; /** @default 0 *\/ count?: number; }"
      * ```
      */
-    buildEventDetailFromProperties(properties, _eventName) {
+    buildEventDetailFromProperties(properties, _eventName, multiline = false) {
         if (properties.length === 0)
             return "null";
         /**
@@ -1221,12 +1286,15 @@ class ComponentParser {
                 comment = `@default ${defaultValue}`;
             }
             if (comment) {
+                if (multiline) {
+                    return `/** ${comment} */\n  ${name}${optionalMarker}: ${type};`;
+                }
                 return `/** ${comment} */ ${name}${optionalMarker}: ${type};`;
             }
             return `${name}${optionalMarker}: ${type};`;
         })
-            .join(" ");
-        return `{ ${props} }`;
+            .join(multiline ? "\n  " : " ");
+        return multiline ? `{\n  ${props}\n}` : `{ ${props} }`;
     }
     /**
      * Generates a TypeScript type name for a context key.
@@ -1919,6 +1987,20 @@ class ComponentParser {
                                     description = jsdocInfo.description;
                             }
                         }
+                        // Merge returnType into type for function declarations if not overridden by @type
+                        if (isFunctionDeclaration && type === "() => any" && returnType) {
+                            if (params && params.length > 0) {
+                                const paramStrings = params.map((param) => {
+                                    const optional = param.optional ? "?" : "";
+                                    return `${param.name}${optional}: ${param.type}`;
+                                });
+                                const paramsString = paramStrings.join(", ");
+                                type = `(${paramsString}) => ${returnType}`;
+                            }
+                            else {
+                                type = `() => ${returnType}`;
+                            }
+                        }
                         if (!description && type && this.typedefs.has(type)) {
                             description = this.typedefs.get(type)?.description;
                         }
@@ -2138,6 +2220,20 @@ class ComponentParser {
                                 description = jsdocInfo.description;
                         }
                     }
+                    // Merge returnType into type for function declarations if not overridden by @type
+                    if (isFunctionDeclaration && type === "() => any" && returnType) {
+                        if (params && params.length > 0) {
+                            const paramStrings = params.map((param) => {
+                                const optional = param.optional ? "?" : "";
+                                return `${param.name}${optional}: ${param.type}`;
+                            });
+                            const paramsString = paramStrings.join(", ");
+                            type = `(${paramsString}) => ${returnType}`;
+                        }
+                        else {
+                            type = `() => ${returnType}`;
+                        }
+                    }
                     if (!description && type && this.typedefs.has(type)) {
                         description = this.typedefs.get(type)?.description;
                     }

package/lib/element-tag-map.d.ts

@@ -3,8 +3,7 @@
  *
  * Maps HTML element tag names to their corresponding TypeScript element types.
  * Used for generating proper TypeScript types for element bindings and rest props.
- *
- * @see {@link https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts#L19263 | TypeScript lib.dom.d.ts}
+ * See the TypeScript lib.dom.d.ts for the original source.
  *
  * @example
  * ```ts

package/lib/element-tag-map.js

@@ -6,8 +6,7 @@ exports.getElementByTag = getElementByTag;
  *
  * Maps HTML element tag names to their corresponding TypeScript element types.
  * Used for generating proper TypeScript types for element bindings and rest props.
- *
- * @see {@link https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts#L19263 | TypeScript lib.dom.d.ts}
+ * See the TypeScript lib.dom.d.ts for the original source.
  *
  * @example
  * ```ts

package/package.json

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