@fuzdev/fuz_util 0.49.0 → 0.49.1

package/dist/svelte_preprocess_helpers.d.ts

@@ -41,14 +41,16 @@ export declare const find_attribute: (node: AST.Component, name: string) => AST.
 /**
  * Recursively evaluates an expression AST node to a static string value.
  *
- * Handles string `Literal`, `TemplateLiteral` without interpolation, and
- * `BinaryExpression` with the `+` operator (string concatenation).
+ * Handles string `Literal`, `TemplateLiteral` (including interpolations when all
+ * expressions resolve), `BinaryExpression` with `+`, and `Identifier` lookup
+ * via an optional bindings map built by `build_static_bindings`.
  * Returns `null` for dynamic expressions, non-string literals, or unsupported node types.
  *
  * @param expr An ESTree expression AST node.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the expression is dynamic.
  */
-export declare const evaluate_static_expr: (expr: Expression) => string | null;
+export declare const evaluate_static_expr: (expr: Expression, bindings?: ReadonlyMap<string, string>) => string | null;
 /**
  * Extracts a static string value from a Svelte attribute value AST node.
  *
@@ -61,9 +63,25 @@ export declare const evaluate_static_expr: (expr: Expression) => string | null;
  * Returns `null` for null literals, mixed arrays, dynamic expressions, and non-string values.
  *
  * @param value The attribute value from `AST.Attribute['value']`.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the value is dynamic.
  */
-export declare const extract_static_string: (value: AST.Attribute["value"]) => string | null;
+export declare const extract_static_string: (value: AST.Attribute["value"], bindings?: ReadonlyMap<string, string>) => string | null;
+/**
+ * Builds a map of statically resolvable `const` bindings from a Svelte AST.
+ *
+ * Scans top-level `const` variable declarations in both instance and module scripts.
+ * For each declarator with a plain `Identifier` pattern and a statically evaluable
+ * initializer, adds the binding to the map. Processes declarations in source order
+ * so that chained references resolve: `const a = 'x'; const b = a;` maps `b` to `'x'`.
+ *
+ * Skips destructuring patterns, `let`/`var` declarations, and declarations
+ * whose initializers reference dynamic values.
+ *
+ * @param ast The parsed Svelte AST root node.
+ * @returns Map of variable names to their resolved static string values.
+ */
+export declare const build_static_bindings: (ast: AST.Root) => Map<string, string>;
 /**
  * Resolves local names that import from specified source paths.
  *

package/dist/svelte_preprocess_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"svelte_preprocess_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte_preprocess_helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,eAAe,EAAC,MAAM,QAAQ,CAAC;AACnG,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AAEzC,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACpC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;CAC1B;AAED,qDAAqD;AACrD,MAAM,WAAW,uBAAuB;IACvC,gEAAgE;IAChE,WAAW,EAAE,iBAAiB,CAAC;IAC/B,mDAAmD;IACnD,SAAS,EAAE,eAAe,GAAG,sBAAsB,CAAC;CACpD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,GAAG,CAAC,SAAS,EAAE,MAAM,MAAM,KAAG,GAAG,CAAC,SAAS,GAAG,SAOlF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,UAAU,KAAG,MAAM,GAAG,IAchE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,KAAG,MAAM,GAAG,IAkB9E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GACnC,KAAK,GAAG,CAAC,IAAI,EACb,mBAAmB,KAAK,CAAC,MAAM,CAAC,KAC9B,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAcrC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GAAI,QAAQ,GAAG,CAAC,MAAM,KAAG,MAYhE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,SAAS,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC1C,SAAQ,MAAa,KACnB,MAyBF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,MAAM,MAAM,EACZ,OAAO,GAAG,CAAC,OAAO,CAAC,KACjB,OAYF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MAc/C,CAAC"}
+{"version":3,"file":"svelte_preprocess_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte_preprocess_helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,eAAe,EAAC,MAAM,QAAQ,CAAC;AACnG,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AAEzC,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACpC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;CAC1B;AAED,qDAAqD;AACrD,MAAM,WAAW,uBAAuB;IACvC,gEAAgE;IAChE,WAAW,EAAE,iBAAiB,CAAC;IAC/B,mDAAmD;IACnD,SAAS,EAAE,eAAe,GAAG,sBAAsB,CAAC;CACpD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,GAAG,CAAC,SAAS,EAAE,MAAM,MAAM,KAAG,GAAG,CAAC,SAAS,GAAG,SAOlF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAChC,MAAM,UAAU,EAChB,WAAW,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,KACpC,MAAM,GAAG,IA+BX,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,GACjC,OAAO,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,EAC7B,WAAW,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,KACpC,MAAM,GAAG,IAkBX,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GAAI,KAAK,GAAG,CAAC,IAAI,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAiBvE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GACnC,KAAK,GAAG,CAAC,IAAI,EACb,mBAAmB,KAAK,CAAC,MAAM,CAAC,KAC9B,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAcrC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GAAI,QAAQ,GAAG,CAAC,MAAM,KAAG,MAYhE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,SAAS,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC1C,SAAQ,MAAa,KACnB,MAyBF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,MAAM,MAAM,EACZ,OAAO,GAAG,CAAC,OAAO,CAAC,KACjB,OAYF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MAc/C,CAAC"}

package/dist/svelte_preprocess_helpers.js

@@ -32,30 +32,50 @@ export const find_attribute = (node, name) => {
 /**
  * Recursively evaluates an expression AST node to a static string value.
  *
- * Handles string `Literal`, `TemplateLiteral` without interpolation, and
- * `BinaryExpression` with the `+` operator (string concatenation).
+ * Handles string `Literal`, `TemplateLiteral` (including interpolations when all
+ * expressions resolve), `BinaryExpression` with `+`, and `Identifier` lookup
+ * via an optional bindings map built by `build_static_bindings`.
  * Returns `null` for dynamic expressions, non-string literals, or unsupported node types.
  *
  * @param expr An ESTree expression AST node.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the expression is dynamic.
  */
-export const evaluate_static_expr = (expr) => {
+export const evaluate_static_expr = (expr, bindings) => {
     if (expr.type === 'Literal' && typeof expr.value === 'string')
         return expr.value;
-    if (expr.type === 'TemplateLiteral' && expr.expressions.length === 0) {
-        return expr.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+    if (expr.type === 'TemplateLiteral') {
+        if (expr.expressions.length === 0) {
+            return expr.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+        }
+        // Try resolving interpolations through bindings
+        const parts = [];
+        for (let i = 0; i < expr.quasis.length; i++) {
+            const quasi = expr.quasis[i];
+            parts.push(quasi.value.cooked ?? quasi.value.raw);
+            if (i < expr.expressions.length) {
+                const val = evaluate_static_expr(expr.expressions[i], bindings);
+                if (val === null)
+                    return null;
+                parts.push(val);
+            }
+        }
+        return parts.join('');
     }
     if (expr.type === 'BinaryExpression' && expr.operator === '+') {
         if (expr.left.type === 'PrivateIdentifier')
             return null;
-        const left = evaluate_static_expr(expr.left);
+        const left = evaluate_static_expr(expr.left, bindings);
         if (left === null)
             return null;
-        const right = evaluate_static_expr(expr.right);
+        const right = evaluate_static_expr(expr.right, bindings);
         if (right === null)
             return null;
         return left + right;
     }
+    if (expr.type === 'Identifier' && bindings?.has(expr.name)) {
+        return bindings.get(expr.name);
+    }
     return null;
 };
 /**
@@ -70,9 +90,10 @@ export const evaluate_static_expr = (expr) => {
  * Returns `null` for null literals, mixed arrays, dynamic expressions, and non-string values.
  *
  * @param value The attribute value from `AST.Attribute['value']`.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the value is dynamic.
  */
-export const extract_static_string = (value) => {
+export const extract_static_string = (value, bindings) => {
     // Boolean attribute (e.g., <Mdz inline />)
     if (value === true)
         return null;
@@ -89,7 +110,43 @@ export const extract_static_string = (value) => {
     // Null literal
     if (expr.type === 'Literal' && expr.value === null)
         return null;
-    return evaluate_static_expr(expr);
+    return evaluate_static_expr(expr, bindings);
+};
+/**
+ * Builds a map of statically resolvable `const` bindings from a Svelte AST.
+ *
+ * Scans top-level `const` variable declarations in both instance and module scripts.
+ * For each declarator with a plain `Identifier` pattern and a statically evaluable
+ * initializer, adds the binding to the map. Processes declarations in source order
+ * so that chained references resolve: `const a = 'x'; const b = a;` maps `b` to `'x'`.
+ *
+ * Skips destructuring patterns, `let`/`var` declarations, and declarations
+ * whose initializers reference dynamic values.
+ *
+ * @param ast The parsed Svelte AST root node.
+ * @returns Map of variable names to their resolved static string values.
+ */
+export const build_static_bindings = (ast) => {
+    const bindings = new Map();
+    for (const script of [ast.instance, ast.module]) {
+        if (!script)
+            continue;
+        for (const node of script.content.body) {
+            if (node.type !== 'VariableDeclaration' || node.kind !== 'const')
+                continue;
+            for (const declarator of node.declarations) {
+                if (declarator.id.type !== 'Identifier')
+                    continue;
+                if (!declarator.init)
+                    continue;
+                const value = evaluate_static_expr(declarator.init, bindings);
+                if (value !== null) {
+                    bindings.set(declarator.id.name, value);
+                }
+            }
+        }
+    }
+    return bindings;
 };
 /**
  * Resolves local names that import from specified source paths.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_util",
-  "version": "0.49.0",
+  "version": "0.49.1",
   "description": "utility belt for JS",
   "glyph": "🦕",
   "logo": "logo.svg",

package/src/lib/svelte_preprocess_helpers.ts

@@ -53,26 +53,48 @@ export const find_attribute = (node: AST.Component, name: string): AST.Attribute
 /**
  * Recursively evaluates an expression AST node to a static string value.
  *
- * Handles string `Literal`, `TemplateLiteral` without interpolation, and
- * `BinaryExpression` with the `+` operator (string concatenation).
+ * Handles string `Literal`, `TemplateLiteral` (including interpolations when all
+ * expressions resolve), `BinaryExpression` with `+`, and `Identifier` lookup
+ * via an optional bindings map built by `build_static_bindings`.
  * Returns `null` for dynamic expressions, non-string literals, or unsupported node types.
  *
  * @param expr An ESTree expression AST node.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the expression is dynamic.
  */
-export const evaluate_static_expr = (expr: Expression): string | null => {
+export const evaluate_static_expr = (
+	expr: Expression,
+	bindings?: ReadonlyMap<string, string>,
+): string | null => {
 	if (expr.type === 'Literal' && typeof expr.value === 'string') return expr.value;
-	if (expr.type === 'TemplateLiteral' && expr.expressions.length === 0) {
-		return expr.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+	if (expr.type === 'TemplateLiteral') {
+		if (expr.expressions.length === 0) {
+			return expr.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+		}
+		// Try resolving interpolations through bindings
+		const parts: Array<string> = [];
+		for (let i = 0; i < expr.quasis.length; i++) {
+			const quasi = expr.quasis[i]!;
+			parts.push(quasi.value.cooked ?? quasi.value.raw);
+			if (i < expr.expressions.length) {
+				const val = evaluate_static_expr(expr.expressions[i]!, bindings);
+				if (val === null) return null;
+				parts.push(val);
+			}
+		}
+		return parts.join('');
 	}
 	if (expr.type === 'BinaryExpression' && expr.operator === '+') {
 		if (expr.left.type === 'PrivateIdentifier') return null;
-		const left = evaluate_static_expr(expr.left);
+		const left = evaluate_static_expr(expr.left, bindings);
 		if (left === null) return null;
-		const right = evaluate_static_expr(expr.right);
+		const right = evaluate_static_expr(expr.right, bindings);
 		if (right === null) return null;
 		return left + right;
 	}
+	if (expr.type === 'Identifier' && bindings?.has(expr.name)) {
+		return bindings.get(expr.name)!;
+	}
 	return null;
 };
 
@@ -88,9 +110,13 @@ export const evaluate_static_expr = (expr: Expression): string | null => {
  * Returns `null` for null literals, mixed arrays, dynamic expressions, and non-string values.
  *
  * @param value The attribute value from `AST.Attribute['value']`.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the value is dynamic.
  */
-export const extract_static_string = (value: AST.Attribute['value']): string | null => {
+export const extract_static_string = (
+	value: AST.Attribute['value'],
+	bindings?: ReadonlyMap<string, string>,
+): string | null => {
 	// Boolean attribute (e.g., <Mdz inline />)
 	if (value === true) return null;
 
@@ -107,7 +133,40 @@ export const extract_static_string = (value: AST.Attribute['value']): string | n
 	const expr = value.expression;
 	// Null literal
 	if (expr.type === 'Literal' && expr.value === null) return null;
-	return evaluate_static_expr(expr);
+	return evaluate_static_expr(expr, bindings);
+};
+
+/**
+ * Builds a map of statically resolvable `const` bindings from a Svelte AST.
+ *
+ * Scans top-level `const` variable declarations in both instance and module scripts.
+ * For each declarator with a plain `Identifier` pattern and a statically evaluable
+ * initializer, adds the binding to the map. Processes declarations in source order
+ * so that chained references resolve: `const a = 'x'; const b = a;` maps `b` to `'x'`.
+ *
+ * Skips destructuring patterns, `let`/`var` declarations, and declarations
+ * whose initializers reference dynamic values.
+ *
+ * @param ast The parsed Svelte AST root node.
+ * @returns Map of variable names to their resolved static string values.
+ */
+export const build_static_bindings = (ast: AST.Root): Map<string, string> => {
+	const bindings: Map<string, string> = new Map();
+	for (const script of [ast.instance, ast.module]) {
+		if (!script) continue;
+		for (const node of script.content.body) {
+			if (node.type !== 'VariableDeclaration' || node.kind !== 'const') continue;
+			for (const declarator of node.declarations) {
+				if (declarator.id.type !== 'Identifier') continue;
+				if (!declarator.init) continue;
+				const value = evaluate_static_expr(declarator.init, bindings);
+				if (value !== null) {
+					bindings.set(declarator.id.name, value);
+				}
+			}
+		}
+	}
+	return bindings;
 };
 
 /**