fix: wildcard pattern matching for root-level and filename patterns

Author: privatenumber

src/utils/get-build-entry-points/expand-exports-wildcards.ts

@@ -7,35 +7,50 @@ const extensionPattern = /\.[^./]+$/;
 
 /**
  * Extract wildcard match from file path based on pattern
- * @param filePath - File path with extension
+ * @param pathWithoutExtension - File path without extension
  * @param patternParts - Parts between wildcards (e.g., [""] or ["/index", ""])
  * @returns Captured wildcard value, or undefined if no match
  */
 const extractWildcardMatch = (
-	filePath: string,
+	pathWithoutExtension: string,
 	patternParts: string[],
 ): string | undefined => {
-	const pathWithoutExtension = filePath.replace(extensionPattern, '');
-
 	// Early validation: check if path ends with the last pattern part
 	const lastPart = patternParts.at(-1)!;
 	if (!pathWithoutExtension.endsWith(lastPart)) {
 		return;
 	}
 
-	// Multiple wildcards: find the repeated capture value by trying different capture lengths
-	// Example: "./*" → "./dist/*/*/index.js" with "a/b/a/b/index" captures "a/b"
-	// Example: "./*" → "./dist/*/_/*/_/*.mjs" with "foo/_/foo/_/foo" captures "foo"
-	const segments = pathWithoutExtension.split('/').filter(Boolean);
+	// Detect if this is a path-based pattern (contains '/') or filename-based pattern
+	const isPathPattern = patternParts.some(part => part.includes('/'));
+
+	if (isPathPattern) {
+		// Path-based patterns: split by '/' and try different segment lengths
+		// Example: "./*" → "./dist/*/*/index.js" with "a/b/a/b/index" captures "a/b"
+		// Example: "./*" → "./dist/*/_/*/_/*.mjs" with "foo/_/foo/_/foo" captures "foo"
+		const segments = pathWithoutExtension.split('/').filter(Boolean);
 
-	// Try different capture lengths (from 1 segment up to total length)
-	for (let captureLength = 1; captureLength <= segments.length; captureLength += 1) {
-		const captureValue = segments.slice(0, captureLength).join('/');
+		// Try different capture lengths (from 1 segment up to total length)
+		for (let captureLength = 1; captureLength <= segments.length; captureLength += 1) {
+			const captureValue = segments.slice(0, captureLength).join('/');
 
-		// Build expected pattern by joining parts with the capture value
-		const expectedPath = captureValue + patternParts.join(captureValue);
-		if (expectedPath === pathWithoutExtension) {
-			return expectedPath;
+			// Build expected pattern by joining parts with the capture value
+			const expectedPath = captureValue + patternParts.join(captureValue);
+			if (expectedPath === pathWithoutExtension) {
+				return expectedPath;
+			}
+		}
+	} else {
+		// Filename-based patterns: try different character lengths
+		// Example: "x.*.y.*" with "foo.y.foo" should capture "foo"
+		for (let captureLength = 1; captureLength <= pathWithoutExtension.length; captureLength += 1) {
+			const captureValue = pathWithoutExtension.slice(0, captureLength);
+
+			// Build expected pattern by joining parts with the capture value
+			const expectedPath = captureValue + patternParts.join(captureValue);
+			if (expectedPath === pathWithoutExtension) {
+				return expectedPath;
+			}
 		}
 	}
 };
@@ -80,9 +95,77 @@ export const expandBuildOutputWildcards = async (
 			// Split by wildcards to get prefix and pattern parts
 			const [outputPrefix, ...patternParts] = outputPathWithoutExtension.split('*');
 
-			// Find the matching src:dist pair (most specific first)
+			// Separate directory path from filename prefix
+			// Find the last '/' to split directory from filename component
+			const lastSlashIndex = outputPrefix.lastIndexOf('/');
+			const directoryPrefix = lastSlashIndex === -1
+				? outputPrefix
+				: outputPrefix.slice(0, lastSlashIndex + 1);
+			const filenamePrefix = lastSlashIndex >= 0
+				? outputPrefix.slice(lastSlashIndex + 1)
+				: '';
+
+			// Helper function to check if a file matches the wildcard pattern
+			const matchesPattern = (filePath: string): boolean => {
+				// Strip source extension for pattern matching
+				const filePathWithoutExtension = filePath.replace(extensionPattern, '');
+				const fileName = filePathWithoutExtension.split('/').at(-1) || '';
+
+				// Check filename prefix
+				if (filenamePrefix && !fileName.startsWith(filenamePrefix)) {
+					return false;
+				}
+
+				// For single wildcard patterns, check suffix
+				if (patternParts.length === 1) {
+					const suffix = patternParts[0];
+					if (suffix) {
+						// If suffix contains path separators, check against full path
+						// Otherwise, check against filename only
+						const checkTarget = suffix.includes('/') ? filePathWithoutExtension : fileName;
+						if (!checkTarget.endsWith(suffix)) {
+							return false;
+						}
+					}
+					return true;
+				}
+
+				// For multiple wildcard patterns, use extractWildcardMatch
+				// This validates that all wildcards capture the same value
+				// For filename patterns with prefix, strip it before matching
+				const matchTarget = filenamePrefix
+					? fileName.slice(filenamePrefix.length)
+					: filePathWithoutExtension;
+				return !!extractWildcardMatch(matchTarget, patternParts);
+			};
+
+			// Handle root-level patterns (directoryPrefix is './')
+			if (directoryPrefix === './') {
+				// Expand for each srcdist pair
+				const allExpansions = await Promise.all(
+					sortedByDistLength.map(async (srcdist) => {
+						const srcPath = srcdist.srcResolved;
+						const allFiles = await getDirectoryFiles(srcPath);
+						return allFiles.flatMap((filePath) => {
+							if (!matchesPattern(filePath)) {
+								return [];
+							}
+
+							// Strip source extension before appending output extension
+							const filePathWithoutExtension = filePath.replace(extensionPattern, '');
+							return [{
+								...output,
+								outputPath: srcdist.dist + filePathWithoutExtension + matchedExtension,
+							}];
+						});
+					}),
+				);
+				return allExpansions.flat();
+			}
+
+			// Non-root-level patterns: find matching src:dist pair based on directory prefix
 			const srcdistMatch = sortedByDistLength.find(
-				({ dist }) => outputPrefix === dist || outputPrefix.startsWith(dist),
+				({ dist }) => directoryPrefix === dist || directoryPrefix.startsWith(dist),
 			);
 
 			if (!srcdistMatch) {
@@ -91,19 +174,32 @@ export const expandBuildOutputWildcards = async (
 
 			const srcPath = path.posix.join(
 				srcdistMatch.srcResolved,
-				outputPrefix.slice(srcdistMatch.dist.length),
+				directoryPrefix.slice(srcdistMatch.dist.length),
 			);
+
 			const allFiles = await getDirectoryFiles(srcPath);
 			return allFiles.flatMap((filePath) => {
-				const match = extractWildcardMatch(filePath, patternParts);
-				if (match) {
+				if (!matchesPattern(filePath)) {
+					return [];
+				}
+
+				// Strip source extension before appending output extension
+				const filePathWithoutExtension = filePath.replace(extensionPattern, '');
+
+				// For multiple wildcard patterns, use the matched path from extractWildcardMatch
+				if (patternParts.length > 1) {
+					const match = extractWildcardMatch(filePathWithoutExtension, patternParts);
 					return [{
 						...output,
-						outputPath: outputPrefix + match + matchedExtension,
+						outputPath: directoryPrefix + match + matchedExtension,
 					}];
 				}
 
-				return [];
+				// For single wildcard patterns, preserve the full relative path
+				return [{
+					...output,
+					outputPath: directoryPrefix + filePathWithoutExtension + matchedExtension,
+				}];
 			});
 		}),
 	);