styled-components-to-stylex-codemod 0.0.48 → 0.0.49

package/dist/{extract-external-interface-CvkkJZb1.mjs → ast-walk-DigTJqU7.mjs}

@@ -380,4 +380,29 @@ function getFileImportsFromRes(name) {
 	return cached;
 }
 //#endregion
-export { resolveBarrelReExport as a, UNSUPPORTED_SHOULD_FORWARD_PROP_WARNING as c, getReExportedSourceName as i, fileImportsFrom as n, resolveBarrelReExportBinding as o, findImportSource as r, Logger as s, fileExports as t };
+//#region src/internal/utilities/ast-walk.ts
+const SKIPPED_KEYS = new Set([
+	"loc",
+	"comments",
+	"leadingComments",
+	"trailingComments"
+]);
+function walkAst(root, visitor) {
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const child of node) visit(child);
+			return;
+		}
+		const n = node;
+		visitor(n);
+		for (const key of Object.keys(n)) {
+			if (SKIPPED_KEYS.has(key)) continue;
+			const child = n[key];
+			if (child && typeof child === "object") visit(child);
+		}
+	};
+	visit(root);
+}
+//#endregion
+export { getReExportedSourceName as a, Logger as c, findImportSource as i, UNSUPPORTED_SHOULD_FORWARD_PROP_WARNING as l, fileExports as n, resolveBarrelReExport as o, fileImportsFrom as r, resolveBarrelReExportBinding as s, walkAst as t };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as CollectedWarning, c as MarkerFileContext, l as defineAdapter, n as TransformMode, o as AdapterInput, s as ImportSource } from "./transform-types-Bshr_dBf.mjs";
+import { a as CollectedWarning, c as MarkerFileContext, l as defineAdapter, n as TransformMode, o as AdapterInput, s as ImportSource } from "./transform-types-CHRHLCj_.mjs";
 
 //#region src/run.d.ts
 interface RunTransformOptions {

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { c as describeValue, i as defineAdapter, n as mergeMarkerDeclarations, s as assertValidAdapterInput, t as transformedComponentAcceptsSx } from "./sx-surface-BzqO3hcC.mjs";
-import { a as resolveBarrelReExport, s as Logger } from "./extract-external-interface-CvkkJZb1.mjs";
-import { r as extractStyledDefBasesFromSource } from "./compute-leaf-set-90UrZ9WP.mjs";
+import { c as Logger, o as resolveBarrelReExport, t as walkAst } from "./ast-walk-DigTJqU7.mjs";
+import { i as extractStyledDefBasesFromSource, t as createPrepassParser } from "./prepass-parser-CwdDzSgx.mjs";
 import { r as toRealPath } from "./path-utils-BC4U8X_q.mjs";
 import jscodeshift from "jscodeshift";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -8,6 +8,162 @@ import { dirname, join, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { glob, readFile, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
+//#region src/internal/prepass/resolve-static-members.ts
+/**
+* Resolves the underlying component name(s) a static member access like `Select.Option` refers to,
+* by structurally walking the defining module's AST.
+*
+* This replaces an earlier regex-over-source approach: regexes could not reliably skip type
+* annotations, stop at the right `;`, or distinguish identifiers from type names. We parse once
+* (cached per source) with the shared prepass parser and answer member lookups against real nodes.
+*/
+/**
+* Given the module `source`, the candidate root component names a local binding resolves to, and a
+* static member path (`["Option"]` for `Select.Option`), returns every component name the member
+* path can statically resolve to, plus the final member name as a fallback (matching the prior
+* behavior so downstream metadata lookups still have something to try).
+*/
+function resolveStaticMemberComponentNames(source, rootNames, memberPath, parserName = "tsx") {
+	const program = parseProgram(source, parserName);
+	const fallbackMember = memberPath[memberPath.length - 1];
+	const fallback = fallbackMember ? [fallbackMember] : [];
+	if (!program) return [...new Set([...rootNames, ...fallback])];
+	const index = buildModuleIndex(program);
+	let owners = expandStaticComponentOwners(index, rootNames);
+	for (const memberName of memberPath) {
+		const nextOwners = /* @__PURE__ */ new Set();
+		for (const ownerName of owners) for (const target of findStaticMemberTargets(index, ownerName, memberName)) nextOwners.add(target);
+		owners = nextOwners;
+		if (owners.size === 0) break;
+	}
+	return [...new Set([...owners, ...fallback])];
+}
+const programCache = /* @__PURE__ */ new Map();
+function parseProgram(source, parserName) {
+	const cached = programCache.get(source);
+	if (cached !== void 0) return cached;
+	const parsed = tryParse(source, parserName);
+	programCache.set(source, parsed);
+	return parsed;
+}
+function tryParse(source, parserName) {
+	for (const name of parserName === "tsx" ? ["tsx", "ts"] : [parserName]) try {
+		const ast = createPrepassParser(name).parse(source);
+		return ast.program ?? ast;
+	} catch {}
+	return null;
+}
+function buildModuleIndex(program) {
+	const initializers = /* @__PURE__ */ new Map();
+	const memberAssignments = /* @__PURE__ */ new Map();
+	walkAst(program, (node) => {
+		if (node.type === "VariableDeclarator") {
+			const name = identifierName(node.id);
+			const init = node.init;
+			if (name && init) initializers.set(name, init);
+			return;
+		}
+		if (node.type === "AssignmentExpression" && node.operator === "=") {
+			const target = capitalizedIdentifierName(node.right);
+			const member = staticMemberAccess(node.left);
+			if (target && member) addMemberTarget(memberAssignments, member.object, member.property, target);
+		}
+	});
+	return {
+		initializers,
+		memberAssignments
+	};
+}
+/**
+* Expands the root binding names to every capitalized identifier transitively referenced from their
+* initializers (e.g. `const X = cond ? A : B` pulls in `A` and `B`). Mirrors the breadth the member
+* lookup needs without assuming a particular declaration shape.
+*/
+function expandStaticComponentOwners(index, rootNames) {
+	const owners = new Set(rootNames);
+	const visit = (name) => {
+		const init = index.initializers.get(name);
+		if (!init) return;
+		for (const referenced of collectCapitalizedIdentifiers(init)) if (!owners.has(referenced)) {
+			owners.add(referenced);
+			visit(referenced);
+		}
+	};
+	for (const name of rootNames) visit(name);
+	return owners;
+}
+function findStaticMemberTargets(index, ownerName, memberName) {
+	const targets = new Set(index.memberAssignments.get(ownerName)?.get(memberName) ?? []);
+	const init = index.initializers.get(ownerName);
+	for (const objectLiteral of objectLiteralsFromInitializer(index, init)) collectMemberTargetsFromObjectLiteral(objectLiteral, memberName, targets);
+	return targets;
+}
+/** Object expressions an owner's value is built from: a direct literal or `Object.assign(...)` args. */
+function objectLiteralsFromInitializer(index, init) {
+	if (!init) return [];
+	if (init.type === "ObjectExpression") return [init];
+	if (isObjectAssignCall(init)) {
+		const literals = [];
+		for (const arg of init.arguments ?? []) if (arg.type === "ObjectExpression") literals.push(arg);
+		else {
+			const referenced = identifierName(arg);
+			const referencedInit = referenced ? index.initializers.get(referenced) : void 0;
+			if (referencedInit?.type === "ObjectExpression") literals.push(referencedInit);
+		}
+		return literals;
+	}
+	return [];
+}
+function collectMemberTargetsFromObjectLiteral(objectLiteral, memberName, targets) {
+	for (const property of objectLiteral.properties ?? []) {
+		if (property.type !== "ObjectProperty" && property.type !== "Property") continue;
+		if (identifierName(property.key) !== memberName) continue;
+		const target = capitalizedIdentifierName(property.value);
+		if (target) targets.add(target);
+	}
+}
+function isObjectAssignCall(node) {
+	if (node.type !== "CallExpression") return false;
+	const member = staticMemberAccess(node.callee);
+	return member?.object === "Object" && member.property === "assign";
+}
+function collectCapitalizedIdentifiers(node) {
+	const names = /* @__PURE__ */ new Set();
+	walkAst(node, (child) => {
+		if (child.type === "Identifier" && /^[A-Z]/.test(String(child.name))) names.add(String(child.name));
+	});
+	return names;
+}
+function staticMemberAccess(node) {
+	if (!node || node.type !== "MemberExpression" && node.type !== "OptionalMemberExpression" || node.computed === true) return null;
+	const object = identifierName(node.object);
+	const property = identifierName(node.property);
+	return object && property ? {
+		object,
+		property
+	} : null;
+}
+function addMemberTarget(memberAssignments, object, property, target) {
+	let byMember = memberAssignments.get(object);
+	if (!byMember) {
+		byMember = /* @__PURE__ */ new Map();
+		memberAssignments.set(object, byMember);
+	}
+	let targets = byMember.get(property);
+	if (!targets) {
+		targets = /* @__PURE__ */ new Set();
+		byMember.set(property, targets);
+	}
+	targets.add(target);
+}
+function identifierName(node) {
+	return node?.type === "Identifier" && typeof node.name === "string" ? node.name : null;
+}
+function capitalizedIdentifierName(node) {
+	const name = identifierName(node);
+	return name && /^[A-Z]/.test(name) ? name : null;
+}
+//#endregion
 //#region src/run.ts
 /**
 * Runs the codemod over input files with an adapter.
@@ -149,7 +305,7 @@ async function runTransform(options) {
 	const { createModuleResolver } = await import("./resolve-imports-DgSAddIF.mjs").then((n) => n.n);
 	const sharedResolver = createModuleResolver();
 	filePaths = orderFilesByLocalImportDependencies(filePaths, sharedResolver, toRealPath);
-	const { runPrepass } = await import("./run-prepass-1yZOVT3P.mjs");
+	const { runPrepass } = await import("./run-prepass-BWQCThfh.mjs");
 	const absoluteFiles = filePaths.map((f) => resolve(f));
 	const absoluteConsumers = consumerFilePaths.map((f) => resolve(f));
 	let prepassResult;
@@ -249,12 +405,15 @@ async function runTransform(options) {
 					if (!resolvedImport) return;
 					const resolvedPath = toRealPath(resolvedImport);
 					const definitionSourcePath = resolveExistingSourcePath(resolveBarrelReExport(resolvedPath, ctx.importedName, prepassResolve, cachedRead) ?? resolvedPath);
-					const autoInterfaceNames = ctx.importedName === "default" ? [ctx.localName, ctx.importedName] : [ctx.importedName];
+					const memberPath = ctx.memberPath ?? [];
+					const autoInterfaceNames = memberPath.length > 0 ? [ctx.localName, memberPath[memberPath.length - 1]] : ctx.importedName === "default" ? [ctx.localName, ctx.importedName] : [ctx.importedName];
 					const styledDefinitionNames = getStyledDefinitionNames(definitionSourcePath);
-					const sourceComponentNames = ctx.importedName === "default" ? [ctx.localName, getDefaultExportedName(definitionSourcePath)].filter((name) => typeof name === "string") : [ctx.importedName];
+					const rootSourceComponentNames = ctx.importedName === "default" ? [ctx.localName, getDefaultExportedName(definitionSourcePath)].filter((name) => typeof name === "string") : [ctx.importedName];
+					const sourceComponentNames = memberPath.length > 0 ? resolveStaticMemberComponentNames(cachedRead(definitionSourcePath), rootSourceComponentNames, memberPath) : rootSourceComponentNames;
 					const typedComponent = findTypedComponentMetadata(prepassResult.typeScriptMetadata, definitionSourcePath, sourceComponentNames);
 					if (typedComponent?.supportsSxProp === true) return {
 						acceptsSx: true,
+						...typedComponent.sxTarget ? { sxTarget: typedComponent.sxTarget } : {},
 						sxExcludedProperties: typedComponent.sxExcludedProperties,
 						sxAllowedProperties: typedComponent.sxAllowedProperties
 					};

package/dist/{compute-leaf-set-90UrZ9WP.mjs → prepass-parser-CwdDzSgx.mjs}

@@ -1,4 +1,5 @@
-import { o as resolveBarrelReExportBinding, r as findImportSource } from "./extract-external-interface-CvkkJZb1.mjs";
+import { i as findImportSource, s as resolveBarrelReExportBinding } from "./ast-walk-DigTJqU7.mjs";
+import { parse } from "@babel/parser";
 //#region src/internal/prepass/compute-leaf-set.ts
 /**
 * Computes which styled-component bindings are "leaves" for leaves-only mode:
@@ -239,4 +240,101 @@ function findDefaultExportedLocalName(source) {
 	return source.match(/\bexport\s+default\s+([A-Z][A-Za-z0-9]*)\b/)?.[1] ?? source.match(/\bexport\s*\{[^}]*\b([A-Z][A-Za-z0-9]*)\s+as\s+default\b[^}]*\}/)?.[1];
 }
 //#endregion
-export { extractStyledDefBasesFromAstProgram as n, extractStyledDefBasesFromSource as r, computeGlobalLeafKeys as t };
+//#region src/internal/prepass/prepass-parser.ts
+/**
+* Shared babel parser for prepass modules.
+*
+* Uses @babel/parser directly with `tokens: false` for ~35% faster parsing
+* compared to jscodeshift's getParser (which enables token generation).
+*
+* Both scan-cross-file-selectors and extract-external-interface can share this parser
+* to avoid duplicate parser initialization.
+*/
+/**
+* Create a babel parser with tokens disabled, matching jscodeshift's plugin set
+* for the given parser name.
+*
+* - `tsx` / `ts`: TypeScript plugins (tsx also includes JSX)
+* - `babel` / `babylon` / `flow`: Flow plugins + JSX
+*
+* Note: jscodeshift's `flow` parser uses the `flow-parser` package (not babel).
+* We always use `@babel/parser` with the `flow` plugin instead, since it produces
+* the same AST node types (ImportDeclaration, TaggedTemplateExpression) that the
+* prepass walks, and avoids an extra parser dependency.
+*/
+function createPrepassParser(parserName = "tsx") {
+	const options = parserName === "ts" || parserName === "tsx" ? buildOptions(TS_PLUGINS, parserName === "tsx") : buildOptions(FLOW_PLUGINS, true);
+	return { parse(source) {
+		return parse(source, options);
+	} };
+}
+function buildOptions(plugins, includeJsx) {
+	return {
+		sourceType: "module",
+		allowImportExportEverywhere: true,
+		allowReturnOutsideFunction: true,
+		startLine: 1,
+		tokens: false,
+		plugins: includeJsx ? ["jsx", ...plugins] : plugins
+	};
+}
+/**
+* Plugins for TypeScript parsers (ts, tsx).
+* Same as jscodeshift's tsOptions.plugins minus "jsx" (added conditionally).
+*/
+const TS_PLUGINS = [
+	"asyncGenerators",
+	"decoratorAutoAccessors",
+	"bigInt",
+	"classPrivateMethods",
+	"classPrivateProperties",
+	"classProperties",
+	"decorators-legacy",
+	"doExpressions",
+	"dynamicImport",
+	"exportDefaultFrom",
+	"exportNamespaceFrom",
+	"functionBind",
+	"functionSent",
+	"importAttributes",
+	"importMeta",
+	"nullishCoalescingOperator",
+	"numericSeparator",
+	"objectRestSpread",
+	"optionalCatchBinding",
+	"optionalChaining",
+	["pipelineOperator", { proposal: "minimal" }],
+	"throwExpressions",
+	"typescript"
+];
+/**
+* Plugins for Flow/Babylon parsers (babel, babylon, flow).
+* Same as jscodeshift's babylon parser plugins minus "jsx" (added conditionally).
+*/
+const FLOW_PLUGINS = [
+	["flow", { all: true }],
+	"flowComments",
+	"asyncGenerators",
+	"bigInt",
+	"classProperties",
+	"classPrivateProperties",
+	"classPrivateMethods",
+	["decorators", { decoratorsBeforeExport: false }],
+	"doExpressions",
+	"dynamicImport",
+	"exportDefaultFrom",
+	"exportNamespaceFrom",
+	"functionBind",
+	"functionSent",
+	"importMeta",
+	"logicalAssignment",
+	"nullishCoalescingOperator",
+	"numericSeparator",
+	"objectRestSpread",
+	"optionalCatchBinding",
+	"optionalChaining",
+	["pipelineOperator", { proposal: "minimal" }],
+	"throwExpressions"
+];
+//#endregion
+export { extractStyledDefBasesFromSource as i, computeGlobalLeafKeys as n, extractStyledDefBasesFromAstProgram as r, createPrepassParser as t };

package/dist/{prop-usage-Bz3z0V2F.mjs → prop-usage-QtOSsKTr.mjs}

@@ -61,5 +61,19 @@ function mergeComponentPropUsage(info, usage) {
 		if (!propInfo.values.some((existing) => existing === value.value)) propInfo.values.push(value.value);
 	}
 }
+/**
+* Formats a `prop === value` JS condition for an observed static variant bucket,
+* quoting strings and emitting numbers bare. Shared by every observed-variant emitter.
+*/
+function formatObservedVariantCondition(propName, value) {
+	return `${propName} === ${typeof value === "number" ? String(value) : JSON.stringify(value)}`;
+}
+function getExhaustiveObservedStaticValues(info, propName) {
+	const propUsage = info?.props[propName];
+	if (!info || info.hasUnknownUsage || !propUsage || propUsage.hasUnknown) return null;
+	if (propUsage.values.length < 1) return null;
+	const values = propUsage.values.filter((value) => typeof value === "string" || typeof value === "number");
+	return values.length === propUsage.values.length ? values : null;
+}
 //#endregion
-export { readStaticJsxLiteral as i, createComponentPropUsageInfo as n, mergeComponentPropUsage as r, KNOWN_NON_ELEMENT_PROPS as t };
+export { mergeComponentPropUsage as a, getExhaustiveObservedStaticValues as i, createComponentPropUsageInfo as n, readStaticJsxLiteral as o, formatObservedVariantCondition as r, KNOWN_NON_ELEMENT_PROPS as t };

package/dist/{run-prepass-1yZOVT3P.mjs → run-prepass-BWQCThfh.mjs}

@@ -1,13 +1,12 @@
-import { a as resolveBarrelReExport, n as fileImportsFrom, o as resolveBarrelReExportBinding, r as findImportSource, s as Logger, t as fileExports } from "./extract-external-interface-CvkkJZb1.mjs";
-import { n as extractStyledDefBasesFromAstProgram, r as extractStyledDefBasesFromSource, t as computeGlobalLeafKeys } from "./compute-leaf-set-90UrZ9WP.mjs";
+import { c as Logger, i as findImportSource, n as fileExports, o as resolveBarrelReExport, r as fileImportsFrom, s as resolveBarrelReExportBinding, t as walkAst } from "./ast-walk-DigTJqU7.mjs";
+import { i as extractStyledDefBasesFromSource, n as computeGlobalLeafKeys, r as extractStyledDefBasesFromAstProgram, t as createPrepassParser } from "./prepass-parser-CwdDzSgx.mjs";
 import { r as escapeRegex } from "./string-utils-DD9wdRHW.mjs";
 import { n as isTemplatePlaceholderInSelectorContext, r as PLACEHOLDER_RE, t as isSelectorContext } from "./selector-context-heuristic-LVizWWOR.mjs";
-import { i as readStaticJsxLiteral, n as createComponentPropUsageInfo, r as mergeComponentPropUsage, t as KNOWN_NON_ELEMENT_PROPS } from "./prop-usage-Bz3z0V2F.mjs";
+import { a as mergeComponentPropUsage, n as createComponentPropUsageInfo, o as readStaticJsxLiteral, t as KNOWN_NON_ELEMENT_PROPS } from "./prop-usage-QtOSsKTr.mjs";
 import { relative, resolve } from "node:path";
 import { readFileSync, realpathSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { parse } from "@babel/parser";
 //#region src/internal/utilities/collection-utils.ts
 /** Add a value to a Set stored in a Map, creating the Set if it doesn't exist. */
 function addToSetMap(map, key, value) {
@@ -19,103 +18,6 @@ function addToSetMap(map, key, value) {
 	set.add(value);
 }
 //#endregion
-//#region src/internal/prepass/prepass-parser.ts
-/**
-* Shared babel parser for prepass modules.
-*
-* Uses @babel/parser directly with `tokens: false` for ~35% faster parsing
-* compared to jscodeshift's getParser (which enables token generation).
-*
-* Both scan-cross-file-selectors and extract-external-interface can share this parser
-* to avoid duplicate parser initialization.
-*/
-/**
-* Create a babel parser with tokens disabled, matching jscodeshift's plugin set
-* for the given parser name.
-*
-* - `tsx` / `ts`: TypeScript plugins (tsx also includes JSX)
-* - `babel` / `babylon` / `flow`: Flow plugins + JSX
-*
-* Note: jscodeshift's `flow` parser uses the `flow-parser` package (not babel).
-* We always use `@babel/parser` with the `flow` plugin instead, since it produces
-* the same AST node types (ImportDeclaration, TaggedTemplateExpression) that the
-* prepass walks, and avoids an extra parser dependency.
-*/
-function createPrepassParser(parserName = "tsx") {
-	const options = parserName === "ts" || parserName === "tsx" ? buildOptions(TS_PLUGINS, parserName === "tsx") : buildOptions(FLOW_PLUGINS, true);
-	return { parse(source) {
-		return parse(source, options);
-	} };
-}
-function buildOptions(plugins, includeJsx) {
-	return {
-		sourceType: "module",
-		allowImportExportEverywhere: true,
-		allowReturnOutsideFunction: true,
-		startLine: 1,
-		tokens: false,
-		plugins: includeJsx ? ["jsx", ...plugins] : plugins
-	};
-}
-/**
-* Plugins for TypeScript parsers (ts, tsx).
-* Same as jscodeshift's tsOptions.plugins minus "jsx" (added conditionally).
-*/
-const TS_PLUGINS = [
-	"asyncGenerators",
-	"decoratorAutoAccessors",
-	"bigInt",
-	"classPrivateMethods",
-	"classPrivateProperties",
-	"classProperties",
-	"decorators-legacy",
-	"doExpressions",
-	"dynamicImport",
-	"exportDefaultFrom",
-	"exportNamespaceFrom",
-	"functionBind",
-	"functionSent",
-	"importAttributes",
-	"importMeta",
-	"nullishCoalescingOperator",
-	"numericSeparator",
-	"objectRestSpread",
-	"optionalCatchBinding",
-	"optionalChaining",
-	["pipelineOperator", { proposal: "minimal" }],
-	"throwExpressions",
-	"typescript"
-];
-/**
-* Plugins for Flow/Babylon parsers (babel, babylon, flow).
-* Same as jscodeshift's babylon parser plugins minus "jsx" (added conditionally).
-*/
-const FLOW_PLUGINS = [
-	["flow", { all: true }],
-	"flowComments",
-	"asyncGenerators",
-	"bigInt",
-	"classProperties",
-	"classPrivateProperties",
-	"classPrivateMethods",
-	["decorators", { decoratorsBeforeExport: false }],
-	"doExpressions",
-	"dynamicImport",
-	"exportDefaultFrom",
-	"exportNamespaceFrom",
-	"functionBind",
-	"functionSent",
-	"importMeta",
-	"logicalAssignment",
-	"nullishCoalescingOperator",
-	"numericSeparator",
-	"objectRestSpread",
-	"optionalCatchBinding",
-	"optionalChaining",
-	["pipelineOperator", { proposal: "minimal" }],
-	"throwExpressions"
-];
-//#endregion
 //#region src/internal/prepass/scan-cross-file-selectors.ts
 /**
 * Pre-filter: matches any bare `${Identifier}` template expression.
@@ -750,7 +652,7 @@ function isTypeScriptParser(parserName) {
 }
 async function loadTypeScriptAnalysis() {
 	try {
-		return await import("./typescript-analysis-C_25uBrt.mjs");
+		return await import("./typescript-analysis-CmIDxfLv.mjs");
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
 		if (message.includes("typescript") && (message.includes("Cannot find") || message.includes("ERR_MODULE_NOT_FOUND"))) throw new Error(["TypeScript parser runs require the optional `typescript` package for compiler metadata.", "Install TypeScript in the project (supported range: >=5.0.0 <6), or use a non-TypeScript parser."].join("\n"));
@@ -883,14 +785,16 @@ function scanConsumerJsxUsages(filePath, source, componentNames, parser) {
 	}
 	const importNodes = [];
 	const jsxOpenings = [];
-	walkForImportsAndJsxOpenings(ast.program ?? ast, importNodes, jsxOpenings);
+	const program = ast.program ?? ast;
+	walkForImportsAndJsxOpenings(program, importNodes, jsxOpenings);
 	const importMap = buildImportMapFromNodes(importNodes);
+	const staticIdentifierValues = collectStaticIdentifierValues(program);
 	const resultMap = /* @__PURE__ */ new Map();
 	const staticPropUsages = [];
 	for (const opening of jsxOpenings) {
 		const resolvedComponent = resolveJsxOpeningComponent(opening.name, importMap, componentNames);
 		if (!resolvedComponent) continue;
-		const openingUsage = readConsumerOpeningUsage(opening);
+		const openingUsage = readConsumerOpeningUsage(opening, staticIdentifierValues);
 		const { externalProps } = openingUsage;
 		if (externalProps.className || externalProps.style || externalProps.spreadProps || externalProps.elementProps) {
 			const key = `${resolvedComponent.name}\0${resolvedComponent.importSource ?? ""}`;
@@ -941,7 +845,7 @@ function resolveJsxOpeningComponent(name, importMap, componentNames) {
 		importSource: importEntry.source
 	} : void 0;
 }
-function readConsumerOpeningUsage(opening) {
+function readConsumerOpeningUsage(opening, staticIdentifierValues) {
 	const externalProps = {
 		className: false,
 		style: false,
@@ -964,7 +868,7 @@ function readConsumerOpeningUsage(opening) {
 		else if (propName === "style") externalProps.style = true;
 		else if (isElementConsumerProp(propName)) externalProps.elementProps = true;
 		if (!KNOWN_NON_ELEMENT_PROPS.has(propName)) {
-			const value = readStaticJsxLiteral(attr);
+			const value = readStaticJsxLiteral(attr) ?? readStaticIdentifierJsxValue(attr, staticIdentifierValues);
 			props[propName] = value === void 0 ? { kind: "unknown" } : {
 				kind: "static",
 				value
@@ -979,6 +883,113 @@ function readConsumerOpeningUsage(opening) {
 		}
 	};
 }
+function collectStaticIdentifierValues(program) {
+	const values = /* @__PURE__ */ new Map();
+	for (const declaration of moduleLevelVariableDeclarations(program)) {
+		if (declaration.kind !== "const") continue;
+		const declarators = declaration.declarations ?? [];
+		for (const decl of declarators) {
+			const name = decl.id?.type === "Identifier" ? decl.id.name : null;
+			const value = staticValueFromNode(decl.init);
+			if (name && value !== void 0) values.set(name, value);
+		}
+	}
+	if (values.size === 0) return values;
+	const bindingCounts = countBoundNames(program);
+	const shadowedNames = [];
+	for (const [name] of values) if ((bindingCounts.get(name) ?? 0) > 1) shadowedNames.push(name);
+	for (const name of shadowedNames) values.delete(name);
+	return values;
+}
+/** Top-level `const`/`let`/`var` declarations, unwrapping `export` declarations. */
+function moduleLevelVariableDeclarations(program) {
+	const body = program.body ?? [];
+	const declarations = [];
+	for (const node of body) if (node.type === "VariableDeclaration") declarations.push(node);
+	else if (node.type === "ExportNamedDeclaration") {
+		const inner = node.declaration;
+		if (inner?.type === "VariableDeclaration") declarations.push(inner);
+	}
+	return declarations;
+}
+/** Counts how many times each name is introduced as a binding anywhere in the module. */
+function countBoundNames(program) {
+	const counts = /* @__PURE__ */ new Map();
+	const bump = (name) => {
+		if (name) counts.set(name, (counts.get(name) ?? 0) + 1);
+	};
+	const bumpId = (node) => {
+		if (node?.type === "Identifier") bump(node.name ?? "");
+	};
+	walkAst(program, (node) => {
+		switch (node.type) {
+			case "VariableDeclarator":
+				collectPatternNames(node.id, bump);
+				break;
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+				bumpId(node.id);
+				for (const param of node.params ?? []) collectPatternNames(param, bump);
+				break;
+			case "ClassDeclaration":
+			case "ClassExpression":
+				bumpId(node.id);
+				break;
+			case "CatchClause":
+				collectPatternNames(node.param, bump);
+				break;
+			case "ImportSpecifier":
+			case "ImportDefaultSpecifier":
+			case "ImportNamespaceSpecifier":
+				bumpId(node.local);
+				break;
+		}
+	});
+	return counts;
+}
+/** Collects every identifier name bound by a (possibly destructured) binding pattern. */
+function collectPatternNames(node, add) {
+	if (!node) return;
+	switch (node.type) {
+		case "Identifier":
+			add(node.name ?? "");
+			break;
+		case "ObjectPattern":
+			for (const property of node.properties ?? []) if (property.type === "RestElement") collectPatternNames(property.argument, add);
+			else collectPatternNames(property.value, add);
+			break;
+		case "ArrayPattern":
+			for (const element of node.elements ?? []) collectPatternNames(element ?? void 0, add);
+			break;
+		case "AssignmentPattern":
+			collectPatternNames(node.left, add);
+			break;
+		case "RestElement":
+			collectPatternNames(node.argument, add);
+			break;
+		case "TSParameterProperty":
+			collectPatternNames(node.parameter, add);
+			break;
+	}
+}
+function readStaticIdentifierJsxValue(attr, staticIdentifierValues) {
+	const value = attr.value;
+	const expr = value?.type === "JSXExpressionContainer" ? value.expression : null;
+	const name = expr?.type === "Identifier" ? expr.name : null;
+	return name ? staticIdentifierValues.get(name) : void 0;
+}
+const STATIC_LITERAL_NODE_TYPES = new Set([
+	"Literal",
+	"StringLiteral",
+	"NumericLiteral",
+	"BooleanLiteral"
+]);
+function staticValueFromNode(node) {
+	if (!node || !STATIC_LITERAL_NODE_TYPES.has(node.type)) return;
+	const value = node.value;
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : void 0;
+}
 function isElementConsumerProp(propName) {
 	return !KNOWN_NON_ELEMENT_PROPS.has(propName) && !propName.startsWith("$");
 }