styled-components-to-stylex-codemod 0.0.37 → 0.0.39

package/dist/prop-usage-D6ZiDfzz.mjs

@@ -0,0 +1,136 @@
+import { compile } from "stylis";
+//#region src/internal/styled-css.ts
+/** Matches `__SC_EXPR_N__` and captures the slot index in group 1. */
+const PLACEHOLDER_RE = /__SC_EXPR_(\d+)__/;
+function parseStyledTemplateLiteral(template) {
+	const parts = [];
+	const slots = [];
+	for (let i = 0; i < template.quasis.length; i++) {
+		const quasi = template.quasis[i];
+		parts.push(quasi.value.raw);
+		const expr = template.expressions[i];
+		if (!expr) continue;
+		const placeholder = makeInterpolationPlaceholder(i);
+		const startOffset = parts.join("").length;
+		parts.push(placeholder);
+		const endOffset = parts.join("").length;
+		slots.push({
+			index: i,
+			placeholder,
+			expression: expr,
+			startOffset,
+			endOffset
+		});
+	}
+	const rawCss = parts.join("");
+	return {
+		rawCss,
+		slots,
+		stylisAst: compile(terminateStandaloneInterpolationStatements(rawCss))
+	};
+}
+function terminateStandaloneInterpolationStatements(css) {
+	let parenDepth = 0;
+	const lines = css.split(/(?<=\n)/);
+	const depthsBeforeLine = [];
+	for (const line of lines) {
+		depthsBeforeLine.push(parenDepth);
+		parenDepth = updateParenDepth(parenDepth, line);
+	}
+	return lines.map((line, index) => {
+		return depthsBeforeLine[index] === 0 && /^\s*__SC_EXPR_\d+__\s*$/.test(line) && isBeforeAtRule(lines, index) ? line.replace(/(\s*)$/, ";$1") : line;
+	}).join("");
+}
+function makeInterpolationPlaceholder(index) {
+	return `__SC_EXPR_${index}__`;
+}
+function isBeforeAtRule(lines, startIndex) {
+	for (let i = startIndex + 1; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		if (!trimmed || /^__SC_EXPR_\d+__\s*;?$/.test(trimmed)) continue;
+		return trimmed.startsWith("@");
+	}
+	return false;
+}
+function updateParenDepth(startDepth, line) {
+	let depth = startDepth;
+	let inString = false;
+	for (let i = 0; i < line.length; i++) {
+		const ch = line[i];
+		if ((ch === "\"" || ch === "'") && line[i - 1] !== "\\") {
+			if (!inString) inString = ch;
+			else if (inString === ch) inString = false;
+			continue;
+		}
+		if (inString) continue;
+		if (ch === "(") depth++;
+		else if (ch === ")") depth = Math.max(0, depth - 1);
+	}
+	return depth;
+}
+//#endregion
+//#region src/internal/utilities/jsx-static-literal.ts
+function readStaticJsxLiteral(attr) {
+	if (!isObjectRecord(attr) || attr.type !== "JSXAttribute") return;
+	if (!("value" in attr) || attr.value == null) return true;
+	const directLiteral = readLiteralNodeValue(attr.value);
+	if (directLiteral !== void 0) return directLiteral;
+	if (!isObjectRecord(attr.value) || attr.value.type !== "JSXExpressionContainer") return;
+	return readLiteralNodeValue(attr.value.expression);
+}
+function readLiteralNodeValue(node) {
+	if (!isObjectRecord(node)) return;
+	if (node.type === "StringLiteral" || node.type === "NumericLiteral" || node.type === "BooleanLiteral") return isStaticLiteral(node.value) ? node.value : void 0;
+	if (node.type === "Literal") return isStaticLiteral(node.value) ? node.value : void 0;
+	if (node.type === "UnaryExpression" && node.operator === "-") {
+		const value = readLiteralNodeValue(node.argument);
+		return typeof value === "number" ? -value : void 0;
+	}
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isStaticLiteral(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+//#endregion
+//#region src/internal/utilities/prop-usage.ts
+const KNOWN_NON_ELEMENT_PROPS = new Set([
+	"className",
+	"style",
+	"as",
+	"ref",
+	"forwardedAs",
+	"key",
+	"children"
+]);
+function createComponentPropUsageInfo(name) {
+	return {
+		componentName: name,
+		usageCount: 0,
+		hasUnknownUsage: false,
+		props: {}
+	};
+}
+function mergeComponentPropUsage(info, usage) {
+	info.usageCount += 1;
+	if (usage.hasSpread) info.hasUnknownUsage = true;
+	const presentProps = new Set(Object.keys(usage.props));
+	for (const [propName, propInfo] of Object.entries(info.props)) if (!presentProps.has(propName)) propInfo.omittedCount += 1;
+	for (const [propName, value] of Object.entries(usage.props)) {
+		const propInfo = info.props[propName] ?? (info.props[propName] = {
+			values: [],
+			hasUnknown: false,
+			usageCount: 0,
+			omittedCount: info.usageCount - 1
+		});
+		propInfo.usageCount += 1;
+		if (value.kind === "unknown") {
+			propInfo.hasUnknown = true;
+			continue;
+		}
+		if (!propInfo.values.some((existing) => existing === value.value)) propInfo.values.push(value.value);
+	}
+}
+//#endregion
+export { PLACEHOLDER_RE as a, readStaticJsxLiteral as i, createComponentPropUsageInfo as n, parseStyledTemplateLiteral as o, mergeComponentPropUsage as r, terminateStandaloneInterpolationStatements as s, KNOWN_NON_ELEMENT_PROPS as t };

package/dist/{run-prepass-5LTAQkG0.mjs → run-prepass-qEr_Mc3y.mjs}

@@ -1,7 +1,8 @@
-import { a as Logger, i as resolveBarrelReExport, n as fileImportsFrom, r as findImportSource, t as fileExports } from "./extract-external-interface-BgvS5GC0.mjs";
-import { r as escapeRegex } from "./string-utils-ChXtospT.mjs";
-import { t as PLACEHOLDER_RE } from "./styled-css-DVtGPEUe.mjs";
-import { t as isSelectorContext } from "./selector-context-heuristic-DE3JAmpc.mjs";
+import { a as Logger, i as resolveBarrelReExport, n as fileImportsFrom, r as findImportSource, t as fileExports } from "./extract-external-interface-CdHbvfxu.mjs";
+import { n as extractStyledDefBasesFromAstProgram, r as extractStyledDefBasesFromSource, t as computeGlobalLeafKeys } from "./compute-leaf-set-Drcu2eju.mjs";
+import { r as escapeRegex } from "./string-utils-DD9wdRHW.mjs";
+import { a as PLACEHOLDER_RE, i as readStaticJsxLiteral, n as createComponentPropUsageInfo, r as mergeComponentPropUsage, t as KNOWN_NON_ELEMENT_PROPS } from "./prop-usage-D6ZiDfzz.mjs";
+import { t as isSelectorContext } from "./selector-context-heuristic-6_jSRGkZ.mjs";
 import { relative, resolve } from "node:path";
 import { readFileSync, realpathSync } from "node:fs";
 import { execSync } from "node:child_process";
@@ -383,243 +384,6 @@ function deduplicateAndResolve(filesToTransform, consumerPaths) {
 	return result;
 }
 //#endregion
-//#region src/internal/prepass/compute-leaf-set.ts
-/**
-* Computes which styled-component bindings are "leaves" for leaves-only mode:
-* intrinsic bases (`styled.div`) or transitive wrappers around other leaf styled
-* components in the transform set. Uses AST extraction (primary), regex fallback,
-* fixed-point + import resolution (same helpers as consumer analysis).
-*/
-const RX_EXPORT_DECL = String.raw`(?:export\s+)?(?:const|let|var)\s+`;
-/** `const Name = styled.tag` — intrinsic HTML/SVG tag member. */
-const STYLED_INTRINSIC_MEMBER_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\.([a-z][a-zA-Z0-9]*)\b`, "g");
-/** `const Name = styled("tag")` — intrinsic string tag. */
-const STYLED_INTRINSIC_STRING_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\s*\(\s*["']([^"']+)["']`, "g");
-/** `const Name = styled(Component)` — wraps another component identifier. */
-const STYLED_COMPONENT_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\s*\(\s*([A-Z][A-Za-z0-9]*)\s*\)`, "g");
-/**
-* Regex-derived styled definition bases for files in the transform set.
-* Later entries for the same component name overwrite earlier ones (rare).
-*/
-function extractStyledDefBasesFromSource(filePath, source, into) {
-	let map = into.get(filePath);
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		into.set(filePath, map);
-	}
-	STYLED_INTRINSIC_MEMBER_RE.lastIndex = 0;
-	for (const m of source.matchAll(STYLED_INTRINSIC_MEMBER_RE)) {
-		const name = m[1];
-		if (name) map.set(name, { kind: "intrinsic" });
-	}
-	STYLED_INTRINSIC_STRING_RE.lastIndex = 0;
-	for (const m of source.matchAll(STYLED_INTRINSIC_STRING_RE)) {
-		const name = m[1];
-		if (name) map.set(name, { kind: "intrinsic" });
-	}
-	STYLED_COMPONENT_RE.lastIndex = 0;
-	for (const m of source.matchAll(STYLED_COMPONENT_RE)) {
-		const name = m[1];
-		const ident = m[2];
-		if (name && ident) map.set(name, {
-			kind: "component",
-			ident
-		});
-	}
-}
-/**
-* AST-based extraction: understands `let`/`var`, export blocks, named `styled` imports,
-* and `.attrs` / `.withConfig` chains before the tagged template.
-* Results merge into `into`; bindings found here override regex entries for the same name.
-*/
-function extractStyledDefBasesFromAstProgram(filePath, program, styledLocalNames, into) {
-	if (styledLocalNames.size === 0) return;
-	let map = into.get(filePath);
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		into.set(filePath, map);
-	}
-	const body = program.body;
-	if (!body) return;
-	for (const stmt of body) walkStatement(stmt);
-	function walkStatement(stmt) {
-		if (stmt.type === "VariableDeclaration") {
-			for (const d of stmt.declarations ?? []) processDeclarator(d);
-			return;
-		}
-		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) walkStatement(stmt.declaration);
-	}
-	function processDeclarator(decl) {
-		if (decl.type !== "VariableDeclarator") return;
-		const id = decl.id;
-		if (id.type !== "Identifier" || typeof id.name !== "string") return;
-		const tpl = findTaggedTemplate(unwrapInitializer(decl.init));
-		if (!tpl || tpl.type !== "TaggedTemplateExpression") return;
-		const base = classifyStyledTemplateTag(tpl.tag, styledLocalNames);
-		if (base) map.set(id.name, base);
-	}
-}
-function unwrapInitializer(node) {
-	let cur = node ?? void 0;
-	while (cur) {
-		if (cur.type === "TSAsExpression" || cur.type === "AsExpression") {
-			cur = cur.expression;
-			continue;
-		}
-		if (cur.type === "ParenthesizedExpression") {
-			cur = cur.expression;
-			continue;
-		}
-		return cur;
-	}
-}
-function findTaggedTemplate(node) {
-	const n = unwrapInitializer(node);
-	if (!n) return;
-	if (n.type === "TaggedTemplateExpression") return n;
-}
-/** Peel `.attrs` / `.withConfig` / nested calls down to `styled.div` or `styled(X)`. */
-function peelStyledApplication(tag, styledNames) {
-	let cur = tag;
-	while (cur) {
-		if (cur.type === "CallExpression") {
-			const callee = cur.callee;
-			if (callee?.type === "MemberExpression") {
-				cur = callee;
-				continue;
-			}
-			if (callee?.type === "Identifier" && typeof callee.name === "string" && styledNames.has(callee.name)) return cur;
-			return null;
-		}
-		if (cur.type === "MemberExpression") {
-			const obj = cur.object;
-			if (obj?.type === "Identifier" && typeof obj.name === "string" && styledNames.has(obj.name)) return cur;
-			cur = obj;
-			continue;
-		}
-		break;
-	}
-	return null;
-}
-function classifyStyledTemplateTag(tag, styledNames) {
-	const root = peelStyledApplication(tag, styledNames);
-	if (!root) return null;
-	if (root.type === "MemberExpression") {
-		const obj = root.object;
-		const prop = root.property;
-		const objName = obj?.type === "Identifier" ? obj.name : void 0;
-		if (obj?.type !== "Identifier" || typeof objName !== "string" || !styledNames.has(objName)) return null;
-		const isComputed = Boolean(root.computed);
-		if (isComputed && prop?.type === "StringLiteral" && typeof prop.value === "string") return { kind: "intrinsic" };
-		if (!isComputed && prop?.type === "Identifier" && typeof prop.name === "string") return { kind: "intrinsic" };
-		return null;
-	}
-	if (root.type === "CallExpression") {
-		const callee = root.callee;
-		const arg0 = root.arguments?.[0];
-		const calleeName = callee?.type === "Identifier" ? callee.name : void 0;
-		if (callee?.type !== "Identifier" || typeof calleeName !== "string" || !styledNames.has(calleeName) || !arg0) return null;
-		if (arg0.type === "Identifier" && typeof arg0.name === "string") return {
-			kind: "component",
-			ident: arg0.name
-		};
-		if (arg0.type === "StringLiteral" && typeof arg0.value === "string") return { kind: "intrinsic" };
-		return null;
-	}
-	return null;
-}
-/**
-* Fixed-point: a styled binding is a leaf if its base is intrinsic, or its base
-* component resolves (same-file or import) to another leaf binding in the transform set.
-*
-* @param transformSet - Absolute realpaths of files being transformed
-* @param styledDefBases - From {@link extractStyledDefBasesFromSource}
-* @param resolve - Module path resolver
-* @param cachedRead - Read file source for import resolution
-*/
-function computeGlobalLeafKeys(args) {
-	const { transformSet, styledDefBases, resolve, cachedRead, toRealPath, resolveBaseComponent } = args;
-	/** fileRealPath → Set of local binding names that are leaves */
-	const globalLeaves = /* @__PURE__ */ new Map();
-	const ensureSet = (file) => {
-		let s = globalLeaves.get(file);
-		if (!s) {
-			s = /* @__PURE__ */ new Set();
-			globalLeaves.set(file, s);
-		}
-		return s;
-	};
-	const isLeaf = (file, name) => globalLeaves.get(file)?.has(name) ?? false;
-	const tryResolveImportedLeaf = (file, ident) => {
-		const importInfo = findImportSource(cachedRead(file), ident);
-		if (!importInfo) return false;
-		const initialDefFile = resolve(importInfo.source, file);
-		if (!initialDefFile) return false;
-		const defReal = toRealPath(resolveBarrelReExport(initialDefFile, importInfo.isDefault ? "default" : importInfo.exportedName, resolve, cachedRead) ?? initialDefFile);
-		if (!transformSet.has(defReal)) return false;
-		return leafKeyExists(defReal, importInfo.exportedName, importInfo.isDefault, cachedRead, globalLeaves);
-	};
-	const tryResolveAdapterIntrinsic = (file, ident) => {
-		if (!resolveBaseComponent) return false;
-		const importInfo = findImportSource(cachedRead(file), ident);
-		if (!importInfo) return false;
-		try {
-			const result = resolveBaseComponent({
-				importSource: importInfo.source,
-				importedName: importInfo.exportedName,
-				staticProps: {},
-				filePath: file
-			});
-			return typeof result?.tagName === "string" && result.tagName.trim() !== "";
-		} catch {
-			return false;
-		}
-	};
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const [filePath, nameMap] of styledDefBases) {
-			const fileReal = toRealPath(filePath);
-			if (!transformSet.has(fileReal)) continue;
-			for (const [name, base] of nameMap) {
-				if (isLeaf(fileReal, name)) continue;
-				if (base.kind === "intrinsic") {
-					ensureSet(fileReal).add(name);
-					changed = true;
-					continue;
-				}
-				const ident = base.ident;
-				if (isLeaf(fileReal, ident)) {
-					ensureSet(fileReal).add(name);
-					changed = true;
-					continue;
-				}
-				if (tryResolveAdapterIntrinsic(filePath, ident)) {
-					ensureSet(fileReal).add(name);
-					changed = true;
-					continue;
-				}
-				if (tryResolveImportedLeaf(filePath, ident)) {
-					ensureSet(fileReal).add(name);
-					changed = true;
-				}
-			}
-		}
-	}
-	const globalLeafKeys = /* @__PURE__ */ new Set();
-	for (const [file, names] of globalLeaves) for (const name of names) globalLeafKeys.add(`${file}:${name}`);
-	return globalLeafKeys;
-}
-function leafKeyExists(defFile, exportedName, allowDefaultFallback, cachedRead, globalLeaves) {
-	if (globalLeaves.get(defFile)?.has(exportedName) ?? false) return true;
-	if (!allowDefaultFallback) return false;
-	const defaultLocalName = findDefaultExportedLocalName(cachedRead(defFile));
-	return defaultLocalName ? globalLeaves.get(defFile)?.has(defaultLocalName) ?? false : false;
-}
-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
 //#region src/internal/prepass/run-prepass.ts
 /**
 * Unified prepass: single pass for both cross-file selector scanning
@@ -693,6 +457,7 @@ async function runPrepass(options) {
 	const styleUsages = /* @__PURE__ */ new Map();
 	const elementPropUsages = /* @__PURE__ */ new Map();
 	const spreadPropUsages = /* @__PURE__ */ new Map();
+	const propUsageCandidates = /* @__PURE__ */ new Map();
 	const styledWrapperUsages = [];
 	const fileContents = /* @__PURE__ */ new Map();
 	const cachedRead = (filePath) => {
@@ -727,14 +492,16 @@ async function runPrepass(options) {
 				categorizeSelectorUsages(usages, componentsNeedingMarkerSidecar, componentsNeedingGlobalSelectorBridge);
 			}
 		}
+		if (hasStyled) {
+			STYLED_DEF_RE.lastIndex = 0;
+			for (const m of source.matchAll(STYLED_DEF_RE)) if (m[1]) addToSetMap(styledDefFiles, filePath, m[1]);
+		}
 		if (createExternalInterface && hasStyled) {
 			STYLED_CALL_RE.lastIndex = 0;
 			for (const m of source.matchAll(STYLED_CALL_RE)) if (m[1]) styledCallUsages.push({
 				file: filePath,
 				name: m[1]
 			});
-			STYLED_DEF_RE.lastIndex = 0;
-			for (const m of source.matchAll(STYLED_DEF_RE)) if (m[1]) addToSetMap(styledDefFiles, filePath, m[1]);
 			STYLED_COMPONENT_WRAPPER_RE.lastIndex = 0;
 			for (const m of source.matchAll(STYLED_COMPONENT_WRAPPER_RE)) if (m[1] && m[2]) styledWrapperUsages.push({
 				file: filePath,
@@ -759,22 +526,37 @@ async function runPrepass(options) {
 		}
 	}
 	const styledFileCount = fileContents.size;
-	if (createExternalInterface && styledDefFiles.size > 0) {
+	if (styledDefFiles.size > 0) {
 		const allStyledNames = /* @__PURE__ */ new Set();
 		for (const names of styledDefFiles.values()) for (const name of names) allStyledNames.add(name);
 		if (allStyledNames.size > 0) {
-			const rgHits = rgClassNameStyleFilter(uniqueAllFiles);
+			const rgHits = createExternalInterface ? rgClassNameStyleFilter(uniqueAllFiles) : void 0;
+			const jsxHits = rgJsxComponentFilter(uniqueAllFiles);
 			const scanAndRecord = (filePath, source) => {
-				for (const result of scanConsumerProps(source, allStyledNames)) {
+				if (createExternalInterface) for (const result of scanConsumerProps(source, allStyledNames)) {
 					addToSetMap(classNameStyleUsages, result.name, filePath);
 					if (result.className) addToSetMap(classNameUsages, result.name, filePath);
 					if (result.style) addToSetMap(styleUsages, result.name, filePath);
 					if (result.elementProps) addToSetMap(elementPropUsages, result.name, filePath);
 					if (result.spreadProps) addToSetMap(spreadPropUsages, result.name, filePath);
 				}
+				for (const usage of scanConsumerStaticPropUsages(filePath, source, allStyledNames, parser)) {
+					const entries = propUsageCandidates.get(usage.name) ?? [];
+					entries.push(usage);
+					propUsageCandidates.set(usage.name, entries);
+				}
 			};
-			for (const [filePath, source] of fileContents) scanAndRecord(filePath, source);
-			const filesToScan = rgHits ? [...rgHits].filter((f) => allFilesSet.has(f) && !fileContents.has(f)) : uniqueAllFiles.filter((f) => !fileContents.has(f));
+			for (const [filePath, source] of fileContents) {
+				if (jsxHits && !jsxHits.has(filePath) && (!createExternalInterface || !rgHits?.has(filePath))) continue;
+				scanAndRecord(filePath, source);
+			}
+			const filesToScan = (() => {
+				const hits = /* @__PURE__ */ new Set();
+				const hasAnyFilter = createExternalInterface && rgHits !== void 0 || jsxHits !== void 0;
+				if (createExternalInterface && rgHits) for (const f of rgHits) hits.add(f);
+				if (jsxHits) for (const f of jsxHits) hits.add(f);
+				return hasAnyFilter ? [...hits].filter((f) => allFilesSet.has(f) && !fileContents.has(f)) : uniqueAllFiles.filter((f) => !fileContents.has(f));
+			})();
 			for (const filePath of filesToScan) {
 				const source = cachedRead(filePath);
 				if (!source) continue;
@@ -876,6 +658,13 @@ async function runPrepass(options) {
 			targetPath: defFile
 		});
 	}
+	const propUsageByFile = buildPropUsageByFile({
+		styledDefFiles,
+		propUsageCandidates,
+		cachedRead,
+		resolve: resolve$1,
+		toRealPath
+	});
 	let globalLeafKeys;
 	if (leavesOnly) {
 		const styledDefBases = /* @__PURE__ */ new Map();
@@ -893,6 +682,7 @@ async function runPrepass(options) {
 		selectorUsages,
 		componentsNeedingMarkerSidecar,
 		componentsNeedingGlobalSelectorBridge,
+		propUsageByFile,
 		styledDefFiles: createExternalInterface ? styledDefFiles : void 0,
 		globalLeafKeys
 	};
@@ -901,7 +691,10 @@ async function runPrepass(options) {
 		const reStyled = consumerAnalysis ? [...consumerAnalysis.values()].filter((v) => v.styles).length : 0;
 		const asProp = consumerAnalysis ? [...consumerAnalysis.values()].filter((v) => v.as).length : 0;
 		const refProp = consumerAnalysis ? [...consumerAnalysis.values()].filter((v) => v.ref).length : 0;
-		Logger.info(`Prepass: scanned ${uniqueAllFiles.length} files in ${elapsed}s — ${styledFileCount} with styled-components, ${selectorUsages.size} cross-file selectors, ${reStyled} re-styled, ${asProp} as-prop, ${refProp} ref-prop, ${classNameStyleUsages.size} className/style, ${forwardedAsConsumers.size} forwardedAs\n`);
+		const propUsageCount = [...propUsageByFile.values()].reduce((sum, byComponent) => {
+			return sum + byComponent.size;
+		}, 0);
+		Logger.info(`Prepass: scanned ${uniqueAllFiles.length} files in ${elapsed}s — ${styledFileCount} with styled-components, ${selectorUsages.size} cross-file selectors, ${reStyled} re-styled, ${asProp} as-prop, ${refProp} ref-prop, ${classNameStyleUsages.size} className/style, ${propUsageCount} prop-usage, ${forwardedAsConsumers.size} forwardedAs\n`);
 	}
 	if (process.env.DEBUG_CODEMOD) logPrepassDebug(uniqueAllFiles, crossFileInfo, consumerAnalysis);
 	return {
@@ -987,16 +780,6 @@ function buildLocalToImportedMap(source) {
 	}
 	return map;
 }
-/** Props that don't indicate element-specific usage (non-element props). */
-const KNOWN_NON_ELEMENT_PROPS = new Set([
-	"className",
-	"style",
-	"as",
-	"ref",
-	"forwardedAs",
-	"key",
-	"children"
-]);
 /**
 * Scan source for JSX usage of specific components with className, style,
 * element-specific props, or JSX spread.
@@ -1047,6 +830,114 @@ function scanConsumerProps(source, componentNames) {
 	}
 	return [...resultMap.values()];
 }
+function scanConsumerStaticPropUsages(filePath, source, componentNames, parser) {
+	if (!/<[A-Z]/.test(source)) return [];
+	let ast;
+	try {
+		ast = parser.parse(source);
+	} catch {
+		return [];
+	}
+	const importNodes = [];
+	const jsxOpenings = [];
+	walkForImportsAndJsxOpenings(ast.program ?? ast, importNodes, jsxOpenings);
+	const importMap = buildImportMapFromNodes(importNodes);
+	const usages = [];
+	for (const opening of jsxOpenings) {
+		const tagName = getJsxOpeningIdentifierName(opening.name);
+		if (!tagName) continue;
+		const importEntry = importMap.get(tagName);
+		const resolvedName = componentNames.has(tagName) ? tagName : importEntry && componentNames.has(importEntry.importedName) ? importEntry.importedName : void 0;
+		if (!resolvedName) continue;
+		const props = {};
+		let hasSpread = false;
+		for (const attr of opening.attributes ?? []) {
+			if (!attr) continue;
+			if (attr.type === "JSXSpreadAttribute") {
+				hasSpread = true;
+				continue;
+			}
+			if (attr.type !== "JSXAttribute") continue;
+			const propName = getJsxAttributeName(attr.name);
+			if (!propName || KNOWN_NON_ELEMENT_PROPS.has(propName)) continue;
+			const value = readStaticJsxLiteral(attr);
+			props[propName] = value === void 0 ? { kind: "unknown" } : {
+				kind: "static",
+				value
+			};
+		}
+		usages.push({
+			name: resolvedName,
+			filePath,
+			usage: {
+				props,
+				hasSpread
+			}
+		});
+	}
+	return usages;
+}
+function buildPropUsageByFile(args) {
+	const { styledDefFiles, propUsageCandidates, cachedRead, resolve, toRealPath } = args;
+	const propUsageByFile = /* @__PURE__ */ new Map();
+	for (const [defFile, names] of styledDefFiles) {
+		const defSrc = cachedRead(defFile);
+		for (const name of names) {
+			const candidates = propUsageCandidates.get(name);
+			if (!candidates || !fileExports(defSrc, name)) continue;
+			for (const candidate of candidates) {
+				const usageFile = candidate.filePath;
+				if (usageFile !== defFile && !fileImportsFrom(cachedRead(usageFile), usageFile, name, defFile, resolve)) continue;
+				mergeComponentPropUsage(getOrCreateComponentPropUsage(getOrCreatePropUsageFileMap(propUsageByFile, toRealPath(defFile)), name), candidate.usage);
+			}
+		}
+	}
+	return propUsageByFile;
+}
+function getOrCreatePropUsageFileMap(propUsageByFile, filePath) {
+	let byComponent = propUsageByFile.get(filePath);
+	if (!byComponent) {
+		byComponent = /* @__PURE__ */ new Map();
+		propUsageByFile.set(filePath, byComponent);
+	}
+	return byComponent;
+}
+function getOrCreateComponentPropUsage(byComponent, name) {
+	let info = byComponent.get(name);
+	if (!info) {
+		info = createComponentPropUsageInfo(name);
+		byComponent.set(name, info);
+	}
+	return info;
+}
+function walkForImportsAndJsxOpenings(node, imports, jsxOpenings) {
+	if (!node || typeof node !== "object") return;
+	const n = node;
+	if (n.type === "ImportDeclaration") {
+		imports.push(n);
+		return;
+	}
+	if (n.type === "JSXOpeningElement") {
+		jsxOpenings.push(n);
+		return;
+	}
+	for (const key of Object.keys(n)) {
+		if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+		const val = n[key];
+		if (Array.isArray(val)) for (const child of val) walkForImportsAndJsxOpenings(child, imports, jsxOpenings);
+		else if (val && typeof val === "object" && val.type) walkForImportsAndJsxOpenings(val, imports, jsxOpenings);
+	}
+}
+function getJsxOpeningIdentifierName(name) {
+	if (!name) return null;
+	if (name.type === "JSXIdentifier" && typeof name.name === "string") return name.name;
+	return null;
+}
+function getJsxAttributeName(name) {
+	if (!name) return null;
+	if (name.type === "JSXIdentifier" && typeof name.name === "string") return name.name;
+	return null;
+}
 /**
 * Use ripgrep to find files containing `className` or `style` props.
 * Searches for the prop keywords (not component names) to keep the pattern
@@ -1076,6 +967,31 @@ function rgClassNameStyleFilter(files) {
 		return;
 	}
 }
+/** Use ripgrep to find files with PascalCase JSX tags. */
+function rgJsxComponentFilter(files) {
+	const dirs = deduplicateParentDirs(files);
+	if (dirs.length === 0) return;
+	try {
+		const globArgs = [
+			"*.tsx",
+			"*.jsx",
+			"*.ts",
+			"*.js",
+			"*.mts",
+			"*.cts",
+			"*.mjs",
+			"*.cjs"
+		].map((glob) => `--glob ${shellQuote(glob)}`).join(" ");
+		const output = execSync(`rg -l ${shellQuote(String.raw`<[A-Z]`)} ${globArgs} ${dirs.map(shellQuote).join(" ")}`, {
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+		return new Set(output.trim().split("\n").filter(Boolean).map((f) => resolve(f)));
+	} catch (err) {
+		if (err instanceof Error && "status" in err && err.status === 1) return /* @__PURE__ */ new Set();
+		return;
+	}
+}
 /** Scan a single file for cross-file selector usages using AST parsing. */
 function scanFileForSelectorsAst(filePath, source, transformSet, resolver, parser, toRealPath, readFile, cache, failOnParseError) {
 	const hash = cache ? createHash("md5").update(source).digest("hex") : void 0;
@@ -1123,7 +1039,8 @@ function scanFileForSelectorsAst(filePath, source, transformSet, resolver, parse
 		if (!imp || imp.source === "styled-components") continue;
 		const resolvedPath = resolver.resolve(filePath, imp.source);
 		if (!resolvedPath) continue;
-		const realResolved = toRealPath(resolvedPath);
+		const initialResolved = toRealPath(resolvedPath);
+		const realResolved = toRealPath(resolveBarrelReExport(initialResolved, imp.importedName, (specifier, fromFile) => resolver.resolve(fromFile, specifier) ?? null, readFile) ?? initialResolved);
 		if (realResolved === filePath) continue;
 		const usage = {
 			localName,