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

package/dist/{bridge-consumer-patcher-BzAIO9pC.mjs → bridge-consumer-patcher-31jI1854.mjs}

@@ -1,5 +1,5 @@
 import { n as toRealPath } from "./path-utils-BIpoL4Ue.mjs";
-import { r as escapeRegex } from "./string-utils-KggM5TNH.mjs";
+import { r as escapeRegex } from "./string-utils-DD9wdRHW.mjs";
 import { t as isSelectorContext } from "./selector-context-heuristic-6_jSRGkZ.mjs";
 import { readFileSync } from "node:fs";
 //#region src/internal/bridge-consumer-patcher.ts
@@ -102,6 +102,7 @@ function patchConsumerFile(filePath, replacements) {
 			return match;
 		});
 	}
+	modified = removeNowUnusedComponentImports(modified, replacements);
 	return modified !== source ? modified : null;
 }
 /** Find the end position of an import statement starting at startIdx (handles multi-line imports). */
@@ -119,5 +120,149 @@ function isInStyledTemplateSelectorContext(source, offset, length) {
 function hasExactImportName(importSpecifiers, name) {
 	return new RegExp(`(?:^|[^A-Za-z0-9_$])${escapeRegex(name)}(?:$|[^A-Za-z0-9_$])`).test(importSpecifiers);
 }
+function removeNowUnusedComponentImports(source, replacements) {
+	let modified = source;
+	for (const replacement of replacements) {
+		if (hasIdentifierUsageOutsideImports(modified, replacement.localName)) continue;
+		modified = removeNamedImportSpecifier(modified, replacement.importSource, replacement.localName);
+	}
+	return modified;
+}
+function hasIdentifierUsageOutsideImports(source, name) {
+	const withoutImports = stripImportDeclarations(stripComments(source));
+	return new RegExp(`(^|[^A-Za-z0-9_$])${escapeRegex(name)}($|[^A-Za-z0-9_$])`).test(withoutImports);
+}
+function stripImportDeclarations(source) {
+	const lines = source.split(/(?<=\n)/);
+	let result = "";
+	let inImport = false;
+	let nestingDepth = 0;
+	for (const line of lines) {
+		if (!inImport && !isImportDeclarationStart(line)) {
+			result += line;
+			continue;
+		}
+		inImport = true;
+		nestingDepth += getImportNestingDelta(line);
+		if (nestingDepth <= 0 && isImportDeclarationEnd(line)) {
+			inImport = false;
+			nestingDepth = 0;
+		}
+	}
+	return result;
+}
+function isImportDeclarationStart(line) {
+	const match = line.match(/^[ \t]*import\b/);
+	if (!match) return false;
+	const next = line.slice(match[0].length).trimStart()[0];
+	return next !== "(" && next !== ".";
+}
+function isImportDeclarationEnd(line) {
+	const trimmed = line.trim();
+	return trimmed.endsWith(";") || /^import\s+["'][^"']+["']$/.test(trimmed) || /\bfrom\s+["'][^"']+["'](?:\s+with\s+\{[^}]*\})?$/.test(trimmed);
+}
+function getImportNestingDelta(line) {
+	let depth = 0;
+	let quote = null;
+	for (let index = 0; index < line.length; index += 1) {
+		const char = line[index];
+		if (quote) {
+			if (char === "\\") index += 1;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "'" || char === "\"") quote = char;
+		else if (char === "{" || char === "(" || char === "[") depth += 1;
+		else if (char === "}" || char === ")" || char === "]") depth -= 1;
+	}
+	return depth;
+}
+function stripComments(source) {
+	let result = "";
+	let state = "normal";
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index] ?? "";
+		const next = source[index + 1] ?? "";
+		if (state === "lineComment") {
+			if (char === "\n") {
+				result += char;
+				state = "normal";
+			} else result += " ";
+			continue;
+		}
+		if (state === "blockComment") {
+			if (char === "*" && next === "/") {
+				result += "  ";
+				index += 1;
+				state = "normal";
+			} else result += char === "\n" ? "\n" : " ";
+			continue;
+		}
+		if (state === "template") {
+			if (char === "/" && next === "/") {
+				result += "  ";
+				index += 1;
+				state = "lineComment";
+				continue;
+			}
+			if (char === "/" && next === "*") {
+				result += "  ";
+				index += 1;
+				state = "blockComment";
+				continue;
+			}
+			result += char;
+			if (char === "\\") {
+				result += next;
+				index += 1;
+				continue;
+			}
+			if (char === "`") state = "normal";
+			continue;
+		}
+		if (state === "singleQuote" || state === "doubleQuote") {
+			result += char;
+			if (char === "\\") {
+				result += next;
+				index += 1;
+				continue;
+			}
+			if (state === "singleQuote" && char === "'" || state === "doubleQuote" && char === "\"") state = "normal";
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			result += "  ";
+			index += 1;
+			state = "lineComment";
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			result += "  ";
+			index += 1;
+			state = "blockComment";
+			continue;
+		}
+		if (char === "'") state = "singleQuote";
+		else if (char === "\"") state = "doubleQuote";
+		else if (char === "`") state = "template";
+		result += char;
+	}
+	return result;
+}
+function removeNamedImportSpecifier(source, importSource, localName) {
+	const namedImportRegex = new RegExp(`import\\s+([\\w$]+\\s*,\\s*)?\\{([^}]*)\\}\\s+from\\s+(['"]${escapeRegex(importSource)}['"]\\s*;?)`, "g");
+	return source.replace(namedImportRegex, (_match, defaultPart, specifierList, fromClause) => {
+		const remainingSpecifiers = String(specifierList).split(",").map((specifier) => specifier.trim()).filter(Boolean).filter((specifier) => getImportedSpecifierLocalName(specifier) !== localName);
+		if (remainingSpecifiers.length > 0) return `import ${defaultPart ?? ""}{ ${remainingSpecifiers.join(", ")} } from ${fromClause}`;
+		const defaultName = String(defaultPart ?? "").replace(/,\s*$/, "").trim();
+		if (defaultName) return `import ${defaultName} from ${fromClause}`;
+		return "";
+	});
+}
+function getImportedSpecifierLocalName(specifier) {
+	const aliasMatch = specifier.match(/\bas\s+([A-Za-z_$][\w$]*)$/);
+	if (aliasMatch?.[1]) return aliasMatch[1];
+	return specifier.trim();
+}
 //#endregion
 export { buildConsumerReplacements, patchConsumerFile };

package/dist/{forwarded-as-consumer-patcher-Cs0X-olz.mjs → forwarded-as-consumer-patcher-BYCrqzRm.mjs}

@@ -1,5 +1,5 @@
 import { n as toRealPath } from "./path-utils-BIpoL4Ue.mjs";
-import { r as escapeRegex } from "./string-utils-KggM5TNH.mjs";
+import { r as escapeRegex } from "./string-utils-DD9wdRHW.mjs";
 import { readFileSync } from "node:fs";
 //#region src/internal/forwarded-as-consumer-patcher.ts
 /**

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--9qCqNSJ.mjs";
+import { a as CollectedWarning, c as MarkerFileContext, l as defineAdapter, n as TransformMode, o as AdapterInput, s as ImportSource } from "./transform-types-DJpFQ5xm.mjs";
 
 //#region src/run.d.ts
 interface RunTransformOptions {

package/dist/index.mjs

@@ -149,7 +149,7 @@ async function runTransform(options) {
 	const { createModuleResolver } = await import("./resolve-imports-BlxKezSJ.mjs").then((n) => n.n);
 	const sharedResolver = createModuleResolver();
 	filePaths = orderFilesByLocalImportDependencies(filePaths, sharedResolver, toRealPath);
-	const { runPrepass } = await import("./run-prepass-Us5SBTib.mjs");
+	const { runPrepass } = await import("./run-prepass-qEr_Mc3y.mjs");
 	const absoluteFiles = filePaths.map((f) => resolve(f));
 	const absoluteConsumers = consumerFilePaths.map((f) => resolve(f));
 	let prepassResult;
@@ -172,6 +172,7 @@ async function runTransform(options) {
 				selectorUsages: /* @__PURE__ */ new Map(),
 				componentsNeedingMarkerSidecar: /* @__PURE__ */ new Map(),
 				componentsNeedingGlobalSelectorBridge: /* @__PURE__ */ new Map(),
+				propUsageByFile: /* @__PURE__ */ new Map(),
 				globalLeafKeys: leavesOnly ? /* @__PURE__ */ new Set() : void 0
 			},
 			consumerAnalysis: void 0,
@@ -308,7 +309,7 @@ async function runTransform(options) {
 	const result = await runTransformSequentially(transformModule, filePaths, runnerOptions);
 	if (sidecarFiles.size > 0 && !dryRun) for (const [sidecarPath, content] of sidecarFiles) await writeFile(sidecarPath, mergeSidecarContent(sidecarPath, content), "utf-8");
 	if (bridgeResults.size > 0 && !dryRun) {
-		const { buildConsumerReplacements, patchConsumerFile } = await import("./bridge-consumer-patcher-BzAIO9pC.mjs");
+		const { buildConsumerReplacements, patchConsumerFile } = await import("./bridge-consumer-patcher-31jI1854.mjs");
 		const consumerReplacements = buildConsumerReplacements(crossFilePrepassResult.selectorUsages, bridgeResults, transformedFiles);
 		const patchedFiles = [];
 		for (const [consumerPath, replacements] of consumerReplacements) {
@@ -321,7 +322,7 @@ async function runTransform(options) {
 		if (formatterCommands && patchedFiles.length > 0) await runFormatters(formatterCommands, patchedFiles);
 	}
 	if (prepassResult.forwardedAsConsumers.size > 0 && !dryRun) {
-		const { buildForwardedAsReplacements, patchConsumerForwardedAs } = await import("./forwarded-as-consumer-patcher-Cs0X-olz.mjs");
+		const { buildForwardedAsReplacements, patchConsumerForwardedAs } = await import("./forwarded-as-consumer-patcher-BYCrqzRm.mjs");
 		const forwardedAsReplacements = buildForwardedAsReplacements(prepassResult.forwardedAsConsumers, transformedFiles);
 		const patchedFiles = [];
 		for (const [consumerPath, entries] of forwardedAsReplacements) {
@@ -334,7 +335,7 @@ async function runTransform(options) {
 		if (formatterCommands && patchedFiles.length > 0) await runFormatters(formatterCommands, patchedFiles);
 	}
 	if (transientPropRenames.size > 0 && !dryRun) {
-		const { collectTransientPropPatches } = await import("./transient-prop-consumer-patcher-DLsKxg1R.mjs");
+		const { collectTransientPropPatches } = await import("./transient-prop-consumer-patcher-DdIYPSFk.mjs");
 		const patches = collectTransientPropPatches({
 			transientPropRenames,
 			consumerFilePaths: consumerFilePaths.map((p) => resolve(p)),

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-Us5SBTib.mjs → run-prepass-qEr_Mc3y.mjs}

@@ -1,7 +1,7 @@
 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-KggM5TNH.mjs";
-import { t as PLACEHOLDER_RE } from "./styled-css-BVR82jN5.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";
@@ -457,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) => {
@@ -491,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,
@@ -523,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;
@@ -640,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();
@@ -657,6 +682,7 @@ async function runPrepass(options) {
 		selectorUsages,
 		componentsNeedingMarkerSidecar,
 		componentsNeedingGlobalSelectorBridge,
+		propUsageByFile,
 		styledDefFiles: createExternalInterface ? styledDefFiles : void 0,
 		globalLeafKeys
 	};
@@ -665,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 {
@@ -751,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.
@@ -811,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
@@ -840,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;

package/dist/{string-utils-KggM5TNH.mjs → string-utils-DD9wdRHW.mjs}

@@ -104,6 +104,21 @@ function isPrettierIgnoreComment(body) {
 	return /^\s*prettier-ignore\s*$/.test(body);
 }
 /**
+* Returns true if a comment body is only a visual marker for a styles section.
+* These markers describe the old styled-components grouping, not emitted StyleX code.
+*/
+function isStyleSectionMarkerComment(body) {
+	const marker = body.trim().replace(/^[-\s]+/, "").replace(/[-\s]+$/, "").trim().toLowerCase();
+	return /^(?:styled\s*-?\s*components?|styles?)$/.test(marker);
+}
+function getCommentBody(comment) {
+	const c = comment && typeof comment === "object" ? comment : {};
+	return typeof c.value === "string" ? c.value : "";
+}
+function isJSDocBlockComment(comment) {
+	return (comment && typeof comment === "object" ? comment : {}).type === "CommentBlock" && getCommentBody(comment).trimStart().startsWith("*");
+}
+/**
 * Normalizes whitespace in a CSS value string.
 * Collapses all sequences of whitespace (including newlines) to single spaces
 * and trims leading/trailing whitespace.
@@ -125,4 +140,4 @@ function hasTopLevelMatch(value, pattern) {
 	return false;
 }
 //#endregion
-export { isPrettierIgnoreComment as a, kebabToCamelCase as c, normalizeWhitespace as d, sanitizeIdentifier as f, isBackgroundImageValue as i, looksLikeLength as l, capitalize as n, isSingleBackgroundComponent as o, escapeRegex as r, isValidIdentifierName as s, camelToKebabCase as t, lowerFirst as u };
+export { isBackgroundImageValue as a, isSingleBackgroundComponent as c, kebabToCamelCase as d, looksLikeLength as f, sanitizeIdentifier as h, getCommentBody as i, isStyleSectionMarkerComment as l, normalizeWhitespace as m, capitalize as n, isJSDocBlockComment as o, lowerFirst as p, escapeRegex as r, isPrettierIgnoreComment as s, camelToKebabCase as t, isValidIdentifierName as u };