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

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

@@ -5,6 +5,7 @@ import { readFileSync } from "node:fs";
 * Logger and warning types for transform diagnostics.
 * Core concepts: severity classification and source context reporting.
 */
+const CASCADE_CONFLICT_WARNING = "styled(ImportedComponent) wraps a component whose file uses styled-components — convert the base component's file first to avoid CSS cascade conflicts";
 const UNSUPPORTED_SHOULD_FORWARD_PROP_WARNING = "Unsupported shouldForwardProp pattern (only !prop.startsWith(), ![].includes(prop), and prop !== are supported)";
 /**
 * When fileCount <= this threshold, warnings are printed per-file inline and
@@ -134,6 +135,7 @@ function createContextReplacer() {
 		return value;
 	};
 }
+const MAX_DEPENDED_FILE_GROUPS = 15;
 var LoggerReport = class {
 	warnings;
 	fileCount;
@@ -163,6 +165,20 @@ var LoggerReport = class {
 			lines.push("");
 			lines.push(`▸ ${group.message} (${group.warnings.length})`);
 			lines.push("");
+			const dependedFileGroups = this.groupDependedFiles(group);
+			if (dependedFileGroups.length > 0) {
+				lines.push("  Top depended files:");
+				lines.push("");
+				for (const [index, dependedFileGroup] of dependedFileGroups.entries()) {
+					const usageCount = dependedFileGroup.usageFiles.length;
+					const usageLabel = usageCount === 1 ? "usage file" : "usage files";
+					lines.push(`  ${index + 1}. ${dependedFileGroup.dependedFilePath} (${usageCount} ${usageLabel})`);
+					for (const usageFile of dependedFileGroup.usageFiles.slice(0, MAX_EXAMPLES)) lines.push(`     ${usageFile}`);
+					const remainingUsageFiles = usageCount - MAX_EXAMPLES;
+					if (remainingUsageFiles > 0) lines.push(`     ... and ${remainingUsageFiles} more usage file(s)`);
+					lines.push("");
+				}
+			}
 			const seenFiles = /* @__PURE__ */ new Set();
 			const uniqueLocations = [];
 			for (const loc of group.warnings) if (!seenFiles.has(loc.filePath)) {
@@ -212,6 +228,21 @@ var LoggerReport = class {
 		}
 		return Array.from(groupMap.values()).sort((a, b) => b.warnings.length - a.warnings.length);
 	}
+	groupDependedFiles(group) {
+		if (group.message !== "styled(ImportedComponent) wraps a component whose file uses styled-components — convert the base component's file first to avoid CSS cascade conflicts") return [];
+		const groupMap = /* @__PURE__ */ new Map();
+		for (const warning of group.warnings) {
+			const dependedFilePath = getCascadeDependedFilePath(warning);
+			if (!dependedFilePath) continue;
+			const dependedFileWarnings = groupMap.get(dependedFilePath) ?? [];
+			dependedFileWarnings.push(warning);
+			groupMap.set(dependedFilePath, dependedFileWarnings);
+		}
+		return Array.from(groupMap.entries()).map(([dependedFilePath, warnings]) => ({
+			dependedFilePath,
+			usageFiles: uniqueSorted(warnings.map((warning) => warning.filePath))
+		})).sort((a, b) => b.usageFiles.length - a.usageFiles.length).slice(0, MAX_DEPENDED_FILE_GROUPS);
+	}
 	getSnippet(filePath, loc) {
 		if (!loc) return;
 		const lines = this.getFileLines(filePath);
@@ -240,6 +271,18 @@ var LoggerReport = class {
 		}
 	}
 };
+function getCascadeDependedFilePath(warning) {
+	const context = warning.context;
+	if (!context || typeof context !== "object") return;
+	const record = context;
+	const definitionPath = record.definitionPath;
+	if (typeof definitionPath === "string") return definitionPath;
+	const importedPath = record.importedPath;
+	return typeof importedPath === "string" ? importedPath : void 0;
+}
+function uniqueSorted(values) {
+	return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
+}
 const WARN_BG_COLOR = "\x1B[43m";
 const WARN_TEXT_COLOR = "\x1B[30m";
 const ERROR_BG_COLOR = "\x1B[41m";
@@ -380,4 +423,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, CASCADE_CONFLICT_WARNING as c, findImportSource as i, Logger as l, fileExports as n, resolveBarrelReExport as o, fileImportsFrom as r, resolveBarrelReExportBinding as s, walkAst as t, UNSUPPORTED_SHOULD_FORWARD_PROP_WARNING as u };

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 { l as Logger, o as resolveBarrelReExport, t as walkAst } from "./ast-walk-DgShpexa.mjs";
+import { i as extractStyledDefBasesFromSource, t as createPrepassParser } from "./prepass-parser-BRDlW3DI.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-Da3N174M.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
 					};
@@ -339,7 +498,23 @@ async function runTransform(options) {
 				transformedFiles: /* @__PURE__ */ new Set()
 			},
 			silent: true,
-			isolateFiles: true
+			isolateFiles: true,
+			createIsolatedOptions(filePath) {
+				const isolatedTransformedFiles = /* @__PURE__ */ new Set();
+				return {
+					...runnerOptions,
+					dry: true,
+					print: false,
+					sidecarFiles: /* @__PURE__ */ new Map(),
+					bridgeResults: /* @__PURE__ */ new Map(),
+					transformedFiles: isolatedTransformedFiles,
+					transformedFileSources: /* @__PURE__ */ new Map(),
+					transientPropRenames: /* @__PURE__ */ new Map(),
+					crossFilePrepassResult: createStandalonePrepassResult(crossFilePrepassResult, filePath, isolatedTransformedFiles),
+					silent: true,
+					isolateFiles: true
+				};
+			}
 		});
 		standaloneWarnings = Logger.createReport().getWarnings();
 		Logger._clearCollected();
@@ -480,6 +655,46 @@ function readFileForOrdering(filePath) {
 		return "";
 	}
 }
+function createStandalonePrepassResult(prepass, filePath, transformedFiles) {
+	const standaloneFile = toRealPath(resolve(filePath));
+	const selectorUsages = /* @__PURE__ */ new Map();
+	const componentsNeedingMarkerSidecar = /* @__PURE__ */ new Map();
+	const componentsNeedingGlobalSelectorBridge = /* @__PURE__ */ new Map();
+	for (const [consumerPath, usages] of prepass.selectorUsages) {
+		const consumerIsTransformed = toRealPath(consumerPath) === standaloneFile;
+		const isolatedUsages = usages.map((usage) => ({
+			...usage,
+			consumerIsTransformed
+		}));
+		selectorUsages.set(consumerPath, isolatedUsages);
+		for (const usage of isolatedUsages) {
+			if (usage.bridgeComponentName) continue;
+			if (consumerIsTransformed) addSetMapEntry(componentsNeedingMarkerSidecar, usage.resolvedPath, usage.importedName);
+			addSetMapEntry(componentsNeedingGlobalSelectorBridge, usage.resolvedPath, usage.importedName);
+		}
+	}
+	return {
+		...prepass,
+		selectorUsages,
+		componentsNeedingMarkerSidecar,
+		componentsNeedingGlobalSelectorBridge,
+		globalLeafKeys: getStandaloneGlobalLeafKeys(prepass.globalLeafKeys, standaloneFile),
+		transformedFiles
+	};
+}
+function getStandaloneGlobalLeafKeys(globalLeafKeys, standaloneFile) {
+	if (!globalLeafKeys) return;
+	const filePrefix = `${standaloneFile}:`;
+	return new Set([...globalLeafKeys].filter((key) => key.startsWith(filePrefix)));
+}
+function addSetMapEntry(map, key, value) {
+	const values = map.get(key);
+	if (values) {
+		values.add(value);
+		return;
+	}
+	map.set(key, new Set([value]));
+}
 async function runTransformSequentially(transformModule, filePaths, options) {
 	const transform = await loadTransformFunction(transformModule);
 	const aggregate = {
@@ -491,20 +706,25 @@ async function runTransformSequentially(transformModule, filePaths, options) {
 		files: []
 	};
 	const startedAt = performance.now();
-	const j = jscodeshift.withParser(options.parser);
-	const api = {
-		j,
-		jscodeshift: j,
-		stats: () => {},
-		report: (msg) => {
-			if (!options.silent) process.stdout.write(`${msg}\n`);
-		}
+	const createApi = () => {
+		const j = jscodeshift.withParser(options.parser);
+		return {
+			j,
+			jscodeshift: j,
+			stats: () => {},
+			report: (msg) => {
+				if (!options.silent) process.stdout.write(`${msg}\n`);
+			}
+		};
 	};
+	const sharedApi = createApi();
 	for (const filePath of filePaths) {
+		const fileOptions = options.createIsolatedOptions?.(filePath) ?? options;
+		const api = fileOptions.isolateFiles === true ? createApi() : sharedApi;
 		if (options.isolateFiles === true) {
-			options.transformedFiles.clear();
-			options.transformedFileSources.clear();
-			options.crossFilePrepassResult?.transformedFiles?.clear();
+			fileOptions.transformedFiles.clear();
+			fileOptions.transformedFileSources.clear();
+			fileOptions.crossFilePrepassResult?.transformedFiles?.clear();
 		}
 		let source;
 		try {
@@ -522,8 +742,8 @@ async function runTransformSequentially(transformModule, filePaths, options) {
 			const output = await transform({
 				path: filePath,
 				source
-			}, api, options);
-			if (output !== null) options.transformedFileSources.set(toRealPath(filePath), output);
+			}, api, fileOptions);
+			if (output !== null) fileOptions.transformedFileSources.set(toRealPath(filePath), output);
 			if (output === null) {
 				aggregate.skip += 1;
 				aggregate.files.push({
@@ -540,8 +760,8 @@ async function runTransformSequentially(transformModule, filePaths, options) {
 				});
 				continue;
 			}
-			if (options.print) process.stdout.write(`${output}\n`);
-			if (!options.dry) await writeFile(filePath, output, "utf-8");
+			if (fileOptions.print) process.stdout.write(`${output}\n`);
+			if (!fileOptions.dry) await writeFile(filePath, output, "utf-8");
 			aggregate.ok += 1;
 			aggregate.files.push({
 				filePath,

package/dist/{compute-leaf-set-90UrZ9WP.mjs → prepass-parser-BRDlW3DI.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-DgShpexa.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 };