@yahoo/uds 3.114.0-beta.2 → 3.114.0

package/dist/tailwind/dist/purger/optimized/utils/componentAnalyzer.cjs

@@ -1,12 +1,9 @@
 /*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
 const require_runtime = require('../../../../../_virtual/_rolldown/runtime.cjs');
 const require_index = require('../../../../../motion-tokens/dist/index.cjs');
-let ts_morph = require("ts-morph");
-let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_runtime.__toESM(node_path);
-let fast_glob = require("fast-glob");
-fast_glob = require_runtime.__toESM(fast_glob);
+let ts_morph = require("ts-morph");
 
 //#region ../tailwind/dist/purger/optimized/utils/componentAnalyzer.js
 /*! © 2026 Yahoo, Inc. UDS Tailwind and Purger v0.0.0-development */
@@ -18,31 +15,27 @@ let knownComponents = null;
 * Map of component name -> file path
 */
 let componentPaths = null;
-let scannedComponentsDir = null;
-const scanComponentFilePaths = async (componentsDir) => (0, fast_glob.default)("**/*.tsx", {
-	cwd: componentsDir,
-	absolute: true
-});
 /**
 * Scan src/components to build a map of all component files
 */
-const scanComponentFiles = async (componentsDir) => {
-	if (componentPaths && scannedComponentsDir === componentsDir) return componentPaths;
+async function scanComponentFiles(componentsDir) {
+	if (componentPaths) return componentPaths;
 	componentPaths = /* @__PURE__ */ new Map();
 	knownComponents = /* @__PURE__ */ new Set();
-	scannedComponentsDir = componentsDir;
-	const nextComponentPaths = componentPaths;
-	const nextKnownComponents = knownComponents;
-	(await scanComponentFilePaths(componentsDir)).forEach((file) => {
-		if (file.includes(".test.") || file.endsWith("index.tsx")) return;
+	const glob = new Bun.Glob("**/*.tsx");
+	for await (const file of glob.scan({
+		cwd: componentsDir,
+		absolute: true
+	})) {
+		if (file.includes(".test.") || file.endsWith("index.tsx")) continue;
 		const fileName = node_path.default.basename(file, ".tsx");
 		if (/^[A-Z]/.test(fileName)) {
-			nextComponentPaths.set(fileName, file);
-			nextKnownComponents.add(fileName);
+			componentPaths.set(fileName, file);
+			knownComponents.add(fileName);
 		}
-	});
-	return nextComponentPaths;
-};
+	}
+	return componentPaths;
+}
 /**
 * Analyze an object literal for variant key mappings.
 * Handles:
@@ -50,64 +43,60 @@ const scanComponentFiles = async (componentsDir) => {
 * - Nullish coalescing: { fontSize: fontSize ?? variant } -> variant maps to fontSize
 * - Conditional spreads: ...(condition ? { props } : {}) -> recursively analyze props
 */
-const analyzeObjectForVariantMappings = (objLiteral, styleProps, getStylesLiterals, propToVariantKeys, sourceFile) => {
-	objLiteral.getProperties().forEach((prop) => {
-		if (ts_morph.Node.isPropertyAssignment(prop)) {
-			analyzeVariantPropertyAssignment(prop, styleProps, getStylesLiterals, propToVariantKeys);
-			return;
+function analyzeObjectForVariantMappings(objLiteral, styleProps, getStylesLiterals, propToVariantKeys, sourceFile) {
+	for (const prop of objLiteral.getProperties()) if (ts_morph.Node.isPropertyAssignment(prop)) {
+		const variantKey = prop.getName();
+		if (variantKey && !styleProps.includes(variantKey)) styleProps.push(variantKey);
+		const initializer = prop.getInitializer();
+		if (initializer && ts_morph.Node.isStringLiteral(initializer)) getStylesLiterals.set(variantKey, initializer.getLiteralValue());
+		if (initializer && ts_morph.Node.isIdentifier(initializer)) {
+			const propName = initializer.getText();
+			const existing = propToVariantKeys.get(propName) ?? [];
+			if (!existing.includes(variantKey)) {
+				existing.push(variantKey);
+				propToVariantKeys.set(propName, existing);
+			}
+		}
+		if (initializer && ts_morph.Node.isBinaryExpression(initializer)) {
+			const operatorToken = initializer.getOperatorToken();
+			if (operatorToken.getKind() === ts_morph.SyntaxKind.QuestionQuestionToken || operatorToken.getKind() === ts_morph.SyntaxKind.BarBarToken) {
+				const rightSide = initializer.getRight();
+				if (ts_morph.Node.isIdentifier(rightSide)) {
+					const fallbackPropName = rightSide.getText();
+					const existing = propToVariantKeys.get(fallbackPropName) ?? [];
+					if (!existing.includes(variantKey)) {
+						existing.push(variantKey);
+						propToVariantKeys.set(fallbackPropName, existing);
+					}
+				}
+			}
 		}
-		if (ts_morph.Node.isSpreadAssignment(prop)) analyzeVariantSpreadAssignment(prop, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
-	});
-};
-const addStyleProp = (styleProps, variantKey) => {
-	if (!styleProps.includes(variantKey)) styleProps.push(variantKey);
-};
-const addPropToVariantKeyMapping = (propToVariantKeys, propName, variantKey) => {
-	const existing = propToVariantKeys.get(propName) ?? [];
-	if (!existing.includes(variantKey)) propToVariantKeys.set(propName, [...existing, variantKey]);
-};
-const extractFallbackIdentifier = (initializer) => {
-	if (!ts_morph.Node.isBinaryExpression(initializer)) return null;
-	const operatorKind = initializer.getOperatorToken().getKind();
-	if (!(operatorKind === ts_morph.SyntaxKind.QuestionQuestionToken || operatorKind === ts_morph.SyntaxKind.BarBarToken) || !ts_morph.Node.isIdentifier(initializer.getRight())) return null;
-	return initializer.getRight().getText();
-};
-const analyzeVariantPropertyAssignment = (prop, styleProps, getStylesLiterals, propToVariantKeys) => {
-	const variantKey = prop.getName();
-	addStyleProp(styleProps, variantKey);
-	const initializer = prop.getInitializer();
-	if (!initializer) return;
-	if (ts_morph.Node.isStringLiteral(initializer)) getStylesLiterals.set(variantKey, initializer.getLiteralValue());
-	if (ts_morph.Node.isIdentifier(initializer)) addPropToVariantKeyMapping(propToVariantKeys, initializer.getText(), variantKey);
-	const fallbackIdentifier = extractFallbackIdentifier(initializer);
-	if (fallbackIdentifier) addPropToVariantKeyMapping(propToVariantKeys, fallbackIdentifier, variantKey);
-};
-const findVariableObjectLiteral = (sourceFile, variableName) => {
-	const initializer = sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.VariableDeclaration).find((candidate) => candidate.getName() === variableName)?.getInitializer();
-	return initializer && ts_morph.Node.isObjectLiteralExpression(initializer) ? initializer : null;
-};
-const analyzeVariantSpreadAssignment = (prop, styleProps, getStylesLiterals, propToVariantKeys, sourceFile) => {
-	const spreadExpr = prop.getExpression();
-	if (ts_morph.Node.isParenthesizedExpression(spreadExpr)) {
-		const conditionalExpr = spreadExpr.getExpression();
-		if (ts_morph.Node.isConditionalExpression(conditionalExpr)) {
-			const whenTrue = conditionalExpr.getWhenTrue();
-			if (!ts_morph.Node.isObjectLiteralExpression(whenTrue)) return;
-			analyzeObjectForVariantMappings(whenTrue, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
+	} else if (ts_morph.Node.isSpreadAssignment(prop)) {
+		const spreadExpr = prop.getExpression();
+		if (ts_morph.Node.isParenthesizedExpression(spreadExpr)) {
+			const inner = spreadExpr.getExpression();
+			if (ts_morph.Node.isConditionalExpression(inner)) {
+				const whenTrue = inner.getWhenTrue();
+				if (ts_morph.Node.isObjectLiteralExpression(whenTrue)) analyzeObjectForVariantMappings(whenTrue, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
+			}
+		}
+		if (ts_morph.Node.isIdentifier(spreadExpr)) {
+			const varName = spreadExpr.getText();
+			const varDecl = sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.VariableDeclaration).find((v) => v.getName() === varName);
+			if (varDecl) {
+				const varInit = varDecl.getInitializer();
+				if (varInit && ts_morph.Node.isObjectLiteralExpression(varInit)) analyzeObjectForVariantMappings(varInit, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
+			}
 		}
 	}
-	if (ts_morph.Node.isIdentifier(spreadExpr)) {
-		const objectLiteral = findVariableObjectLiteral(sourceFile, spreadExpr.getText());
-		if (objectLiteral) analyzeObjectForVariantMappings(objectLiteral, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
-	}
-};
+}
 /**
 * Analyzes a UDS component file to extract:
 * 1. Default prop values (e.g., display = 'flex')
 * 2. Props passed to getStyles()
 * 3. Internal UDS component usage
 */
-const analyzeComponent = (project, componentPath) => {
+function analyzeComponent(project, componentPath) {
 	const sourceFile = project.getSourceFile(componentPath);
 	if (!sourceFile) return null;
 	const componentName = node_path.default.basename(componentPath, ".tsx");
@@ -119,9 +108,98 @@ const analyzeComponent = (project, componentPath) => {
 	const internalComponents = [];
 	const internalComponentProps = /* @__PURE__ */ new Map();
 	const propToVariantKeys = /* @__PURE__ */ new Map();
-	collectComponentDefaultsAndProps(sourceFile, defaultProps, componentPropNames);
-	collectGetStylesMetadata(sourceFile, styleProps, getStylesLiterals, propToVariantKeys);
-	collectCxLiterals(sourceFile, cxLiterals);
+	const functions = [...sourceFile.getFunctions(), ...sourceFile.getVariableDeclarations().filter((v) => {
+		const init = v.getInitializer();
+		return init && (ts_morph.Node.isArrowFunction(init) || ts_morph.Node.isCallExpression(init));
+	})];
+	for (const fn of functions) {
+		if (ts_morph.Node.isVariableDeclaration(fn)) {
+			const init = fn.getInitializer();
+			if (!init) continue;
+			if (ts_morph.Node.isCallExpression(init)) {
+				const args = init.getArguments();
+				for (const arg of args) if (ts_morph.Node.isFunctionExpression(arg) || ts_morph.Node.isArrowFunction(arg)) {
+					extractDefaultsFromFunction(arg, defaultProps);
+					extractAllPropNames(arg, componentPropNames);
+				}
+			}
+			if (ts_morph.Node.isArrowFunction(init)) {
+				extractDefaultsFromFunction(init, defaultProps);
+				extractAllPropNames(init, componentPropNames);
+			}
+		}
+		if (ts_morph.Node.isFunctionDeclaration(fn)) {
+			extractDefaultsFromFunction(fn, defaultProps);
+			extractAllPropNames(fn, componentPropNames);
+		}
+	}
+	const getStylesCalls = sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === "getStyles");
+	for (const call of getStylesCalls) {
+		const args = call.getArguments();
+		if (args.length > 0 && ts_morph.Node.isObjectLiteralExpression(args[0])) {
+			const objLiteral = args[0];
+			for (const prop of objLiteral.getProperties()) if (ts_morph.Node.isPropertyAssignment(prop)) {
+				const variantKey = prop.getName();
+				if (variantKey && !styleProps.includes(variantKey)) styleProps.push(variantKey);
+				const initializer = prop.getInitializer();
+				if (initializer && ts_morph.Node.isStringLiteral(initializer)) getStylesLiterals.set(variantKey, initializer.getLiteralValue());
+				if (initializer && ts_morph.Node.isIdentifier(initializer)) {
+					const propName = initializer.getText();
+					const existing = propToVariantKeys.get(propName) ?? [];
+					if (!existing.includes(variantKey)) {
+						existing.push(variantKey);
+						propToVariantKeys.set(propName, existing);
+					}
+				}
+				if (initializer && ts_morph.Node.isBinaryExpression(initializer)) {
+					const operatorToken = initializer.getOperatorToken();
+					if (operatorToken.getKind() === ts_morph.SyntaxKind.QuestionQuestionToken || operatorToken.getKind() === ts_morph.SyntaxKind.BarBarToken) {
+						const rightSide = initializer.getRight();
+						if (ts_morph.Node.isIdentifier(rightSide)) {
+							const fallbackPropName = rightSide.getText();
+							const existing = propToVariantKeys.get(fallbackPropName) ?? [];
+							if (!existing.includes(variantKey)) {
+								existing.push(variantKey);
+								propToVariantKeys.set(fallbackPropName, existing);
+							}
+						}
+					}
+				}
+				if (initializer && ts_morph.Node.isConditionalExpression(initializer)) {
+					const whenTrue = initializer.getWhenTrue();
+					const whenFalse = initializer.getWhenFalse();
+					const extractLiterals = (node) => {
+						const literals = [];
+						if (ts_morph.Node.isStringLiteral(node)) literals.push(node.getLiteralValue());
+						else if (ts_morph.Node.isConditionalExpression(node)) {
+							literals.push(...extractLiterals(node.getWhenTrue()));
+							literals.push(...extractLiterals(node.getWhenFalse()));
+						}
+						return literals;
+					};
+					[...extractLiterals(whenTrue), ...extractLiterals(whenFalse)].forEach((value, index) => {
+						const literalKey = index === 0 ? variantKey : `${variantKey}:${index}`;
+						getStylesLiterals.set(literalKey, value);
+					});
+				}
+			} else if (ts_morph.Node.isShorthandPropertyAssignment(prop)) {
+				const propName = prop.getName();
+				if (propName && !styleProps.includes(propName)) styleProps.push(propName);
+			} else if (ts_morph.Node.isSpreadAssignment(prop)) {
+				const spreadExpr = prop.getExpression();
+				if (ts_morph.Node.isIdentifier(spreadExpr)) {
+					const varName = spreadExpr.getText();
+					const varDecl = sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.VariableDeclaration).find((v) => v.getName() === varName);
+					if (varDecl) {
+						const varInit = varDecl.getInitializer();
+						if (varInit && ts_morph.Node.isObjectLiteralExpression(varInit)) analyzeObjectForVariantMappings(varInit, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
+					}
+				}
+			}
+		}
+	}
+	const cxCalls = sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === "cx");
+	for (const call of cxCalls) for (const arg of call.getArguments()) extractCxStringLiterals(arg, cxLiterals);
 	extractInternalComponents(sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentPropNames);
 	return {
 		name: componentName,
@@ -135,194 +213,96 @@ const analyzeComponent = (project, componentPath) => {
 		propToVariantKeys,
 		motionVarPrefixes: extractMotionVarPrefixes(sourceFile)
 	};
-};
-const getComponentFunctionNodes = (sourceFile) => [...sourceFile.getFunctions(), ...sourceFile.getVariableDeclarations().filter((declaration) => {
-	const initializer = declaration.getInitializer();
-	return initializer && (ts_morph.Node.isArrowFunction(initializer) || ts_morph.Node.isCallExpression(initializer));
-})];
-const collectComponentDefaultsAndProps = (sourceFile, defaultProps, componentPropNames) => {
-	getComponentFunctionNodes(sourceFile).forEach((fn) => {
-		if (ts_morph.Node.isFunctionDeclaration(fn)) {
-			extractDefaultsFromFunction(fn, defaultProps);
-			extractAllPropNames(fn, componentPropNames);
-			return;
-		}
-		if (!ts_morph.Node.isVariableDeclaration(fn)) return;
-		const initializer = fn.getInitializer();
-		if (!initializer) return;
-		if (ts_morph.Node.isCallExpression(initializer)) initializer.getArguments().forEach((arg) => {
-			if (ts_morph.Node.isFunctionExpression(arg) || ts_morph.Node.isArrowFunction(arg)) {
-				extractDefaultsFromFunction(arg, defaultProps);
-				extractAllPropNames(arg, componentPropNames);
-			}
-		});
-		if (ts_morph.Node.isArrowFunction(initializer)) {
-			extractDefaultsFromFunction(initializer, defaultProps);
-			extractAllPropNames(initializer, componentPropNames);
-		}
-	});
-};
-const extractConditionalStringLiterals = (node) => {
-	if (ts_morph.Node.isStringLiteral(node)) return [node.getLiteralValue()];
-	if (ts_morph.Node.isConditionalExpression(node)) return [...extractConditionalStringLiterals(node.getWhenTrue()), ...extractConditionalStringLiterals(node.getWhenFalse())];
-	return [];
-};
-const storeVariantLiteralValues = (variantKey, literalValues, getStylesLiterals) => {
-	literalValues.forEach((value, index) => {
-		const literalKey = index === 0 ? variantKey : `${variantKey}:${index}`;
-		getStylesLiterals.set(literalKey, value);
-	});
-};
-const handleGetStylesPropertyAssignment = (prop, styleProps, getStylesLiterals, propToVariantKeys) => {
-	const variantKey = prop.getName();
-	addStyleProp(styleProps, variantKey);
-	const initializer = prop.getInitializer();
-	if (!initializer) return;
-	if (ts_morph.Node.isStringLiteral(initializer)) getStylesLiterals.set(variantKey, initializer.getLiteralValue());
-	if (ts_morph.Node.isIdentifier(initializer)) addPropToVariantKeyMapping(propToVariantKeys, initializer.getText(), variantKey);
-	const fallbackIdentifier = extractFallbackIdentifier(initializer);
-	if (fallbackIdentifier) addPropToVariantKeyMapping(propToVariantKeys, fallbackIdentifier, variantKey);
-	if (ts_morph.Node.isConditionalExpression(initializer)) storeVariantLiteralValues(variantKey, [...extractConditionalStringLiterals(initializer.getWhenTrue()), ...extractConditionalStringLiterals(initializer.getWhenFalse())], getStylesLiterals);
-};
-const handleGetStylesObjectProperty = (prop, styleProps, getStylesLiterals, propToVariantKeys, sourceFile) => {
-	if (ts_morph.Node.isPropertyAssignment(prop)) {
-		handleGetStylesPropertyAssignment(prop, styleProps, getStylesLiterals, propToVariantKeys);
-		return;
-	}
-	if (ts_morph.Node.isShorthandPropertyAssignment(prop)) {
-		addStyleProp(styleProps, prop.getName());
-		return;
-	}
-	if (ts_morph.Node.isSpreadAssignment(prop) && ts_morph.Node.isIdentifier(prop.getExpression())) {
-		const objectLiteral = findVariableObjectLiteral(sourceFile, prop.getExpression().getText());
-		if (objectLiteral) analyzeObjectForVariantMappings(objectLiteral, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
-	}
-};
-const collectGetStylesMetadata = (sourceFile, styleProps, getStylesLiterals, propToVariantKeys) => {
-	sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === "getStyles").forEach((call) => {
-		const args = call.getArguments();
-		if (args.length === 0 || !ts_morph.Node.isObjectLiteralExpression(args[0])) return;
-		args[0].getProperties().forEach((prop) => {
-			handleGetStylesObjectProperty(prop, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
-		});
-	});
-};
-const collectCxLiterals = (sourceFile, cxLiterals) => {
-	sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === "cx").forEach((call) => {
-		call.getArguments().forEach((arg) => extractCxStringLiterals(arg, cxLiterals));
-	});
-};
+}
 /**
 * Extract UDS components used internally in the file and their prop values.
 * Also detects prop aliasing (e.g., columnGap={gap} means gap -> columnGap).
 */
-const extractInternalComponents = (sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentProps) => {
-	collectImportedInternalComponents(sourceFile, internalComponents);
-	collectInternalComponentUsages(sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentProps);
-};
-const isInternalUdsModule = (moduleSpec) => {
-	return (moduleSpec.startsWith("@yahoo/uds") || moduleSpec.startsWith("../") || moduleSpec.startsWith("./")) && (moduleSpec.includes("/components/") || moduleSpec === "@yahoo/uds");
-};
-const pushUniqueComponentName = (components, name) => {
-	if (/^[A-Z]/.test(name) && !components.includes(name)) components.push(name);
-};
-const collectImportedInternalComponents = (sourceFile, internalComponents) => {
-	sourceFile.getImportDeclarations().forEach((importDecl) => {
-		if (!isInternalUdsModule(importDecl.getModuleSpecifierValue())) return;
-		importDecl.getNamedImports().forEach((namedImport) => pushUniqueComponentName(internalComponents, namedImport.getName()));
-	});
-};
-const getOrCreateComponentPropsMap = (internalComponentProps, componentName) => {
-	const existing = internalComponentProps.get(componentName);
-	if (existing) return existing;
-	const created = /* @__PURE__ */ new Map();
-	internalComponentProps.set(componentName, created);
-	return created;
-};
-const extractJsxAttributeLiteralValues = (attr, componentProps, propToVariantKeys) => {
-	if (!ts_morph.Node.isJsxAttribute(attr)) return null;
-	const propName = attr.getNameNode().getText();
-	const initializer = attr.getInitializer();
-	if (!initializer) return {
-		propName,
-		values: []
-	};
-	if (ts_morph.Node.isStringLiteral(initializer)) return {
-		propName,
-		values: [initializer.getLiteralValue()]
-	};
-	if (!ts_morph.Node.isJsxExpression(initializer)) return {
-		propName,
-		values: []
-	};
-	const expr = initializer.getExpression();
-	if (expr && ts_morph.Node.isStringLiteral(expr)) return {
-		propName,
-		values: [expr.getLiteralValue()]
-	};
-	if (expr && ts_morph.Node.isIdentifier(expr)) {
-		const identifierName = expr.getText();
-		if (componentProps.has(identifierName) && identifierName !== propName) addPropToVariantKeyMapping(propToVariantKeys, identifierName, propName);
+function extractInternalComponents(sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentProps) {
+	for (const importDecl of sourceFile.getImportDeclarations()) {
+		const moduleSpec = importDecl.getModuleSpecifierValue();
+		if (moduleSpec.startsWith("@yahoo/uds") || moduleSpec.startsWith("../") || moduleSpec.startsWith("./")) {
+			if (moduleSpec.includes("/components/") || moduleSpec === "@yahoo/uds") for (const namedImport of importDecl.getNamedImports()) {
+				const name = namedImport.getName();
+				if (/^[A-Z]/.test(name) && !internalComponents.includes(name)) internalComponents.push(name);
+			}
+		}
 	}
-	return {
-		propName,
-		values: []
-	};
-};
-const collectInternalComponentUsages = (sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentProps) => {
-	[...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxOpeningElement)].forEach((element) => {
+	const jsxElements = [...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxOpeningElement)];
+	for (const element of jsxElements) {
 		const tagName = element.getTagNameNode().getText();
-		if (!/^[A-Z]/.test(tagName)) return;
-		pushUniqueComponentName(internalComponents, tagName);
-		element.getAttributes().forEach((attr) => {
-			const extracted = extractJsxAttributeLiteralValues(attr, componentProps, propToVariantKeys);
-			if (!extracted || extracted.values.length === 0) return;
-			const componentPropsMap = getOrCreateComponentPropsMap(internalComponentProps, tagName);
-			const existingValues = componentPropsMap.get(extracted.propName) ?? [];
-			const mergedValues = [...new Set([...existingValues, ...extracted.values])];
-			componentPropsMap.set(extracted.propName, mergedValues);
-		});
-	});
-};
+		if (!/^[A-Z]/.test(tagName)) continue;
+		if (!internalComponents.includes(tagName)) internalComponents.push(tagName);
+		const attrs = element.getAttributes();
+		for (const attr of attrs) if (ts_morph.Node.isJsxAttribute(attr)) {
+			const propName = attr.getNameNode().getText();
+			const initializer = attr.getInitializer();
+			let values = [];
+			if (initializer) {
+				if (ts_morph.Node.isStringLiteral(initializer)) values = [initializer.getLiteralValue()];
+				else if (ts_morph.Node.isJsxExpression(initializer)) {
+					const expr = initializer.getExpression();
+					if (expr && ts_morph.Node.isStringLiteral(expr)) values = [expr.getLiteralValue()];
+					else if (expr && ts_morph.Node.isIdentifier(expr)) {
+						const identifierName = expr.getText();
+						if (componentProps.has(identifierName) && identifierName !== propName) {
+							const existing = propToVariantKeys.get(identifierName) ?? [];
+							if (!existing.includes(propName)) {
+								existing.push(propName);
+								propToVariantKeys.set(identifierName, existing);
+							}
+						}
+					}
+				}
+			}
+			if (values.length > 0) {
+				let componentPropsMap = internalComponentProps.get(tagName);
+				if (!componentPropsMap) {
+					componentPropsMap = /* @__PURE__ */ new Map();
+					internalComponentProps.set(tagName, componentPropsMap);
+				}
+				const existingValues = componentPropsMap.get(propName) ?? [];
+				for (const v of values) if (!existingValues.includes(v)) existingValues.push(v);
+				componentPropsMap.set(propName, existingValues);
+			}
+		}
+	}
+}
 /**
 * Extract default prop values from a function's parameter destructuring
 */
-const extractDefaultsFromFunction = (fn, defaults) => {
+function extractDefaultsFromFunction(fn, defaults) {
 	let params = [];
 	if (ts_morph.Node.isFunctionDeclaration(fn) || ts_morph.Node.isFunctionExpression(fn)) params = fn.getParameters();
 	else if (ts_morph.Node.isArrowFunction(fn)) params = fn.getParameters();
-	params.forEach((param) => {
-		if (!ts_morph.Node.isParameterDeclaration(param)) return;
+	for (const param of params) {
+		if (!ts_morph.Node.isParameterDeclaration(param)) continue;
 		const nameNode = param.getNameNode();
-		if (!nameNode || !ts_morph.Node.isObjectBindingPattern(nameNode)) return;
-		nameNode.getElements().forEach((element) => {
+		if (!nameNode || !ts_morph.Node.isObjectBindingPattern(nameNode)) continue;
+		for (const element of nameNode.getElements()) {
 			const propName = element.getPropertyNameNode()?.getText() || element.getName();
 			const initializer = element.getInitializer();
 			if (initializer && ts_morph.Node.isStringLiteral(initializer)) defaults.set(propName, initializer.getLiteralValue());
-			else if (initializer && ts_morph.Node.isIdentifier(initializer)) {
-				const resolved = resolveIdentifierToStringLiteral(initializer);
-				if (resolved) defaults.set(propName, resolved);
-			}
-		});
-	});
-};
+		}
+	}
+}
 /**
 * Extract ALL prop names from a function's parameter destructuring (not just defaults)
 */
-const extractAllPropNames = (fn, propNames) => {
+function extractAllPropNames(fn, propNames) {
 	let params = [];
 	if (ts_morph.Node.isFunctionDeclaration(fn) || ts_morph.Node.isFunctionExpression(fn)) params = fn.getParameters();
 	else if (ts_morph.Node.isArrowFunction(fn)) params = fn.getParameters();
-	params.forEach((param) => {
-		if (!ts_morph.Node.isParameterDeclaration(param)) return;
+	for (const param of params) {
+		if (!ts_morph.Node.isParameterDeclaration(param)) continue;
 		const nameNode = param.getNameNode();
-		if (!nameNode || !ts_morph.Node.isObjectBindingPattern(nameNode)) return;
-		nameNode.getElements().forEach((element) => {
+		if (!nameNode || !ts_morph.Node.isObjectBindingPattern(nameNode)) continue;
+		for (const element of nameNode.getElements()) {
 			const propName = element.getPropertyNameNode()?.getText() || element.getName();
 			propNames.add(propName);
-		});
-	});
-};
+		}
+	}
+}
 /**
 * Extract string literals from cx() call arguments.
 * Handles:
@@ -330,25 +310,22 @@ const extractAllPropNames = (fn, propNames) => {
 * - Object keys: cx({ 'class1': condition, 'class2': true })
 * - Nested calls and arrays
 */
-const extractCxStringLiterals = (node, literals) => {
-	if (ts_morph.Node.isStringLiteral(node)) node.getLiteralValue().split(/\s+/).filter(Boolean).forEach((cls) => {
-		if (!literals.includes(cls)) literals.push(cls);
-	});
-	else if (ts_morph.Node.isObjectLiteralExpression(node)) node.getProperties().forEach((prop) => {
-		if (ts_morph.Node.isPropertyAssignment(prop)) {
+function extractCxStringLiterals(node, literals) {
+	if (ts_morph.Node.isStringLiteral(node)) {
+		const classes = node.getLiteralValue().split(/\s+/).filter(Boolean);
+		for (const cls of classes) if (!literals.includes(cls)) literals.push(cls);
+	} else if (ts_morph.Node.isObjectLiteralExpression(node)) {
+		for (const prop of node.getProperties()) if (ts_morph.Node.isPropertyAssignment(prop)) {
 			const nameNode = prop.getNameNode();
-			if (ts_morph.Node.isStringLiteral(nameNode)) nameNode.getLiteralValue().split(/\s+/).filter(Boolean).forEach((cls) => {
-				if (!literals.includes(cls)) literals.push(cls);
-			});
-			else if (ts_morph.Node.isIdentifier(nameNode)) {
+			if (ts_morph.Node.isStringLiteral(nameNode)) {
+				const classes = nameNode.getLiteralValue().split(/\s+/).filter(Boolean);
+				for (const cls of classes) if (!literals.includes(cls)) literals.push(cls);
+			} else if (ts_morph.Node.isIdentifier(nameNode)) {
 				const cls = nameNode.getText();
 				if (!literals.includes(cls)) literals.push(cls);
 			}
 		}
-	});
-	else if (ts_morph.Node.isArrayLiteralExpression(node)) node.getElements().forEach((element) => {
-		extractCxStringLiterals(element, literals);
-	});
+	} else if (ts_morph.Node.isArrayLiteralExpression(node)) for (const element of node.getElements()) extractCxStringLiterals(element, literals);
 	else if (ts_morph.Node.isConditionalExpression(node)) {
 		extractCxStringLiterals(node.getWhenTrue(), literals);
 		extractCxStringLiterals(node.getWhenFalse(), literals);
@@ -356,54 +333,59 @@ const extractCxStringLiterals = (node, literals) => {
 		extractCxStringLiterals(node.getLeft(), literals);
 		extractCxStringLiterals(node.getRight(), literals);
 	}
-};
+}
 /**
 * Try to resolve an identifier to its initializer value (for const declarations)
 */
-const resolveIdentifierToObject = (sourceFile, identifier) => {
-	const decl = sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.VariableDeclaration).find((candidate) => candidate.getName() === identifier);
-	if (!decl) return null;
-	let initializer = decl.getInitializer();
-	if (!initializer) return null;
-	if (ts_morph.Node.isAsExpression(initializer)) initializer = initializer.getExpression();
-	if (!ts_morph.Node.isObjectLiteralExpression(initializer)) return null;
-	const result = {};
-	initializer.getProperties().forEach((prop) => {
-		if (!ts_morph.Node.isPropertyAssignment(prop)) return;
-		const propName = prop.getName();
-		const propInit = prop.getInitializer();
-		if (propInit && ts_morph.Node.isStringLiteral(propInit)) result[propName] = propInit.getLiteralValue();
-	});
-	return result;
-};
+function resolveIdentifierToObject(sourceFile, identifier) {
+	const varDecls = sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.VariableDeclaration);
+	for (const decl of varDecls) {
+		if (decl.getName() !== identifier) continue;
+		let initializer = decl.getInitializer();
+		if (!initializer) continue;
+		if (ts_morph.Node.isAsExpression(initializer)) initializer = initializer.getExpression();
+		if (!ts_morph.Node.isObjectLiteralExpression(initializer)) continue;
+		const result = {};
+		for (const prop of initializer.getProperties()) {
+			if (!ts_morph.Node.isPropertyAssignment(prop)) continue;
+			const propName = prop.getName();
+			const propInit = prop.getInitializer();
+			if (propInit && ts_morph.Node.isStringLiteral(propInit)) result[propName] = propInit.getLiteralValue();
+		}
+		return result;
+	}
+	return null;
+}
 /**
 * Extract motion CSS variable prefixes from SpringMotionConfig usage.
 * Returns prefixes like ['--uds-motion-bouncy-4-', '--uds-motion-smooth-3-']
 */
-const extractMotionVarPrefixes = (sourceFile) => {
+function extractMotionVarPrefixes(sourceFile) {
 	const prefixes = [];
-	[...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxOpeningElement)].forEach((element) => {
-		if (element.getTagNameNode().getText() !== "SpringMotionConfig") return;
+	const jsxElements = [...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxOpeningElement)];
+	for (const element of jsxElements) {
+		if (element.getTagNameNode().getText() !== "SpringMotionConfig") continue;
 		const props = {
 			layoutVariant: null,
 			layoutSpeed: null,
 			colorVariant: null,
 			colorSpeed: null
 		};
-		element.getAttributes().forEach((attr) => {
+		const attrs = element.getAttributes();
+		for (const attr of attrs) {
 			if (ts_morph.Node.isJsxSpreadAttribute(attr)) {
 				const expr = attr.getExpression();
 				if (ts_morph.Node.isIdentifier(expr)) {
 					const spreadObj = resolveIdentifierToObject(sourceFile, expr.getText());
-					if (spreadObj) Object.keys(props).forEach((key) => {
-						if (key in spreadObj) props[key] = spreadObj[key];
-					});
+					if (spreadObj) {
+						for (const key of Object.keys(props)) if (key in spreadObj) props[key] = spreadObj[key];
+					}
 				}
-				return;
+				continue;
 			}
-			if (!ts_morph.Node.isJsxAttribute(attr)) return;
+			if (!ts_morph.Node.isJsxAttribute(attr)) continue;
 			const propName = attr.getNameNode().getText();
-			if (!(propName in props)) return;
+			if (!(propName in props)) continue;
 			const initializer = attr.getInitializer();
 			if (initializer) {
 				if (ts_morph.Node.isStringLiteral(initializer)) props[propName] = initializer.getLiteralValue();
@@ -412,64 +394,14 @@ const extractMotionVarPrefixes = (sourceFile) => {
 					if (expr && ts_morph.Node.isStringLiteral(expr)) props[propName] = expr.getLiteralValue();
 				}
 			}
-		});
+		}
 		const layoutPrefix = `--uds-motion-${props.layoutVariant ?? require_index.SPRING_MOTION_DEFAULTS.layoutVariant}-${props.layoutSpeed ?? require_index.SPRING_MOTION_DEFAULTS.layoutSpeed}-`;
 		if (!prefixes.includes(layoutPrefix)) prefixes.push(layoutPrefix);
 		const colorPrefix = `--uds-motion-${props.colorVariant ?? require_index.SPRING_MOTION_DEFAULTS.colorVariant}-${props.colorSpeed ?? require_index.SPRING_MOTION_DEFAULTS.colorSpeed}-`;
 		if (!prefixes.includes(colorPrefix)) prefixes.push(colorPrefix);
-	});
+	}
 	return prefixes;
-};
-const resolveIdentifierToStringLiteral = (identifier) => {
-	if (!ts_morph.Node.isIdentifier(identifier)) return null;
-	const symbol = identifier.getSymbol();
-	if (!symbol) return resolveImportedIdentifier(identifier);
-	const resolvedDeclarationValue = symbol.getDeclarations().reduce((resolved, declaration) => {
-		if (resolved) return resolved;
-		if (ts_morph.Node.isVariableDeclaration(declaration)) {
-			let initializer = declaration.getInitializer();
-			if (initializer && ts_morph.Node.isAsExpression(initializer)) initializer = initializer.getExpression();
-			if (initializer && ts_morph.Node.isStringLiteral(initializer)) return initializer.getLiteralValue();
-		}
-		if (ts_morph.Node.isEnumMember(declaration)) {
-			const initializer = declaration.getInitializer();
-			if (initializer && ts_morph.Node.isStringLiteral(initializer)) return initializer.getLiteralValue();
-		}
-	}, void 0);
-	if (resolvedDeclarationValue) return resolvedDeclarationValue;
-	return resolveImportedIdentifier(identifier);
-};
-const resolveImportedIdentifier = (identifier) => {
-	if (!ts_morph.Node.isIdentifier(identifier)) return null;
-	const name = identifier.getText();
-	const sourceFile = identifier.getSourceFile();
-	const project = sourceFile.getProject();
-	const baseDir = node_path.default.dirname(sourceFile.getFilePath());
-	const importResolution = sourceFile.getImportDeclarations().reduce((resolvedImport, importDecl) => {
-		if (resolvedImport) return resolvedImport;
-		if (!importDecl.getNamedImports().find((n) => n.getName() === name)) return;
-		const moduleSpec = importDecl.getModuleSpecifierValue();
-		if (!moduleSpec.startsWith(".")) return;
-		const resolvedBase = node_path.default.resolve(baseDir, moduleSpec);
-		return [
-			resolvedBase,
-			`${resolvedBase}.ts`,
-			`${resolvedBase}.tsx`
-		].reduce((resolvedCandidate, candidate) => {
-			if (resolvedCandidate) return resolvedCandidate;
-			if (!(0, node_fs.existsSync)(candidate)) return;
-			const importedFile = project.addSourceFileAtPathIfExists(candidate);
-			if (!importedFile) return;
-			const varDecl = importedFile.getVariableDeclaration(name);
-			if (!varDecl) return;
-			let initializer = varDecl.getInitializer();
-			if (initializer && ts_morph.Node.isAsExpression(initializer)) initializer = initializer.getExpression();
-			return initializer && ts_morph.Node.isStringLiteral(initializer) ? initializer.getLiteralValue() : void 0;
-		}, void 0);
-	}, void 0);
-	if (importResolution) return importResolution;
-	return null;
-};
+}
 
 //#endregion
 exports.analyzeComponent = analyzeComponent;