refactor(@angular/build): scope cache directory by project name in normalizeCacheOptions

Accept an optional `projectName` parameter in `normalizeCacheOptions` to
consistently scope `path` and `localPath` per project across the
application, dev-server, library, ng-packagr, and unit-test builders.

Author: alan-agius4

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

@@ -182,8 +182,7 @@ export async function normalizeOptions(
   const { projectRoot, projectSourceRoot } = getProjectRootPaths(workspaceRoot, projectMetadata);
 
   // Gather persistent caching option and provide a project specific cache location
-  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);
-  cacheOptions.path = path.join(cacheOptions.path, projectName);
+  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot, projectName);
 
   const i18nOptions: I18nOptions & {
     duplicateTranslationBehavior?: I18NTranslation;

packages/angular/build/src/builders/dev-server/options.ts

@@ -39,7 +39,7 @@ export async function normalizeOptions(
   const projectMetadata = await context.getProjectMetadata(projectName);
   const projectRoot = path.join(workspaceRoot, (projectMetadata.root as string | undefined) ?? '');
 
-  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);
+  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot, projectName);
 
   // Target specifier defaults to the current project's build target using a development configuration
   const buildTargetSpecifier = options.buildTarget ?? `::development`;

packages/angular/build/src/builders/dev-server/vite/server.ts

@@ -167,7 +167,6 @@ export async function setupServer(
     externalMetadata.explicitBrowser.length === 0 && ssrMode === ServerSsrMode.NoSsr;
   const cacheDir = join(
     serverOptions.cacheOptions.localPath ?? serverOptions.cacheOptions.path,
-    serverOptions.buildTarget.project,
     'vite',
   );
 

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

@@ -50,9 +50,7 @@ export async function normalizeLibraryOptions(
     clearScreen,
   } = options;
 
-  const resolvedTsConfigPath = path.resolve(workspaceRoot, tsConfig);
   const packageJsonPath = path.join(projectRoot, 'package.json');
-
   let packageJson: PackageJsonData;
   try {
     const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
@@ -112,7 +110,7 @@ export async function normalizeLibraryOptions(
     projectSourceRoot,
   );
 
-  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);
+  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot, projectName);
   const styleIncludePaths = (stylePreprocessorOptions?.includePaths ?? []).map((p: string) =>
     path.resolve(workspaceRoot, p),
   );
@@ -131,7 +129,7 @@ export async function normalizeLibraryOptions(
     outputPath: path.resolve(workspaceRoot, options.outputPath ?? path.join('dist', projectName)),
     deleteOutputPath,
     packageJsonPath,
-    tsConfigPath: resolvedTsConfigPath,
+    tsConfigPath: path.resolve(workspaceRoot, tsConfig),
     entryPoints,
     inlineStyleLanguage,
     styleIncludePaths,

packages/angular/build/src/builders/ng-packagr/builder.ts

@@ -66,6 +66,7 @@ export async function* execute(
   const { enabled: cacheEnabled, path: cacheDirectory } = normalizeCacheOptions(
     metadata,
     context.workspaceRoot,
+    projectName,
   );
 
   const ngPackagrOptions: NgPackagrOptions = {

packages/angular/build/src/builders/unit-test/options.ts

@@ -64,8 +64,7 @@ export async function normalizeOptions(
   const { projectRoot, projectSourceRoot } = getProjectRootPaths(workspaceRoot, projectMetadata);
 
   // Gather persistent caching option and provide a project specific cache location
-  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);
-  cacheOptions.path = path.join(cacheOptions.path, projectName);
+  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot, projectName);
 
   const {
     runner,

packages/angular/build/src/utils/normalize-cache.ts

@@ -97,9 +97,22 @@ function getCacheBasePath(workspaceRoot: string, cachePathSetting: string): stri
   return resolve(workspaceRoot, cachePathSetting);
 }
 
+/**
+ * Normalizes the persistent disk cache configuration for a project or workspace.
+ *
+ * Resolves whether disk caching is enabled based on the CLI cache metadata, current runtime
+ * environment (local vs. CI, or WebContainers), and computes the versioned cache directory paths
+ * (resolving shared Git worktree paths when applicable).
+ *
+ * @param projectMetadata The project or workspace metadata object containing optional `cli.cache` settings.
+ * @param workspaceRoot The absolute path to the workspace root directory.
+ * @param projectName Optional name of the project used to scope the resolved cache path.
+ * @returns The normalized disk cache options including enabled state and resolved directory paths.
+ */
 export function normalizeCacheOptions(
   projectMetadata: unknown,
   workspaceRoot: string,
+  projectName: string = '',
 ): NormalizedCachedOptions {
   const cacheMetadata = hasCacheMetadata(projectMetadata) ? projectMetadata.cli.cache : {};
 
@@ -129,8 +142,8 @@ export function normalizeCacheOptions(
   return {
     enabled: cacheEnabled,
     basePath: cacheBasePath,
-    path: join(cacheBasePath, VERSION),
+    path: join(cacheBasePath, VERSION, projectName),
     localBasePath: localCacheBasePath,
-    localPath: join(localCacheBasePath, VERSION),
+    localPath: join(localCacheBasePath, VERSION, projectName),
   };
 }

packages/angular/build/src/utils/normalize-cache_spec.ts

@@ -197,4 +197,41 @@ describe('normalizeCacheOptions', () => {
     expect(options.localBasePath).toBe(resolve(workspaceRoot, '.angular/cache'));
     expect(options.localPath).toBe(resolve(workspaceRoot, '.angular/cache', '0.0.0-PLACEHOLDER'));
   });
+
+  it('should scope path and localPath to projectName when provided', async () => {
+    const workspaceRoot = join(tempDir, 'project');
+    await mkdir(join(workspaceRoot, '.git'), { recursive: true });
+
+    const options = normalizeCacheOptions({}, workspaceRoot, 'my-app');
+
+    expect(options.basePath).toBe(resolve(workspaceRoot, '.angular/cache'));
+    expect(options.path).toBe(resolve(workspaceRoot, '.angular/cache/0.0.0-PLACEHOLDER/my-app'));
+    expect(options.localBasePath).toBe(resolve(workspaceRoot, '.angular/cache'));
+    expect(options.localPath).toBe(
+      resolve(workspaceRoot, '.angular/cache/0.0.0-PLACEHOLDER/my-app'),
+    );
+  });
+
+  it('should scope path and localPath to projectName in a git worktree', async () => {
+    const mainRepoRoot = join(tempDir, 'main-repo');
+    const mainGitDir = join(mainRepoRoot, '.git');
+    const worktreeRoot = join(tempDir, 'worktree');
+
+    await mkdir(mainGitDir, { recursive: true });
+
+    const worktreeMetadataDir = join(mainGitDir, 'worktrees/wt-1');
+    await mkdir(worktreeMetadataDir, { recursive: true });
+    await mkdir(worktreeRoot, { recursive: true });
+    await writeFile(join(worktreeRoot, '.git'), `gitdir: ${worktreeMetadataDir}`);
+    await writeFile(join(worktreeMetadataDir, 'commondir'), '../..');
+
+    const options = normalizeCacheOptions({}, worktreeRoot, 'my-lib');
+
+    expect(options.basePath).toBe(resolve(mainRepoRoot, '.angular/cache'));
+    expect(options.path).toBe(resolve(mainRepoRoot, '.angular/cache/0.0.0-PLACEHOLDER/my-lib'));
+    expect(options.localBasePath).toBe(resolve(worktreeRoot, '.angular/cache'));
+    expect(options.localPath).toBe(
+      resolve(worktreeRoot, '.angular/cache/0.0.0-PLACEHOLDER/my-lib'),
+    );
+  });
 });