@angular-devkit/build-angular 16.0.0-next.6 → 16.0.0-rc.0

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

@@ -6,13 +6,35 @@
  * 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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.
@@ -30,13 +52,12 @@ function execute(options, context, transforms = {}) {
         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.
+        // Use vite-based development server for esbuild-based builds
         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, rxjs_1.defer)(() => Promise.resolve().then(() => __importStar(require('./vite-server')))).pipe((0, rxjs_1.switchMap)(({ serveWithVite }) => serveWithVite(normalizedOptions, builderName, context)));
         }
-        return (0, webpack_server_1.serveWebpackBrowser)(normalizedOptions, builderName, context, transforms);
+        // Use Webpack for all other browser targets
+        return (0, rxjs_1.defer)(() => Promise.resolve().then(() => __importStar(require('./webpack-server')))).pipe((0, rxjs_1.switchMap)(({ serveWebpackBrowser }) => serveWebpackBrowser(normalizedOptions, builderName, context, transforms)));
     }));
 }
 exports.execute = execute;
@@ -65,4 +86,4 @@ case.
     normalizedOptions.port = await (0, check_port_1.checkPort)(normalizedOptions.port, normalizedOptions.host);
     return { builderName, normalizedOptions };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/src/builders/dev-server/load-proxy-config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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
+ */
+export declare function loadProxyConfiguration(root: string, proxyConfig: string | undefined): Promise<any>;

package/src/builders/dev-server/load-proxy-config.js

@@ -0,0 +1,113 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadProxyConfiguration = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const error_1 = require("../../utils/error");
+const load_esm_1 = require("../../utils/load-esm");
+async function loadProxyConfiguration(root, proxyConfig) {
+    if (!proxyConfig) {
+        return undefined;
+    }
+    const proxyPath = (0, node_path_1.resolve)(root, proxyConfig);
+    if (!(0, node_fs_1.existsSync)(proxyPath)) {
+        throw new Error(`Proxy configuration file ${proxyPath} does not exist.`);
+    }
+    switch ((0, node_path_1.extname)(proxyPath)) {
+        case '.json': {
+            const content = await (0, promises_1.readFile)(proxyPath, 'utf-8');
+            const { parse, printParseErrorCode } = await Promise.resolve().then(() => __importStar(require('jsonc-parser')));
+            const parseErrors = [];
+            const proxyConfiguration = parse(content, parseErrors, { allowTrailingComma: true });
+            if (parseErrors.length > 0) {
+                let errorMessage = `Proxy configuration file ${proxyPath} contains parse errors:`;
+                for (const parseError of parseErrors) {
+                    const { line, column } = getJsonErrorLineColumn(parseError.offset, content);
+                    errorMessage += `\n[${line}, ${column}] ${printParseErrorCode(parseError.error)}`;
+                }
+                throw new Error(errorMessage);
+            }
+            return proxyConfiguration;
+        }
+        case '.mjs':
+            // Load the ESM configuration file using the TypeScript dynamic import workaround.
+            // Once TypeScript provides support for keeping the dynamic import this workaround can be
+            // changed to a direct dynamic import.
+            return (await (0, load_esm_1.loadEsmModule)((0, node_url_1.pathToFileURL)(proxyPath))).default;
+        case '.cjs':
+            return require(proxyPath);
+        default:
+            // The file could be either CommonJS or ESM.
+            // CommonJS is tried first then ESM if loading fails.
+            try {
+                return require(proxyPath);
+            }
+            catch (e) {
+                (0, error_1.assertIsError)(e);
+                if (e.code === 'ERR_REQUIRE_ESM') {
+                    // Load the ESM configuration file using the TypeScript dynamic import workaround.
+                    // Once TypeScript provides support for keeping the dynamic import this workaround can be
+                    // changed to a direct dynamic import.
+                    return (await (0, load_esm_1.loadEsmModule)((0, node_url_1.pathToFileURL)(proxyPath))).default;
+                }
+                throw e;
+            }
+    }
+}
+exports.loadProxyConfiguration = loadProxyConfiguration;
+/**
+ * Calculates the line and column for an error offset in the content of a JSON file.
+ * @param location The offset error location from the beginning of the content.
+ * @param content The full content of the file containing the error.
+ * @returns An object containing the line and column
+ */
+function getJsonErrorLineColumn(offset, content) {
+    if (offset === 0) {
+        return { line: 1, column: 1 };
+    }
+    let line = 0;
+    let position = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        ++line;
+        const nextNewline = content.indexOf('\n', position);
+        if (nextNewline === -1 || nextNewline > offset) {
+            break;
+        }
+        position = nextNewline + 1;
+    }
+    return { line, column: offset - position + 1 };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,11 @@
+/**
+ * @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 { BuilderContext } from '@angular-devkit/architect';
+import type { NormalizedDevServerOptions } from './options';
+import type { DevServerBuilderOutput } from './webpack-server';
+export declare function serveWithVite(serverOptions: NormalizedDevServerOptions, builderName: string, context: BuilderContext): AsyncIterableIterator<DevServerBuilderOutput>;

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

@@ -0,0 +1,287 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveWithVite = void 0;
+const mrmime_1 = require("mrmime");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const vite_1 = require("vite");
+const browser_esbuild_1 = require("../browser-esbuild");
+const load_proxy_config_1 = require("./load-proxy-config");
+function hashContent(contents) {
+    // TODO: Consider xxhash
+    return (0, node_crypto_1.createHash)('sha256').update(contents).digest();
+}
+async function* serveWithVite(serverOptions, builderName, context) {
+    // Get the browser configuration from the target name.
+    const rawBrowserOptions = (await context.getTargetOptions(serverOptions.browserTarget));
+    const browserOptions = (await context.validateOptions({
+        ...rawBrowserOptions,
+        watch: serverOptions.watch,
+        poll: serverOptions.poll,
+        verbose: serverOptions.verbose,
+    }, builderName));
+    let server;
+    let listeningAddress;
+    const outputFiles = new Map();
+    const assets = new Map();
+    // TODO: Switch this to an architect schedule call when infrastructure settings are supported
+    for await (const result of (0, browser_esbuild_1.buildEsbuildBrowser)(browserOptions, context, { write: false })) {
+        (0, node_assert_1.default)(result.outputFiles, 'Builder did not provide result files.');
+        // Analyze result files for changes
+        const seen = new Set(['/index.html']);
+        for (const file of result.outputFiles) {
+            const filePath = '/' + (0, vite_1.normalizePath)(file.path);
+            seen.add(filePath);
+            // Skip analysis of sourcemaps
+            if (filePath.endsWith('.map')) {
+                outputFiles.set(filePath, {
+                    contents: file.contents,
+                    size: file.contents.byteLength,
+                    updated: false,
+                });
+                continue;
+            }
+            let fileHash;
+            const existingRecord = outputFiles.get(filePath);
+            if (existingRecord && existingRecord.size === file.contents.byteLength) {
+                // Only hash existing file when needed
+                if (existingRecord.hash === undefined) {
+                    existingRecord.hash = hashContent(existingRecord.contents);
+                }
+                // Compare against latest result output
+                fileHash = hashContent(file.contents);
+                if (fileHash.equals(existingRecord.hash)) {
+                    // Same file
+                    existingRecord.updated = false;
+                    continue;
+                }
+            }
+            outputFiles.set(filePath, {
+                contents: file.contents,
+                size: file.contents.byteLength,
+                hash: fileHash,
+                updated: true,
+            });
+        }
+        // Clear stale output files
+        for (const file of outputFiles.keys()) {
+            if (!seen.has(file)) {
+                outputFiles.delete(file);
+            }
+        }
+        assets.clear();
+        if (result.assetFiles) {
+            for (const asset of result.assetFiles) {
+                assets.set('/' + (0, vite_1.normalizePath)(asset.destination), asset.source);
+            }
+        }
+        if (server) {
+            // Invalidate any updated files
+            for (const [file, record] of outputFiles) {
+                if (record.updated) {
+                    const updatedModules = server.moduleGraph.getModulesByFile(file);
+                    updatedModules?.forEach((m) => server?.moduleGraph.invalidateModule(m));
+                }
+            }
+            // Send reload command to clients
+            if (serverOptions.liveReload) {
+                context.logger.info('Reloading client(s)...');
+                server.ws.send({
+                    type: 'full-reload',
+                    path: '*',
+                });
+            }
+        }
+        else {
+            // Setup server and start listening
+            server = await setupServer(serverOptions, outputFiles, assets);
+            await server.listen();
+            listeningAddress = server.httpServer?.address();
+            // log connection information
+            server.printUrls();
+        }
+        // TODO: adjust output typings to reflect both development servers
+        yield { success: true, port: listeningAddress?.port };
+    }
+    if (server) {
+        let deferred;
+        context.addTeardown(async () => {
+            await server?.close();
+            deferred?.();
+        });
+        await new Promise((resolve) => (deferred = resolve));
+    }
+}
+exports.serveWithVite = serveWithVite;
+async function setupServer(serverOptions, outputFiles, assets) {
+    const proxy = await (0, load_proxy_config_1.loadProxyConfiguration)(serverOptions.workspaceRoot, serverOptions.proxyConfig);
+    const configuration = {
+        configFile: false,
+        envFile: false,
+        cacheDir: node_path_1.default.join(serverOptions.cacheOptions.path, 'vite'),
+        root: serverOptions.workspaceRoot,
+        publicDir: false,
+        esbuild: false,
+        mode: 'development',
+        appType: 'spa',
+        css: {
+            devSourcemap: true,
+        },
+        server: {
+            port: serverOptions.port,
+            strictPort: true,
+            host: serverOptions.host,
+            open: serverOptions.open,
+            headers: serverOptions.headers,
+            proxy,
+            // Currently does not appear to be a way to disable file watching directly so ignore all files
+            watch: {
+                ignored: ['**/*'],
+            },
+        },
+        plugins: [
+            {
+                name: 'vite:angular-memory',
+                // Ensures plugin hooks run before built-in Vite hooks
+                enforce: 'pre',
+                async resolveId(source, importer) {
+                    if (importer && source.startsWith('.')) {
+                        // Remove query if present
+                        const [importerFile] = importer.split('?', 1);
+                        source = (0, vite_1.normalizePath)(node_path_1.default.join(node_path_1.default.dirname(importerFile), source));
+                    }
+                    const [file] = source.split('?', 1);
+                    if (outputFiles.has(file)) {
+                        return source;
+                    }
+                },
+                load(id) {
+                    const [file] = id.split('?', 1);
+                    const code = outputFiles.get(file)?.contents;
+                    const map = outputFiles.get(file + '.map')?.contents;
+                    return (code && {
+                        code: code && Buffer.from(code).toString('utf-8'),
+                        map: map && Buffer.from(map).toString('utf-8'),
+                    });
+                },
+                configureServer(server) {
+                    // Assets and resources get handled first
+                    server.middlewares.use(function angularAssetsMiddleware(req, res, next) {
+                        if (req.url === undefined || res.writableEnded) {
+                            return;
+                        }
+                        // Parse the incoming request.
+                        // The base of the URL is unused but required to parse the URL.
+                        const parsedUrl = new URL(req.url, 'http://localhost');
+                        const extension = node_path_1.default.extname(parsedUrl.pathname);
+                        // Rewrite all build assets to a vite raw fs URL
+                        const assetSourcePath = assets.get(parsedUrl.pathname);
+                        if (assetSourcePath !== undefined) {
+                            req.url = `/@fs/${assetSourcePath}`;
+                            next();
+                            return;
+                        }
+                        // Resource files are handled directly.
+                        // Global stylesheets (CSS files) are currently considered resources to workaround
+                        // dev server sourcemap issues with stylesheets.
+                        if (extension !== '.js' && extension !== '.html') {
+                            const outputFile = outputFiles.get(parsedUrl.pathname);
+                            if (outputFile) {
+                                const mimeType = (0, mrmime_1.lookup)(extension);
+                                if (mimeType) {
+                                    res.setHeader('Content-Type', mimeType);
+                                }
+                                res.setHeader('Cache-Control', 'no-cache');
+                                if (serverOptions.headers) {
+                                    Object.entries(serverOptions.headers).forEach(([name, value]) => res.setHeader(name, value));
+                                }
+                                res.end(outputFile.contents);
+                                return;
+                            }
+                        }
+                        next();
+                    });
+                    // Returning a function, installs middleware after the main transform middleware but
+                    // before the built-in HTML middleware
+                    return () => server.middlewares.use(function angularIndexMiddleware(req, res, next) {
+                        if (req.url === '/' || req.url === `/index.html`) {
+                            const rawHtml = outputFiles.get('/index.html')?.contents;
+                            if (rawHtml) {
+                                server
+                                    .transformIndexHtml(req.url, Buffer.from(rawHtml).toString('utf-8'), req.originalUrl)
+                                    .then((processedHtml) => {
+                                    res.setHeader('Content-Type', 'text/html');
+                                    res.setHeader('Cache-Control', 'no-cache');
+                                    if (serverOptions.headers) {
+                                        Object.entries(serverOptions.headers).forEach(([name, value]) => res.setHeader(name, value));
+                                    }
+                                    res.end(processedHtml);
+                                })
+                                    .catch((error) => next(error));
+                                return;
+                            }
+                        }
+                        next();
+                    });
+                },
+            },
+        ],
+        optimizeDeps: {
+            // TODO: Consider enabling for known safe dependencies (@angular/* ?)
+            disabled: true,
+        },
+    };
+    if (serverOptions.ssl) {
+        if (serverOptions.sslCert && serverOptions.sslKey) {
+            // server configuration is defined above
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            configuration.server.https = {
+                cert: await (0, promises_1.readFile)(serverOptions.sslCert),
+                key: await (0, promises_1.readFile)(serverOptions.sslKey),
+            };
+        }
+        else {
+            const { default: basicSslPlugin } = await Promise.resolve().then(() => __importStar(require('@vitejs/plugin-basic-ssl')));
+            configuration.plugins ?? (configuration.plugins = []);
+            configuration.plugins.push(basicSslPlugin());
+        }
+    }
+    const server = await (0, vite_1.createServer)(configuration);
+    return server;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vite-server.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/dev-server/vite-server.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 type { BuilderContext } from '@angular-devkit/architect';\nimport type { json } from '@angular-devkit/core';\nimport { lookup as lookupMimeType } from 'mrmime';\nimport assert from 'node:assert';\nimport { BinaryLike, createHash } from 'node:crypto';\nimport { readFile } from 'node:fs/promises';\nimport type { AddressInfo } from 'node:net';\nimport path from 'node:path';\nimport { InlineConfig, ViteDevServer, createServer, normalizePath } from 'vite';\nimport { buildEsbuildBrowser } from '../browser-esbuild';\nimport type { Schema as BrowserBuilderOptions } from '../browser-esbuild/schema';\nimport { loadProxyConfiguration } from './load-proxy-config';\nimport type { NormalizedDevServerOptions } from './options';\nimport type { DevServerBuilderOutput } from './webpack-server';\n\ninterface OutputFileRecord {\n  contents: Uint8Array;\n  size: number;\n  hash?: Buffer;\n  updated: boolean;\n}\n\nfunction hashContent(contents: BinaryLike): Buffer {\n  // TODO: Consider xxhash\n  return createHash('sha256').update(contents).digest();\n}\n\nexport async function* serveWithVite(\n  serverOptions: NormalizedDevServerOptions,\n  builderName: string,\n  context: BuilderContext,\n): AsyncIterableIterator<DevServerBuilderOutput> {\n  // Get the browser configuration from the target name.\n  const rawBrowserOptions = (await context.getTargetOptions(\n    serverOptions.browserTarget,\n  )) as json.JsonObject & BrowserBuilderOptions;\n\n  const browserOptions = (await context.validateOptions(\n    {\n      ...rawBrowserOptions,\n      watch: serverOptions.watch,\n      poll: serverOptions.poll,\n      verbose: serverOptions.verbose,\n    } as json.JsonObject & BrowserBuilderOptions,\n    builderName,\n  )) as json.JsonObject & BrowserBuilderOptions;\n\n  let server: ViteDevServer | undefined;\n  let listeningAddress: AddressInfo | undefined;\n  const outputFiles = new Map<string, OutputFileRecord>();\n  const assets = new Map<string, string>();\n  // TODO: Switch this to an architect schedule call when infrastructure settings are supported\n  for await (const result of buildEsbuildBrowser(browserOptions, context, { write: false })) {\n    assert(result.outputFiles, 'Builder did not provide result files.');\n\n    // Analyze result files for changes\n    const seen = new Set<string>(['/index.html']);\n    for (const file of result.outputFiles) {\n      const filePath = '/' + normalizePath(file.path);\n      seen.add(filePath);\n\n      // Skip analysis of sourcemaps\n      if (filePath.endsWith('.map')) {\n        outputFiles.set(filePath, {\n          contents: file.contents,\n          size: file.contents.byteLength,\n          updated: false,\n        });\n\n        continue;\n      }\n\n      let fileHash: Buffer | undefined;\n      const existingRecord = outputFiles.get(filePath);\n      if (existingRecord && existingRecord.size === file.contents.byteLength) {\n        // Only hash existing file when needed\n        if (existingRecord.hash === undefined) {\n          existingRecord.hash = hashContent(existingRecord.contents);\n        }\n\n        // Compare against latest result output\n        fileHash = hashContent(file.contents);\n        if (fileHash.equals(existingRecord.hash)) {\n          // Same file\n          existingRecord.updated = false;\n          continue;\n        }\n      }\n\n      outputFiles.set(filePath, {\n        contents: file.contents,\n        size: file.contents.byteLength,\n        hash: fileHash,\n        updated: true,\n      });\n    }\n\n    // Clear stale output files\n    for (const file of outputFiles.keys()) {\n      if (!seen.has(file)) {\n        outputFiles.delete(file);\n      }\n    }\n\n    assets.clear();\n    if (result.assetFiles) {\n      for (const asset of result.assetFiles) {\n        assets.set('/' + normalizePath(asset.destination), asset.source);\n      }\n    }\n\n    if (server) {\n      // Invalidate any updated files\n      for (const [file, record] of outputFiles) {\n        if (record.updated) {\n          const updatedModules = server.moduleGraph.getModulesByFile(file);\n          updatedModules?.forEach((m) => server?.moduleGraph.invalidateModule(m));\n        }\n      }\n\n      // Send reload command to clients\n      if (serverOptions.liveReload) {\n        context.logger.info('Reloading client(s)...');\n\n        server.ws.send({\n          type: 'full-reload',\n          path: '*',\n        });\n      }\n    } else {\n      // Setup server and start listening\n      server = await setupServer(serverOptions, outputFiles, assets);\n\n      await server.listen();\n      listeningAddress = server.httpServer?.address() as AddressInfo;\n\n      // log connection information\n      server.printUrls();\n    }\n\n    // TODO: adjust output typings to reflect both development servers\n    yield { success: true, port: listeningAddress?.port } as unknown as DevServerBuilderOutput;\n  }\n\n  if (server) {\n    let deferred: () => void;\n    context.addTeardown(async () => {\n      await server?.close();\n      deferred?.();\n    });\n    await new Promise<void>((resolve) => (deferred = resolve));\n  }\n}\n\nasync function setupServer(\n  serverOptions: NormalizedDevServerOptions,\n  outputFiles: Map<string, OutputFileRecord>,\n  assets: Map<string, string>,\n): Promise<ViteDevServer> {\n  const proxy = await loadProxyConfiguration(\n    serverOptions.workspaceRoot,\n    serverOptions.proxyConfig,\n  );\n\n  const configuration: InlineConfig = {\n    configFile: false,\n    envFile: false,\n    cacheDir: path.join(serverOptions.cacheOptions.path, 'vite'),\n    root: serverOptions.workspaceRoot,\n    publicDir: false,\n    esbuild: false,\n    mode: 'development',\n    appType: 'spa',\n    css: {\n      devSourcemap: true,\n    },\n    server: {\n      port: serverOptions.port,\n      strictPort: true,\n      host: serverOptions.host,\n      open: serverOptions.open,\n      headers: serverOptions.headers,\n      proxy,\n      // Currently does not appear to be a way to disable file watching directly so ignore all files\n      watch: {\n        ignored: ['**/*'],\n      },\n    },\n    plugins: [\n      {\n        name: 'vite:angular-memory',\n        // Ensures plugin hooks run before built-in Vite hooks\n        enforce: 'pre',\n        async resolveId(source, importer) {\n          if (importer && source.startsWith('.')) {\n            // Remove query if present\n            const [importerFile] = importer.split('?', 1);\n\n            source = normalizePath(path.join(path.dirname(importerFile), source));\n          }\n\n          const [file] = source.split('?', 1);\n          if (outputFiles.has(file)) {\n            return source;\n          }\n        },\n        load(id) {\n          const [file] = id.split('?', 1);\n          const code = outputFiles.get(file)?.contents;\n          const map = outputFiles.get(file + '.map')?.contents;\n\n          return (\n            code && {\n              code: code && Buffer.from(code).toString('utf-8'),\n              map: map && Buffer.from(map).toString('utf-8'),\n            }\n          );\n        },\n        configureServer(server) {\n          // Assets and resources get handled first\n          server.middlewares.use(function angularAssetsMiddleware(req, res, next) {\n            if (req.url === undefined || res.writableEnded) {\n              return;\n            }\n\n            // Parse the incoming request.\n            // The base of the URL is unused but required to parse the URL.\n            const parsedUrl = new URL(req.url, 'http://localhost');\n            const extension = path.extname(parsedUrl.pathname);\n\n            // Rewrite all build assets to a vite raw fs URL\n            const assetSourcePath = assets.get(parsedUrl.pathname);\n            if (assetSourcePath !== undefined) {\n              req.url = `/@fs/${assetSourcePath}`;\n              next();\n\n              return;\n            }\n\n            // Resource files are handled directly.\n            // Global stylesheets (CSS files) are currently considered resources to workaround\n            // dev server sourcemap issues with stylesheets.\n            if (extension !== '.js' && extension !== '.html') {\n              const outputFile = outputFiles.get(parsedUrl.pathname);\n              if (outputFile) {\n                const mimeType = lookupMimeType(extension);\n                if (mimeType) {\n                  res.setHeader('Content-Type', mimeType);\n                }\n                res.setHeader('Cache-Control', 'no-cache');\n                if (serverOptions.headers) {\n                  Object.entries(serverOptions.headers).forEach(([name, value]) =>\n                    res.setHeader(name, value),\n                  );\n                }\n                res.end(outputFile.contents);\n\n                return;\n              }\n            }\n\n            next();\n          });\n\n          // Returning a function, installs middleware after the main transform middleware but\n          // before the built-in HTML middleware\n          return () =>\n            server.middlewares.use(function angularIndexMiddleware(req, res, next) {\n              if (req.url === '/' || req.url === `/index.html`) {\n                const rawHtml = outputFiles.get('/index.html')?.contents;\n                if (rawHtml) {\n                  server\n                    .transformIndexHtml(\n                      req.url,\n                      Buffer.from(rawHtml).toString('utf-8'),\n                      req.originalUrl,\n                    )\n                    .then((processedHtml) => {\n                      res.setHeader('Content-Type', 'text/html');\n                      res.setHeader('Cache-Control', 'no-cache');\n                      if (serverOptions.headers) {\n                        Object.entries(serverOptions.headers).forEach(([name, value]) =>\n                          res.setHeader(name, value),\n                        );\n                      }\n                      res.end(processedHtml);\n                    })\n                    .catch((error) => next(error));\n\n                  return;\n                }\n              }\n\n              next();\n            });\n        },\n      },\n    ],\n    optimizeDeps: {\n      // TODO: Consider enabling for known safe dependencies (@angular/* ?)\n      disabled: true,\n    },\n  };\n\n  if (serverOptions.ssl) {\n    if (serverOptions.sslCert && serverOptions.sslKey) {\n      // server configuration is defined above\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      configuration.server!.https = {\n        cert: await readFile(serverOptions.sslCert),\n        key: await readFile(serverOptions.sslKey),\n      };\n    } else {\n      const { default: basicSslPlugin } = await import('@vitejs/plugin-basic-ssl');\n      configuration.plugins ??= [];\n      configuration.plugins.push(basicSslPlugin());\n    }\n  }\n\n  const server = await createServer(configuration);\n\n  return server;\n}\n"]}

package/src/utils/normalize-asset-patterns.js

@@ -80,6 +80,9 @@ function normalizeAssetPatterns(assetPatterns, workspaceRoot, projectRoot, proje
             const output = path.relative(resolvedSourceRoot, path.resolve(workspaceRoot, input));
             assetPattern = { glob, input, output };
         }
+        else {
+            assetPattern.output = path.join('.', assetPattern.output);
+        }
         if (assetPattern.output.startsWith('..')) {
             throw new Error('An asset cannot be written to a location outside of the output path.');
         }
@@ -87,4 +90,4 @@ function normalizeAssetPatterns(assetPatterns, workspaceRoot, projectRoot, proje
     });
 }
 exports.normalizeAssetPatterns = normalizeAssetPatterns;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/src/webpack/utils/stats.d.ts

@@ -22,6 +22,7 @@ export interface BundleStats {
     initial: boolean;
     stats: BundleStatsData;
 }
+export declare function generateBuildStatsTable(data: BundleStats[], colors: boolean, showTotalSize: boolean, showEstimatedTransferSize: boolean, budgetFailures?: BudgetCalculatorResult[]): string;
 export declare function statsWarningsToString(json: StatsCompilation, statsConfig: WebpackStatsOptions): string;
 export declare function statsErrorsToString(json: StatsCompilation, statsConfig: WebpackStatsOptions): string;
 export declare function statsHasErrors(json: StatsCompilation): boolean;