refactor: add absolute entry point support to browser-esbuild

This allows `browser-esbuild` to consume absolute file paths and `entryPoints`. Absolute paths will always output in the root of the output directory with the same basename, since they are not within the workspace root and cannot exist at any guaranteed unique relative path. No attempt is made to check if the absolute path is actually within the workspace root, since this would require a call to `fs.realpath()` and make this logic dependent on the actual file system structure which introduces a lot of complexity we'd rather avoid.

Longer term, the ideal approach is probably to leverage virtual files in some capacity, but this should be sufficient for now.

`main` functionality is left alone, and absolute paths like `/main.ts` are treated as relative to the workspace root. This is to preserve existing functionality and discourage public API usage of file paths outside the workspace.

(cherry picked from commit e22352b)

Author: dgp1130

packages/angular_devkit/build_angular/src/builders/browser-esbuild/options.ts

@@ -252,18 +252,36 @@ function normalizeEntryPoints(
     return { 'main': path.join(workspaceRoot, main) };
   } else {
     // Use `entryPoints` alone.
-    return Object.fromEntries(
-      Array.from(entryPoints).map((entryPoint) => {
-        const parsedEntryPoint = path.parse(entryPoint);
+    const entryPointPaths: Record<string, string> = {};
+    for (const entryPoint of entryPoints) {
+      const parsedEntryPoint = path.parse(entryPoint);
 
-        return [
-          // File path without extension.
-          path.join(parsedEntryPoint.dir, parsedEntryPoint.name),
-          // Full file path.
-          path.join(workspaceRoot, entryPoint),
-        ];
-      }),
-    );
+      // Use the input file path without an extension as the "name" of the entry point dictating its output location.
+      // Relative entry points are generated at the same relative path in the output directory.
+      // Absolute entry points are always generated with the same file name in the root of the output directory. This includes absolute
+      // paths pointing at files actually within the workspace root.
+      const entryPointName = path.isAbsolute(entryPoint)
+        ? parsedEntryPoint.name
+        : path.join(parsedEntryPoint.dir, parsedEntryPoint.name);
+
+      // Get the full file path to the entry point input.
+      const entryPointPath = path.isAbsolute(entryPoint)
+        ? entryPoint
+        : path.join(workspaceRoot, entryPoint);
+
+      // Check for conflicts with previous entry points.
+      const existingEntryPointPath = entryPointPaths[entryPointName];
+      if (existingEntryPointPath) {
+        throw new Error(
+          `\`${existingEntryPointPath}\` and \`${entryPointPath}\` both output to the same location \`${entryPointName}\`.` +
+            ' Rename or move one of the files to fix the conflict.',
+        );
+      }
+
+      entryPointPaths[entryPointName] = entryPointPath;
+    }
+
+    return entryPointPaths;
   }
 }
 

packages/angular_devkit/build_angular/src/builders/browser-esbuild/tests/options/entry-points_spec.ts

@@ -6,10 +6,23 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import { promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import * as path from 'path';
 import { buildEsbuildBrowserInternal } from '../../index';
 import { BASE_OPTIONS, BROWSER_BUILDER_INFO, describeBuilder } from '../setup';
 
 describeBuilder(buildEsbuildBrowserInternal, BROWSER_BUILDER_INFO, (harness) => {
+  let tempDir!: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(tmpdir(), 'angular-cli-e2e-browser-esbuild-main-spec-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true });
+  });
+
   describe('Option: "entryPoints"', () => {
     it('provides multiple entry points', async () => {
       await harness.writeFiles({
@@ -62,5 +75,46 @@ describeBuilder(buildEsbuildBrowserInternal, BROWSER_BUILDER_INFO, (harness) =>
 
       expect(error?.message).toContain('Only one of `main` or `entryPoints` may be provided.');
     });
+
+    it('resolves entry points outside the workspace root', async () => {
+      const entry = path.join(tempDir, 'entry.mjs');
+      await fs.writeFile(entry, `console.log('entry');`);
+
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        main: undefined,
+        entryPoints: new Set([entry]),
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      harness.expectFile('dist/entry.js').toExist();
+    });
+
+    it('throws an error when multiple entry points output to the same location', async () => {
+      // Would generate `/entry.mjs` in the output directory.
+      const entry1 = path.join(tempDir, 'entry.mjs');
+      await fs.writeFile(entry1, `console.log('entry1');`);
+
+      // Would also generate `/entry.mjs` in the output directory.
+      const subDir = path.join(tempDir, 'subdir');
+      await fs.mkdir(subDir);
+      const entry2 = path.join(subDir, 'entry.mjs');
+      await fs.writeFile(entry2, `console.log('entry2');`);
+
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        main: undefined,
+        entryPoints: new Set([entry1, entry2]),
+      });
+
+      const { result, error } = await harness.executeOnce();
+      expect(result).toBeUndefined();
+
+      expect(error?.message).toContain(entry1);
+      expect(error?.message).toContain(entry2);
+      expect(error?.message).toContain('both output to the same location');
+    });
   });
 });

packages/angular_devkit/build_angular/src/builders/browser-esbuild/tests/options/main_spec.ts

@@ -71,5 +71,20 @@ describeBuilder(buildEsbuildBrowser, BROWSER_BUILDER_INFO, (harness) => {
 
       expect(error?.message).toContain('cannot be an empty string');
     });
+
+    it('resolves an absolute path as relative inside the workspace root', async () => {
+      await harness.writeFile('file.mjs', `console.log('Hello!');`);
+
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        main: '/file.mjs',
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      // Always uses the name `main.js` for the `main` option.
+      harness.expectFile('dist/main.js').toExist();
+    });
   });
 });