@angular-devkit/build-angular 16.0.0-next.5 → 16.0.0-next.6

package/src/builders/browser-esbuild/options.js

@@ -16,7 +16,6 @@ const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
 const utils_1 = require("../../utils");
 const normalize_cache_1 = require("../../utils/normalize-cache");
-const normalize_polyfills_1 = require("../../utils/normalize-polyfills");
 const package_chunk_sort_1 = require("../../utils/package-chunk-sort");
 const webpack_browser_config_1 = require("../../utils/webpack-browser-config");
 const helpers_1 = require("../../webpack/utils/helpers");
@@ -38,11 +37,6 @@ async function normalizeOptions(context, projectName, options) {
     const projectSourceRoot = node_path_1.default.join(workspaceRoot, projectMetadata.sourceRoot ?? 'src');
     const cacheOptions = (0, normalize_cache_1.normalizeCacheOptions)(projectMetadata, workspaceRoot);
     const mainEntryPoint = node_path_1.default.join(workspaceRoot, options.main);
-    // Currently esbuild do not support multiple files per entry-point
-    const [polyfillsEntryPoint, ...remainingPolyfills] = (0, normalize_polyfills_1.normalizePolyfills)(options.polyfills, workspaceRoot);
-    if (remainingPolyfills.length) {
-        context.logger.warn(`The 'polyfills' option currently does not support multiple entries by this experimental builder. The first entry will be used.`);
-    }
     const tsconfig = node_path_1.default.join(workspaceRoot, options.tsConfig);
     const outputPath = node_path_1.default.join(workspaceRoot, options.outputPath);
     const optimizationOptions = (0, utils_1.normalizeOptimization)(options.optimization);
@@ -78,7 +72,8 @@ async function normalizeOptions(context, projectName, options) {
     let tailwindConfiguration;
     const tailwindConfigurationPath = findTailwindConfigurationFile(workspaceRoot, projectRoot);
     if (tailwindConfigurationPath) {
-        const resolver = (0, node_module_1.createRequire)(projectRoot);
+        // Create a node resolver at the project root as a directory
+        const resolver = (0, node_module_1.createRequire)(projectRoot + '/');
         try {
             tailwindConfiguration = {
                 file: tailwindConfigurationPath,
@@ -103,9 +98,6 @@ async function normalizeOptions(context, projectName, options) {
     const entryPoints = {
         main: mainEntryPoint,
     };
-    if (polyfillsEntryPoint) {
-        entryPoints['polyfills'] = polyfillsEntryPoint;
-    }
     let indexHtmlOptions;
     if (options.index) {
         indexHtmlOptions = {
@@ -120,7 +112,7 @@ async function normalizeOptions(context, projectName, options) {
         };
     }
     // Initial options to keep
-    const { allowedCommonJsDependencies, aot, baseHref, buildOptimizer, crossOrigin, externalDependencies, extractLicenses, inlineStyleLanguage = 'css', poll, preserveSymlinks, statsJson, stylePreprocessorOptions, subresourceIntegrity, verbose, watch, } = options;
+    const { allowedCommonJsDependencies, aot, baseHref, buildOptimizer, crossOrigin, externalDependencies, extractLicenses, inlineStyleLanguage = 'css', poll, polyfills, preserveSymlinks, statsJson, stylePreprocessorOptions, subresourceIntegrity, verbose, watch, } = options;
     // Return all the normalized options
     return {
         advancedOptimizations: buildOptimizer,
@@ -133,6 +125,7 @@ async function normalizeOptions(context, projectName, options) {
         inlineStyleLanguage,
         jit: !aot,
         stats: !!statsJson,
+        polyfills: polyfills === undefined || Array.isArray(polyfills) ? polyfills : [polyfills],
         poll,
         // If not explicitly set, default to the Node.js process argument
         preserveSymlinks: preserveSymlinks ?? process.execArgv.includes('--preserve-symlinks'),
@@ -173,4 +166,4 @@ function findTailwindConfigurationFile(workspaceRoot, projectRoot) {
     }
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/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 fs from 'node:fs';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { normalizeAssetPatterns, normalizeOptimization, normalizeSourceMaps } from '../../utils';\nimport { normalizeCacheOptions } from '../../utils/normalize-cache';\nimport { normalizePolyfills } from '../../utils/normalize-polyfills';\nimport { generateEntryPoints } from '../../utils/package-chunk-sort';\nimport { getIndexInputFile, getIndexOutputFile } from '../../utils/webpack-browser-config';\nimport { normalizeGlobalStyles } from '../../webpack/utils/helpers';\nimport { Schema as BrowserBuilderOptions, OutputHashing } from './schema';\n\nexport type NormalizedBrowserOptions = Awaited<ReturnType<typeof normalizeOptions>>;\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: BrowserBuilderOptions,\n) {\n  const workspaceRoot = context.workspaceRoot;\n  const projectMetadata = await context.getProjectMetadata(projectName);\n  const projectRoot = path.join(workspaceRoot, (projectMetadata.root as string | undefined) ?? '');\n  const projectSourceRoot = path.join(\n    workspaceRoot,\n    (projectMetadata.sourceRoot as string | undefined) ?? 'src',\n  );\n\n  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);\n\n  const mainEntryPoint = path.join(workspaceRoot, options.main);\n\n  // Currently esbuild do not support multiple files per entry-point\n  const [polyfillsEntryPoint, ...remainingPolyfills] = normalizePolyfills(\n    options.polyfills,\n    workspaceRoot,\n  );\n\n  if (remainingPolyfills.length) {\n    context.logger.warn(\n      `The 'polyfills' option currently does not support multiple entries by this experimental builder. The first entry will be used.`,\n    );\n  }\n\n  const tsconfig = path.join(workspaceRoot, options.tsConfig);\n  const outputPath = 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      options.outputHashing === OutputHashing.All || options.outputHashing === OutputHashing.Media\n        ? '[name].[hash]'\n        : '[name]',\n  };\n  if (options.resourcesOutputPath) {\n    outputNames.media = path.join(options.resourcesOutputPath, outputNames.media);\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  let tailwindConfiguration: { file: string; package: string } | undefined;\n  const tailwindConfigurationPath = findTailwindConfigurationFile(workspaceRoot, projectRoot);\n  if (tailwindConfigurationPath) {\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 serviceWorkerOptions;\n  if (options.serviceWorker) {\n    // If ngswConfigPath is not specified, the default is 'ngsw-config.json' within the project root\n    serviceWorkerOptions = options.ngswConfigPath\n      ? path.join(workspaceRoot, options.ngswConfigPath)\n      : path.join(projectRoot, 'ngsw-config.json');\n  }\n\n  // Setup bundler entry points\n  const entryPoints: Record<string, string> = {\n    main: mainEntryPoint,\n  };\n  if (polyfillsEntryPoint) {\n    entryPoints['polyfills'] = polyfillsEntryPoint;\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  // Initial options to keep\n  const {\n    allowedCommonJsDependencies,\n    aot,\n    baseHref,\n    buildOptimizer,\n    crossOrigin,\n    externalDependencies,\n    extractLicenses,\n    inlineStyleLanguage = 'css',\n    poll,\n    preserveSymlinks,\n    statsJson,\n    stylePreprocessorOptions,\n    subresourceIntegrity,\n    verbose,\n    watch,\n  } = options;\n\n  // Return all the normalized options\n  return {\n    advancedOptimizations: buildOptimizer,\n    allowedCommonJsDependencies,\n    baseHref,\n    cacheOptions,\n    crossOrigin,\n    externalDependencies,\n    extractLicenses,\n    inlineStyleLanguage,\n    jit: !aot,\n    stats: !!statsJson,\n    poll,\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    verbose,\n    watch,\n    workspaceRoot,\n    entryPoints,\n    optimizationOptions,\n    outputPath,\n    sourcemapOptions,\n    tsconfig,\n    projectRoot,\n    assets,\n    outputNames,\n    fileReplacements,\n    globalStyles,\n    serviceWorkerOptions,\n    indexHtmlOptions,\n    tailwindConfiguration,\n  };\n}\n\nfunction findTailwindConfigurationFile(\n  workspaceRoot: string,\n  projectRoot: string,\n): string | undefined {\n  // A configuration file can exist in the project or workspace root\n  // The list of valid config files can be found:\n  // https://github.com/tailwindlabs/tailwindcss/blob/8845d112fb62d79815b50b3bae80c317450b8b92/src/util/resolveConfigPath.js#L46-L52\n  const tailwindConfigFiles = ['tailwind.config.js', 'tailwind.config.cjs'];\n  for (const basePath of [projectRoot, workspaceRoot]) {\n    for (const configFile of tailwindConfigFiles) {\n      // Project level configuration should always take precedence.\n      const fullPath = path.join(basePath, configFile);\n      if (fs.existsSync(fullPath)) {\n        return fullPath;\n      }\n    }\n  }\n\n  return undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/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 fs from 'node:fs';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { normalizeAssetPatterns, normalizeOptimization, normalizeSourceMaps } from '../../utils';\nimport { normalizeCacheOptions } from '../../utils/normalize-cache';\nimport { generateEntryPoints } from '../../utils/package-chunk-sort';\nimport { getIndexInputFile, getIndexOutputFile } from '../../utils/webpack-browser-config';\nimport { normalizeGlobalStyles } from '../../webpack/utils/helpers';\nimport { Schema as BrowserBuilderOptions, OutputHashing } from './schema';\n\nexport type NormalizedBrowserOptions = Awaited<ReturnType<typeof normalizeOptions>>;\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: BrowserBuilderOptions,\n) {\n  const workspaceRoot = context.workspaceRoot;\n  const projectMetadata = await context.getProjectMetadata(projectName);\n  const projectRoot = path.join(workspaceRoot, (projectMetadata.root as string | undefined) ?? '');\n  const projectSourceRoot = path.join(\n    workspaceRoot,\n    (projectMetadata.sourceRoot as string | undefined) ?? 'src',\n  );\n\n  const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);\n\n  const mainEntryPoint = path.join(workspaceRoot, options.main);\n  const tsconfig = path.join(workspaceRoot, options.tsConfig);\n  const outputPath = 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      options.outputHashing === OutputHashing.All || options.outputHashing === OutputHashing.Media\n        ? '[name].[hash]'\n        : '[name]',\n  };\n  if (options.resourcesOutputPath) {\n    outputNames.media = path.join(options.resourcesOutputPath, outputNames.media);\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  let tailwindConfiguration: { file: string; package: string } | undefined;\n  const tailwindConfigurationPath = 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 serviceWorkerOptions;\n  if (options.serviceWorker) {\n    // If ngswConfigPath is not specified, the default is 'ngsw-config.json' within the project root\n    serviceWorkerOptions = options.ngswConfigPath\n      ? path.join(workspaceRoot, options.ngswConfigPath)\n      : path.join(projectRoot, 'ngsw-config.json');\n  }\n\n  // Setup bundler entry points\n  const entryPoints: Record<string, string> = {\n    main: mainEntryPoint,\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  // Initial options to keep\n  const {\n    allowedCommonJsDependencies,\n    aot,\n    baseHref,\n    buildOptimizer,\n    crossOrigin,\n    externalDependencies,\n    extractLicenses,\n    inlineStyleLanguage = 'css',\n    poll,\n    polyfills,\n    preserveSymlinks,\n    statsJson,\n    stylePreprocessorOptions,\n    subresourceIntegrity,\n    verbose,\n    watch,\n  } = options;\n\n  // Return all the normalized options\n  return {\n    advancedOptimizations: buildOptimizer,\n    allowedCommonJsDependencies,\n    baseHref,\n    cacheOptions,\n    crossOrigin,\n    externalDependencies,\n    extractLicenses,\n    inlineStyleLanguage,\n    jit: !aot,\n    stats: !!statsJson,\n    polyfills: polyfills === undefined || Array.isArray(polyfills) ? polyfills : [polyfills],\n    poll,\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    verbose,\n    watch,\n    workspaceRoot,\n    entryPoints,\n    optimizationOptions,\n    outputPath,\n    sourcemapOptions,\n    tsconfig,\n    projectRoot,\n    assets,\n    outputNames,\n    fileReplacements,\n    globalStyles,\n    serviceWorkerOptions,\n    indexHtmlOptions,\n    tailwindConfiguration,\n  };\n}\n\nfunction findTailwindConfigurationFile(\n  workspaceRoot: string,\n  projectRoot: string,\n): string | undefined {\n  // A configuration file can exist in the project or workspace root\n  // The list of valid config files can be found:\n  // https://github.com/tailwindlabs/tailwindcss/blob/8845d112fb62d79815b50b3bae80c317450b8b92/src/util/resolveConfigPath.js#L46-L52\n  const tailwindConfigFiles = ['tailwind.config.js', 'tailwind.config.cjs'];\n  for (const basePath of [projectRoot, workspaceRoot]) {\n    for (const configFile of tailwindConfigFiles) {\n      // Project level configuration should always take precedence.\n      const fullPath = path.join(basePath, configFile);\n      if (fs.existsSync(fullPath)) {\n        return fullPath;\n      }\n    }\n  }\n\n  return undefined;\n}\n"]}

package/src/builders/browser-esbuild/stylesheet-plugin.js

@@ -0,0 +1,46 @@
+"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
+//  */
+// import type { OnLoadResult, Plugin, PluginBuild } from 'esbuild';
+// import assert from 'node:assert';
+// import { readFile } from 'node:fs/promises';
+// /**
+//  * Base class for all Angular esbuild stylesheet plugins
+//  */
+// export abstract class StylesheetPlugin implements Plugin {
+//   abstract readonly name: string;
+//   constructor(
+//     private readonly filters: { file: RegExp; inline: RegExp },
+//     private readonly inlineComponentData?: Record<string, string>,
+//   ) {}
+//   setup(build: PluginBuild): Promise<void> {
+//     // Add a load callback to support inline Component styles
+//     build.onLoad(
+//       { filter: this.filters.inline, namespace: 'angular:styles/component' },
+//       async (args) => {
+//         const data = this.inlineComponentData?.[args.path];
+//         assert(data, `component style name should always be found [${args.path}]`);
+//         const [, , filePath] = args.path.split(';', 3);
+//         return this.process(data, filePath, postcssProcessor, options);
+//       },
+//     );
+//     // Add a load callback to support files from disk
+//     build.onLoad({ filter: this.filters.file }, async (args) => {
+//       const data = await readFile(args.path, 'utf-8');
+//       return this.process(data, args.path, postcssProcessor, options);
+//     });
+//   }
+//   protected abstract process(data: string, filename: string): Promise<OnLoadResult>;
+//   bind(): Plugin {
+//     return {
+//       name: this.name,
+//       setup: this.setup.bind(this),
+//     };
+//   }
+// }
+//# sourceMappingURL=data:application/json;base64,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

package/src/builders/dev-server/builder.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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
+ */
+import { BuilderContext } from '@angular-devkit/architect';
+import { Observable } from 'rxjs';
+import { ExecutionTransformer } from '../../transforms';
+import { IndexHtmlTransform } from '../../utils/index-file/index-html-generator';
+import { Schema as DevServerBuilderOptions } from './schema';
+import { DevServerBuilderOutput } from './webpack-server';
+/**
+ * A Builder that executes a development server based on the provided browser target option.
+ * @param options Dev Server options.
+ * @param context The build context.
+ * @param transforms A map of transforms that can be used to hook into some logic (such as
+ * transforming webpack configuration before passing it to webpack).
+ *
+ * @experimental Direct usage of this function is considered experimental.
+ */
+export declare function execute(options: DevServerBuilderOptions, context: BuilderContext, transforms?: {
+    webpackConfiguration?: ExecutionTransformer<import('webpack').Configuration>;
+    logging?: import('@angular-devkit/build-webpack').WebpackLoggingCallback;
+    indexHtml?: IndexHtmlTransform;
+}): Observable<DevServerBuilderOutput>;

package/src/builders/dev-server/builder.js

@@ -0,0 +1,68 @@
+"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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = void 0;
+const rxjs_1 = require("rxjs");
+const check_port_1 = require("../../utils/check-port");
+const purge_cache_1 = require("../../utils/purge-cache");
+const options_1 = require("./options");
+const webpack_server_1 = require("./webpack-server");
+/**
+ * A Builder that executes a development server based on the provided browser target option.
+ * @param options Dev Server options.
+ * @param context The build context.
+ * @param transforms A map of transforms that can be used to hook into some logic (such as
+ * transforming webpack configuration before passing it to webpack).
+ *
+ * @experimental Direct usage of this function is considered experimental.
+ */
+function execute(options, context, transforms = {}) {
+    // Determine project name from builder context target
+    const projectName = context.target?.project;
+    if (!projectName) {
+        context.logger.error(`The 'dev-server' builder requires a target to be specified.`);
+        return rxjs_1.EMPTY;
+    }
+    return (0, rxjs_1.defer)(() => initialize(options, projectName, context)).pipe((0, rxjs_1.switchMap)(({ builderName, normalizedOptions }) => {
+        // Issue a warning that the dev-server does not currently support the experimental esbuild-
+        // based builder and will use Webpack.
+        if (builderName === '@angular-devkit/build-angular:browser-esbuild') {
+            context.logger.warn('WARNING: The experimental esbuild-based builder is not currently supported ' +
+                'by the dev-server. The stable Webpack-based builder will be used instead.');
+        }
+        return (0, webpack_server_1.serveWebpackBrowser)(normalizedOptions, builderName, context, transforms);
+    }));
+}
+exports.execute = execute;
+async function initialize(initialOptions, projectName, context) {
+    // Purge old build disk cache.
+    await (0, purge_cache_1.purgeStaleBuildCache)(context);
+    const normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, initialOptions);
+    const builderName = await context.getBuilderNameForTarget(normalizedOptions.browserTarget);
+    if (!normalizedOptions.disableHostCheck &&
+        !/^127\.\d+\.\d+\.\d+/g.test(normalizedOptions.host) &&
+        normalizedOptions.host !== 'localhost') {
+        context.logger.warn(`
+Warning: This is a simple server for use in testing or debugging Angular applications
+locally. It hasn't been reviewed for security issues.
+
+Binding this server to an open connection can result in compromising your application or
+computer. Using a different host than the one passed to the "--host" flag might result in
+websocket connection issues. You might need to use "--disable-host-check" if that's the
+case.
+    `);
+    }
+    if (normalizedOptions.disableHostCheck) {
+        context.logger.warn('Warning: Running a server with --disable-host-check is a security risk. ' +
+            'See https://medium.com/webpack/webpack-dev-server-middleware-security-issues-1489d950874a for more information.');
+    }
+    normalizedOptions.port = await (0, check_port_1.checkPort)(normalizedOptions.port, normalizedOptions.host);
+    return { builderName, normalizedOptions };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/builders/dev-server/index.d.ts

@@ -5,8 +5,10 @@
  * 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
  */
+import { execute } from './builder';
 import { Schema as DevServerBuilderOptions } from './schema';
-import { DevServerBuilderOutput, serveWebpackBrowser } from './webpack-server';
-export { DevServerBuilderOptions, DevServerBuilderOutput, serveWebpackBrowser };
+import { DevServerBuilderOutput } from './webpack-server';
+export { DevServerBuilderOptions, DevServerBuilderOutput, execute as executeDevServerBuilder };
 declare const _default: import("../../../../architect/src/internal").Builder<DevServerBuilderOptions & import("../../../../core/src").JsonObject>;
 export default _default;
+export { execute as serveWebpackBrowser };

package/src/builders/dev-server/index.js

@@ -7,9 +7,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serveWebpackBrowser = void 0;
+exports.serveWebpackBrowser = exports.executeDevServerBuilder = void 0;
 const architect_1 = require("@angular-devkit/architect");
-const webpack_server_1 = require("./webpack-server");
-Object.defineProperty(exports, "serveWebpackBrowser", { enumerable: true, get: function () { return webpack_server_1.serveWebpackBrowser; } });
-exports.default = (0, architect_1.createBuilder)(webpack_server_1.serveWebpackBrowser);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3NyYy9idWlsZGVycy9kZXYtc2VydmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7OztBQUVILHlEQUEwRDtBQUUxRCxxREFBK0U7QUFFckIsb0dBRnpCLG9DQUFtQixPQUV5QjtBQUM3RSxrQkFBZSxJQUFBLHlCQUFhLEVBQWtELG9DQUFtQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHsgY3JlYXRlQnVpbGRlciB9IGZyb20gJ0Bhbmd1bGFyLWRldmtpdC9hcmNoaXRlY3QnO1xuaW1wb3J0IHsgU2NoZW1hIGFzIERldlNlcnZlckJ1aWxkZXJPcHRpb25zIH0gZnJvbSAnLi9zY2hlbWEnO1xuaW1wb3J0IHsgRGV2U2VydmVyQnVpbGRlck91dHB1dCwgc2VydmVXZWJwYWNrQnJvd3NlciB9IGZyb20gJy4vd2VicGFjay1zZXJ2ZXInO1xuXG5leHBvcnQgeyBEZXZTZXJ2ZXJCdWlsZGVyT3B0aW9ucywgRGV2U2VydmVyQnVpbGRlck91dHB1dCwgc2VydmVXZWJwYWNrQnJvd3NlciB9O1xuZXhwb3J0IGRlZmF1bHQgY3JlYXRlQnVpbGRlcjxEZXZTZXJ2ZXJCdWlsZGVyT3B0aW9ucywgRGV2U2VydmVyQnVpbGRlck91dHB1dD4oc2VydmVXZWJwYWNrQnJvd3Nlcik7XG4iXX0=
+const builder_1 = require("./builder");
+Object.defineProperty(exports, "executeDevServerBuilder", { enumerable: true, get: function () { return builder_1.execute; } });
+Object.defineProperty(exports, "serveWebpackBrowser", { enumerable: true, get: function () { return builder_1.execute; } });
+exports.default = (0, architect_1.createBuilder)(builder_1.execute);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3NyYy9idWlsZGVycy9kZXYtc2VydmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7OztBQUVILHlEQUEwRDtBQUMxRCx1Q0FBb0M7QUFJaUMsd0dBSjVELGlCQUFPLE9BSTRFO0FBSXhFLG9HQVJYLGlCQUFPLE9BUXVCO0FBSHZDLGtCQUFlLElBQUEseUJBQWEsRUFBa0QsaUJBQU8sQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7IGNyZWF0ZUJ1aWxkZXIgfSBmcm9tICdAYW5ndWxhci1kZXZraXQvYXJjaGl0ZWN0JztcbmltcG9ydCB7IGV4ZWN1dGUgfSBmcm9tICcuL2J1aWxkZXInO1xuaW1wb3J0IHsgU2NoZW1hIGFzIERldlNlcnZlckJ1aWxkZXJPcHRpb25zIH0gZnJvbSAnLi9zY2hlbWEnO1xuaW1wb3J0IHsgRGV2U2VydmVyQnVpbGRlck91dHB1dCB9IGZyb20gJy4vd2VicGFjay1zZXJ2ZXInO1xuXG5leHBvcnQgeyBEZXZTZXJ2ZXJCdWlsZGVyT3B0aW9ucywgRGV2U2VydmVyQnVpbGRlck91dHB1dCwgZXhlY3V0ZSBhcyBleGVjdXRlRGV2U2VydmVyQnVpbGRlciB9O1xuZXhwb3J0IGRlZmF1bHQgY3JlYXRlQnVpbGRlcjxEZXZTZXJ2ZXJCdWlsZGVyT3B0aW9ucywgRGV2U2VydmVyQnVpbGRlck91dHB1dD4oZXhlY3V0ZSk7XG5cbi8vIFRlbXBvcmFyeSBleHBvcnQgdG8gc3VwcG9ydCBzcGVjc1xuZXhwb3J0IHsgZXhlY3V0ZSBhcyBzZXJ2ZVdlYnBhY2tCcm93c2VyIH07XG4iXX0=

package/src/builders/dev-server/options.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @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
+ */
+import { BuilderContext } from '@angular-devkit/architect';
+import { Schema as DevServerOptions } from './schema';
+export type NormalizedDevServerOptions = Awaited<ReturnType<typeof normalizeOptions>>;
+/**
+ * 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.
+ */
+export declare function normalizeOptions(context: BuilderContext, projectName: string, options: DevServerOptions): Promise<{
+    browserTarget: import("@angular-devkit/architect").Target;
+    host: string;
+    port: number;
+    poll: number | undefined;
+    open: boolean | undefined;
+    verbose: boolean | undefined;
+    watch: boolean | undefined;
+    liveReload: boolean | undefined;
+    hmr: boolean | undefined;
+    headers: {
+        [key: string]: string;
+    } | undefined;
+    workspaceRoot: string;
+    projectRoot: string;
+    cacheOptions: import("../../utils/normalize-cache").NormalizedCachedOptions;
+    allowedHosts: string[] | undefined;
+    disableHostCheck: boolean | undefined;
+    proxyConfig: string | undefined;
+    servePath: string | undefined;
+    publicHost: string | undefined;
+    ssl: boolean | undefined;
+    sslCert: string | undefined;
+    sslKey: string | undefined;
+}>;

package/src/builders/dev-server/options.js

@@ -0,0 +1,61 @@
+"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 architect_1 = require("@angular-devkit/architect");
+const node_path_1 = __importDefault(require("node:path"));
+const normalize_cache_1 = require("../../utils/normalize-cache");
+/**
+ * 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 = node_path_1.default.join(workspaceRoot, projectMetadata.root ?? '');
+    const cacheOptions = (0, normalize_cache_1.normalizeCacheOptions)(projectMetadata, workspaceRoot);
+    const browserTarget = (0, architect_1.targetFromTargetString)(options.browserTarget);
+    // Initial options to keep
+    const { host, port, poll, open, verbose, watch, allowedHosts, disableHostCheck, liveReload, hmr, headers, proxyConfig, servePath, publicHost, ssl, sslCert, sslKey, } = options;
+    // Return all the normalized options
+    return {
+        browserTarget,
+        host: host ?? 'localhost',
+        port: port ?? 4200,
+        poll,
+        open,
+        verbose,
+        watch,
+        liveReload,
+        hmr,
+        headers,
+        workspaceRoot,
+        projectRoot,
+        cacheOptions,
+        allowedHosts,
+        disableHostCheck,
+        proxyConfig,
+        servePath,
+        publicHost,
+        ssl,
+        sslCert,
+        sslKey,
+    };
+}
+exports.normalizeOptions = normalizeOptions;
+//# sourceMappingURL=data:application/json;base64,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

package/src/builders/dev-server/webpack-server.d.ts

@@ -12,8 +12,7 @@ import webpack from 'webpack';
 import { ExecutionTransformer } from '../../transforms';
 import { IndexHtmlTransform } from '../../utils/index-file/index-html-generator';
 import { BuildEventStats } from '../../webpack/utils/stats';
-import { Schema } from './schema';
-export type DevServerBuilderOptions = Schema;
+import { NormalizedDevServerOptions } from './options';
 /**
  * @experimental Direct usage of this type is considered experimental.
  */
@@ -24,13 +23,12 @@ export type DevServerBuilderOutput = DevServerBuildOutput & {
 /**
  * Reusable implementation of the Angular Webpack development server builder.
  * @param options Dev Server options.
+ * @param builderName The name of the builder used to build the application.
  * @param context The build context.
  * @param transforms A map of transforms that can be used to hook into some logic (such as
  *     transforming webpack configuration before passing it to webpack).
- *
- * @experimental Direct usage of this function is considered experimental.
  */
-export declare function serveWebpackBrowser(options: DevServerBuilderOptions, context: BuilderContext, transforms?: {
+export declare function serveWebpackBrowser(options: NormalizedDevServerOptions, builderName: string, context: BuilderContext, transforms?: {
     webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;
     logging?: WebpackLoggingCallback;
     indexHtml?: IndexHtmlTransform;