sveld 0.24.2 → 0.24.3

package/lib/ComponentParser.d.ts

@@ -119,6 +119,11 @@ export default class ComponentParser {
      * TypeScript directives are stripped before parsing, so we can safely take the last comment.
      */
     private static findJSDocComment;
+    /**
+     * Check if a MemberExpression represents a well-known numeric constant.
+     * (e.g., Number.POSITIVE_INFINITY, Math.PI, etc.)
+     */
+    private isNumericConstant;
     private sourceAtPos;
     private collectReactiveVars;
     private addProp;

package/lib/ComponentParser.js

@@ -62,6 +62,34 @@ class ComponentParser {
             return undefined;
         return leadingComments[leadingComments.length - 1];
     }
+    /**
+     * Check if a MemberExpression represents a well-known numeric constant.
+     * (e.g., Number.POSITIVE_INFINITY, Math.PI, etc.)
+     */
+    isNumericConstant(memberExpr) {
+        if (memberExpr.type !== "MemberExpression")
+            return false;
+        const objectName = memberExpr.object?.name;
+        const propertyName = memberExpr.property?.name;
+        if (!objectName || !propertyName)
+            return false;
+        if (objectName === "Number") {
+            return [
+                "POSITIVE_INFINITY",
+                "NEGATIVE_INFINITY",
+                "MAX_VALUE",
+                "MIN_VALUE",
+                "MAX_SAFE_INTEGER",
+                "MIN_SAFE_INTEGER",
+                "EPSILON",
+                "NaN",
+            ].includes(propertyName);
+        }
+        if (objectName === "Math") {
+            return ["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"].includes(propertyName);
+        }
+        return false;
+    }
     sourceAtPos(start, end) {
         return this.source?.slice(start, end);
     }
@@ -643,6 +671,15 @@ class ComponentParser {
                                     // Don't infer type, just preserve existing type annotation.
                                     value = this.sourceAtPos(init.start, init.end);
                                 }
+                                else if (init.type === "MemberExpression") {
+                                    // Handle member expressions like Number.POSITIVE_INFINITY, Math.PI, etc.
+                                    value = this.sourceAtPos(init.start, init.end);
+                                    // Infer type as "number" for well-known numeric constants
+                                    if (this.isNumericConstant(init)) {
+                                        type = "number";
+                                    }
+                                    // Otherwise, don't infer type, just preserve existing type annotation.
+                                }
                                 else {
                                     value = init.raw;
                                     type = init.value == null ? undefined : typeof init.value;
@@ -804,6 +841,15 @@ class ComponentParser {
                                 // Don't infer type, just preserve existing type annotation.
                                 value = this.sourceAtPos(init.start, init.end);
                             }
+                            else if (init.type === "MemberExpression") {
+                                // Handle member expressions like Number.POSITIVE_INFINITY, Math.PI, etc.
+                                value = this.sourceAtPos(init.start, init.end);
+                                // Infer type as "number" for well-known numeric constants
+                                if (this.isNumericConstant(init)) {
+                                    type = "number";
+                                }
+                                // Otherwise, don't infer type, just preserve existing type annotation.
+                            }
                             else {
                                 value = init.raw;
                                 type = init.value == null ? undefined : typeof init.value;

package/lib/writer/writer-ts-definitions-core.js

@@ -354,6 +354,10 @@ function genModuleExports(def) {
             const rest_type = rest.map((item) => `=>${item}`).join("");
             type_def = `export declare function ${prop.name}${first}:${second}${rest_type};`;
         }
+        else if (prop.kind === "const") {
+            // For const exports from script context="module", use declare const instead of type
+            type_def = `export declare const ${prop.name}: ${prop.type || ANY_TYPE};`;
+        }
         return `
       ${prop_comments.length > 0 ? `/**\n${prop_comments}*/` : EMPTY_STR}
       ${type_def}`;

package/package.json

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