feat(@angular/build): support patterns in library entryPoints

A key and its entry file path in `entryPoints` can each contain one `*`,
as with subpath patterns in package.json `exports`. For example
`"./*": "projects/lib/*/public-api.ts"` adds an entry point for every
matching file, with the matched part of the path, which can include `/`,
used in the key.

Explicit entry points take precedence over a pattern match with the same
name or the same entry file, and a pattern that matches no files is an
error. Patterns are expanded when the build starts.

Author: thekhegay

packages/angular/build/src/builders/library/options.ts

@@ -9,6 +9,7 @@
 import type { BuilderContext } from '@angular-devkit/architect';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { escapePath, glob } from 'tinyglobby';
 import type { StylesheetPluginsass } from '../../tools/esbuild/stylesheets/stylesheet-plugin-factory';
 import { normalizeAssetPatterns } from '../../utils';
 import { supportColor } from '../../utils/color';
@@ -154,7 +155,7 @@ export async function normalizeLibraryOptions(
     throw new Error(`The package.json at '${packageJsonPath}' must contain a 'name'.`);
   }
 
-  const entryPoints = normalizeEntryPoints(
+  const entryPoints = await normalizeEntryPoints(
     rawEntryPoints,
     workspaceRoot,
     resolvedTsConfigPath,
@@ -303,31 +304,31 @@ function normalizeEntryPoint(
 /**
  * Normalizes all entry points for the library project.
  *
+ * A key and its entry file path can each contain a single '*', the same as subpath patterns
+ * in package.json `exports`. The '*' in the path matches any non-empty string, including '/',
+ * and adds an entry point for every matching file, with the matched value substituted into
+ * the key. Explicit entry points take precedence over pattern matches with the same name or
+ * the same entry file.
+ *
  * @param rawEntryPoints The raw entryPoints dictionary from schema options.
  * @param workspaceRoot The workspace root directory.
  * @param defaultTsConfigPath The default tsConfig path for the project.
  * @param projectName The project name used in error reporting.
  * @param packageName The root package name (e.g. `@my/lib`).
  * @returns A Map of normalized entry points keyed by name.
  */
-function normalizeEntryPoints(
+async function normalizeEntryPoints(
   rawEntryPoints: LibraryBuilderOptions['entryPoints'],
   workspaceRoot: string,
   defaultTsConfigPath: string,
   projectName: string,
   packageName: string,
-): Map<string, NormalizedEntryPoint> {
+): Promise<Map<string, NormalizedEntryPoint>> {
   const entryPoints = new Map<string, NormalizedEntryPoint>();
+  const patterns: [string, LibraryBuilderOptions['entryPoints'][string]][] = [];
   let hasPrimary = false;
 
-  for (const [key, value] of Object.entries(rawEntryPoints)) {
-    const entryPoint = normalizeEntryPoint(
-      key,
-      value,
-      workspaceRoot,
-      defaultTsConfigPath,
-      packageName,
-    );
+  const addEntryPoint = (key: string, entryPoint: NormalizedEntryPoint) => {
     if (entryPoints.has(entryPoint.name)) {
       throw new Error(
         `Duplicate entry point detected: '${key}' resolves to the same name ('${entryPoint.name}') as an existing entry point.`,
@@ -337,6 +338,44 @@ function normalizeEntryPoints(
     if (entryPoint.isPrimary) {
       hasPrimary = true;
     }
+  };
+
+  for (const [key, value] of Object.entries(rawEntryPoints)) {
+    const entryFile = typeof value === 'string' ? value : value.entryPoint;
+    if (key.includes('*') || entryFile.includes('*')) {
+      patterns.push([key, value]);
+      continue;
+    }
+
+    addEntryPoint(
+      key,
+      normalizeEntryPoint(key, value, workspaceRoot, defaultTsConfigPath, packageName),
+    );
+  }
+
+  const explicitNames = new Set(entryPoints.keys());
+  const explicitFiles = new Set(Array.from(entryPoints.values(), (e) => e.entryFilePath));
+
+  for (const [key, value] of patterns) {
+    const entryFile = typeof value === 'string' ? value : value.entryPoint;
+    for (const [matchedKey, matchedFile] of await expandEntryPointPattern(
+      key,
+      entryFile,
+      workspaceRoot,
+    )) {
+      const entryPoint = normalizeEntryPoint(
+        matchedKey,
+        typeof value === 'string' ? matchedFile : { ...value, entryPoint: matchedFile },
+        workspaceRoot,
+        defaultTsConfigPath,
+        packageName,
+      );
+      if (explicitNames.has(entryPoint.name) || explicitFiles.has(entryPoint.entryFilePath)) {
+        continue;
+      }
+
+      addEntryPoint(matchedKey, entryPoint);
+    }
   }
 
   if (!hasPrimary) {
@@ -347,3 +386,59 @@ function normalizeEntryPoints(
 
   return entryPoints;
 }
+
+/**
+ * Expands an entry point pattern into the key and entry file of every matching file,
+ * sorted by key.
+ *
+ * @param key The entry point key containing a single '*'.
+ * @param entryFile The entry file path containing a single '*'.
+ * @param workspaceRoot The workspace root directory.
+ * @returns The expanded keys and absolute entry file paths.
+ */
+async function expandEntryPointPattern(
+  key: string,
+  entryFile: string,
+  workspaceRoot: string,
+): Promise<[string, string][]> {
+  if (key.split('*').length !== 2 || entryFile.split('*').length !== 2) {
+    throw new Error(
+      `Invalid entry point pattern '${key}': the key and the entry file path must each contain exactly one '*'.`,
+    );
+  }
+
+  const pattern = toPosixPath(path.resolve(workspaceRoot, entryFile));
+  const starIndex = pattern.indexOf('*');
+  const prefix = pattern.slice(0, starIndex);
+  const suffix = pattern.slice(starIndex + 1);
+  const baseDir = prefix.slice(0, prefix.lastIndexOf('/') + 1);
+
+  const files = await glob(`**/*${escapePath(suffix.slice(suffix.lastIndexOf('/') + 1))}`, {
+    cwd: baseDir,
+    ignore: ['**/node_modules/**'],
+  });
+
+  const [keyPrefix, keySuffix] = key.split('*');
+  const matches: [string, string][] = [];
+  for (const file of files) {
+    const filePath = baseDir + file;
+    if (
+      filePath.length <= prefix.length + suffix.length ||
+      !filePath.startsWith(prefix) ||
+      !filePath.endsWith(suffix) ||
+      !/\.m?ts$/.test(filePath) ||
+      /\.d\.m?ts$/.test(filePath)
+    ) {
+      continue;
+    }
+
+    const match = filePath.slice(prefix.length, filePath.length - suffix.length);
+    matches.push([keyPrefix + match + keySuffix, filePath]);
+  }
+
+  if (matches.length === 0) {
+    throw new Error(`Entry point pattern '${key}' did not match any files: '${entryFile}'.`);
+  }
+
+  return matches.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+}

packages/angular/build/src/builders/library/schema.json

@@ -6,7 +6,7 @@
   "properties": {
     "entryPoints": {
       "type": "object",
-      "description": "Map of package entry points. The '.' key represents the primary entry point; other keys define secondary subpath entry points.",
+      "description": "Map of package entry points. The '.' key represents the primary entry point; other keys define secondary subpath entry points. A key and its entry file path can each contain one '*' (e.g. './*': 'projects/lib/*/public-api.ts') to add an entry point for every matching file, as with subpath patterns in package.json 'exports'. Patterns are expanded when the build starts.",
       "required": ["."],
       "additionalProperties": {
         "oneOf": [

packages/angular/build/src/builders/library/tests/options/entry-points_spec.ts

@@ -72,5 +72,94 @@ describeLibraryBuilder(executeLibraryBuilder, LIBRARY_BUILDER_INFO, (harness) =>
       expect(error).toBeDefined();
       expect((error as Error).message).toMatch(/must be a TypeScript file \('\.ts' or '\.mts'\)/);
     });
+
+    it('should add an entry point for every file matched by a pattern', async () => {
+      await harness.writeFiles({
+        'projects/lib/feature/src/public-api.ts': 'export const FEATURE = 1;\n',
+        'projects/lib/nested/child/src/public-api.ts': 'export const CHILD = 2;\n',
+      });
+
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        entryPoints: {
+          '.': 'projects/lib/src/public-api.ts',
+          './*': 'projects/lib/*/src/public-api.ts',
+        },
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      const { exports } = JSON.parse(harness.readFile('dist/lib/package.json'));
+      expect(Object.keys(exports).sort()).toEqual([
+        '.',
+        './feature',
+        './nested/child',
+        './package.json',
+      ]);
+      harness.expectFile('dist/lib/fesm2022/lib-feature.mjs').content.toContain('FEATURE');
+      harness.expectFile('dist/lib/fesm2022/lib-nested-child.mjs').content.toContain('CHILD');
+    });
+
+    it('should prefer an explicit entry point over a pattern match for the same file', async () => {
+      await harness.writeFiles({
+        'projects/lib/feature/src/public-api.ts': 'export const FEATURE = 1;\n',
+        'projects/lib/other/src/public-api.ts': 'export const OTHER = 2;\n',
+      });
+
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        entryPoints: {
+          '.': 'projects/lib/src/public-api.ts',
+          './*': 'projects/lib/*/src/public-api.ts',
+          './renamed': 'projects/lib/other/src/public-api.ts',
+        },
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      const { exports } = JSON.parse(harness.readFile('dist/lib/package.json'));
+      expect(Object.keys(exports).sort()).toEqual([
+        '.',
+        './feature',
+        './package.json',
+        './renamed',
+      ]);
+    });
+
+    it('should fail when a pattern does not match any files', async () => {
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        entryPoints: {
+          '.': 'projects/lib/src/public-api.ts',
+          './*': 'projects/lib/*/missing.ts',
+        },
+      });
+
+      const { result, error } = await harness.executeOnce({
+        outputLogsOnException: false,
+        outputLogsOnFailure: false,
+      });
+      expect(result).toBeUndefined();
+      expect((error as Error).message).toMatch(/did not match any files/);
+    });
+
+    it('should fail when only the key or the path contains a pattern', async () => {
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        entryPoints: {
+          '.': 'projects/lib/src/public-api.ts',
+          './*': 'projects/lib/src/public-api.ts',
+        },
+      });
+
+      const { result, error } = await harness.executeOnce({
+        outputLogsOnException: false,
+        outputLogsOnFailure: false,
+      });
+      expect(result).toBeUndefined();
+      expect((error as Error).message).toMatch(/must each contain exactly one '\*'/);
+    });
   });
 });