@yahoo/uds 3.114.0 → 3.115.0-beta.1

package/dist/tailwind/dist/purger/optimized/purgeFromCode.js

@@ -8,20 +8,20 @@ import { Node, Project, SyntaxKind, ts } from "ts-morph";
 /**
 * Get component info with all its dependencies (using pre-generated data)
 */
-function getComponentWithDeps(componentName) {
+const getComponentWithDeps = (componentName) => {
 	const visited = /* @__PURE__ */ new Set();
 	const result = [];
-	function collect(name) {
+	const collect = (name) => {
 		if (visited.has(name)) return;
 		visited.add(name);
-		const info = componentCache[name];
+		const info = resolveComponentInfo(name);
 		if (!info) return;
 		result.push(info);
-		for (const depName of info.internalComponents) collect(depName);
-	}
+		info.internalComponents.forEach((depName) => collect(depName));
+	};
 	collect(componentName);
 	return result;
-}
+};
 /**
 * Auto-variants lookup (loaded at module init)
 */
@@ -30,10 +30,96 @@ let autoVariantsCache = null;
 * Pre-generated component data (loaded at module init)
 */
 let componentCache = null;
-async function purgeFromCodeOptimized(code, options) {
+/**
+* Map of normalized component name -> actual component cache key
+* Useful when internal components are imported without namespace separators
+* (e.g., MenuItemBase vs Menu.ItemBase).
+*/
+let componentNameLookup = null;
+const buildComponentNameLookup = (data) => {
+	const lookup = {};
+	Object.keys(data).forEach((key) => {
+		const normalized = normalizeComponentName(key);
+		if (!lookup[normalized]) lookup[normalized] = key;
+	});
+	return lookup;
+};
+const resolveComponentInfo = (name) => {
+	if (componentCache && componentCache[name]) return componentCache[name];
+	const normalized = normalizeComponentName(name);
+	const mappedName = componentNameLookup?.[normalized];
+	if (mappedName && componentCache) return componentCache[mappedName];
+};
+const getModuleSpecifierValue = (importDecl) => {
+	return importDecl.getModuleSpecifierValue() ?? importDecl.getModuleSpecifier().getText().replace(/^['"]|['"]$/g, "");
+};
+const isUdsComponentModule = (moduleSpecifier) => {
+	const cleaned = moduleSpecifier.replace(/^['"]|['"]$/g, "");
+	return cleaned === "@yahoo/uds" || cleaned.startsWith("@yahoo/uds/");
+};
+/**
+* Normalize component name to match autoVariants keys (lower camel, no punctuation).
+*/
+const normalizeComponentName = (name) => {
+	const cleaned = name.replace(/\W/g, "");
+	return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+};
+/**
+* Fallback: infer prop -> variant key mapping from autoVariants when the
+* generated component data misses it (e.g., helpers like buildAvatarRootClasses).
+*/
+const getAutoVariantKeysForProp = (componentName, propName) => {
+	if (!autoVariantsCache) return [];
+	const segments = componentName.match(/[A-Z][a-z0-9]*/g) ?? [];
+	const candidates = new Set([normalizeComponentName(componentName)]);
+	if (segments.length > 0) Array.from({ length: segments.length }, (_, index) => index + 1).forEach((i) => {
+		const partial = segments.slice(0, i).join("");
+		candidates.add(normalizeComponentName(partial));
+	});
+	const propLower = propName.toLowerCase();
+	return Object.keys(autoVariantsCache).filter((key) => {
+		const keyLower = key.toLowerCase();
+		return Array.from(candidates).some((candidate) => keyLower.startsWith(candidate) && keyLower.includes(propLower));
+	});
+};
+const getVariantKeysForProp = (componentInfo, propName) => {
+	const keys = new Set(componentInfo.propToVariantKeys?.[propName] ?? []);
+	getAutoVariantKeysForProp(componentInfo.name, propName).forEach((inferred) => keys.add(inferred));
+	return [...keys];
+};
+const extractClassNamePrimitives = (sourceFile) => {
+	const classes = [];
+	sourceFile.getDescendantsOfKind(SyntaxKind.JsxAttribute).forEach((attr) => {
+		if (attr.getNameNode().getText() !== "className") return;
+		const initializer = attr.getInitializer();
+		if (!initializer) return;
+		const values = [];
+		if (Node.isStringLiteral(initializer)) values.push(initializer.getLiteralText());
+		else if (Node.isJsxExpression(initializer)) {
+			const expr = initializer.getExpression();
+			if (expr) values.push(...extractStringLiterals(expr));
+		}
+		values.forEach((raw) => {
+			classes.push(...raw.split(/\s+/).filter(Boolean));
+		});
+	});
+	sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment).forEach((prop) => {
+		if (prop.getName() !== "className") return;
+		const initializer = prop.getInitializer();
+		if (!initializer) return;
+		extractStringLiterals(initializer).forEach((raw) => {
+			classes.push(...raw.split(/\s+/).filter(Boolean));
+		});
+	});
+	return classes;
+};
+const purgeFromCodeOptimized = async (code, options) => {
 	const { variants, autoVariants, componentData } = options;
 	if (!autoVariantsCache) autoVariantsCache = autoVariants;
-	if (!componentCache) componentCache = componentData;
+	if (!componentCache) {
+		componentCache = componentData;
+		componentNameLookup = buildComponentNameLookup(componentData);
+	}
 	const startTime = performance.now();
 	const sourceFile = new Project({ useInMemoryFileSystem: true }).createSourceFile("input.tsx", code);
 	const stats = {
@@ -44,105 +130,126 @@ async function purgeFromCodeOptimized(code, options) {
 		expressionsResolved: 0
 	};
 	const imports = [];
-	for (const importDecl of sourceFile.getImportDeclarations()) if (importDecl.getModuleSpecifier().getText().includes("@yahoo/uds")) for (const namedImport of importDecl.getNamedImports()) imports.push(namedImport.getName());
+	sourceFile.getImportDeclarations().forEach((importDecl) => {
+		if (isUdsComponentModule(getModuleSpecifierValue(importDecl))) importDecl.getNamedImports().forEach((namedImport) => imports.push(namedImport.getName()));
+	});
 	const componentProps = /* @__PURE__ */ new Map();
+	const referencedComponents = /* @__PURE__ */ new Set();
 	const getStylesProps = extractGetStylesCalls(sourceFile, stats, variants);
-	for (const imp of imports) {
-		const references = findComponentReferences(sourceFile, imp);
-		const propsMap = componentProps.get(imp) ?? /* @__PURE__ */ new Map();
-		for (const reference of references) {
-			const props = extractPropsFromReference(reference, stats, sourceFile);
-			for (const [propName, values] of props) if (values.length > 0) {
-				const existing = propsMap.get(propName) ?? /* @__PURE__ */ new Set();
-				for (const val of values) existing.add(val);
-				propsMap.set(propName, existing);
-			}
-		}
-		componentProps.set(imp, propsMap);
-	}
+	imports.forEach((imp) => {
+		findComponentReferences(sourceFile, imp).forEach((reference) => {
+			const componentName = reference.getTagNameNode().getText() || imp;
+			referencedComponents.add(componentName);
+			const propsMap = componentProps.get(componentName) ?? /* @__PURE__ */ new Map();
+			extractPropsFromReference(reference, stats, sourceFile).forEach(([propName, values]) => {
+				if (values.length > 0) {
+					const existing = propsMap.get(propName) ?? /* @__PURE__ */ new Set();
+					values.forEach((val) => existing.add(val));
+					propsMap.set(propName, existing);
+				}
+			});
+			componentProps.set(componentName, propsMap);
+		});
+		if (!componentProps.has(imp)) componentProps.set(imp, /* @__PURE__ */ new Map());
+	});
 	const allComponents = [];
 	const seenComponents = /* @__PURE__ */ new Set();
-	for (const componentName of imports) {
-		const componentsWithDeps = getComponentWithDeps(componentName);
-		for (const comp of componentsWithDeps) if (!seenComponents.has(comp.name)) {
-			seenComponents.add(comp.name);
-			allComponents.push(comp);
-		}
-	}
+	new Set([...imports, ...referencedComponents]).forEach((componentName) => {
+		getComponentWithDeps(componentName).forEach((comp) => {
+			if (!seenComponents.has(comp.name)) {
+				seenComponents.add(comp.name);
+				allComponents.push(comp);
+			}
+		});
+	});
 	const safelist = [];
-	for (const [propName, values] of getStylesProps) {
+	[...getStylesProps.entries()].forEach(([propName, values]) => {
 		const variantGroup = variants[propName];
-		if (variantGroup) for (const value of values) {
+		if (variantGroup) values.forEach((value) => {
 			const cls = variantGroup[value];
 			if (cls) safelist.push(cls.replaceAll("\\", ""));
-		}
-	}
-	for (const componentInfo of allComponents) {
+		});
+	});
+	allComponents.forEach((componentInfo) => {
 		const userProps = componentProps.get(componentInfo.name) ?? /* @__PURE__ */ new Map();
-		for (const [propName, propValue] of Object.entries(componentInfo.defaultProps)) {
-			if (userProps.has(propName)) continue;
+		Object.entries(componentInfo.defaultProps).forEach(([propName, propValue]) => {
+			if (userProps.has(propName)) return;
 			const variantGroup = variants[propName];
 			if (variantGroup) {
 				const cls = variantGroup[propValue];
 				if (cls) safelist.push(cls.replaceAll("\\", ""));
 			}
-			const variantKeys = componentInfo.propToVariantKeys?.[propName];
-			if (variantKeys) for (const variantKey of variantKeys) {
-				const mappedVariantGroup = variants[variantKey];
+			const variantKeys = getVariantKeysForProp(componentInfo, propName);
+			if (variantKeys.length > 0) variantKeys.forEach((variantKey) => {
+				const mappedVariantGroup = variants[variantKey] ?? autoVariantsCache[variantKey];
 				if (mappedVariantGroup) {
 					const cls = mappedVariantGroup[propValue];
 					if (cls) safelist.push(cls.replaceAll("\\", ""));
 				}
-			}
-		}
-		for (const [propName, propValue] of Object.entries(componentInfo.getStylesLiterals)) {
+			});
+		});
+		Object.entries(componentInfo.getStylesLiterals).forEach(([propName, propValue]) => {
 			const variantGroup = variants[propName.replace(/:\d+$/, "")];
 			if (variantGroup) {
 				const cls = variantGroup[propValue];
 				if (cls) safelist.push(cls.replaceAll("\\", ""));
 			}
-		}
-		if (componentInfo.cxLiterals) for (const cls of componentInfo.cxLiterals) safelist.push(cls);
+		});
+		if (componentInfo.cxLiterals) componentInfo.cxLiterals.forEach((cls) => safelist.push(cls));
 		if (componentInfo.propToVariantKeys) {
 			const componentDefaults = options.variantDefaults?.[componentInfo.name] ?? {};
-			for (const [propName, variantKeys] of Object.entries(componentInfo.propToVariantKeys)) {
-				if (userProps.has(propName)) continue;
+			Object.keys(componentInfo.propToVariantKeys).forEach((propName) => {
+				if (userProps.has(propName)) return;
 				const defaultValue = componentDefaults[propName];
-				for (const variantKey of variantKeys) {
+				getVariantKeysForProp(componentInfo, propName).forEach((variantKey) => {
 					const variantGroup = autoVariantsCache[variantKey];
 					if (variantGroup) {
 						if (variantGroup["default"]) safelist.push(variantGroup["default"]);
 						if (defaultValue && variantGroup[defaultValue]) safelist.push(variantGroup[defaultValue]);
 					}
-				}
-			}
+				});
+			});
 		}
-		for (const [_internalCompName, propsRecord] of Object.entries(componentInfo.internalComponentProps)) for (const [propName, propValues] of Object.entries(propsRecord)) {
-			const variantGroup = variants[propName];
-			if (variantGroup) for (const propValue of propValues) {
-				const cls = variantGroup[propValue];
-				if (cls) safelist.push(cls.replaceAll("\\", ""));
+		Object.entries(componentInfo.internalComponentProps).forEach(([_internalCompName, propsRecord]) => {
+			Object.entries(propsRecord).forEach(([propName, propValues]) => {
+				if (propName === "className") {
+					propValues.forEach((propValue) => {
+						propValue.split(/\s+/).filter(Boolean).forEach((cls) => safelist.push(cls));
+					});
+					return;
+				}
+				const variantGroup = variants[propName];
+				if (variantGroup) propValues.forEach((propValue) => {
+					const cls = variantGroup[propValue];
+					if (cls) safelist.push(cls.replaceAll("\\", ""));
+				});
+			});
+		});
+		[...userProps.entries()].forEach(([propName, usedValues]) => {
+			if (propName === "className") {
+				[...usedValues].forEach((value) => {
+					value.split(/\s+/).filter(Boolean).forEach((cls) => safelist.push(cls));
+				});
+				return;
 			}
-		}
-		for (const [propName, usedValues] of userProps) {
 			const variantGroup = variants[propName];
-			if (variantGroup) for (const value of usedValues) {
+			if (variantGroup) [...usedValues].forEach((value) => {
 				const cls = variantGroup[value];
 				if (cls) safelist.push(cls.replaceAll("\\", ""));
-			}
-			const componentsToCheck = [componentInfo, ...getComponentWithDeps(componentInfo.name).slice(1)];
-			for (const comp of componentsToCheck) {
-				const variantKeys = comp.propToVariantKeys?.[propName];
-				if (variantKeys) for (const variantKey of variantKeys) {
+			});
+			[componentInfo, ...getComponentWithDeps(componentInfo.name).slice(1)].forEach((comp) => {
+				const variantKeys = getVariantKeysForProp(comp, propName);
+				if (variantKeys.length > 0) variantKeys.forEach((variantKey) => {
 					const mappedVariantGroup = variants[variantKey];
-					if (mappedVariantGroup) for (const value of usedValues) {
+					if (mappedVariantGroup) [...usedValues].forEach((value) => {
 						const cls = mappedVariantGroup[value];
 						if (cls) safelist.push(cls.replaceAll("\\", ""));
-					}
-				}
-			}
-		}
-	}
+					});
+				});
+			});
+		});
+	});
+	if (options.includeAllClassNamePrimitives) safelist.push(...extractClassNamePrimitives(sourceFile));
 	const finalSafelist = [...new Set(safelist)];
 	stats.timeMs = Math.round(performance.now() - startTime);
 	stats.classesGenerated = finalSafelist.length;
@@ -152,28 +259,29 @@ async function purgeFromCodeOptimized(code, options) {
 		components: [...seenComponents],
 		stats
 	};
-}
+};
 /**
 * Find JSX references for a component in the source file
 */
-function findComponentReferences(sourceFile, componentName) {
+const findComponentReferences = (sourceFile, componentName) => {
 	const references = [];
-	for (const importDecl of sourceFile.getImportDeclarations()) {
-		if (!importDecl.getModuleSpecifier().getText().includes("@yahoo/uds")) continue;
-		for (const namedImport of importDecl.getNamedImports()) if (namedImport.getName() === componentName) {
-			const identifier = namedImport.getFirstDescendantByKindOrThrow(ts.SyntaxKind.Identifier);
-			references.push(...findJsxReferences(identifier));
-		}
-	}
+	sourceFile.getImportDeclarations().forEach((importDecl) => {
+		if (!isUdsComponentModule(getModuleSpecifierValue(importDecl))) return;
+		importDecl.getNamedImports().forEach((namedImport) => {
+			if (namedImport.getName() === componentName) {
+				const identifier = namedImport.getFirstDescendantByKindOrThrow(ts.SyntaxKind.Identifier);
+				references.push(...findJsxReferences(identifier));
+			}
+		});
+	});
 	return references;
-}
+};
 /**
 * Extract props from a JSX reference.
 */
-function extractPropsFromReference(reference, stats, sourceFile) {
+const extractPropsFromReference = (reference, stats, sourceFile) => {
 	const props = [];
-	const attributes = reference.getAttributes();
-	for (const attr of attributes) {
+	reference.getAttributes().forEach((attr) => {
 		if (attr.asKind(SyntaxKind.JsxAttribute)) {
 			const jsxAttr = attr.asKindOrThrow(SyntaxKind.JsxAttribute);
 			const propName = jsxAttr.getNameNode().getText();
@@ -194,16 +302,17 @@ function extractPropsFromReference(reference, stats, sourceFile) {
 		}
 		if (attr.asKind(SyntaxKind.JsxSpreadAttribute)) {
 			stats.spreadsTraced++;
-			const resolvedSpreadProps = traceSpreadInFile(attr.asKindOrThrow(SyntaxKind.JsxSpreadAttribute).getExpression().getText(), sourceFile);
-			for (const [propName, values] of resolvedSpreadProps) if (values.length > 0) props.push([propName, values]);
+			traceSpreadInFile(attr.asKindOrThrow(SyntaxKind.JsxSpreadAttribute).getExpression().getText(), sourceFile).forEach(([propName, values]) => {
+				if (values.length > 0) props.push([propName, values]);
+			});
 		}
-	}
+	});
 	return props;
-}
+};
 /**
 * Trace spread props to their source within the same file.
 */
-function traceSpreadInFile(spreadName, sourceFile) {
+const traceSpreadInFile = (spreadName, sourceFile) => {
 	const props = [];
 	const varDecl = sourceFile.getVariableDeclaration(spreadName);
 	if (!varDecl) return props;
@@ -211,62 +320,64 @@ function traceSpreadInFile(spreadName, sourceFile) {
 	if (!initializer) return props;
 	const objLiteral = initializer.asKind(SyntaxKind.ObjectLiteralExpression) ? initializer.asKindOrThrow(SyntaxKind.ObjectLiteralExpression) : initializer.asKind(SyntaxKind.AsExpression) ? initializer.asKindOrThrow(SyntaxKind.AsExpression).getExpression().asKind(SyntaxKind.ObjectLiteralExpression) ? initializer.asKindOrThrow(SyntaxKind.AsExpression).getExpression().asKindOrThrow(SyntaxKind.ObjectLiteralExpression) : null : null;
 	if (!objLiteral) return props;
-	for (const prop of objLiteral.getProperties()) if (prop.asKind(SyntaxKind.PropertyAssignment)) {
-		const propAssign = prop.asKindOrThrow(SyntaxKind.PropertyAssignment);
-		const propName = propAssign.getName();
-		const propInit = propAssign.getInitializer();
-		if (propInit) {
-			const values = extractStringLiterals(propInit);
-			if (values.length > 0) props.push([propName, values]);
+	objLiteral.getProperties().forEach((prop) => {
+		if (prop.asKind(SyntaxKind.PropertyAssignment)) {
+			const propAssign = prop.asKindOrThrow(SyntaxKind.PropertyAssignment);
+			const propName = propAssign.getName();
+			const propInit = propAssign.getInitializer();
+			if (propInit) {
+				const values = extractStringLiterals(propInit);
+				if (values.length > 0) props.push([propName, values]);
+			}
 		}
-	}
+	});
 	return props;
-}
+};
 /**
 * Extract props from getStyles() calls in user code.
 * This handles cases like:
 *   const styles = getStyles({ backgroundColor: 'brand', spacing: '4' });
 */
-function extractGetStylesCalls(sourceFile, stats, variants) {
+const extractGetStylesCalls = (sourceFile, stats, variants) => {
 	const props = /* @__PURE__ */ new Map();
 	const VALID_VARIANTS = new Set(Object.keys(variants));
-	const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
-	for (const call of callExpressions) {
-		if (call.getExpression().getText() !== "getStyles") continue;
+	sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
+		if (call.getExpression().getText() !== "getStyles") return;
 		const args = call.getArguments();
-		if (args.length === 0) continue;
+		if (args.length === 0) return;
 		const firstArg = args[0];
-		if (!firstArg.asKind(SyntaxKind.ObjectLiteralExpression)) continue;
-		const objLiteral = firstArg.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-		for (const prop of objLiteral.getProperties()) if (prop.asKind(SyntaxKind.PropertyAssignment)) {
-			const propAssign = prop.asKindOrThrow(SyntaxKind.PropertyAssignment);
-			const propName = propAssign.getName();
-			const propInit = propAssign.getInitializer();
-			if (propInit && VALID_VARIANTS.has(propName)) {
-				const values = extractStringLiterals(propInit);
-				if (values.length > 0) {
-					const existing = props.get(propName) ?? /* @__PURE__ */ new Set();
-					for (const v of values) existing.add(v);
-					props.set(propName, existing);
-					stats.expressionsResolved++;
+		if (!firstArg.asKind(SyntaxKind.ObjectLiteralExpression)) return;
+		firstArg.asKindOrThrow(SyntaxKind.ObjectLiteralExpression).getProperties().forEach((prop) => {
+			if (prop.asKind(SyntaxKind.PropertyAssignment)) {
+				const propAssign = prop.asKindOrThrow(SyntaxKind.PropertyAssignment);
+				const propName = propAssign.getName();
+				const propInit = propAssign.getInitializer();
+				if (propInit && VALID_VARIANTS.has(propName)) {
+					const values = extractStringLiterals(propInit);
+					if (values.length > 0) {
+						const existing = props.get(propName) ?? /* @__PURE__ */ new Set();
+						values.forEach((v) => existing.add(v));
+						props.set(propName, existing);
+						stats.expressionsResolved++;
+					}
 				}
-			}
-		} else if (prop.asKind(SyntaxKind.ShorthandPropertyAssignment)) {
-			const shorthand = prop.asKindOrThrow(SyntaxKind.ShorthandPropertyAssignment);
-			const propName = shorthand.getName();
-			if (VALID_VARIANTS.has(propName)) {
-				const values = extractStringLiterals(shorthand.getNameNode());
-				if (values.length > 0) {
-					const existing = props.get(propName) ?? /* @__PURE__ */ new Set();
-					for (const v of values) existing.add(v);
-					props.set(propName, existing);
-					stats.expressionsResolved++;
+			} else if (prop.asKind(SyntaxKind.ShorthandPropertyAssignment)) {
+				const shorthand = prop.asKindOrThrow(SyntaxKind.ShorthandPropertyAssignment);
+				const propName = shorthand.getName();
+				if (VALID_VARIANTS.has(propName)) {
+					const values = extractStringLiterals(shorthand.getNameNode());
+					if (values.length > 0) {
+						const existing = props.get(propName) ?? /* @__PURE__ */ new Set();
+						values.forEach((v) => existing.add(v));
+						props.set(propName, existing);
+						stats.expressionsResolved++;
+					}
 				}
 			}
-		}
-	}
+		});
+	});
 	return props;
-}
+};
 
 //#endregion
 export { purgeFromCodeOptimized };