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

package/dist/prop-usage-SADzZJdX.mjs

@@ -0,0 +1,600 @@
+import { n as createPrepassParser } from "./ast-walk-BOXS-DT7.mjs";
+import { n as isTemplatePlaceholderInSelectorContext, r as PLACEHOLDER_RE } from "./selector-context-heuristic-LVizWWOR.mjs";
+import { resolve } from "node:path";
+import "node:fs";
+//#region src/internal/utilities/collection-utils.ts
+/** Add a value to a Set stored in a Map, creating the Set if it doesn't exist. */
+function addToSetMap(map, key, value) {
+	let set = map.get(key);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		map.set(key, set);
+	}
+	set.add(value);
+}
+//#endregion
+//#region src/internal/prepass/scan-cross-file-selectors.ts
+/**
+* Pre-filter: matches any bare `${Identifier}` template expression.
+* Used to skip files that only contain arrow functions or member expressions
+* in template literals (e.g. `${props => ...}`, `${theme.color}`).
+*/
+const BARE_TEMPLATE_IDENTIFIER_RE = /\$\{\s*[a-zA-Z_$][\w$]*\s*\}/;
+/**
+* Categorize cross-file selector usages into marker sidecar and global selector bridge maps.
+*
+* Bridge usages (from already-converted files) are skipped — the consumer handles marker
+* generation via the forward selector handler, so no sidecar/bridge is needed on the target.
+*/
+function categorizeSelectorUsages(usages, componentsNeedingMarkerSidecar, componentsNeedingGlobalSelectorBridge) {
+	for (const usage of usages) {
+		if (usage.bridgeComponentName) continue;
+		if (usage.consumerIsTransformed) addToSetMap(componentsNeedingMarkerSidecar, usage.resolvedPath, usage.importedName);
+		addToSetMap(componentsNeedingGlobalSelectorBridge, usage.resolvedPath, usage.importedName);
+	}
+}
+/**
+* Regex matching bridge GlobalSelector export patterns (global for matchAll).
+* Matches both:
+*   - Old format: `export const XGlobalSelector = ".sc2sx-..."`
+*   - New format: `` export const XGlobalSelector = `.${xBridgeClass}` ``
+*/
+const BRIDGE_EXPORT_RE = /export\s+const\s+(\w+GlobalSelector)\s*=\s*(?:["']\.sc2sx-|`\.\$\{)/g;
+/**
+* Detect whether an imported name is a bridge GlobalSelector from an
+* already-converted StyleX file.
+*
+* Detection criteria (hybrid fast + safe):
+* 1. Variable name ends with "GlobalSelector" AND the stripped name starts uppercase
+* 2. Target file contains "@stylexjs/stylex" (string check, no parse)
+* 3. Target file has a matching `export const XGlobalSelector = ".sc2sx-"` pattern
+*
+* @returns The stripped component name (e.g., "CollapseArrowIcon" for
+*   "CollapseArrowIconGlobalSelector"), or null if not a bridge.
+*/
+function detectBridgeGlobalSelector(importedName, resolvedPath, readFile) {
+	if (!importedName.endsWith("GlobalSelector")) return null;
+	const stripped = importedName.slice(0, -14);
+	if (!stripped || !/^[A-Z]/.test(stripped)) return null;
+	const content = readFile(resolvedPath);
+	if (!content || !content.includes("@stylexjs/stylex")) return null;
+	let found = false;
+	for (const m of content.matchAll(BRIDGE_EXPORT_RE)) if (m[1] === importedName) {
+		found = true;
+		break;
+	}
+	if (!found) return null;
+	return stripped;
+}
+/**
+* If `importedName` is a bridge GlobalSelector, populate bridge fields on `usage`
+* and find the corresponding component import from the same source.
+*/
+function applyBridgeFields(usage, importedName, localName, resolvedPath, importMap, readFile) {
+	const bridgeName = detectBridgeGlobalSelector(importedName, resolvedPath, readFile);
+	if (!bridgeName) return;
+	usage.bridgeComponentName = bridgeName;
+	const imp = importMap.get(localName);
+	if (!imp) return;
+	let defaultImportLocal;
+	for (const [otherLocal, otherImp] of importMap) {
+		if (otherImp.source !== imp.source || otherLocal === localName) continue;
+		if (otherImp.importedName === bridgeName) {
+			usage.bridgeComponentLocalName = otherLocal;
+			defaultImportLocal = void 0;
+			break;
+		}
+		if (otherImp.importedName === "default" && defaultImportLocal === void 0) defaultImportLocal = otherLocal;
+	}
+	if (defaultImportLocal !== void 0) usage.bridgeComponentLocalName = defaultImportLocal;
+}
+/** Global version for matchAll/replace operations */
+const PLACEHOLDER_RE_G = new RegExp(PLACEHOLDER_RE.source, "g");
+/**
+* Walk the AST collecting ImportDeclaration and TaggedTemplateExpression nodes.
+*
+* Uses a targeted recursive walk — only descends into node types that can
+* contain these targets (skips type annotations, comments, etc.).
+*/
+function walkForImportsAndTemplates(node, imports, templates) {
+	if (!node || typeof node !== "object") return;
+	const n = node;
+	if (n.type === "ImportDeclaration") {
+		imports.push(n);
+		return;
+	}
+	if (n.type === "TaggedTemplateExpression") templates.push(n);
+	for (const key of Object.keys(n)) {
+		if (key === "type" || key === "start" || key === "end" || key === "loc") continue;
+		const val = n[key];
+		if (Array.isArray(val)) for (const child of val) walkForImportsAndTemplates(child, imports, templates);
+		else if (val && typeof val === "object" && val.type) walkForImportsAndTemplates(val, imports, templates);
+	}
+}
+/** Build a map of localName → import info from raw ImportDeclaration nodes. */
+function buildImportMapFromNodes(importNodes) {
+	const map = /* @__PURE__ */ new Map();
+	for (const node of importNodes) {
+		const sourceValue = node.source?.value;
+		if (typeof sourceValue !== "string") continue;
+		const specifiers = node.specifiers;
+		if (!specifiers) continue;
+		for (const spec of specifiers) {
+			const localName = getNodeName(spec.local);
+			if (!localName) continue;
+			if (spec.type === "ImportDefaultSpecifier") map.set(localName, {
+				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, {
+					source: sourceValue,
+					importedName
+				});
+			}
+		}
+	}
+	return map;
+}
+/**
+* Local identifiers that refer to `styled` from `"styled-components"` (default and/or
+* `import { styled }` / `import { styled as sc }`).
+*/
+function collectStyledLocalBindingNames(importNodes) {
+	const names = /* @__PURE__ */ new Set();
+	for (const node of importNodes) {
+		if (node.source?.value !== "styled-components") continue;
+		const specifiers = node.specifiers;
+		if (!specifiers) continue;
+		for (const spec of specifiers) if (spec.type === "ImportDefaultSpecifier") {
+			const name = getNodeName(spec.local);
+			if (name) names.add(name);
+		} else if (spec.type === "ImportSpecifier") {
+			if (getNodeName(spec.imported) === "styled") {
+				const localName = getNodeName(spec.local);
+				if (localName) names.add(localName);
+			}
+		}
+	}
+	return names;
+}
+/** Find the local name for the styled-components default import. */
+function findStyledImportNameFromNodes(importNodes) {
+	let namedStyledLocal;
+	for (const node of importNodes) {
+		if (node.source?.value !== "styled-components") continue;
+		const specifiers = node.specifiers;
+		if (!specifiers) continue;
+		for (const spec of specifiers) if (spec.type === "ImportDefaultSpecifier") {
+			const name = getNodeName(spec.local);
+			if (name) return name;
+		} else if (spec.type === "ImportSpecifier") {
+			if (getNodeName(spec.imported) === "styled") {
+				const localName = getNodeName(spec.local);
+				if (localName) namedStyledLocal = localName;
+			}
+		}
+	}
+	return namedStyledLocal;
+}
+/**
+* Find local names of `css` imported from styled-components.
+* Handles aliased imports like `import { css as sc } from "styled-components"`.
+*/
+function findCssImportNamesFromNodes(importNodes) {
+	const names = /* @__PURE__ */ new Set();
+	for (const node of importNodes) {
+		if (node.source?.value !== "styled-components") continue;
+		const specifiers = node.specifiers;
+		if (!specifiers) continue;
+		for (const spec of specifiers) if (spec.type === "ImportSpecifier") {
+			if (getNodeName(spec.imported) === "css") {
+				const localName = getNodeName(spec.local);
+				if (localName) names.add(localName);
+			}
+		}
+	}
+	return names;
+}
+/**
+* Find local names of imported components used as selectors inside
+* styled-components template literals (both `styled` and `css` tagged templates).
+*/
+function findComponentSelectorLocalsFromNodes(templateNodes, styledImportName, cssImportNames) {
+	const selectorLocals = /* @__PURE__ */ new Set();
+	for (const node of templateNodes) {
+		if (!isStyledTag(node.tag, styledImportName) && !isCssTag(node.tag, cssImportNames)) continue;
+		const quasi = node.quasi;
+		if (!quasi) continue;
+		const quasis = quasi.quasis;
+		const expressions = quasi.expressions;
+		if (!quasis || !expressions) continue;
+		const rawParts = [];
+		for (let i = 0; i < quasis.length; i++) {
+			const value = quasis[i]?.value;
+			rawParts.push(value?.raw ?? "");
+			if (i < expressions.length) rawParts.push(`__SC_EXPR_${i}__`);
+		}
+		const rawCss = rawParts.join("");
+		for (const match of rawCss.matchAll(PLACEHOLDER_RE_G)) {
+			const exprIndex = Number(match[1]);
+			const pos = match.index;
+			if (isTemplatePlaceholderInSelectorContext(rawCss, pos, match[0].length)) {
+				const expr = expressions[exprIndex];
+				if (expr?.type === "Identifier" && typeof expr.name === "string") selectorLocals.add(expr.name);
+			}
+		}
+	}
+	return selectorLocals;
+}
+/**
+* Check whether a styled-components tag expression is a styled call.
+* Matches: styled.div, styled(X), styled.div.attrs(...), styled(X).withConfig(...), etc.
+*/
+function isStyledTag(tag, styledName) {
+	if (!tag || typeof tag !== "object") return false;
+	if (tag.type === "MemberExpression") {
+		const obj = tag.object;
+		if (obj?.type === "Identifier" && obj.name === styledName) return true;
+	}
+	if (tag.type === "CallExpression") {
+		const callee = tag.callee;
+		if (callee?.type === "Identifier" && callee.name === styledName) return true;
+		if (callee?.type === "MemberExpression" && callee.object) return isStyledTag(callee.object, styledName);
+	}
+	return false;
+}
+/** Check if a template tag is the `css` helper from styled-components. */
+function isCssTag(tag, cssImportNames) {
+	if (!tag || !cssImportNames || cssImportNames.size === 0) return false;
+	return tag.type === "Identifier" && typeof tag.name === "string" && cssImportNames.has(tag.name);
+}
+/** Safely extract the name string from an AST identifier-like node. */
+function getNodeName(node) {
+	if (!node || typeof node !== "object") return;
+	if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+}
+/** Deduplicate and resolve two file lists into a single array of absolute paths. */
+function deduplicateAndResolve(filesToTransform, consumerPaths) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const f of filesToTransform) {
+		const abs = resolve(f);
+		if (!seen.has(abs)) {
+			seen.add(abs);
+			result.push(abs);
+		}
+	}
+	for (const f of consumerPaths) {
+		const abs = resolve(f);
+		if (!seen.has(abs)) {
+			seen.add(abs);
+			result.push(abs);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/internal/prepass/stylex-component-exports.ts
+/**
+* Prepass helpers for identifying exported components that already apply StyleX.
+* Core concepts: StyleX import bindings, export names, and local binding traces.
+*/
+function collectStylexExportNames(source) {
+	const parsed = parseProgram(source);
+	if (!parsed) return /* @__PURE__ */ new Set();
+	const stylexUsage = collectStylexUsage(parsed);
+	if (!stylexUsage.hasStylexSurface) return /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	for (const stmt of programBody(parsed)) {
+		collectStylexNamedExports(parsed, stmt, stylexUsage, names);
+		collectStylexDefaultExport(parsed, stmt, stylexUsage, names);
+	}
+	return names;
+}
+function parseProgram(source) {
+	for (const parserName of ["tsx", "babel"]) try {
+		const ast = createPrepassParser(parserName).parse(source);
+		return ast.program ?? ast;
+	} catch {}
+	return null;
+}
+function collectStylexNamedExports(program, stmt, stylexUsage, names) {
+	if (stmt.type !== "ExportNamedDeclaration") return;
+	const declaration = stmt.declaration;
+	for (const localName of declarationLocalNames(declaration)) if (localBindingUsesStylex(program, localName, stylexUsage)) names.add(localName);
+	for (const specifier of astArray(stmt.specifiers)) {
+		if (specifier.type !== "ExportSpecifier") continue;
+		const exportedName = nodeName(specifier.exported);
+		const localName = nodeName(specifier.local);
+		if (exportedName && localName && localBindingUsesStylex(program, localName, stylexUsage)) names.add(exportedName);
+	}
+}
+function declarationLocalNames(declaration) {
+	if (!declaration) return [];
+	if (declaration.type === "VariableDeclaration") return astArray(declaration.declarations).flatMap((declarator) => {
+		const localName = nodeName(declarator.id);
+		return localName ? [localName] : [];
+	});
+	const localName = nodeName(declaration.id);
+	return localName ? [localName] : [];
+}
+function collectStylexDefaultExport(program, stmt, stylexUsage, names) {
+	if (stmt.type !== "ExportDefaultDeclaration") return;
+	const declaration = stmt.declaration;
+	const localName = nodeName(declaration?.id) ?? nodeName(declaration);
+	if (localName ? localBindingUsesStylex(program, localName, stylexUsage) || nodeUsesStylex(declaration, stylexUsage) : nodeUsesStylex(declaration, stylexUsage) || (declaration ? referencedLocalNames(program, declaration).some((referencedName) => localBindingUsesStylex(program, referencedName, stylexUsage)) : false)) names.add("default");
+}
+function collectStylexUsage(program) {
+	const namespaceNames = /* @__PURE__ */ new Set();
+	const createNames = /* @__PURE__ */ new Set();
+	const propsNames = /* @__PURE__ */ new Set();
+	const styleObjectNames = /* @__PURE__ */ new Set();
+	for (const stmt of programBody(program)) {
+		if (stmt.type !== "ImportDeclaration") continue;
+		const importSource = stmt.source?.value;
+		if (typeof importSource !== "string") continue;
+		for (const specifier of astArray(stmt.specifiers)) {
+			const localName = nodeName(specifier.local);
+			if (!localName) continue;
+			if (importSource.includes(".stylex")) {
+				styleObjectNames.add(localName);
+				continue;
+			}
+			if (importSource !== "@stylexjs/stylex") continue;
+			if (specifier.type === "ImportNamespaceSpecifier") {
+				namespaceNames.add(localName);
+				continue;
+			}
+			if (specifier.type === "ImportSpecifier") {
+				const importedName = nodeName(specifier.imported);
+				if (importedName === "create") createNames.add(localName);
+				else if (importedName === "props") propsNames.add(localName);
+			}
+		}
+	}
+	for (const binding of localBindings(program)) if (nodeIsStylexCreateCall(binding.node, namespaceNames, createNames)) styleObjectNames.add(binding.name);
+	return {
+		namespaceNames,
+		propsNames,
+		styleObjectNames,
+		hasStylexSurface: namespaceNames.size > 0 || propsNames.size > 0 || createNames.size > 0 || styleObjectNames.size > 0
+	};
+}
+function localBindingUsesStylex(program, localName, stylexUsage, checkedNames = /* @__PURE__ */ new Set()) {
+	if (checkedNames.has(localName)) return false;
+	checkedNames.add(localName);
+	const node = findLocalBindingNode(program, localName);
+	if (!node) return false;
+	if (nodeUsesStylex(node, stylexUsage)) return true;
+	return referencedLocalNames(program, node).some((referencedName) => localBindingUsesStylex(program, referencedName, stylexUsage, checkedNames));
+}
+function nodeUsesStylex(node, stylexUsage) {
+	if (!node) return false;
+	let found = false;
+	walkValueAst(node, (candidate) => {
+		found ||= candidateUsesStylex(candidate, stylexUsage);
+	});
+	return found;
+}
+function candidateUsesStylex(candidate, stylexUsage) {
+	return nodeIsStylexPropsCall(candidate, stylexUsage.namespaceNames, stylexUsage.propsNames) || nodeIsMergedSxCall(candidate, stylexUsage.styleObjectNames) || isStylexSxAttribute(candidate, stylexUsage.styleObjectNames);
+}
+function findLocalBindingNode(program, localName) {
+	for (const binding of localBindings(program)) if (binding.name === localName) return binding.node;
+}
+function localBindings(program) {
+	const bindings = [];
+	for (const stmt of programBody(program)) {
+		const declaration = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+		if (!declaration) continue;
+		const directBinding = localBindingFromDeclaration(declaration);
+		if (directBinding) {
+			bindings.push(directBinding);
+			continue;
+		}
+		if (declaration.type === "VariableDeclaration") for (const declarator of astArray(declaration.declarations)) {
+			const name = nodeName(declarator.id);
+			const init = declarator.init;
+			if (name && init) bindings.push({
+				name,
+				node: init
+			});
+		}
+	}
+	return bindings;
+}
+function localBindingFromDeclaration(declaration) {
+	if (declaration.type !== "FunctionDeclaration" && declaration.type !== "ClassDeclaration") return null;
+	const name = nodeName(declaration.id);
+	const body = declaration.body;
+	return name && body ? {
+		name,
+		node: body
+	} : null;
+}
+function referencedLocalNames(program, node) {
+	const localNameSet = new Set(localBindings(program).map((binding) => binding.name));
+	const referenced = /* @__PURE__ */ new Set();
+	walkValueAst(node, (candidate) => {
+		if (candidate.type !== "Identifier" && candidate.type !== "JSXIdentifier") return;
+		const name = candidate.name;
+		if (typeof name === "string" && localNameSet.has(name)) referenced.add(name);
+	});
+	return [...referenced];
+}
+function nodeIsStylexCreateCall(node, namespaceNames, createNames) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee?.type === "Identifier") return typeof callee.name === "string" && createNames.has(callee.name);
+	return isStylexMemberCall(callee, namespaceNames, "create");
+}
+function nodeIsStylexPropsCall(node, namespaceNames, propsNames) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee?.type === "Identifier") return typeof callee.name === "string" && propsNames.has(callee.name);
+	return isStylexMemberCall(callee, namespaceNames, "props");
+}
+function nodeIsMergedSxCall(node, styleObjectNames) {
+	if (styleObjectNames.size === 0 || node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee?.type !== "Identifier" || callee.name !== "mergedSx") return false;
+	return astArray(node.arguments).some((arg) => nodeReferencesLocalNames(arg, styleObjectNames));
+}
+function isStylexMemberCall(callee, namespaceNames, propertyName) {
+	if (callee?.type !== "MemberExpression") return false;
+	const objectName = nodeName(callee.object);
+	const property = callee.property;
+	const actualPropertyName = callee.computed === true ? void 0 : nodeName(property);
+	return !!objectName && namespaceNames.has(objectName) && actualPropertyName === propertyName;
+}
+function isStylexSxAttribute(node, styleObjectNames) {
+	if (styleObjectNames.size === 0 || node.type !== "JSXAttribute") return false;
+	if (nodeName(node.name) !== "sx") return false;
+	const value = node.value;
+	if (!value) return false;
+	return nodeReferencesLocalNames(value.type === "JSXExpressionContainer" ? value.expression : value, styleObjectNames);
+}
+function nodeReferencesLocalNames(node, localNames) {
+	if (!node) return false;
+	let found = false;
+	walkValueAst(node, (candidate) => {
+		if (!found && isNamedReference(candidate, localNames)) found = true;
+	});
+	return found;
+}
+function walkValueAst(root, visitor) {
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const child of node) visit(child);
+			return;
+		}
+		const astNode = node;
+		visitor(astNode);
+		for (const key of Object.keys(astNode)) {
+			if (shouldSkipChild(astNode, key)) continue;
+			const child = astNode[key];
+			if (child && typeof child === "object") visit(child);
+		}
+	};
+	visit(root);
+}
+function shouldSkipChild(node, key) {
+	if ([
+		"loc",
+		"comments",
+		"leadingComments",
+		"trailingComments"
+	].includes(key)) return true;
+	if ([
+		"typeAnnotation",
+		"typeParameters",
+		"returnType"
+	].includes(key)) return true;
+	if (key === "key" && (node.type === "ObjectProperty" || node.type === "Property") && node.computed !== true) return true;
+	if (key === "property" && node.type === "MemberExpression" && node.computed !== true) return true;
+	return false;
+}
+function isNamedReference(node, localNames) {
+	if (node.type === "Identifier" || node.type === "JSXIdentifier") return typeof node.name === "string" && localNames.has(node.name);
+	return false;
+}
+function programBody(program) {
+	return astArray(program.body);
+}
+function astArray(value) {
+	return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function isAstNode(value) {
+	return Boolean(value && typeof value === "object");
+}
+function nodeName(node) {
+	if (!node) return;
+	if (node.type === "Identifier" || node.type === "JSXIdentifier" || node.type === "StringLiteral") return typeof node.name === "string" ? node.name : typeof node.value === "string" ? node.value : void 0;
+}
+//#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);
+	}
+}
+/**
+* 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 { walkForImportsAndTemplates as _, mergeComponentPropUsage as a, BARE_TEMPLATE_IDENTIFIER_RE as c, categorizeSelectorUsages as d, collectStyledLocalBindingNames as f, findStyledImportNameFromNodes as g, findCssImportNamesFromNodes as h, getExhaustiveObservedStaticValues as i, applyBridgeFields as l, findComponentSelectorLocalsFromNodes as m, createComponentPropUsageInfo as n, readStaticJsxLiteral as o, deduplicateAndResolve as p, formatObservedVariantCondition as r, collectStylexExportNames as s, KNOWN_NON_ELEMENT_PROPS as t, buildImportMapFromNodes as u, addToSetMap as v };