@angular-devkit/build-angular 16.1.4 → 16.2.0-next.1

package/src/builders/{browser-esbuild → application}/options.d.ts

@@ -6,12 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { BuilderContext } from '@angular-devkit/architect';
-import { Schema as BrowserBuilderOptions } from './schema';
-export type NormalizedBrowserOptions = Awaited<ReturnType<typeof normalizeOptions>>;
+import { Schema as ApplicationBuilderOptions } from './schema';
+export type NormalizedApplicationBuildOptions = Awaited<ReturnType<typeof normalizeOptions>>;
 /** Internal options hidden from builder schema but available when invoked programmatically. */
 interface InternalOptions {
     /**
-     * Entry points to use for the compilation. Incompatible with `main`, which must not be provided. May be relative or absolute paths.
+     * Entry points to use for the compilation. Incompatible with `browser`, which must not be provided. May be relative or absolute paths.
      * If given a relative path, it is resolved relative to the current workspace and will generate an output at the same relative location
      * in the output directory. If given an absolute path, the output will be generated in the root of the output directory with the same base
      * name.
@@ -25,9 +25,9 @@ interface InternalOptions {
      */
     externalPackages?: boolean;
 }
-/** Full set of options for `browser-esbuild` builder. */
-export type BrowserEsbuildOptions = Omit<BrowserBuilderOptions & InternalOptions, 'main'> & {
-    main?: string;
+/** Full set of options for `application` builder. */
+export type ApplicationBuilderInternalOptions = Omit<ApplicationBuilderOptions & InternalOptions, 'browser'> & {
+    browser?: string;
 };
 /**
  * Normalize the user provided options by creating full paths for all path based options
@@ -39,12 +39,13 @@ export type BrowserEsbuildOptions = Omit<BrowserBuilderOptions & InternalOptions
  * @param options An object containing the options to use for the build.
  * @returns An object containing normalized options required to perform the build.
  */
-export declare function normalizeOptions(context: BuilderContext, projectName: string, options: BrowserEsbuildOptions): Promise<{
-    advancedOptimizations: boolean | undefined;
+export declare function normalizeOptions(context: BuilderContext, projectName: string, options: ApplicationBuilderInternalOptions): Promise<{
+    advancedOptimizations: boolean;
     allowedCommonJsDependencies: string[] | undefined;
     baseHref: string | undefined;
     cacheOptions: import("../../utils/normalize-cache").NormalizedCachedOptions;
     crossOrigin: import("./schema").CrossOrigin | undefined;
+    deleteOutputPath: boolean | undefined;
     externalDependencies: string[] | undefined;
     extractLicenses: boolean | undefined;
     inlineStyleLanguage: string;
@@ -57,6 +58,7 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
     preserveSymlinks: boolean;
     stylePreprocessorOptions: import("./schema").StylePreprocessorOptions | undefined;
     subresourceIntegrity: boolean | undefined;
+    serverEntryPoint: string | undefined;
     verbose: boolean | undefined;
     watch: boolean | undefined;
     workspaceRoot: string;
@@ -83,7 +85,7 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
         files: string[];
         initial: boolean;
     }[];
-    serviceWorkerOptions: string | undefined;
+    serviceWorker: any;
     indexHtmlOptions: {
         input: string;
         output: string;

package/src/builders/application/options.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const helpers_1 = require("../../tools/webpack/utils/helpers");
+const utils_1 = require("../../utils");
+const normalize_cache_1 = require("../../utils/normalize-cache");
+const package_chunk_sort_1 = require("../../utils/package-chunk-sort");
+const tailwind_1 = require("../../utils/tailwind");
+const webpack_browser_config_1 = require("../../utils/webpack-browser-config");
+const schema_1 = require("./schema");
+/**
+ * Normalize the user provided options by creating full paths for all path based options
+ * and converting multi-form options into a single form that can be directly used
+ * by the build process.
+ *
+ * @param context The context for current builder execution.
+ * @param projectName The name of the project for the current execution.
+ * @param options An object containing the options to use for the build.
+ * @returns An object containing normalized options required to perform the build.
+ */
+async function normalizeOptions(context, projectName, options) {
+    const workspaceRoot = context.workspaceRoot;
+    const projectMetadata = await context.getProjectMetadata(projectName);
+    const projectRoot = normalizeDirectoryPath(node_path_1.default.join(workspaceRoot, projectMetadata.root ?? ''));
+    const projectSourceRoot = normalizeDirectoryPath(node_path_1.default.join(workspaceRoot, projectMetadata.sourceRoot ?? 'src'));
+    // Gather persistent caching option and provide a project specific cache location
+    const cacheOptions = (0, normalize_cache_1.normalizeCacheOptions)(projectMetadata, workspaceRoot);
+    cacheOptions.path = node_path_1.default.join(cacheOptions.path, projectName);
+    const entryPoints = normalizeEntryPoints(workspaceRoot, options.browser, options.entryPoints);
+    const tsconfig = node_path_1.default.join(workspaceRoot, options.tsConfig);
+    const outputPath = normalizeDirectoryPath(node_path_1.default.join(workspaceRoot, options.outputPath));
+    const optimizationOptions = (0, utils_1.normalizeOptimization)(options.optimization);
+    const sourcemapOptions = (0, utils_1.normalizeSourceMaps)(options.sourceMap ?? false);
+    const assets = options.assets?.length
+        ? (0, utils_1.normalizeAssetPatterns)(options.assets, workspaceRoot, projectRoot, projectSourceRoot)
+        : undefined;
+    const outputNames = {
+        bundles: options.outputHashing === schema_1.OutputHashing.All || options.outputHashing === schema_1.OutputHashing.Bundles
+            ? '[name].[hash]'
+            : '[name]',
+        media: 'media/' +
+            (options.outputHashing === schema_1.OutputHashing.All || options.outputHashing === schema_1.OutputHashing.Media
+                ? '[name].[hash]'
+                : '[name]'),
+    };
+    let fileReplacements;
+    if (options.fileReplacements) {
+        for (const replacement of options.fileReplacements) {
+            fileReplacements ?? (fileReplacements = {});
+            fileReplacements[node_path_1.default.join(workspaceRoot, replacement.replace)] = node_path_1.default.join(workspaceRoot, replacement.with);
+        }
+    }
+    const globalStyles = [];
+    if (options.styles?.length) {
+        const { entryPoints: stylesheetEntrypoints, noInjectNames } = (0, helpers_1.normalizeGlobalStyles)(options.styles || []);
+        for (const [name, files] of Object.entries(stylesheetEntrypoints)) {
+            globalStyles.push({ name, files, initial: !noInjectNames.includes(name) });
+        }
+    }
+    const globalScripts = [];
+    if (options.scripts?.length) {
+        for (const { bundleName, paths, inject } of (0, helpers_1.globalScriptsByBundleName)(options.scripts)) {
+            globalScripts.push({ name: bundleName, files: paths, initial: inject });
+        }
+    }
+    let tailwindConfiguration;
+    const tailwindConfigurationPath = await (0, tailwind_1.findTailwindConfigurationFile)(workspaceRoot, projectRoot);
+    if (tailwindConfigurationPath) {
+        // Create a node resolver at the project root as a directory
+        const resolver = (0, node_module_1.createRequire)(projectRoot + '/');
+        try {
+            tailwindConfiguration = {
+                file: tailwindConfigurationPath,
+                package: resolver.resolve('tailwindcss'),
+            };
+        }
+        catch {
+            const relativeTailwindConfigPath = node_path_1.default.relative(workspaceRoot, tailwindConfigurationPath);
+            context.logger.warn(`Tailwind CSS configuration file found (${relativeTailwindConfigPath})` +
+                ` but the 'tailwindcss' package is not installed.` +
+                ` To enable Tailwind CSS, please install the 'tailwindcss' package.`);
+        }
+    }
+    let indexHtmlOptions;
+    if (options.index) {
+        indexHtmlOptions = {
+            input: node_path_1.default.join(workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(options.index)),
+            // The output file will be created within the configured output path
+            output: (0, webpack_browser_config_1.getIndexOutputFile)(options.index),
+            // TODO: Use existing information from above to create the insertion order
+            insertionOrder: (0, package_chunk_sort_1.generateEntryPoints)({
+                scripts: options.scripts ?? [],
+                styles: options.styles ?? [],
+            }),
+        };
+    }
+    let serverEntryPoint;
+    if (options.server) {
+        serverEntryPoint = node_path_1.default.join(workspaceRoot, options.server);
+    }
+    else if (options.server === '') {
+        throw new Error('`server` option cannot be an empty string.');
+    }
+    // Initial options to keep
+    const { allowedCommonJsDependencies, aot, baseHref, crossOrigin, externalDependencies, extractLicenses, inlineStyleLanguage = 'css', outExtension, serviceWorker, poll, polyfills, preserveSymlinks, statsJson, stylePreprocessorOptions, subresourceIntegrity, verbose, watch, progress = true, externalPackages, deleteOutputPath, } = options;
+    // Return all the normalized options
+    return {
+        advancedOptimizations: !!aot,
+        allowedCommonJsDependencies,
+        baseHref,
+        cacheOptions,
+        crossOrigin,
+        deleteOutputPath,
+        externalDependencies,
+        extractLicenses,
+        inlineStyleLanguage,
+        jit: !aot,
+        stats: !!statsJson,
+        polyfills: polyfills === undefined || Array.isArray(polyfills) ? polyfills : [polyfills],
+        poll,
+        progress,
+        externalPackages,
+        // If not explicitly set, default to the Node.js process argument
+        preserveSymlinks: preserveSymlinks ?? process.execArgv.includes('--preserve-symlinks'),
+        stylePreprocessorOptions,
+        subresourceIntegrity,
+        serverEntryPoint,
+        verbose,
+        watch,
+        workspaceRoot,
+        entryPoints,
+        optimizationOptions,
+        outputPath,
+        outExtension,
+        sourcemapOptions,
+        tsconfig,
+        projectRoot,
+        assets,
+        outputNames,
+        fileReplacements,
+        globalStyles,
+        globalScripts,
+        serviceWorker,
+        indexHtmlOptions,
+        tailwindConfiguration,
+    };
+}
+exports.normalizeOptions = normalizeOptions;
+/**
+ * Normalize entry point options. To maintain compatibility with the legacy browser builder, we need a single `browser`
+ * option which defines a single entry point. However, we also want to support multiple entry points as an internal option.
+ * The two options are mutually exclusive and if `browser` is provided it will be used as the sole entry point.
+ * If `entryPoints` are provided, they will be used as the set of entry points.
+ *
+ * @param workspaceRoot Path to the root of the Angular workspace.
+ * @param browser The `browser` option pointing at the application entry point. While required per the schema file, it may be omitted by
+ *     programmatic usages of `browser-esbuild`.
+ * @param entryPoints Set of entry points to use if provided.
+ * @returns An object mapping entry point names to their file paths.
+ */
+function normalizeEntryPoints(workspaceRoot, browser, entryPoints = new Set()) {
+    if (browser === '') {
+        throw new Error('`browser` option cannot be an empty string.');
+    }
+    // `browser` and `entryPoints` are mutually exclusive.
+    if (browser && entryPoints.size > 0) {
+        throw new Error('Only one of `browser` or `entryPoints` may be provided.');
+    }
+    if (!browser && entryPoints.size === 0) {
+        // Schema should normally reject this case, but programmatic usages of the builder might make this mistake.
+        throw new Error('Either `browser` or at least one `entryPoints` value must be provided.');
+    }
+    // Schema types force `browser` to always be provided, but it may be omitted when the builder is invoked programmatically.
+    if (browser) {
+        // Use `browser` alone.
+        return { 'main': node_path_1.default.join(workspaceRoot, browser) };
+    }
+    else {
+        // Use `entryPoints` alone.
+        const entryPointPaths = {};
+        for (const entryPoint of entryPoints) {
+            const parsedEntryPoint = node_path_1.default.parse(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 = node_path_1.default.isAbsolute(entryPoint)
+                ? parsedEntryPoint.name
+                : node_path_1.default.join(parsedEntryPoint.dir, parsedEntryPoint.name);
+            // Get the full file path to the entry point input.
+            const entryPointPath = node_path_1.default.isAbsolute(entryPoint)
+                ? entryPoint
+                : node_path_1.default.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;
+    }
+}
+/**
+ * Normalize a directory path string.
+ * Currently only removes a trailing slash if present.
+ * @param path A path string.
+ * @returns A normalized path string.
+ */
+function normalizeDirectoryPath(path) {
+    const last = path[path.length - 1];
+    if (last === '/' || last === '\\') {
+        return path.slice(0, -1);
+    }
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/application/options.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { BuilderContext } from '@angular-devkit/architect';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\nimport {\n  globalScriptsByBundleName,\n  normalizeGlobalStyles,\n} from '../../tools/webpack/utils/helpers';\nimport { normalizeAssetPatterns, normalizeOptimization, normalizeSourceMaps } from '../../utils';\nimport { normalizeCacheOptions } from '../../utils/normalize-cache';\nimport { generateEntryPoints } from '../../utils/package-chunk-sort';\nimport { findTailwindConfigurationFile } from '../../utils/tailwind';\nimport { getIndexInputFile, getIndexOutputFile } from '../../utils/webpack-browser-config';\nimport { Schema as ApplicationBuilderOptions, OutputHashing } from './schema';\n\nexport type NormalizedApplicationBuildOptions = Awaited<ReturnType<typeof normalizeOptions>>;\n\n/** Internal options hidden from builder schema but available when invoked programmatically. */\ninterface InternalOptions {\n  /**\n   * Entry points to use for the compilation. Incompatible with `browser`, which must not be provided. May be relative or absolute paths.\n   * If given a relative path, it is resolved relative to the current workspace and will generate an output at the same relative location\n   * in the output directory. If given an absolute path, the output will be generated in the root of the output directory with the same base\n   * name.\n   */\n  entryPoints?: Set<string>;\n\n  /** File extension to use for the generated output files. */\n  outExtension?: 'js' | 'mjs';\n\n  /**\n   * Indicates whether all node packages should be marked as external.\n   * Currently used by the dev-server to support prebundling.\n   */\n  externalPackages?: boolean;\n}\n\n/** Full set of options for `application` builder. */\nexport type ApplicationBuilderInternalOptions = Omit<\n  ApplicationBuilderOptions & InternalOptions,\n  'browser'\n> & {\n  // `browser` can be `undefined` if `entryPoints` is used.\n  browser?: string;\n};\n\n/**\n * Normalize the user provided options by creating full paths for all path based options\n * and converting multi-form options into a single form that can be directly used\n * by the build process.\n *\n * @param context The context for current builder execution.\n * @param projectName The name of the project for the current execution.\n * @param options An object containing the options to use for the build.\n * @returns An object containing normalized options required to perform the build.\n */\nexport async function normalizeOptions(\n  context: BuilderContext,\n  projectName: string,\n  options: ApplicationBuilderInternalOptions,\n) {\n  const workspaceRoot = context.workspaceRoot;\n  const projectMetadata = await context.getProjectMetadata(projectName);\n  const projectRoot = normalizeDirectoryPath(\n    path.join(workspaceRoot, (projectMetadata.root as string | undefined) ?? ''),\n  );\n  const projectSourceRoot = normalizeDirectoryPath(\n    path.join(workspaceRoot, (projectMetadata.sourceRoot as string | undefined) ?? 'src'),\n  );\n\n  // Gather persistent caching option and provide a project specific cache location\n  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);\n  cacheOptions.path = path.join(cacheOptions.path, projectName);\n\n  const entryPoints = normalizeEntryPoints(workspaceRoot, options.browser, options.entryPoints);\n  const tsconfig = path.join(workspaceRoot, options.tsConfig);\n  const outputPath = normalizeDirectoryPath(path.join(workspaceRoot, options.outputPath));\n  const optimizationOptions = normalizeOptimization(options.optimization);\n  const sourcemapOptions = normalizeSourceMaps(options.sourceMap ?? false);\n  const assets = options.assets?.length\n    ? normalizeAssetPatterns(options.assets, workspaceRoot, projectRoot, projectSourceRoot)\n    : undefined;\n\n  const outputNames = {\n    bundles:\n      options.outputHashing === OutputHashing.All || options.outputHashing === OutputHashing.Bundles\n        ? '[name].[hash]'\n        : '[name]',\n    media:\n      'media/' +\n      (options.outputHashing === OutputHashing.All || options.outputHashing === OutputHashing.Media\n        ? '[name].[hash]'\n        : '[name]'),\n  };\n\n  let fileReplacements: Record<string, string> | undefined;\n  if (options.fileReplacements) {\n    for (const replacement of options.fileReplacements) {\n      fileReplacements ??= {};\n      fileReplacements[path.join(workspaceRoot, replacement.replace)] = path.join(\n        workspaceRoot,\n        replacement.with,\n      );\n    }\n  }\n\n  const globalStyles: { name: string; files: string[]; initial: boolean }[] = [];\n  if (options.styles?.length) {\n    const { entryPoints: stylesheetEntrypoints, noInjectNames } = normalizeGlobalStyles(\n      options.styles || [],\n    );\n    for (const [name, files] of Object.entries(stylesheetEntrypoints)) {\n      globalStyles.push({ name, files, initial: !noInjectNames.includes(name) });\n    }\n  }\n\n  const globalScripts: { name: string; files: string[]; initial: boolean }[] = [];\n  if (options.scripts?.length) {\n    for (const { bundleName, paths, inject } of globalScriptsByBundleName(options.scripts)) {\n      globalScripts.push({ name: bundleName, files: paths, initial: inject });\n    }\n  }\n\n  let tailwindConfiguration: { file: string; package: string } | undefined;\n  const tailwindConfigurationPath = await findTailwindConfigurationFile(workspaceRoot, projectRoot);\n  if (tailwindConfigurationPath) {\n    // Create a node resolver at the project root as a directory\n    const resolver = createRequire(projectRoot + '/');\n    try {\n      tailwindConfiguration = {\n        file: tailwindConfigurationPath,\n        package: resolver.resolve('tailwindcss'),\n      };\n    } catch {\n      const relativeTailwindConfigPath = path.relative(workspaceRoot, tailwindConfigurationPath);\n      context.logger.warn(\n        `Tailwind CSS configuration file found (${relativeTailwindConfigPath})` +\n          ` but the 'tailwindcss' package is not installed.` +\n          ` To enable Tailwind CSS, please install the 'tailwindcss' package.`,\n      );\n    }\n  }\n\n  let indexHtmlOptions;\n  if (options.index) {\n    indexHtmlOptions = {\n      input: path.join(workspaceRoot, getIndexInputFile(options.index)),\n      // The output file will be created within the configured output path\n      output: getIndexOutputFile(options.index),\n      // TODO: Use existing information from above to create the insertion order\n      insertionOrder: generateEntryPoints({\n        scripts: options.scripts ?? [],\n        styles: options.styles ?? [],\n      }),\n    };\n  }\n\n  let serverEntryPoint: string | undefined;\n  if (options.server) {\n    serverEntryPoint = path.join(workspaceRoot, options.server);\n  } else if (options.server === '') {\n    throw new Error('`server` option cannot be an empty string.');\n  }\n\n  // Initial options to keep\n  const {\n    allowedCommonJsDependencies,\n    aot,\n    baseHref,\n    crossOrigin,\n    externalDependencies,\n    extractLicenses,\n    inlineStyleLanguage = 'css',\n    outExtension,\n    serviceWorker,\n    poll,\n    polyfills,\n    preserveSymlinks,\n    statsJson,\n    stylePreprocessorOptions,\n    subresourceIntegrity,\n    verbose,\n    watch,\n    progress = true,\n    externalPackages,\n    deleteOutputPath,\n  } = options;\n\n  // Return all the normalized options\n  return {\n    advancedOptimizations: !!aot,\n    allowedCommonJsDependencies,\n    baseHref,\n    cacheOptions,\n    crossOrigin,\n    deleteOutputPath,\n    externalDependencies,\n    extractLicenses,\n    inlineStyleLanguage,\n    jit: !aot,\n    stats: !!statsJson,\n    polyfills: polyfills === undefined || Array.isArray(polyfills) ? polyfills : [polyfills],\n    poll,\n    progress,\n    externalPackages,\n    // If not explicitly set, default to the Node.js process argument\n    preserveSymlinks: preserveSymlinks ?? process.execArgv.includes('--preserve-symlinks'),\n    stylePreprocessorOptions,\n    subresourceIntegrity,\n    serverEntryPoint,\n    verbose,\n    watch,\n    workspaceRoot,\n    entryPoints,\n    optimizationOptions,\n    outputPath,\n    outExtension,\n    sourcemapOptions,\n    tsconfig,\n    projectRoot,\n    assets,\n    outputNames,\n    fileReplacements,\n    globalStyles,\n    globalScripts,\n    serviceWorker,\n    indexHtmlOptions,\n    tailwindConfiguration,\n  };\n}\n\n/**\n * Normalize entry point options. To maintain compatibility with the legacy browser builder, we need a single `browser`\n * option which defines a single entry point. However, we also want to support multiple entry points as an internal option.\n * The two options are mutually exclusive and if `browser` is provided it will be used as the sole entry point.\n * If `entryPoints` are provided, they will be used as the set of entry points.\n *\n * @param workspaceRoot Path to the root of the Angular workspace.\n * @param browser The `browser` option pointing at the application entry point. While required per the schema file, it may be omitted by\n *     programmatic usages of `browser-esbuild`.\n * @param entryPoints Set of entry points to use if provided.\n * @returns An object mapping entry point names to their file paths.\n */\nfunction normalizeEntryPoints(\n  workspaceRoot: string,\n  browser: string | undefined,\n  entryPoints: Set<string> = new Set(),\n): Record<string, string> {\n  if (browser === '') {\n    throw new Error('`browser` option cannot be an empty string.');\n  }\n\n  // `browser` and `entryPoints` are mutually exclusive.\n  if (browser && entryPoints.size > 0) {\n    throw new Error('Only one of `browser` or `entryPoints` may be provided.');\n  }\n  if (!browser && entryPoints.size === 0) {\n    // Schema should normally reject this case, but programmatic usages of the builder might make this mistake.\n    throw new Error('Either `browser` or at least one `entryPoints` value must be provided.');\n  }\n\n  // Schema types force `browser` to always be provided, but it may be omitted when the builder is invoked programmatically.\n  if (browser) {\n    // Use `browser` alone.\n    return { 'main': path.join(workspaceRoot, browser) };\n  } else {\n    // Use `entryPoints` alone.\n    const entryPointPaths: Record<string, string> = {};\n    for (const entryPoint of entryPoints) {\n      const parsedEntryPoint = path.parse(entryPoint);\n\n      // Use the input file path without an extension as the \"name\" of the entry point dictating its output location.\n      // Relative entry points are generated at the same relative path in the output directory.\n      // Absolute entry points are always generated with the same file name in the root of the output directory. This includes absolute\n      // paths pointing at files actually within the workspace root.\n      const entryPointName = path.isAbsolute(entryPoint)\n        ? parsedEntryPoint.name\n        : path.join(parsedEntryPoint.dir, parsedEntryPoint.name);\n\n      // Get the full file path to the entry point input.\n      const entryPointPath = path.isAbsolute(entryPoint)\n        ? entryPoint\n        : path.join(workspaceRoot, entryPoint);\n\n      // Check for conflicts with previous entry points.\n      const existingEntryPointPath = entryPointPaths[entryPointName];\n      if (existingEntryPointPath) {\n        throw new Error(\n          `\\`${existingEntryPointPath}\\` and \\`${entryPointPath}\\` both output to the same location \\`${entryPointName}\\`.` +\n            ' Rename or move one of the files to fix the conflict.',\n        );\n      }\n\n      entryPointPaths[entryPointName] = entryPointPath;\n    }\n\n    return entryPointPaths;\n  }\n}\n\n/**\n * Normalize a directory path string.\n * Currently only removes a trailing slash if present.\n * @param path A path string.\n * @returns A normalized path string.\n */\nfunction normalizeDirectoryPath(path: string): string {\n  const last = path[path.length - 1];\n  if (last === '/' || last === '\\\\') {\n    return path.slice(0, -1);\n  }\n\n  return path;\n}\n"]}