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

package/dist/{compute-leaf-set-Drcu2eju.mjs → compute-leaf-set-Be5Cgxnr.mjs}

@@ -1,4 +1,4 @@
-import { i as resolveBarrelReExport, r as findImportSource } from "./extract-external-interface-CdHbvfxu.mjs";
+import { o as resolveBarrelReExportBinding, r as findImportSource } from "./extract-external-interface-B61N1a6q.mjs";
 //#region src/internal/prepass/compute-leaf-set.ts
 /**
 * Computes which styled-component bindings are "leaves" for leaves-only mode:
@@ -171,9 +171,12 @@ function computeGlobalLeafKeys(args) {
 		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);
+		const reExport = resolveBarrelReExportBinding(initialDefFile, importInfo.isDefault ? "default" : importInfo.exportedName, resolve, cachedRead);
+		const defFile = reExport?.filePath ?? initialDefFile;
+		const exportedName = reExport?.exportedName ?? importInfo.exportedName;
+		const defReal = toRealPath(defFile);
 		if (!transformSet.has(defReal)) return false;
-		return leafKeyExists(defReal, importInfo.exportedName, importInfo.isDefault, cachedRead, globalLeaves);
+		return leafKeyExists(defReal, exportedName, exportedName === "default" || importInfo.isDefault, cachedRead, globalLeaves);
 	};
 	const tryResolveAdapterIntrinsic = (file, ident) => {
 		if (!resolveBaseComponent) return false;

package/dist/{extract-external-interface-CdHbvfxu.mjs → extract-external-interface-B61N1a6q.mjs}

@@ -292,6 +292,9 @@ function getImportSourceRes(localName) {
 	return cached;
 }
 function resolveBarrelReExport(filePath, name, resolve, read) {
+	return resolveBarrelReExportBinding(filePath, name, resolve, read)?.filePath ?? null;
+}
+function resolveBarrelReExportBinding(filePath, name, resolve, read) {
 	const basename = path.basename(filePath);
 	if (basename !== "index.ts" && basename !== "index.tsx") return null;
 	let src;
@@ -300,14 +303,25 @@ function resolveBarrelReExport(filePath, name, resolve, read) {
 	} catch {
 		return null;
 	}
-	const namedMatch = src.match(getBarrelExportRe(name));
-	if (namedMatch?.[1]) return resolve(namedMatch[1], filePath);
+	for (const match of src.matchAll(/export\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g)) {
+		const sourceName = getReExportedSourceName(match[1] ?? "", name);
+		const specifier = match[2];
+		if (!sourceName || !specifier) continue;
+		const resolved = resolve(specifier, filePath);
+		if (resolved) return {
+			filePath: resolved,
+			exportedName: sourceName
+		};
+	}
 	for (const match of src.matchAll(/export\s*\*\s*from\s*["']([^"']+)["']/g)) {
 		const specifier = match[1];
 		if (!specifier) continue;
 		const resolved = resolve(specifier, filePath);
 		if (resolved) try {
-			if (fileExports(read(resolved), name)) return resolved;
+			if (fileExports(read(resolved), name)) return {
+				filePath: resolved,
+				exportedName: name
+			};
 		} catch {}
 	}
 	return null;
@@ -315,6 +329,16 @@ function resolveBarrelReExport(filePath, name, resolve, read) {
 function fileExports(src, name) {
 	return getFileExportsRe(name).test(src);
 }
+function getReExportedSourceName(specifiers, exportedName) {
+	for (const raw of specifiers.split(",")) {
+		const parts = raw.trim().split(/\s+as\s+/);
+		const local = parts[0]?.trim();
+		const exported = (parts[1] ?? parts[0])?.trim();
+		if (!local || !exported) continue;
+		if (exported === exportedName) return local;
+	}
+	return null;
+}
 const fileExportsReCache = /* @__PURE__ */ new Map();
 function getFileExportsRe(name) {
 	let re = fileExportsReCache.get(name);
@@ -324,16 +348,7 @@ function getFileExportsRe(name) {
 	}
 	return re;
 }
-const barrelExportReCache = /* @__PURE__ */ new Map();
-function getBarrelExportRe(name) {
-	let re = barrelExportReCache.get(name);
-	if (!re) {
-		re = new RegExp(String.raw`export\s*\{[^}]*\b${name}\b[^}]*\}\s*from\s*["']([^"']+)["']`);
-		barrelExportReCache.set(name, re);
-	}
-	return re;
-}
-function fileImportsFrom(usageSrc, usageFile, name, defFile, resolve) {
+function fileImportsFrom(usageSrc, usageFile, name, defFile, resolve, read) {
 	const [namedRe, defaultRe] = getFileImportsFromRes(name);
 	namedRe.lastIndex = 0;
 	defaultRe.lastIndex = 0;
@@ -343,11 +358,17 @@ function fileImportsFrom(usageSrc, usageFile, name, defFile, resolve) {
 		const specifier = match[1];
 		if (!specifier) continue;
 		const resolved = resolve(specifier, usageFile);
-		if (resolved && path.resolve(resolved) === path.resolve(defFile)) return true;
+		if (resolved && importCanReferenceDefinition(resolved, name, defFile, resolve, read)) return true;
 		if (specifier.endsWith(stem) || specifier.endsWith(`${parent}/${stem}`) || specifier.endsWith(parent)) return true;
 	}
 	return false;
 }
+function importCanReferenceDefinition(resolvedImport, name, defFile, resolve, read) {
+	if (path.resolve(resolvedImport) === path.resolve(defFile)) return true;
+	if (!read) return false;
+	const reExportedFile = resolveBarrelReExport(resolvedImport, name, resolve, read);
+	return reExportedFile !== null && path.resolve(reExportedFile) === path.resolve(defFile);
+}
 const fileImportsFromReCache = /* @__PURE__ */ new Map();
 function getFileImportsFromRes(name) {
 	let cached = fileImportsFromReCache.get(name);
@@ -358,4 +379,4 @@ function getFileImportsFromRes(name) {
 	return cached;
 }
 //#endregion
-export { Logger as a, resolveBarrelReExport as i, fileImportsFrom as n, findImportSource as r, fileExports as t };
+export { resolveBarrelReExport as a, getReExportedSourceName as i, fileImportsFrom as n, resolveBarrelReExportBinding as o, findImportSource as r, Logger as s, fileExports 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-DJpFQ5xm.mjs";
+import { a as CollectedWarning, c as MarkerFileContext, l as defineAdapter, n as TransformMode, o as AdapterInput, s as ImportSource } from "./transform-types-Bl-oPkjl.mjs";
 
 //#region src/run.d.ts
 interface RunTransformOptions {

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { o as assertValidAdapterInput, r as defineAdapter, s as describeValue, t as mergeMarkerDeclarations } from "./merge-markers-BC5YNB7D.mjs";
-import { a as Logger, i as resolveBarrelReExport } from "./extract-external-interface-CdHbvfxu.mjs";
-import { r as extractStyledDefBasesFromSource } from "./compute-leaf-set-Drcu2eju.mjs";
+import { a as defineAdapter, c as assertValidAdapterInput, l as describeValue, r as mergeMarkerDeclarations, t as detectExportedComponentSxProp } from "./wrapped-component-interface-yvZ-_HMO.mjs";
+import { a as resolveBarrelReExport, s as Logger } from "./extract-external-interface-B61N1a6q.mjs";
+import { r as extractStyledDefBasesFromSource } from "./compute-leaf-set-Be5Cgxnr.mjs";
 import { n as toRealPath } from "./path-utils-BIpoL4Ue.mjs";
 import jscodeshift from "jscodeshift";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -146,10 +146,10 @@ async function runTransform(options) {
 		`Pattern(s): ${consumerPatterns.join(", ")}`,
 		"Check that the glob pattern is correct and files exist."
 	].join("\n"));
-	const { createModuleResolver } = await import("./resolve-imports-BlxKezSJ.mjs").then((n) => n.n);
+	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-qEr_Mc3y.mjs");
+	const { runPrepass } = await import("./run-prepass-J4t6jkCI.mjs");
 	const absoluteFiles = filePaths.map((f) => resolve(f));
 	const absoluteConsumers = consumerFilePaths.map((f) => resolve(f));
 	let prepassResult;
@@ -180,6 +180,7 @@ async function runTransform(options) {
 		};
 	}
 	const transformedFiles = /* @__PURE__ */ new Set();
+	const transformedFileSources = /* @__PURE__ */ new Map();
 	const crossFilePrepassResult = {
 		...prepassResult.crossFileInfo,
 		transformedFiles
@@ -243,12 +244,16 @@ async function runTransform(options) {
 					if (!resolvedImport) return;
 					const resolvedPath = toRealPath(resolvedImport);
 					const definitionSourcePath = resolveExistingSourcePath(resolveBarrelReExport(resolvedPath, ctx.importedName, prepassResolve, cachedRead) ?? resolvedPath);
-					if (!transformedFiles.has(toRealPath(definitionSourcePath))) return;
 					const autoInterfaceNames = 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 definitionSource = cachedRead(definitionSourcePath);
-					if (!(definitionSource.includes("sx?: stylex.StyleXStyles") && sourceComponentNames.some((name) => definitionSource.includes(name))) && !sourceComponentNames.some((name) => styledDefinitionNames.has(name))) return;
+					if (sourceComponentNames.some((name) => detectExportedComponentSxProp({
+						absolutePath: definitionSourcePath,
+						componentName: name,
+						sourceOverrides: transformedFileSources
+					}))) return { acceptsSx: true };
+					if (!transformedFiles.has(toRealPath(definitionSourcePath))) return;
+					if (!sourceComponentNames.some((name) => styledDefinitionNames.has(name))) return;
 					return autoInterfaceNames.map((name) => lookupAutoExternalInterface(definitionSourcePath, name)).find((result) => result !== void 0)?.styles ? { acceptsSx: true } : void 0;
 				}
 			};
@@ -297,7 +302,7 @@ async function runTransform(options) {
 		sidecarFiles,
 		bridgeResults,
 		transformedFiles,
-		transformedFileSources: /* @__PURE__ */ new Map(),
+		transformedFileSources,
 		transientPropRenames,
 		allowPartialMigration: options.allowPartialMigration ?? (leavesOnly ? true : false),
 		transformMode: leavesOnly ? "leavesOnly" : options.transformMode ?? "all",

package/dist/{resolve-imports-BlxKezSJ.mjs → resolve-imports-DgSAddIF.mjs}

@@ -1,3 +1,4 @@
+import "node:module";
 import { ResolverFactory } from "oxc-resolver";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;

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

@@ -1,5 +1,5 @@
-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 { a as resolveBarrelReExport, n as fileImportsFrom, o as resolveBarrelReExportBinding, r as findImportSource, s as Logger, t as fileExports } from "./extract-external-interface-B61N1a6q.mjs";
+import { n as extractStyledDefBasesFromAstProgram, r as extractStyledDefBasesFromSource, t as computeGlobalLeafKeys } from "./compute-leaf-set-Be5Cgxnr.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";
@@ -229,6 +229,10 @@ function buildImportMapFromNodes(importNodes) {
 				source: sourceValue,
 				importedName: "default"
 			});
+			else if (spec.type === "ImportNamespaceSpecifier") map.set(localName, {
+				source: sourceValue,
+				importedName: "*"
+			});
 			else if (spec.type === "ImportSpecifier") {
 				const importedName = getNodeName(spec.imported) ?? localName;
 				map.set(localName, {
@@ -533,14 +537,19 @@ async function runPrepass(options) {
 			const rgHits = createExternalInterface ? rgClassNameStyleFilter(uniqueAllFiles) : void 0;
 			const jsxHits = rgJsxComponentFilter(uniqueAllFiles);
 			const scanAndRecord = (filePath, source) => {
-				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);
+				const jsxScan = scanConsumerJsxUsages(filePath, source, allStyledNames, parser);
+				if (createExternalInterface) for (const result of jsxScan.propResults) {
+					const usage = {
+						filePath,
+						importSource: result.importSource
+					};
+					if (result.className || result.style || result.spreadProps) addConsumerUsage(classNameStyleUsages, result.name, usage);
+					if (result.className) addConsumerUsage(classNameUsages, result.name, usage);
+					if (result.style) addConsumerUsage(styleUsages, result.name, usage);
+					if (result.elementProps) addConsumerUsage(elementPropUsages, result.name, usage);
+					if (result.spreadProps) addConsumerUsage(spreadPropUsages, result.name, usage);
 				}
-				for (const usage of scanConsumerStaticPropUsages(filePath, source, allStyledNames, parser)) {
+				for (const usage of jsxScan.staticPropUsages) {
 					const entries = propUsageCandidates.get(usage.name) ?? [];
 					entries.push(usage);
 					propUsageCandidates.set(usage.name, entries);
@@ -584,7 +593,7 @@ async function runPrepass(options) {
 			}
 			return entry;
 		};
-		const matchUsagesToDefinitions = (usages, field) => {
+		const matchUsageFilesToDefinitions = (usages, field) => {
 			if (usages.size === 0) return;
 			for (const [defFile, names] of styledDefFiles) {
 				const defSrc = cachedRead(defFile);
@@ -596,20 +605,32 @@ async function runPrepass(options) {
 						ensure(defFile, name)[field] = true;
 						continue;
 					}
-					for (const usageFile of usageFiles) if (fileImportsFrom(cachedRead(usageFile), usageFile, name, defFile, resolve$1)) {
+					for (const usageFile of usageFiles) if (fileImportsFrom(cachedRead(usageFile), usageFile, name, defFile, resolve$1, cachedRead)) {
 						ensure(defFile, name)[field] = true;
 						break;
 					}
 				}
 			}
 		};
-		matchUsagesToDefinitions(asUsages, "as");
-		matchUsagesToDefinitions(refUsages, "ref");
-		matchUsagesToDefinitions(classNameStyleUsages, "styles");
-		matchUsagesToDefinitions(classNameUsages, "className");
-		matchUsagesToDefinitions(styleUsages, "style");
-		matchUsagesToDefinitions(elementPropUsages, "elementProps");
-		matchUsagesToDefinitions(spreadPropUsages, "spreadProps");
+		const matchConsumerUsagesToDefinitions = (usages, field) => {
+			if (usages.size === 0) return;
+			for (const [defFile, names] of styledDefFiles) {
+				const defSrc = cachedRead(defFile);
+				for (const name of names) {
+					const usageRefs = usages.get(name);
+					if (!usageRefs) continue;
+					if (!fileExports(defSrc, name)) continue;
+					if (usageRefs.some((usageRef) => consumerUsageReferencesDefinition(usageRef, name, defFile, cachedRead, resolve$1))) ensure(defFile, name)[field] = true;
+				}
+			}
+		};
+		matchUsageFilesToDefinitions(asUsages, "as");
+		matchUsageFilesToDefinitions(refUsages, "ref");
+		matchConsumerUsagesToDefinitions(classNameStyleUsages, "styles");
+		matchConsumerUsagesToDefinitions(classNameUsages, "className");
+		matchConsumerUsagesToDefinitions(styleUsages, "style");
+		matchConsumerUsagesToDefinitions(elementPropUsages, "elementProps");
+		matchConsumerUsagesToDefinitions(spreadPropUsages, "spreadProps");
 		{
 			const seen = /* @__PURE__ */ new Set();
 			for (const { file, name } of styledCallUsages) {
@@ -759,8 +780,27 @@ function importTextMentionsIdentifier(importText, identifier) {
 	}
 	return re.test(importText);
 }
-/** Quick pre-check: does this source mention className or style in a JSX prop context? */
-const CLASSNAME_STYLE_QUICK_RE = /\b(className|style)\s*[={]/;
+function addConsumerUsage(map, name, usage) {
+	const entries = map.get(name) ?? [];
+	if (!entries.some((entry) => entry.filePath === usage.filePath && entry.importSource === usage.importSource)) {
+		entries.push(usage);
+		map.set(name, entries);
+	}
+}
+function consumerUsageReferencesDefinition(usage, name, defFile, cachedRead, resolve) {
+	if (usage.importSource) return importSourceReferencesDefinition(usage.importSource, usage.filePath, name, defFile, resolve, cachedRead);
+	if (usage.filePath === defFile) return true;
+	return fileImportsFrom(cachedRead(usage.filePath), usage.filePath, name, defFile, resolve, cachedRead);
+}
+function importSourceReferencesDefinition(importSource, usageFile, name, defFile, resolve$2, cachedRead) {
+	const resolved = resolve$2(importSource, usageFile);
+	if (!resolved) return false;
+	if (resolve(resolved) === resolve(defFile)) return true;
+	const binding = resolveBarrelReExportBinding(resolved, name, resolve$2, cachedRead);
+	return binding !== null && resolve(binding.filePath) === resolve(defFile);
+}
+/** Quick pre-check: does this source mention JSX that might use external consumer props? */
+const CONSUMER_PROPS_QUICK_RE = /<(?:[A-Z]|[A-Za-z_$][A-Za-z0-9_$]*\.)|\b(className|style)\s*[={]|\{\.\.\./;
 /** Matches `import { Original as Local, ... }` — captures original and local names. */
 const IMPORT_ALIAS_ENTRY_RE = /\b(\w+)\s+as\s+(\w+)/g;
 /**
@@ -783,99 +823,166 @@ function buildLocalToImportedMap(source) {
 /**
 * Scan source for JSX usage of specific components with className, style,
 * element-specific props, or JSX spread.
-* Uses a two-step approach: first quick-checks for className/style keywords,
-* then scans JSX open tags to match component names — avoids building a huge
-* alternation regex when there are hundreds of component names.
-* Handles aliased imports (e.g., `import { Alert as MyAlert }`) by resolving
-* local tag names back to their original exported names.
+* Uses the prepass parser so comments and string literals cannot be mistaken
+* for real JSX consumers.
 */
-function scanConsumerProps(source, componentNames) {
-	if (!CLASSNAME_STYLE_QUICK_RE.test(source)) return [];
-	let aliasMap;
-	const resultMap = /* @__PURE__ */ new Map();
-	for (const m of source.matchAll(/<([A-Z][A-Za-z0-9]*)\b([^<>]*?)(?:\/>|>)/gs)) {
-		const tagName = m[1];
-		const attrText = m[2] ?? "";
-		if (!tagName) continue;
-		let resolvedName;
-		if (componentNames.has(tagName)) resolvedName = tagName;
-		else {
-			aliasMap ??= buildLocalToImportedMap(source);
-			const originalName = aliasMap.get(tagName);
-			if (originalName && componentNames.has(originalName)) resolvedName = originalName;
-		}
-		if (!resolvedName) continue;
-		if (!/\b(?:className|style)\s*[={]/.test(attrText) && !/\{\.\.\./.test(attrText)) continue;
-		let entry = resultMap.get(resolvedName);
-		if (!entry) {
-			entry = {
-				name: resolvedName,
-				className: false,
-				style: false,
-				elementProps: false,
-				spreadProps: false
-			};
-			resultMap.set(resolvedName, entry);
-		}
-		if (/\bclassName\s*[={]/.test(attrText)) entry.className = true;
-		if (/\bstyle\s*[={]/.test(attrText)) entry.style = true;
-		if (/\{\.\.\./.test(attrText)) entry.spreadProps = true;
-		for (const pm of attrText.matchAll(/\b([a-z][a-zA-Z-]*)(?=\s*[={]|\s+[a-z]|\s*$)/gi)) {
-			const propName = pm[1];
-			if (!KNOWN_NON_ELEMENT_PROPS.has(propName) && !propName.startsWith("$")) {
-				entry.elementProps = true;
-				break;
-			}
-		}
-	}
-	return [...resultMap.values()];
-}
-function scanConsumerStaticPropUsages(filePath, source, componentNames, parser) {
-	if (!/<[A-Z]/.test(source)) return [];
+function scanConsumerJsxUsages(filePath, source, componentNames, parser) {
+	if (!CONSUMER_PROPS_QUICK_RE.test(source)) return {
+		propResults: [],
+		staticPropUsages: []
+	};
 	let ast;
 	try {
 		ast = parser.parse(source);
 	} catch {
-		return [];
+		return {
+			propResults: scanConsumerPropsRegexFallback(source, componentNames),
+			staticPropUsages: []
+		};
 	}
 	const importNodes = [];
 	const jsxOpenings = [];
 	walkForImportsAndJsxOpenings(ast.program ?? ast, importNodes, jsxOpenings);
 	const importMap = buildImportMapFromNodes(importNodes);
-	const usages = [];
+	const resultMap = /* @__PURE__ */ new Map();
+	const staticPropUsages = [];
 	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;
+		const resolvedComponent = resolveJsxOpeningComponent(opening.name, importMap, componentNames);
+		if (!resolvedComponent) continue;
+		const openingUsage = readConsumerOpeningUsage(opening);
+		const { externalProps } = openingUsage;
+		if (externalProps.className || externalProps.style || externalProps.spreadProps || externalProps.elementProps) {
+			const key = `${resolvedComponent.name}\0${resolvedComponent.importSource ?? ""}`;
+			let entry = resultMap.get(key);
+			if (!entry) {
+				entry = {
+					name: resolvedComponent.name,
+					importSource: resolvedComponent.importSource,
+					className: false,
+					style: false,
+					elementProps: false,
+					spreadProps: false
+				};
+				resultMap.set(key, entry);
 			}
-			if (attr.type !== "JSXAttribute") continue;
-			const propName = getJsxAttributeName(attr.name);
-			if (!propName || KNOWN_NON_ELEMENT_PROPS.has(propName)) continue;
+			entry.className ||= externalProps.className;
+			entry.style ||= externalProps.style;
+			entry.spreadProps ||= externalProps.spreadProps;
+			entry.elementProps ||= externalProps.elementProps;
+		}
+		staticPropUsages.push({
+			name: resolvedComponent.name,
+			filePath,
+			importSource: resolvedComponent.importSource,
+			usage: openingUsage.staticUsage
+		});
+	}
+	return {
+		propResults: [...resultMap.values()],
+		staticPropUsages
+	};
+}
+function resolveJsxOpeningComponent(name, importMap, componentNames) {
+	const localName = getJsxOpeningIdentifierName(name);
+	if (localName) {
+		if (componentNames.has(localName)) return { name: localName };
+		const importEntry = importMap.get(localName);
+		return importEntry && componentNames.has(importEntry.importedName) ? {
+			name: importEntry.importedName,
+			importSource: importEntry.source
+		} : void 0;
+	}
+	const member = getJsxMemberNameParts(name);
+	if (!member || !componentNames.has(member.propertyName)) return;
+	const importEntry = importMap.get(member.objectName);
+	return importEntry?.importedName === "*" ? {
+		name: member.propertyName,
+		importSource: importEntry.source
+	} : void 0;
+}
+function readConsumerOpeningUsage(opening) {
+	const externalProps = {
+		className: false,
+		style: false,
+		elementProps: false,
+		spreadProps: false
+	};
+	const props = {};
+	let hasSpread = false;
+	for (const attr of opening.attributes ?? []) {
+		if (!attr) continue;
+		if (attr.type === "JSXSpreadAttribute") {
+			externalProps.spreadProps = true;
+			hasSpread = true;
+			continue;
+		}
+		if (attr.type !== "JSXAttribute") continue;
+		const propName = getJsxAttributeName(attr.name);
+		if (!propName) continue;
+		if (propName === "className") externalProps.className = true;
+		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);
 			props[propName] = value === void 0 ? { kind: "unknown" } : {
 				kind: "static",
 				value
 			};
 		}
-		usages.push({
-			name: resolvedName,
-			filePath,
-			usage: {
-				props,
-				hasSpread
+	}
+	return {
+		externalProps,
+		staticUsage: {
+			props,
+			hasSpread
+		}
+	};
+}
+function isElementConsumerProp(propName) {
+	return !KNOWN_NON_ELEMENT_PROPS.has(propName) && !propName.startsWith("$");
+}
+function scanConsumerPropsRegexFallback(source, componentNames) {
+	const resultMap = /* @__PURE__ */ new Map();
+	let aliasMap;
+	for (const match of source.matchAll(/<([A-Z][A-Za-z0-9]*)\b([^<>]*?)(?:\/>|>)/gs)) {
+		const tagName = match[1];
+		const attrText = match[2] ?? "";
+		if (!tagName) continue;
+		const resolvedName = componentNames.has(tagName) ? tagName : (() => {
+			aliasMap ??= buildLocalToImportedMap(source);
+			const originalName = aliasMap.get(tagName);
+			return originalName && componentNames.has(originalName) ? originalName : void 0;
+		})();
+		if (!resolvedName) continue;
+		const className = /\bclassName\s*[={]/.test(attrText);
+		const style = /\bstyle\s*[={]/.test(attrText);
+		const spreadProps = /\{\.\.\./.test(attrText);
+		let elementProps = false;
+		for (const propMatch of attrText.matchAll(/\b([a-z][a-zA-Z-]*)(?=\s*[={]|\s+[a-z]|\s*$)/gi)) {
+			const propName = propMatch[1];
+			if (isElementConsumerProp(propName)) {
+				elementProps = true;
+				break;
 			}
-		});
+		}
+		if (!className && !style && !spreadProps && !elementProps) continue;
+		let entry = resultMap.get(resolvedName);
+		if (!entry) {
+			entry = {
+				name: resolvedName,
+				className: false,
+				style: false,
+				elementProps: false,
+				spreadProps: false
+			};
+			resultMap.set(resolvedName, entry);
+		}
+		entry.className ||= className;
+		entry.style ||= style;
+		entry.spreadProps ||= spreadProps;
+		entry.elementProps ||= elementProps;
 	}
-	return usages;
+	return [...resultMap.values()];
 }
 function buildPropUsageByFile(args) {
 	const { styledDefFiles, propUsageCandidates, cachedRead, resolve, toRealPath } = args;
@@ -886,8 +993,7 @@ function buildPropUsageByFile(args) {
 			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;
+				if (!consumerUsageReferencesDefinition(candidate, name, defFile, cachedRead, resolve)) continue;
 				mergeComponentPropUsage(getOrCreateComponentPropUsage(getOrCreatePropUsageFileMap(propUsageByFile, toRealPath(defFile)), name), candidate.usage);
 			}
 		}
@@ -917,10 +1023,7 @@ function walkForImportsAndJsxOpenings(node, imports, jsxOpenings) {
 		imports.push(n);
 		return;
 	}
-	if (n.type === "JSXOpeningElement") {
-		jsxOpenings.push(n);
-		return;
-	}
+	if (n.type === "JSXOpeningElement") jsxOpenings.push(n);
 	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];
@@ -933,6 +1036,16 @@ function getJsxOpeningIdentifierName(name) {
 	if (name.type === "JSXIdentifier" && typeof name.name === "string") return name.name;
 	return null;
 }
+function getJsxMemberNameParts(name) {
+	if (!name || name.type !== "JSXMemberExpression") return null;
+	const object = name.object;
+	const property = name.property;
+	if (object?.type !== "JSXIdentifier" || typeof object.name !== "string" || property?.type !== "JSXIdentifier" || typeof property.name !== "string") return null;
+	return {
+		objectName: object.name,
+		propertyName: property.name
+	};
+}
 function getJsxAttributeName(name) {
 	if (!name) return null;
 	if (name.type === "JSXIdentifier" && typeof name.name === "string") return name.name;
@@ -967,7 +1080,7 @@ function rgClassNameStyleFilter(files) {
 		return;
 	}
 }
-/** Use ripgrep to find files with PascalCase JSX tags. */
+/** Use ripgrep to find files with PascalCase or namespace JSX tags. */
 function rgJsxComponentFilter(files) {
 	const dirs = deduplicateParentDirs(files);
 	if (dirs.length === 0) return;
@@ -982,7 +1095,7 @@ function rgJsxComponentFilter(files) {
 			"*.mjs",
 			"*.cjs"
 		].map((glob) => `--glob ${shellQuote(glob)}`).join(" ");
-		const output = execSync(`rg -l ${shellQuote(String.raw`<[A-Z]`)} ${globArgs} ${dirs.map(shellQuote).join(" ")}`, {
+		const output = execSync(`rg -l ${shellQuote(String.raw`<([A-Z]|[A-Za-z_$][A-Za-z0-9_$]*\.)`)} ${globArgs} ${dirs.map(shellQuote).join(" ")}`, {
 			encoding: "utf-8",
 			maxBuffer: 10 * 1024 * 1024
 		});