@yahoo/uds 3.104.0 → 3.105.0

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

@@ -0,0 +1,408 @@
+/*! © 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 node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+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 */
+/**
+* Known UDS component names (populated by scanning)
+*/
+let knownComponents = null;
+/**
+* Map of component name -> file path
+*/
+let componentPaths = null;
+/**
+* Scan src/components to build a map of all component files
+*/
+async function scanComponentFiles(componentsDir) {
+	if (componentPaths) 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;
+		const fileName = node_path.default.basename(file, ".tsx");
+		if (/^[A-Z]/.test(fileName)) {
+			componentPaths.set(fileName, file);
+			knownComponents.add(fileName);
+		}
+	}
+	return componentPaths;
+}
+/**
+* Analyze an object literal for variant key mappings.
+* Handles:
+* - Direct property assignments: { fontSize: variant } -> variant maps to fontSize
+* - 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);
+					}
+				}
+			}
+		}
+	} 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);
+			}
+		}
+	}
+}
+/**
+* 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 sourceFile = project.getSourceFile(componentPath);
+	if (!sourceFile) return null;
+	const componentName = node_path.default.basename(componentPath, ".tsx");
+	const defaultProps = /* @__PURE__ */ new Map();
+	const componentPropNames = /* @__PURE__ */ new Set();
+	const styleProps = [];
+	const getStylesLiterals = /* @__PURE__ */ new Map();
+	const cxLiterals = [];
+	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);
+	extractInternalComponents(sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentPropNames);
+	return {
+		name: componentName,
+		filePath: componentPath,
+		defaultProps,
+		styleProps,
+		getStylesLiterals,
+		cxLiterals,
+		internalComponents,
+		internalComponentProps,
+		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 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)) 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
+*/
+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();
+	for (const param of params) {
+		if (!ts_morph.Node.isParameterDeclaration(param)) continue;
+		const nameNode = param.getNameNode();
+		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());
+		}
+	}
+}
+/**
+* Extract ALL prop names from a function's parameter destructuring (not just defaults)
+*/
+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();
+	for (const param of params) {
+		if (!ts_morph.Node.isParameterDeclaration(param)) continue;
+		const nameNode = param.getNameNode();
+		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:
+* - Direct string literals: cx('class1', 'class2')
+* - 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 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)) {
+				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.isConditionalExpression(node)) {
+		extractCxStringLiterals(node.getWhenTrue(), literals);
+		extractCxStringLiterals(node.getWhenFalse(), literals);
+	} else if (ts_morph.Node.isBinaryExpression(node)) {
+		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;
+}
+/**
+* Extract motion CSS variable prefixes from SpringMotionConfig usage.
+* Returns prefixes like ['--uds-motion-bouncy-4-', '--uds-motion-smooth-3-']
+*/
+function 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;
+		const props = {
+			layoutVariant: null,
+			layoutSpeed: null,
+			colorVariant: null,
+			colorSpeed: null
+		};
+		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) {
+						for (const key of Object.keys(props)) if (key in spreadObj) props[key] = spreadObj[key];
+					}
+				}
+				continue;
+			}
+			if (!ts_morph.Node.isJsxAttribute(attr)) continue;
+			const propName = attr.getNameNode().getText();
+			if (!(propName in props)) continue;
+			const initializer = attr.getInitializer();
+			if (initializer) {
+				if (ts_morph.Node.isStringLiteral(initializer)) props[propName] = initializer.getLiteralValue();
+				else if (ts_morph.Node.isJsxExpression(initializer)) {
+					const expr = initializer.getExpression();
+					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;
+}
+
+//#endregion
+exports.analyzeComponent = analyzeComponent;
+exports.scanComponentFiles = scanComponentFiles;