fix(@angular/build): validate library outputPath and avoid duplicate secondary README assets

- Prevent secondary entry-point default `README.md` assets from copying the root or primary `README.md` when sharing `projectRoot` or the primary entry-point directory.
- Validate in `normalizeLibraryOptions` that `outputPath` is not equal to `workspaceRoot`, `projectRoot`, or a parent directory of `projectRoot` before `deleteOutputDir` executes.
- Canonicalize `workspaceRoot` via `canonicalizePath` to ensure consistent Windows drive-letter casing across compilation and file watching.

Author: alan-agius4

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

@@ -13,7 +13,7 @@ import { supportColor } from '../../utils/color';
 import { assertIsError } from '../../utils/error';
 import { normalizeAssetPatterns } from '../../utils/normalize-asset-patterns';
 import { normalizeCacheOptions } from '../../utils/normalize-cache';
-import { toPosixPath } from '../../utils/path';
+import { canonicalizePath, isSubDirectory, toPosixPath } from '../../utils/path';
 import {
   generateSearchDirectories,
   getTailwindConfig,
@@ -39,14 +39,15 @@ export async function normalizeLibraryOptions(
   projectName: string,
   options: LibraryBuilderOptions,
 ): Promise<NormalizedLibraryOptions> {
-  const workspaceRoot = toPosixPath(context.workspaceRoot);
+  const workspaceRoot = toPosixPath(canonicalizePath(context.workspaceRoot));
   const projectMetadata = await context.getProjectMetadata(projectName);
   const projectRootPaths = getProjectRootPaths(workspaceRoot, projectMetadata);
   const projectRoot = toPosixPath(projectRootPaths.projectRoot);
   const projectSourceRoot = toPosixPath(projectRootPaths.projectSourceRoot);
 
   const {
     tsConfig,
+    outputPath: rawOutputPath,
     assets: rawAssets,
     stylePreprocessorOptions,
     inlineStyleLanguage = 'css',
@@ -62,6 +63,19 @@ export async function normalizeLibraryOptions(
     clearScreen,
   } = options;
 
+  const outputPath = toPosixPath(
+    path.resolve(workspaceRoot, rawOutputPath ?? path.posix.join('dist', projectName)),
+  );
+  if (
+    outputPath === workspaceRoot ||
+    outputPath === projectRoot ||
+    isSubDirectory(outputPath, projectRoot)
+  ) {
+    throw new Error(
+      `The 'outputPath' option ('${outputPath}') cannot be the workspace root, project root, or a parent directory of the project root.`,
+    );
+  }
+
   const resolvedTsConfigPath = toPosixPath(path.resolve(workspaceRoot, tsConfig));
   const packageJsonPath = path.posix.join(projectRoot, 'package.json');
 
@@ -105,13 +119,31 @@ export async function normalizeLibraryOptions(
     { glob: 'README.md', input: projectRoot, output: '.' },
   ];
 
+  const primaryEntryPoint = entryPoints.get('.');
+  const primaryEntryDir = primaryEntryPoint
+    ? path.posix.dirname(primaryEntryPoint.entryFilePath)
+    : undefined;
+  const seenReadmeAssets = new Set<string>();
+
   for (const entryPoint of entryPoints.values()) {
     if (entryPoint.isPrimary) {
       continue;
     }
+
+    const entryDir = path.posix.dirname(entryPoint.entryFilePath);
+    if (entryDir === projectRoot || entryDir === primaryEntryDir) {
+      continue;
+    }
+
+    const readmeKey = `${entryDir}:${entryPoint.name}`;
+    if (seenReadmeAssets.has(readmeKey)) {
+      continue;
+    }
+    seenReadmeAssets.add(readmeKey);
+
     defaultAssets.push({
       glob: 'README.md',
-      input: path.posix.dirname(entryPoint.entryFilePath),
+      input: entryDir,
       output: entryPoint.name,
     });
   }
@@ -149,9 +181,7 @@ export async function normalizeLibraryOptions(
     projectRoot,
     packageName,
     packageJson,
-    outputPath: toPosixPath(
-      path.resolve(workspaceRoot, options.outputPath ?? path.posix.join('dist', projectName)),
-    ),
+    outputPath,
     deleteOutputPath,
     packageJsonPath,
     tsConfigPath: resolvedTsConfigPath,

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

@@ -53,5 +53,76 @@ describeLibraryBuilder(executeLibraryBuilder, LIBRARY_BUILDER_INFO, (harness) =>
 
       expect(harness.readFile('dist/lib/docs/README.md')).toBe('# Library Docs');
     });
+
+    it('should not copy root README.md into secondary entry point output when secondary entry point is in projectRoot', async () => {
+      await harness.writeFiles({
+        'projects/lib/README.md': '# Root Library README',
+        'projects/lib/testing.ts': 'export const TESTING = true;',
+      });
+
+      await harness.modifyFile('projects/lib/package.json', (content) => {
+        const pkg = JSON.parse(content);
+        pkg.exports = {
+          '.': './src/public-api.ts',
+          './testing': './testing.ts',
+        };
+
+        return JSON.stringify(pkg, null, 2);
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      expect(harness.readFile('dist/lib/README.md')).toBe('# Root Library README');
+      expect(harness.hasFile('dist/lib/testing/README.md')).toBeFalse();
+    });
+
+    it('should not copy README.md into secondary entry point output when sharing directory with primary entry point', async () => {
+      await harness.writeFiles({
+        'projects/lib/README.md': '# Root Library README',
+        'projects/lib/src/README.md': '# Src README',
+        'projects/lib/src/testing.ts': 'export const TESTING = true;',
+      });
+
+      await harness.modifyFile('projects/lib/package.json', (content) => {
+        const pkg = JSON.parse(content);
+        pkg.exports = {
+          '.': './src/public-api.ts',
+          './testing': './src/testing.ts',
+        };
+
+        return JSON.stringify(pkg, null, 2);
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      expect(harness.readFile('dist/lib/README.md')).toBe('# Root Library README');
+      expect(harness.hasFile('dist/lib/testing/README.md')).toBeFalse();
+    });
+
+    it('should copy secondary entry point README.md when located in its own directory', async () => {
+      await harness.writeFiles({
+        'projects/lib/README.md': '# Root Library README',
+        'projects/lib/testing/README.md': '# Testing Entry Point README',
+        'projects/lib/testing/public-api.ts': 'export const TESTING = true;',
+      });
+
+      await harness.modifyFile('projects/lib/package.json', (content) => {
+        const pkg = JSON.parse(content);
+        pkg.exports = {
+          '.': './src/public-api.ts',
+          './testing': './testing/public-api.ts',
+        };
+
+        return JSON.stringify(pkg, null, 2);
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      expect(harness.readFile('dist/lib/README.md')).toBe('# Root Library README');
+      expect(harness.readFile('dist/lib/testing/README.md')).toBe('# Testing Entry Point README');
+    });
   });
 });

packages/angular/build/src/builders/library/tests/options/output-path_spec.ts

@@ -32,5 +32,58 @@ describeLibraryBuilder(executeLibraryBuilder, LIBRARY_BUILDER_INFO, (harness) =>
       harness.expectFile('dist/custom-output/fesm2022/lib.mjs').toExist();
       harness.expectFile('dist/custom-output/package.json').toExist();
     });
+
+    it('should reject outputPath equal to projectRoot', async () => {
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        outputPath: 'projects/lib',
+      });
+
+      const { result, error } = await harness.executeOnce({
+        outputLogsOnException: false,
+        outputLogsOnFailure: false,
+      });
+      expect(result).toBeUndefined();
+      expect(error).toBeDefined();
+      expect((error as Error).message).toMatch(
+        /The 'outputPath' option .* cannot be the workspace root, project root, or a parent directory of the project root/,
+      );
+      harness.expectFile('projects/lib/package.json').toExist();
+    });
+
+    it('should reject outputPath equal to workspaceRoot', async () => {
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        outputPath: '.',
+      });
+
+      const { result, error } = await harness.executeOnce({
+        outputLogsOnException: false,
+        outputLogsOnFailure: false,
+      });
+      expect(result).toBeUndefined();
+      expect(error).toBeDefined();
+      expect((error as Error).message).toMatch(
+        /The 'outputPath' option .* cannot be the workspace root, project root, or a parent directory of the project root/,
+      );
+    });
+
+    it('should reject outputPath when it is a parent directory of projectRoot', async () => {
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        outputPath: 'projects',
+      });
+
+      const { result, error } = await harness.executeOnce({
+        outputLogsOnException: false,
+        outputLogsOnFailure: false,
+      });
+      expect(result).toBeUndefined();
+      expect(error).toBeDefined();
+      expect((error as Error).message).toMatch(
+        /The 'outputPath' option .* cannot be the workspace root, project root, or a parent directory of the project root/,
+      );
+      harness.expectFile('projects/lib/package.json').toExist();
+    });
   });
 });