@yahoo/uds 3.114.0 → 3.115.0-beta.2

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

@@ -3,7 +3,10 @@ const require_runtime = require('../../../../../_virtual/_rolldown/runtime.cjs')
 const require_index = require('../../../../../motion-tokens/dist/index.cjs');
 let node_path = require("node:path");
 node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
 let ts_morph = require("ts-morph");
+let fast_glob = require("fast-glob");
+fast_glob = require_runtime.__toESM(fast_glob);
 
 //#region ../tailwind/dist/purger/optimized/utils/componentAnalyzer.js
 /*! © 2026 Yahoo, Inc. UDS Tailwind and Purger v0.0.0-development */
@@ -15,27 +18,31 @@ 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
 */
-async function scanComponentFiles(componentsDir) {
-	if (componentPaths) return componentPaths;
+const scanComponentFiles = async (componentsDir) => {
+	if (componentPaths && scannedComponentsDir === componentsDir) return componentPaths;
 	componentPaths = /* @__PURE__ */ new Map();
 	knownComponents = /* @__PURE__ */ new Set();
-	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;
+	scannedComponentsDir = componentsDir;
+	const nextComponentPaths = componentPaths;
+	const nextKnownComponents = knownComponents;
+	(await scanComponentFilePaths(componentsDir)).forEach((file) => {
+		if (file.includes(".test.") || file.endsWith("index.tsx")) return;
 		const fileName = node_path.default.basename(file, ".tsx");
 		if (/^[A-Z]/.test(fileName)) {
-			componentPaths.set(fileName, file);
-			knownComponents.add(fileName);
+			nextComponentPaths.set(fileName, file);
+			nextKnownComponents.add(fileName);
 		}
-	}
-	return componentPaths;
-}
+	});
+	return nextComponentPaths;
+};
 /**
 * Analyze an object literal for variant key mappings.
 * Handles:
@@ -43,60 +50,64 @@ async function scanComponentFiles(componentsDir) {
 * - Nullish coalescing: { fontSize: fontSize ?? variant } -> variant maps to fontSize
 * - Conditional spreads: ...(condition ? { props } : {}) -> recursively analyze props
 */
-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);
-					}
-				}
-			}
+const analyzeObjectForVariantMappings = (objLiteral, styleProps, getStylesLiterals, propToVariantKeys, sourceFile) => {
+	objLiteral.getProperties().forEach((prop) => {
+		if (ts_morph.Node.isPropertyAssignment(prop)) {
+			analyzeVariantPropertyAssignment(prop, styleProps, getStylesLiterals, propToVariantKeys);
+			return;
 		}
-	} 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.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);
 		}
 	}
-}
+	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
 */
-function analyzeComponent(project, componentPath) {
+const analyzeComponent = (project, componentPath) => {
 	const sourceFile = project.getSourceFile(componentPath);
 	if (!sourceFile) return null;
 	const componentName = node_path.default.basename(componentPath, ".tsx");
@@ -108,98 +119,10 @@ function analyzeComponent(project, componentPath) {
 	const internalComponents = [];
 	const internalComponentProps = /* @__PURE__ */ new Map();
 	const propToVariantKeys = /* @__PURE__ */ new Map();
-	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);
+	collectComponentDefaultsAndProps(sourceFile, defaultProps, componentPropNames);
+	collectGetStylesMetadata(sourceFile, styleProps, getStylesLiterals, propToVariantKeys);
+	collectCxLiterals(sourceFile, cxLiterals);
+	collectIntrinsicClassNameLiterals(sourceFile, cxLiterals);
 	extractInternalComponents(sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentPropNames);
 	return {
 		name: componentName,
@@ -213,96 +136,217 @@ function analyzeComponent(project, componentPath) {
 		propToVariantKeys,
 		motionVarPrefixes: extractMotionVarPrefixes(sourceFile)
 	};
-}
-/**
-* Extract UDS components used internally in the file and their prop values.
-* Also detects prop aliasing (e.g., columnGap={gap} means gap -> columnGap).
-*/
-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);
+};
+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;
 	}
-	const jsxElements = [...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxOpeningElement)];
-	for (const element of jsxElements) {
+	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));
+	});
+};
+const pushUniqueClasses = (target, rawValue) => {
+	rawValue.split(/\s+/).filter(Boolean).forEach((className) => {
+		if (!target.includes(className)) target.push(className);
+	});
+};
+const collectIntrinsicClassNameLiterals = (sourceFile, cxLiterals) => {
+	[...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxOpeningElement)].forEach((element) => {
 		const tagName = element.getTagNameNode().getText();
-		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();
+		if (!/^[a-z]/.test(tagName)) return;
+		element.getAttributes().forEach((attr) => {
+			if (!ts_morph.Node.isJsxAttribute(attr) || attr.getNameNode().getText() !== "className") return;
 			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 (!initializer) return;
+			if (ts_morph.Node.isStringLiteral(initializer)) {
+				pushUniqueClasses(cxLiterals, initializer.getLiteralValue());
+				return;
 			}
-			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);
-			}
-		}
+			if (!ts_morph.Node.isJsxExpression(initializer)) return;
+			const expr = initializer.getExpression();
+			if (expr && ts_morph.Node.isStringLiteral(expr)) pushUniqueClasses(cxLiterals, expr.getLiteralValue());
+		});
+	});
+};
+/**
+* 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);
 	}
-}
+	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 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);
+		});
+	});
+};
 /**
 * Extract default prop values from a function's parameter destructuring
 */
-function extractDefaultsFromFunction(fn, defaults) {
+const 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();
-	for (const param of params) {
-		if (!ts_morph.Node.isParameterDeclaration(param)) continue;
+	params.forEach((param) => {
+		if (!ts_morph.Node.isParameterDeclaration(param)) return;
 		const nameNode = param.getNameNode();
-		if (!nameNode || !ts_morph.Node.isObjectBindingPattern(nameNode)) continue;
-		for (const element of nameNode.getElements()) {
+		if (!nameNode || !ts_morph.Node.isObjectBindingPattern(nameNode)) return;
+		nameNode.getElements().forEach((element) => {
 			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)
 */
-function extractAllPropNames(fn, propNames) {
+const 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();
-	for (const param of params) {
-		if (!ts_morph.Node.isParameterDeclaration(param)) continue;
+	params.forEach((param) => {
+		if (!ts_morph.Node.isParameterDeclaration(param)) return;
 		const nameNode = param.getNameNode();
-		if (!nameNode || !ts_morph.Node.isObjectBindingPattern(nameNode)) continue;
-		for (const element of nameNode.getElements()) {
+		if (!nameNode || !ts_morph.Node.isObjectBindingPattern(nameNode)) return;
+		nameNode.getElements().forEach((element) => {
 			const propName = element.getPropertyNameNode()?.getText() || element.getName();
 			propNames.add(propName);
-		}
-	}
-}
+		});
+	});
+};
 /**
 * Extract string literals from cx() call arguments.
 * Handles:
@@ -310,22 +354,25 @@ function extractAllPropNames(fn, propNames) {
 * - Object keys: cx({ 'class1': condition, 'class2': true })
 * - Nested calls and arrays
 */
-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 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)) {
 			const nameNode = prop.getNameNode();
-			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)) {
+			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)) {
 				const cls = nameNode.getText();
 				if (!literals.includes(cls)) literals.push(cls);
 			}
 		}
-	} else if (ts_morph.Node.isArrayLiteralExpression(node)) for (const element of node.getElements()) extractCxStringLiterals(element, literals);
+	});
+	else if (ts_morph.Node.isArrayLiteralExpression(node)) node.getElements().forEach((element) => {
+		extractCxStringLiterals(element, literals);
+	});
 	else if (ts_morph.Node.isConditionalExpression(node)) {
 		extractCxStringLiterals(node.getWhenTrue(), literals);
 		extractCxStringLiterals(node.getWhenFalse(), literals);
@@ -333,59 +380,54 @@ function extractCxStringLiterals(node, literals) {
 		extractCxStringLiterals(node.getLeft(), literals);
 		extractCxStringLiterals(node.getRight(), literals);
 	}
-}
+};
 /**
 * Try to resolve an identifier to its initializer value (for const declarations)
 */
-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;
-}
+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;
+};
 /**
 * Extract motion CSS variable prefixes from SpringMotionConfig usage.
 * Returns prefixes like ['--uds-motion-bouncy-4-', '--uds-motion-smooth-3-']
 */
-function extractMotionVarPrefixes(sourceFile) {
+const extractMotionVarPrefixes = (sourceFile) => {
 	const prefixes = [];
-	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;
+	[...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxOpeningElement)].forEach((element) => {
+		if (element.getTagNameNode().getText() !== "SpringMotionConfig") return;
 		const props = {
 			layoutVariant: null,
 			layoutSpeed: null,
 			colorVariant: null,
 			colorSpeed: null
 		};
-		const attrs = element.getAttributes();
-		for (const attr of attrs) {
+		element.getAttributes().forEach((attr) => {
 			if (ts_morph.Node.isJsxSpreadAttribute(attr)) {
 				const expr = attr.getExpression();
 				if (ts_morph.Node.isIdentifier(expr)) {
 					const spreadObj = resolveIdentifierToObject(sourceFile, expr.getText());
-					if (spreadObj) {
-						for (const key of Object.keys(props)) if (key in spreadObj) props[key] = spreadObj[key];
-					}
+					if (spreadObj) Object.keys(props).forEach((key) => {
+						if (key in spreadObj) props[key] = spreadObj[key];
+					});
 				}
-				continue;
+				return;
 			}
-			if (!ts_morph.Node.isJsxAttribute(attr)) continue;
+			if (!ts_morph.Node.isJsxAttribute(attr)) return;
 			const propName = attr.getNameNode().getText();
-			if (!(propName in props)) continue;
+			if (!(propName in props)) return;
 			const initializer = attr.getInitializer();
 			if (initializer) {
 				if (ts_morph.Node.isStringLiteral(initializer)) props[propName] = initializer.getLiteralValue();
@@ -394,14 +436,64 @@ function 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;