@angular-devkit/build-angular 16.1.0-rc.0 → 16.1.1

package/src/tools/webpack/plugins/esbuild-executor.js

@@ -0,0 +1,121 @@
+"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.EsbuildExecutor = void 0;
+/**
+ * Provides the ability to execute esbuild regardless of the current platform's support
+ * for using the native variant of esbuild. The native variant will be preferred (assuming
+ * the `alwaysUseWasm` constructor option is `false) due to its inherent performance advantages.
+ * At first use of esbuild, a supportability test will be automatically performed and the
+ * WASM-variant will be used if needed by the platform.
+ */
+class EsbuildExecutor {
+    /**
+     * Constructs an instance of the `EsbuildExecutor` class.
+     *
+     * @param alwaysUseWasm If true, the WASM-variant will be preferred and no support test will be
+     * performed; if false (default), the native variant will be preferred.
+     */
+    constructor(alwaysUseWasm = false) {
+        this.alwaysUseWasm = alwaysUseWasm;
+        this.initialized = false;
+        this.esbuildTransform = this.esbuildFormatMessages = () => {
+            throw new Error('esbuild implementation missing');
+        };
+    }
+    /**
+     * Determines whether the native variant of esbuild can be used on the current platform.
+     *
+     * @returns A promise which resolves to `true`, if the native variant of esbuild is support or `false`, if the WASM variant is required.
+     */
+    static async hasNativeSupport() {
+        // Try to use native variant to ensure it is functional for the platform.
+        try {
+            const { formatMessages } = await Promise.resolve().then(() => __importStar(require('esbuild')));
+            await formatMessages([], { kind: 'error' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Initializes the esbuild transform and format messages functions.
+     *
+     * @returns A promise that fulfills when esbuild has been loaded and available for use.
+     */
+    async ensureEsbuild() {
+        if (this.initialized) {
+            return;
+        }
+        // If the WASM variant was preferred at class construction or native is not supported, use WASM
+        if (this.alwaysUseWasm || !(await EsbuildExecutor.hasNativeSupport())) {
+            await this.useWasm();
+            this.initialized = true;
+            return;
+        }
+        try {
+            // Use the faster native variant if available.
+            const { transform, formatMessages } = await Promise.resolve().then(() => __importStar(require('esbuild')));
+            this.esbuildTransform = transform;
+            this.esbuildFormatMessages = formatMessages;
+        }
+        catch {
+            // If the native variant is not installed then use the WASM-based variant
+            await this.useWasm();
+        }
+        this.initialized = true;
+    }
+    /**
+     * Transitions an executor instance to use the WASM-variant of esbuild.
+     */
+    async useWasm() {
+        const { transform, formatMessages } = await Promise.resolve().then(() => __importStar(require('esbuild-wasm')));
+        this.esbuildTransform = transform;
+        this.esbuildFormatMessages = formatMessages;
+        // The ESBUILD_BINARY_PATH environment variable cannot exist when attempting to use the
+        // WASM variant. If it is then the binary located at the specified path will be used instead
+        // of the WASM variant.
+        delete process.env.ESBUILD_BINARY_PATH;
+        this.alwaysUseWasm = true;
+    }
+    async transform(input, options) {
+        await this.ensureEsbuild();
+        return this.esbuildTransform(input, options);
+    }
+    async formatMessages(messages, options) {
+        await this.ensureEsbuild();
+        return this.esbuildFormatMessages(messages, options);
+    }
+}
+exports.EsbuildExecutor = EsbuildExecutor;
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/webpack/plugins/hmr/hmr-accept.js

@@ -0,0 +1,185 @@
+"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 });
+// eslint-disable-next-line import/no-extraneous-dependencies
+const core_1 = require("@angular/core");
+const rxjs_1 = require("rxjs");
+function default_1(mod) {
+    if (!mod['hot']) {
+        return;
+    }
+    if (!(0, core_1.isDevMode)()) {
+        console.error(`[NG HMR] Cannot use HMR when Angular is running in production mode. To prevent production mode, do not call 'enableProdMode()'.`);
+        return;
+    }
+    mod['hot'].accept();
+    mod['hot'].dispose(() => {
+        if (typeof ng === 'undefined') {
+            console.warn(`[NG HMR] Cannot find global 'ng'. Likely this is caused because scripts optimization is enabled.`);
+            return;
+        }
+        if (!ng.getInjector) {
+            // View Engine
+            return;
+        }
+        // Reset JIT compiled components cache
+        (0, core_1.ɵresetCompiledComponents)();
+        const appRoot = getAppRoot();
+        if (!appRoot) {
+            return;
+        }
+        const appRef = getApplicationRef(appRoot);
+        if (!appRef) {
+            return;
+        }
+        // Inputs that are hidden should be ignored
+        const oldInputs = document.querySelectorAll('input:not([type="hidden"]), textarea');
+        const oldOptions = document.querySelectorAll('option');
+        // Create new application
+        appRef.components.forEach((cp) => {
+            const element = cp.location.nativeElement;
+            const parentNode = element.parentNode;
+            parentNode.insertBefore(document.createElement(element.tagName), element);
+            parentNode.removeChild(element);
+        });
+        // Destroy old application, injectors, <style..., etc..
+        const platformRef = getPlatformRef(appRoot);
+        if (platformRef) {
+            platformRef.destroy();
+        }
+        // Restore all inputs and options
+        const bodyElement = document.body;
+        if (oldInputs.length + oldOptions.length === 0 || !bodyElement) {
+            return;
+        }
+        // Use a `MutationObserver` to wait until the app-root element has been bootstrapped.
+        // ie: when the ng-version attribute is added.
+        new MutationObserver((_mutationsList, observer) => {
+            observer.disconnect();
+            const newAppRoot = getAppRoot();
+            if (!newAppRoot) {
+                return;
+            }
+            const newAppRef = getApplicationRef(newAppRoot);
+            if (!newAppRef) {
+                return;
+            }
+            // Wait until the application isStable to restore the form values
+            newAppRef.isStable
+                .pipe((0, rxjs_1.filter)((isStable) => !!isStable), (0, rxjs_1.take)(1))
+                .subscribe(() => restoreFormValues(oldInputs, oldOptions));
+        }).observe(bodyElement, {
+            attributes: true,
+            subtree: true,
+            attributeFilter: ['ng-version'],
+        });
+    });
+}
+exports.default = default_1;
+function getAppRoot() {
+    const appRoot = document.querySelector('[ng-version]');
+    if (!appRoot) {
+        console.warn('[NG HMR] Cannot find the application root component.');
+        return undefined;
+    }
+    return appRoot;
+}
+function getToken(appRoot, token) {
+    return (typeof ng === 'object' && ng.getInjector(appRoot).get(token)) || undefined;
+}
+function getApplicationRef(appRoot) {
+    const appRef = getToken(appRoot, core_1.ApplicationRef);
+    if (!appRef) {
+        console.warn(`[NG HMR] Cannot get 'ApplicationRef'.`);
+        return undefined;
+    }
+    return appRef;
+}
+function getPlatformRef(appRoot) {
+    const platformRef = getToken(appRoot, core_1.PlatformRef);
+    if (!platformRef) {
+        console.warn(`[NG HMR] Cannot get 'PlatformRef'.`);
+        return undefined;
+    }
+    return platformRef;
+}
+function dispatchEvents(element) {
+    element.dispatchEvent(new Event('input', {
+        bubbles: true,
+        cancelable: true,
+    }));
+    element.blur();
+    element.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter' }));
+}
+function restoreFormValues(oldInputs, oldOptions) {
+    // Restore input that are not hidden
+    const newInputs = document.querySelectorAll('input:not([type="hidden"]), textarea');
+    if (newInputs.length && newInputs.length === oldInputs.length) {
+        console.log('[NG HMR] Restoring input/textarea values.');
+        for (let index = 0; index < newInputs.length; index++) {
+            const newElement = newInputs[index];
+            const oldElement = oldInputs[index];
+            switch (oldElement.type) {
+                case 'button':
+                case 'image':
+                case 'submit':
+                case 'reset':
+                    // These types don't need any value change.
+                    continue;
+                case 'radio':
+                case 'checkbox':
+                    newElement.checked = oldElement.checked;
+                    break;
+                case 'color':
+                case 'date':
+                case 'datetime-local':
+                case 'email':
+                case 'hidden':
+                case 'month':
+                case 'number':
+                case 'password':
+                case 'range':
+                case 'search':
+                case 'tel':
+                case 'text':
+                case 'textarea':
+                case 'time':
+                case 'url':
+                case 'week':
+                    newElement.value = oldElement.value;
+                    break;
+                case 'file':
+                    // Ignored due: Uncaught DOMException: Failed to set the 'value' property on 'HTMLInputElement':
+                    // This input element accepts a filename, which may only be programmatically set to the empty string.
+                    break;
+                default:
+                    console.warn('[NG HMR] Unknown input type ' + oldElement.type + '.');
+                    continue;
+            }
+            dispatchEvents(newElement);
+        }
+    }
+    else if (oldInputs.length) {
+        console.warn('[NG HMR] Cannot restore input/textarea values.');
+    }
+    // Restore option
+    const newOptions = document.querySelectorAll('option');
+    if (newOptions.length && newOptions.length === oldOptions.length) {
+        console.log('[NG HMR] Restoring selected options.');
+        for (let index = 0; index < newOptions.length; index++) {
+            const newElement = newOptions[index];
+            newElement.selected = oldOptions[index].selected;
+            dispatchEvents(newElement);
+        }
+    }
+    else if (oldOptions.length) {
+        console.warn('[NG HMR] Cannot restore selected options.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hmr-accept.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/webpack/plugins/hmr/hmr-accept.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\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  ApplicationRef,\n  PlatformRef,\n  Type,\n  isDevMode,\n  ɵresetCompiledComponents,\n} from '@angular/core';\nimport { filter, take } from 'rxjs';\n\n// For the time being we cannot use the DOM lib because it conflicts with @types/node,\n// In future when we remove `yarn admin build` we should have this as a seperate compilation unit\n// which includes DOM lib.\n\n/* eslint-disable no-console */\n/* eslint-disable @typescript-eslint/no-explicit-any */\ndeclare const ng: any;\ndeclare const document: any;\ndeclare const MutationObserver: any;\ndeclare const KeyboardEvent: any;\ndeclare const Event: any;\n\nexport default function (mod: any): void {\n  if (!mod['hot']) {\n    return;\n  }\n\n  if (!isDevMode()) {\n    console.error(\n      `[NG HMR] Cannot use HMR when Angular is running in production mode. To prevent production mode, do not call 'enableProdMode()'.`,\n    );\n\n    return;\n  }\n\n  mod['hot'].accept();\n  mod['hot'].dispose(() => {\n    if (typeof ng === 'undefined') {\n      console.warn(\n        `[NG HMR] Cannot find global 'ng'. Likely this is caused because scripts optimization is enabled.`,\n      );\n\n      return;\n    }\n\n    if (!ng.getInjector) {\n      // View Engine\n      return;\n    }\n\n    // Reset JIT compiled components cache\n    ɵresetCompiledComponents();\n    const appRoot = getAppRoot();\n    if (!appRoot) {\n      return;\n    }\n\n    const appRef = getApplicationRef(appRoot);\n    if (!appRef) {\n      return;\n    }\n\n    // Inputs that are hidden should be ignored\n    const oldInputs = document.querySelectorAll('input:not([type=\"hidden\"]), textarea');\n    const oldOptions = document.querySelectorAll('option');\n\n    // Create new application\n    appRef.components.forEach((cp) => {\n      const element = cp.location.nativeElement;\n      const parentNode = element.parentNode;\n      parentNode.insertBefore(document.createElement(element.tagName), element);\n\n      parentNode.removeChild(element);\n    });\n\n    // Destroy old application, injectors, <style..., etc..\n    const platformRef = getPlatformRef(appRoot);\n    if (platformRef) {\n      platformRef.destroy();\n    }\n\n    // Restore all inputs and options\n    const bodyElement = document.body;\n    if (oldInputs.length + oldOptions.length === 0 || !bodyElement) {\n      return;\n    }\n\n    // Use a `MutationObserver` to wait until the app-root element has been bootstrapped.\n    // ie: when the ng-version attribute is added.\n    new MutationObserver((_mutationsList: any, observer: any) => {\n      observer.disconnect();\n\n      const newAppRoot = getAppRoot();\n      if (!newAppRoot) {\n        return;\n      }\n\n      const newAppRef = getApplicationRef(newAppRoot);\n      if (!newAppRef) {\n        return;\n      }\n\n      // Wait until the application isStable to restore the form values\n      newAppRef.isStable\n        .pipe(\n          filter((isStable) => !!isStable),\n          take(1),\n        )\n        .subscribe(() => restoreFormValues(oldInputs, oldOptions));\n    }).observe(bodyElement, {\n      attributes: true,\n      subtree: true,\n      attributeFilter: ['ng-version'],\n    });\n  });\n}\n\nfunction getAppRoot(): any {\n  const appRoot = document.querySelector('[ng-version]');\n  if (!appRoot) {\n    console.warn('[NG HMR] Cannot find the application root component.');\n\n    return undefined;\n  }\n\n  return appRoot;\n}\n\nfunction getToken<T>(appRoot: any, token: Type<T>): T | undefined {\n  return (typeof ng === 'object' && ng.getInjector(appRoot).get(token)) || undefined;\n}\n\nfunction getApplicationRef(appRoot: any): ApplicationRef | undefined {\n  const appRef = getToken(appRoot, ApplicationRef);\n  if (!appRef) {\n    console.warn(`[NG HMR] Cannot get 'ApplicationRef'.`);\n\n    return undefined;\n  }\n\n  return appRef;\n}\n\nfunction getPlatformRef(appRoot: any): PlatformRef | undefined {\n  const platformRef = getToken(appRoot, PlatformRef);\n  if (!platformRef) {\n    console.warn(`[NG HMR] Cannot get 'PlatformRef'.`);\n\n    return undefined;\n  }\n\n  return platformRef;\n}\n\nfunction dispatchEvents(element: any): void {\n  element.dispatchEvent(\n    new Event('input', {\n      bubbles: true,\n      cancelable: true,\n    }),\n  );\n\n  element.blur();\n\n  element.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter' }));\n}\n\nfunction restoreFormValues(oldInputs: any[], oldOptions: any[]): void {\n  // Restore input that are not hidden\n  const newInputs = document.querySelectorAll('input:not([type=\"hidden\"]), textarea');\n  if (newInputs.length && newInputs.length === oldInputs.length) {\n    console.log('[NG HMR] Restoring input/textarea values.');\n    for (let index = 0; index < newInputs.length; index++) {\n      const newElement = newInputs[index];\n      const oldElement = oldInputs[index];\n\n      switch (oldElement.type) {\n        case 'button':\n        case 'image':\n        case 'submit':\n        case 'reset':\n          // These types don't need any value change.\n          continue;\n        case 'radio':\n        case 'checkbox':\n          newElement.checked = oldElement.checked;\n          break;\n        case 'color':\n        case 'date':\n        case 'datetime-local':\n        case 'email':\n        case 'hidden':\n        case 'month':\n        case 'number':\n        case 'password':\n        case 'range':\n        case 'search':\n        case 'tel':\n        case 'text':\n        case 'textarea':\n        case 'time':\n        case 'url':\n        case 'week':\n          newElement.value = oldElement.value;\n          break;\n        case 'file':\n          // Ignored due: Uncaught DOMException: Failed to set the 'value' property on 'HTMLInputElement':\n          // This input element accepts a filename, which may only be programmatically set to the empty string.\n          break;\n        default:\n          console.warn('[NG HMR] Unknown input type ' + oldElement.type + '.');\n          continue;\n      }\n\n      dispatchEvents(newElement);\n    }\n  } else if (oldInputs.length) {\n    console.warn('[NG HMR] Cannot restore input/textarea values.');\n  }\n\n  // Restore option\n  const newOptions = document.querySelectorAll('option');\n  if (newOptions.length && newOptions.length === oldOptions.length) {\n    console.log('[NG HMR] Restoring selected options.');\n    for (let index = 0; index < newOptions.length; index++) {\n      const newElement = newOptions[index];\n      newElement.selected = oldOptions[index].selected;\n\n      dispatchEvents(newElement);\n    }\n  } else if (oldOptions.length) {\n    console.warn('[NG HMR] Cannot restore selected options.');\n  }\n}\n"]}

package/src/tools/webpack/plugins/hmr/hmr-loader.js

@@ -0,0 +1,25 @@
+"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.HmrLoader = void 0;
+const path_1 = require("path");
+exports.HmrLoader = __filename;
+const hmrAcceptPath = (0, path_1.join)(__dirname, './hmr-accept.js').replace(/\\/g, '/');
+function localizeExtractLoader(content, map) {
+    const source = `${content}
+
+  // HMR Accept Code
+  import ngHmrAccept from '${hmrAcceptPath}';
+  ngHmrAccept(module);
+  `;
+    this.callback(null, source, map);
+    return;
+}
+exports.default = localizeExtractLoader;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG1yLWxvYWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2J1aWxkX2FuZ3VsYXIvc3JjL3Rvb2xzL3dlYnBhY2svcGx1Z2lucy9obXIvaG1yLWxvYWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFFSCwrQkFBNEI7QUFFZixRQUFBLFNBQVMsR0FBRyxVQUFVLENBQUM7QUFDcEMsTUFBTSxhQUFhLEdBQUcsSUFBQSxXQUFJLEVBQUMsU0FBUyxFQUFFLGlCQUFpQixDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQztBQUU3RSxTQUF3QixxQkFBcUIsQ0FFM0MsT0FBZSxFQUNmLEdBQThEO0lBRTlELE1BQU0sTUFBTSxHQUFHLEdBQUcsT0FBTzs7OzZCQUdFLGFBQWE7O0dBRXZDLENBQUM7SUFFRixJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFFakMsT0FBTztBQUNULENBQUM7QUFmRCx3Q0FlQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgeyBqb2luIH0gZnJvbSAncGF0aCc7XG5cbmV4cG9ydCBjb25zdCBIbXJMb2FkZXIgPSBfX2ZpbGVuYW1lO1xuY29uc3QgaG1yQWNjZXB0UGF0aCA9IGpvaW4oX19kaXJuYW1lLCAnLi9obXItYWNjZXB0LmpzJykucmVwbGFjZSgvXFxcXC9nLCAnLycpO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBsb2NhbGl6ZUV4dHJhY3RMb2FkZXIoXG4gIHRoaXM6IGltcG9ydCgnd2VicGFjaycpLkxvYWRlckNvbnRleHQ8e30+LFxuICBjb250ZW50OiBzdHJpbmcsXG4gIG1hcDogUGFyYW1ldGVyczxpbXBvcnQoJ3dlYnBhY2snKS5Mb2FkZXJEZWZpbml0aW9uRnVuY3Rpb24+WzFdLFxuKSB7XG4gIGNvbnN0IHNvdXJjZSA9IGAke2NvbnRlbnR9XG5cbiAgLy8gSE1SIEFjY2VwdCBDb2RlXG4gIGltcG9ydCBuZ0htckFjY2VwdCBmcm9tICcke2htckFjY2VwdFBhdGh9JztcbiAgbmdIbXJBY2NlcHQobW9kdWxlKTtcbiAgYDtcblxuICB0aGlzLmNhbGxiYWNrKG51bGwsIHNvdXJjZSwgbWFwKTtcblxuICByZXR1cm47XG59XG4iXX0=

package/src/{webpack → tools/webpack}/plugins/index-html-webpack-plugin.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Compilation, Compiler } from 'webpack';
-import { IndexHtmlGenerator, IndexHtmlGeneratorOptions, IndexHtmlGeneratorProcessOptions } from '../../utils/index-file/index-html-generator';
+import { IndexHtmlGenerator, IndexHtmlGeneratorOptions, IndexHtmlGeneratorProcessOptions } from '../../../utils/index-file/index-html-generator';
 export interface IndexHtmlWebpackPluginOptions extends IndexHtmlGeneratorOptions, Omit<IndexHtmlGeneratorProcessOptions, 'files'> {
 }
 export declare class IndexHtmlWebpackPlugin extends IndexHtmlGenerator {

package/src/tools/webpack/plugins/index-html-webpack-plugin.js

@@ -0,0 +1,85 @@
+"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.IndexHtmlWebpackPlugin = void 0;
+const path_1 = require("path");
+const webpack_1 = require("webpack");
+const error_1 = require("../../../utils/error");
+const index_html_generator_1 = require("../../../utils/index-file/index-html-generator");
+const webpack_diagnostics_1 = require("../../../utils/webpack-diagnostics");
+const PLUGIN_NAME = 'index-html-webpack-plugin';
+class IndexHtmlWebpackPlugin extends index_html_generator_1.IndexHtmlGenerator {
+    get compilation() {
+        if (this._compilation) {
+            return this._compilation;
+        }
+        throw new Error('compilation is undefined.');
+    }
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            this._compilation = compilation;
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,
+            }, callback);
+        });
+        const callback = async (assets) => {
+            const files = [];
+            try {
+                for (const chunk of this.compilation.chunks) {
+                    for (const file of chunk.files) {
+                        if (file.endsWith('.hot-update.js')) {
+                            continue;
+                        }
+                        files.push({
+                            name: chunk.name,
+                            file,
+                            extension: (0, path_1.extname)(file),
+                        });
+                    }
+                }
+                const { content, warnings, errors } = await this.process({
+                    files,
+                    outputPath: (0, path_1.dirname)(this.options.outputPath),
+                    baseHref: this.options.baseHref,
+                    lang: this.options.lang,
+                });
+                assets[this.options.outputPath] = new webpack_1.sources.RawSource(content);
+                warnings.forEach((msg) => (0, webpack_diagnostics_1.addWarning)(this.compilation, msg));
+                errors.forEach((msg) => (0, webpack_diagnostics_1.addError)(this.compilation, msg));
+            }
+            catch (error) {
+                (0, error_1.assertIsError)(error);
+                (0, webpack_diagnostics_1.addError)(this.compilation, error.message);
+            }
+        };
+    }
+    async readAsset(path) {
+        const data = this.compilation.assets[(0, path_1.basename)(path)].source();
+        return typeof data === 'string' ? data : data.toString();
+    }
+    async readIndex(path) {
+        return new Promise((resolve, reject) => {
+            this.compilation.inputFileSystem.readFile(path, (err, data) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                this.compilation.fileDependencies.add(path);
+                resolve(data?.toString() ?? '');
+            });
+        });
+    }
+}
+exports.IndexHtmlWebpackPlugin = IndexHtmlWebpackPlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index-html-webpack-plugin.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/webpack/plugins/index-html-webpack-plugin.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 { basename, dirname, extname } from 'path';\nimport { Compilation, Compiler, sources } from 'webpack';\nimport { assertIsError } from '../../../utils/error';\nimport { FileInfo } from '../../../utils/index-file/augment-index-html';\nimport {\n  IndexHtmlGenerator,\n  IndexHtmlGeneratorOptions,\n  IndexHtmlGeneratorProcessOptions,\n} from '../../../utils/index-file/index-html-generator';\nimport { addError, addWarning } from '../../../utils/webpack-diagnostics';\n\nexport interface IndexHtmlWebpackPluginOptions\n  extends IndexHtmlGeneratorOptions,\n    Omit<IndexHtmlGeneratorProcessOptions, 'files'> {}\n\nconst PLUGIN_NAME = 'index-html-webpack-plugin';\nexport class IndexHtmlWebpackPlugin extends IndexHtmlGenerator {\n  private _compilation: Compilation | undefined;\n  get compilation(): Compilation {\n    if (this._compilation) {\n      return this._compilation;\n    }\n\n    throw new Error('compilation is undefined.');\n  }\n\n  constructor(override readonly options: IndexHtmlWebpackPluginOptions) {\n    super(options);\n  }\n\n  apply(compiler: Compiler) {\n    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {\n      this._compilation = compilation;\n      compilation.hooks.processAssets.tapPromise(\n        {\n          name: PLUGIN_NAME,\n          stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,\n        },\n        callback,\n      );\n    });\n\n    const callback = async (assets: Record<string, unknown>) => {\n      const files: FileInfo[] = [];\n\n      try {\n        for (const chunk of this.compilation.chunks) {\n          for (const file of chunk.files) {\n            if (file.endsWith('.hot-update.js')) {\n              continue;\n            }\n\n            files.push({\n              name: chunk.name,\n              file,\n              extension: extname(file),\n            });\n          }\n        }\n\n        const { content, warnings, errors } = await this.process({\n          files,\n          outputPath: dirname(this.options.outputPath),\n          baseHref: this.options.baseHref,\n          lang: this.options.lang,\n        });\n\n        assets[this.options.outputPath] = new sources.RawSource(content);\n\n        warnings.forEach((msg) => addWarning(this.compilation, msg));\n        errors.forEach((msg) => addError(this.compilation, msg));\n      } catch (error) {\n        assertIsError(error);\n        addError(this.compilation, error.message);\n      }\n    };\n  }\n\n  override async readAsset(path: string): Promise<string> {\n    const data = this.compilation.assets[basename(path)].source();\n\n    return typeof data === 'string' ? data : data.toString();\n  }\n\n  protected override async readIndex(path: string): Promise<string> {\n    return new Promise<string>((resolve, reject) => {\n      this.compilation.inputFileSystem.readFile(\n        path,\n        (err?: Error | null, data?: string | Buffer) => {\n          if (err) {\n            reject(err);\n\n            return;\n          }\n\n          this.compilation.fileDependencies.add(path);\n          resolve(data?.toString() ?? '');\n        },\n      );\n    });\n  }\n}\n"]}

package/src/{webpack → tools/webpack}/plugins/index.js

@@ -30,4 +30,4 @@ var javascript_optimizer_plugin_1 = require("./javascript-optimizer-plugin");
 Object.defineProperty(exports, "JavaScriptOptimizerPlugin", { enumerable: true, get: function () { return javascript_optimizer_plugin_1.JavaScriptOptimizerPlugin; } });
 var postcss_cli_resources_1 = require("./postcss-cli-resources");
 Object.defineProperty(exports, "PostcssCliResources", { enumerable: true, get: function () { return __importDefault(postcss_cli_resources_1).default; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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