@angular-devkit/build-angular 16.2.1 → 17.0.0-next.3

package/src/builders/extract-i18n/webpack-extraction.js

@@ -0,0 +1,100 @@
+"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.extractMessages = void 0;
+const build_webpack_1 = require("@angular-devkit/build-webpack");
+const rxjs_1 = require("rxjs");
+const webpack_1 = __importDefault(require("webpack"));
+const configs_1 = require("../../tools/webpack/configs");
+const stats_1 = require("../../tools/webpack/utils/stats");
+const webpack_browser_config_1 = require("../../utils/webpack-browser-config");
+const schema_1 = require("../browser/schema");
+class NoEmitPlugin {
+    apply(compiler) {
+        compiler.hooks.shouldEmit.tap('angular-no-emit', () => false);
+    }
+}
+async function extractMessages(options, builderName, context, transforms = {}) {
+    const messages = [];
+    let useLegacyIds = true;
+    const browserOptions = await context.validateOptions(await context.getTargetOptions(options.browserTarget), builderName);
+    const builderOptions = {
+        ...browserOptions,
+        optimization: false,
+        sourceMap: {
+            scripts: true,
+            styles: false,
+            vendor: true,
+        },
+        buildOptimizer: false,
+        aot: true,
+        progress: options.progress,
+        budgets: [],
+        assets: [],
+        scripts: [],
+        styles: [],
+        deleteOutputPath: false,
+        extractLicenses: false,
+        subresourceIntegrity: false,
+        outputHashing: schema_1.OutputHashing.None,
+        namedChunks: true,
+        allowedCommonJsDependencies: undefined,
+    };
+    const { config } = await (0, webpack_browser_config_1.generateBrowserWebpackConfigFromContext)(builderOptions, context, (wco) => {
+        // Default value for legacy message ids is currently true
+        useLegacyIds = wco.tsConfig.options.enableI18nLegacyMessageIdFormat ?? true;
+        const partials = [
+            { plugins: [new NoEmitPlugin()] },
+            (0, configs_1.getCommonConfig)(wco),
+        ];
+        // Add Ivy application file extractor support
+        partials.unshift({
+            module: {
+                rules: [
+                    {
+                        test: /\.[cm]?[tj]sx?$/,
+                        loader: require.resolve('./ivy-extract-loader'),
+                        options: {
+                            messageHandler: (fileMessages) => messages.push(...fileMessages),
+                        },
+                    },
+                ],
+            },
+        });
+        // Replace all stylesheets with empty content
+        partials.push({
+            module: {
+                rules: [
+                    {
+                        test: /\.(css|scss|sass|less)$/,
+                        loader: require.resolve('./empty-loader'),
+                    },
+                ],
+            },
+        });
+        return partials;
+    }, 
+    // During extraction we don't need specific browser support.
+    { supportedBrowsers: undefined });
+    const builderResult = await (0, rxjs_1.lastValueFrom)((0, build_webpack_1.runWebpack)((await transforms?.webpackConfiguration?.(config)) || config, context, {
+        logging: (0, stats_1.createWebpackLoggingCallback)(builderOptions, context.logger),
+        webpackFactory: webpack_1.default,
+    }));
+    return {
+        builderResult,
+        basePath: config.context || options.projectRoot,
+        messages,
+        useLegacyIds,
+    };
+}
+exports.extractMessages = extractMessages;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webpack-extraction.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/extract-i18n/webpack-extraction.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 { ɵParsedMessage as LocalizeMessage } from '@angular/localize';\nimport { BuilderContext } from '@angular-devkit/architect';\nimport { BuildResult, runWebpack } from '@angular-devkit/build-webpack';\nimport { lastValueFrom } from 'rxjs';\nimport webpack, { type Configuration } from 'webpack';\nimport { getCommonConfig } from '../../tools/webpack/configs';\nimport { createWebpackLoggingCallback } from '../../tools/webpack/utils/stats';\nimport { ExecutionTransformer } from '../../transforms';\nimport { generateBrowserWebpackConfigFromContext } from '../../utils/webpack-browser-config';\nimport { OutputHashing, Schema } from '../browser/schema';\nimport { NormalizedExtractI18nOptions } from './options';\n\nclass NoEmitPlugin {\n  apply(compiler: webpack.Compiler): void {\n    compiler.hooks.shouldEmit.tap('angular-no-emit', () => false);\n  }\n}\n\nexport async function extractMessages(\n  options: NormalizedExtractI18nOptions,\n  builderName: string,\n  context: BuilderContext,\n  transforms: {\n    webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;\n  } = {},\n): Promise<{\n  builderResult: BuildResult;\n  basePath: string;\n  messages: LocalizeMessage[];\n  useLegacyIds: boolean;\n}> {\n  const messages: LocalizeMessage[] = [];\n  let useLegacyIds = true;\n\n  const browserOptions = await context.validateOptions(\n    await context.getTargetOptions(options.browserTarget),\n    builderName,\n  );\n\n  const builderOptions = {\n    ...browserOptions,\n    optimization: false,\n    sourceMap: {\n      scripts: true,\n      styles: false,\n      vendor: true,\n    },\n    buildOptimizer: false,\n    aot: true,\n    progress: options.progress,\n    budgets: [],\n    assets: [],\n    scripts: [],\n    styles: [],\n    deleteOutputPath: false,\n    extractLicenses: false,\n    subresourceIntegrity: false,\n    outputHashing: OutputHashing.None,\n    namedChunks: true,\n    allowedCommonJsDependencies: undefined,\n  } as unknown as Schema;\n  const { config } = await generateBrowserWebpackConfigFromContext(\n    builderOptions,\n    context,\n    (wco) => {\n      // Default value for legacy message ids is currently true\n      useLegacyIds = wco.tsConfig.options.enableI18nLegacyMessageIdFormat ?? true;\n\n      const partials: (Promise<Configuration> | Configuration)[] = [\n        { plugins: [new NoEmitPlugin()] },\n        getCommonConfig(wco),\n      ];\n\n      // Add Ivy application file extractor support\n      partials.unshift({\n        module: {\n          rules: [\n            {\n              test: /\\.[cm]?[tj]sx?$/,\n              loader: require.resolve('./ivy-extract-loader'),\n              options: {\n                messageHandler: (fileMessages: LocalizeMessage[]) => messages.push(...fileMessages),\n              },\n            },\n          ],\n        },\n      });\n\n      // Replace all stylesheets with empty content\n      partials.push({\n        module: {\n          rules: [\n            {\n              test: /\\.(css|scss|sass|less)$/,\n              loader: require.resolve('./empty-loader'),\n            },\n          ],\n        },\n      });\n\n      return partials;\n    },\n    // During extraction we don't need specific browser support.\n    { supportedBrowsers: undefined },\n  );\n\n  const builderResult = await lastValueFrom(\n    runWebpack((await transforms?.webpackConfiguration?.(config)) || config, context, {\n      logging: createWebpackLoggingCallback(builderOptions, context.logger),\n      webpackFactory: webpack,\n    }),\n  );\n\n  return {\n    builderResult,\n    basePath: config.context || options.projectRoot,\n    messages,\n    useLegacyIds,\n  };\n}\n"]}

package/src/builders/jest/schema.d.ts

@@ -11,15 +11,12 @@ export interface Schema {
      */
     include?: string[];
     /**
-     * Polyfills to be included in the build.
+     * A list of polyfills to include in the build. Can be a full path for a file, relative to
+     * the current workspace or module specifier. Example: 'zone.js'.
      */
-    polyfills?: Polyfills;
+    polyfills?: string[];
     /**
      * The name of the TypeScript configuration file.
      */
     tsConfig: string;
 }
-/**
- * Polyfills to be included in the build.
- */
-export type Polyfills = string[] | string;

package/src/builders/jest/schema.js

@@ -2,4 +2,4 @@
 // THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE
 // CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvamVzdC9zY2hlbWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLG1GQUFtRjtBQUNuRixvRkFBb0YiLCJzb3VyY2VzQ29udGVudCI6WyJcbi8vIFRISVMgRklMRSBJUyBBVVRPTUFUSUNBTExZIEdFTkVSQVRFRC4gVE8gVVBEQVRFIFRISVMgRklMRSBZT1UgTkVFRCBUTyBDSEFOR0UgVEhFXG4vLyBDT1JSRVNQT05ESU5HIEpTT04gU0NIRU1BIEZJTEUsIFRIRU4gUlVOIGRldmtpdC1hZG1pbiBidWlsZCAob3IgYmF6ZWwgYnVpbGQgLi4uKS5cblxuLyoqXG4gKiBKZXN0IHRhcmdldCBvcHRpb25zXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2NoZW1hIHtcbiAgICAvKipcbiAgICAgKiBHbG9icyBvZiBmaWxlcyB0byBleGNsdWRlLCByZWxhdGl2ZSB0byB0aGUgcHJvamVjdCByb290LlxuICAgICAqL1xuICAgIGV4Y2x1ZGU/OiBzdHJpbmdbXTtcbiAgICAvKipcbiAgICAgKiBHbG9icyBvZiBmaWxlcyB0byBpbmNsdWRlLCByZWxhdGl2ZSB0byBwcm9qZWN0IHJvb3QuXG4gICAgICovXG4gICAgaW5jbHVkZT86IHN0cmluZ1tdO1xuICAgIC8qKlxuICAgICAqIFBvbHlmaWxscyB0byBiZSBpbmNsdWRlZCBpbiB0aGUgYnVpbGQuXG4gICAgICovXG4gICAgcG9seWZpbGxzPzogUG9seWZpbGxzO1xuICAgIC8qKlxuICAgICAqIFRoZSBuYW1lIG9mIHRoZSBUeXBlU2NyaXB0IGNvbmZpZ3VyYXRpb24gZmlsZS5cbiAgICAgKi9cbiAgICB0c0NvbmZpZzogc3RyaW5nO1xufVxuXG4vKipcbiAqIFBvbHlmaWxscyB0byBiZSBpbmNsdWRlZCBpbiB0aGUgYnVpbGQuXG4gKi9cbmV4cG9ydCB0eXBlIFBvbHlmaWxscyA9IHN0cmluZ1tdIHwgc3RyaW5nO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvamVzdC9zY2hlbWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLG1GQUFtRjtBQUNuRixvRkFBb0YiLCJzb3VyY2VzQ29udGVudCI6WyJcbi8vIFRISVMgRklMRSBJUyBBVVRPTUFUSUNBTExZIEdFTkVSQVRFRC4gVE8gVVBEQVRFIFRISVMgRklMRSBZT1UgTkVFRCBUTyBDSEFOR0UgVEhFXG4vLyBDT1JSRVNQT05ESU5HIEpTT04gU0NIRU1BIEZJTEUsIFRIRU4gUlVOIGRldmtpdC1hZG1pbiBidWlsZCAob3IgYmF6ZWwgYnVpbGQgLi4uKS5cblxuLyoqXG4gKiBKZXN0IHRhcmdldCBvcHRpb25zXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2NoZW1hIHtcbiAgICAvKipcbiAgICAgKiBHbG9icyBvZiBmaWxlcyB0byBleGNsdWRlLCByZWxhdGl2ZSB0byB0aGUgcHJvamVjdCByb290LlxuICAgICAqL1xuICAgIGV4Y2x1ZGU/OiBzdHJpbmdbXTtcbiAgICAvKipcbiAgICAgKiBHbG9icyBvZiBmaWxlcyB0byBpbmNsdWRlLCByZWxhdGl2ZSB0byBwcm9qZWN0IHJvb3QuXG4gICAgICovXG4gICAgaW5jbHVkZT86IHN0cmluZ1tdO1xuICAgIC8qKlxuICAgICAqIEEgbGlzdCBvZiBwb2x5ZmlsbHMgdG8gaW5jbHVkZSBpbiB0aGUgYnVpbGQuIENhbiBiZSBhIGZ1bGwgcGF0aCBmb3IgYSBmaWxlLCByZWxhdGl2ZSB0b1xuICAgICAqIHRoZSBjdXJyZW50IHdvcmtzcGFjZSBvciBtb2R1bGUgc3BlY2lmaWVyLiBFeGFtcGxlOiAnem9uZS5qcycuXG4gICAgICovXG4gICAgcG9seWZpbGxzPzogc3RyaW5nW107XG4gICAgLyoqXG4gICAgICogVGhlIG5hbWUgb2YgdGhlIFR5cGVTY3JpcHQgY29uZmlndXJhdGlvbiBmaWxlLlxuICAgICAqL1xuICAgIHRzQ29uZmlnOiBzdHJpbmc7XG59XG4iXX0=

package/src/builders/jest/schema.json

@@ -25,22 +25,13 @@
       "description": "The name of the TypeScript configuration file."
     },
     "polyfills": {
-      "description": "Polyfills to be included in the build.",
-      "oneOf": [
-        {
-          "type": "array",
-          "description": "A list of polyfills to include in the build. Can be a full path for a file, relative to the current workspace or module specifier. Example: 'zone.js'.",
-          "items": {
-            "type": "string",
-            "uniqueItems": true
-          },
-          "default": []
-        },
-        {
-          "type": "string",
-          "description": "The full path for the polyfills file, relative to the current workspace or a module specifier. Example: 'zone.js'."
-        }
-      ]
+      "type": "array",
+      "description": "A list of polyfills to include in the build. Can be a full path for a file, relative to the current workspace or module specifier. Example: 'zone.js'.",
+      "items": {
+        "type": "string",
+        "uniqueItems": true
+      },
+      "default": []
     }
   },
   "additionalProperties": false,

package/src/builders/prerender/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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, BuilderOutput } from '@angular-devkit/architect';
+import { json } from '@angular-devkit/core';
+import { Schema } from './schema';
+type PrerenderBuilderOptions = Schema & json.JsonObject;
+type PrerenderBuilderOutput = BuilderOutput;
+/**
+ * Builds the browser and server, then renders each route in options.routes
+ * and writes them to prerender/<route>/index.html for each output path in
+ * the browser result.
+ */
+export declare function execute(options: PrerenderBuilderOptions, context: BuilderContext): Promise<PrerenderBuilderOutput>;
+declare const _default: import("../../../../architect/src/internal").Builder<Schema & json.JsonObject>;
+export default _default;

package/src/builders/prerender/index.js

@@ -0,0 +1,180 @@
+"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.execute = void 0;
+const architect_1 = require("@angular-devkit/architect");
+const fs = __importStar(require("fs"));
+const ora_1 = __importDefault(require("ora"));
+const path = __importStar(require("path"));
+const piscina_1 = __importDefault(require("piscina"));
+const utils_1 = require("../../utils");
+const environment_options_1 = require("../../utils/environment-options");
+const error_1 = require("../../utils/error");
+const service_worker_1 = require("../../utils/service-worker");
+const utils_2 = require("./utils");
+/**
+ * Schedules the server and browser builds and returns their results if both builds are successful.
+ */
+async function _scheduleBuilds(options, context) {
+    const browserTarget = (0, architect_1.targetFromTargetString)(options.browserTarget);
+    const serverTarget = (0, architect_1.targetFromTargetString)(options.serverTarget);
+    const browserTargetRun = await context.scheduleTarget(browserTarget, {
+        watch: false,
+        serviceWorker: false,
+        // todo: handle service worker augmentation
+    });
+    const serverTargetRun = await context.scheduleTarget(serverTarget, {
+        watch: false,
+    });
+    try {
+        const [browserResult, serverResult] = await Promise.all([
+            browserTargetRun.result,
+            serverTargetRun.result,
+        ]);
+        const success = browserResult.success && serverResult.success && browserResult.baseOutputPath !== undefined;
+        const error = browserResult.error || serverResult.error;
+        return { success, error, browserResult, serverResult };
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        return { success: false, error: e.message };
+    }
+    finally {
+        await Promise.all([browserTargetRun.stop(), serverTargetRun.stop()]);
+    }
+}
+/**
+ * Renders each route and writes them to
+ * <route>/index.html for each output path in the browser result.
+ */
+async function _renderUniversal(routes, context, browserResult, serverResult, browserOptions) {
+    const projectName = context.target && context.target.project;
+    if (!projectName) {
+        throw new Error('The builder requires a target.');
+    }
+    const projectMetadata = await context.getProjectMetadata(projectName);
+    const projectRoot = path.join(context.workspaceRoot, projectMetadata.root ?? '');
+    // Users can specify a different base html file e.g. "src/home.html"
+    const indexFile = (0, utils_2.getIndexOutputFile)(browserOptions);
+    const { styles: normalizedStylesOptimization } = (0, utils_1.normalizeOptimization)(browserOptions.optimization);
+    const zonePackage = require.resolve('zone.js', { paths: [context.workspaceRoot] });
+    const { baseOutputPath = '' } = serverResult;
+    const worker = new piscina_1.default({
+        filename: path.join(__dirname, 'render-worker.js'),
+        maxThreads: environment_options_1.maxWorkers,
+        workerData: { zonePackage },
+    });
+    try {
+        // We need to render the routes for each locale from the browser output.
+        for (const { path: outputPath } of browserResult.outputs) {
+            const localeDirectory = path.relative(browserResult.baseOutputPath, outputPath);
+            const serverBundlePath = path.join(baseOutputPath, localeDirectory, 'main.js');
+            if (!fs.existsSync(serverBundlePath)) {
+                throw new Error(`Could not find the main bundle: ${serverBundlePath}`);
+            }
+            const spinner = (0, ora_1.default)(`Prerendering ${routes.length} route(s) to ${outputPath}...`).start();
+            try {
+                const results = (await Promise.all(routes.map((route) => {
+                    const options = {
+                        indexFile,
+                        deployUrl: browserOptions.deployUrl || '',
+                        inlineCriticalCss: !!normalizedStylesOptimization.inlineCritical,
+                        minifyCss: !!normalizedStylesOptimization.minify,
+                        outputPath,
+                        route,
+                        serverBundlePath,
+                    };
+                    return worker.run(options);
+                })));
+                let numErrors = 0;
+                for (const { errors, warnings } of results) {
+                    spinner.stop();
+                    errors?.forEach((e) => context.logger.error(e));
+                    warnings?.forEach((e) => context.logger.warn(e));
+                    spinner.start();
+                    numErrors += errors?.length ?? 0;
+                }
+                if (numErrors > 0) {
+                    throw Error(`Rendering failed with ${numErrors} worker errors.`);
+                }
+            }
+            catch (error) {
+                spinner.fail(`Prerendering routes to ${outputPath} failed.`);
+                (0, error_1.assertIsError)(error);
+                return { success: false, error: error.message };
+            }
+            spinner.succeed(`Prerendering routes to ${outputPath} complete.`);
+            if (browserOptions.serviceWorker) {
+                spinner.start('Generating service worker...');
+                try {
+                    await (0, service_worker_1.augmentAppWithServiceWorker)(projectRoot, context.workspaceRoot, outputPath, browserOptions.baseHref || '/', browserOptions.ngswConfigPath);
+                }
+                catch (error) {
+                    spinner.fail('Service worker generation failed.');
+                    (0, error_1.assertIsError)(error);
+                    return { success: false, error: error.message };
+                }
+                spinner.succeed('Service worker generation complete.');
+            }
+        }
+    }
+    finally {
+        void worker.destroy();
+    }
+    return browserResult;
+}
+/**
+ * Builds the browser and server, then renders each route in options.routes
+ * and writes them to prerender/<route>/index.html for each output path in
+ * the browser result.
+ */
+async function execute(options, context) {
+    const browserTarget = (0, architect_1.targetFromTargetString)(options.browserTarget);
+    const browserOptions = (await context.getTargetOptions(browserTarget));
+    const tsConfigPath = typeof browserOptions.tsConfig === 'string' ? browserOptions.tsConfig : undefined;
+    const routes = await (0, utils_2.getRoutes)(options, tsConfigPath, context);
+    if (!routes.length) {
+        throw new Error(`Could not find any routes to prerender.`);
+    }
+    const result = await _scheduleBuilds(options, context);
+    const { success, error, browserResult, serverResult } = result;
+    if (!success || !browserResult || !serverResult) {
+        return { success, error };
+    }
+    return _renderUniversal(routes, context, browserResult, serverResult, browserOptions);
+}
+exports.execute = execute;
+exports.default = (0, architect_1.createBuilder)(execute);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/prerender/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,yDAKmC;AAEnC,uCAAyB;AACzB,8CAAsB;AACtB,2CAA6B;AAC7B,sDAA8B;AAC9B,uCAAoD;AACpD,yEAA6D;AAC7D,6CAAkD;AAClD,+DAAyE;AAMzE,mCAAwD;AAKxD;;GAEG;AACH,KAAK,UAAU,eAAe,CAC5B,OAAgC,EAChC,OAAuB;IAOvB,MAAM,aAAa,GAAG,IAAA,kCAAsB,EAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IACpE,MAAM,YAAY,GAAG,IAAA,kCAAsB,EAAC,OAAO,CAAC,YAAY,CAAC,CAAC;IAElE,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,aAAa,EAAE;QACnE,KAAK,EAAE,KAAK;QACZ,aAAa,EAAE,KAAK;QACpB,2CAA2C;KAC5C,CAAC,CAAC;IACH,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,YAAY,EAAE;QACjE,KAAK,EAAE,KAAK;KACb,CAAC,CAAC;IAEH,IAAI;QACF,MAAM,CAAC,aAAa,EAAE,YAAY,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACtD,gBAAgB,CAAC,MAAyC;YAC1D,eAAe,CAAC,MAAwC;SACzD,CAAC,CAAC;QAEH,MAAM,OAAO,GACX,aAAa,CAAC,OAAO,IAAI,YAAY,CAAC,OAAO,IAAI,aAAa,CAAC,cAAc,KAAK,SAAS,CAAC;QAC9F,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,IAAK,YAAY,CAAC,KAAgB,CAAC;QAEpE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC;KACxD;IAAC,OAAO,CAAC,EAAE;QACV,IAAA,qBAAa,EAAC,CAAC,CAAC,CAAC;QAEjB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;KAC7C;YAAS;QACR,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,gBAAgB,CAAC,IAAI,EAAE,EAAE,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;KACtE;AACH,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,gBAAgB,CAC7B,MAAgB,EAChB,OAAuB,EACvB,aAAmC,EACnC,YAAiC,EACjC,cAAqC;IAErC,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;IAC7D,IAAI,CAAC,WAAW,EAAE;QAChB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;KACnD;IAED,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;IACtE,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAC3B,OAAO,CAAC,aAAa,EACpB,eAAe,CAAC,IAA2B,IAAI,EAAE,CACnD,CAAC;IAEF,oEAAoE;IACpE,MAAM,SAAS,GAAG,IAAA,0BAAkB,EAAC,cAAc,CAAC,CAAC;IACrD,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,GAAG,IAAA,6BAAqB,EACpE,cAAc,CAAC,YAAY,CAC5B,CAAC;IAEF,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;IAEnF,MAAM,EAAE,cAAc,GAAG,EAAE,EAAE,GAAG,YAAY,CAAC;IAC7C,MAAM,MAAM,GAAG,IAAI,iBAAO,CAAC;QACzB,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,kBAAkB,CAAC;QAClD,UAAU,EAAE,gCAAU;QACtB,UAAU,EAAE,EAAE,WAAW,EAAE;KAC5B,CAAC,CAAC;IAEH,IAAI;QACF,wEAAwE;QACxE,KAAK,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,aAAa,CAAC,OAAO,EAAE;YACxD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;YAChF,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC;YAC/E,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE;gBACpC,MAAM,IAAI,KAAK,CAAC,mCAAmC,gBAAgB,EAAE,CAAC,CAAC;aACxE;YAED,MAAM,OAAO,GAAG,IAAA,aAAG,EAAC,gBAAgB,MAAM,CAAC,MAAM,gBAAgB,UAAU,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC;YAE1F,IAAI;gBACF,MAAM,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,CAChC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;oBACnB,MAAM,OAAO,GAAkB;wBAC7B,SAAS;wBACT,SAAS,EAAE,cAAc,CAAC,SAAS,IAAI,EAAE;wBACzC,iBAAiB,EAAE,CAAC,CAAC,4BAA4B,CAAC,cAAc;wBAChE,SAAS,EAAE,CAAC,CAAC,4BAA4B,CAAC,MAAM;wBAChD,UAAU;wBACV,KAAK;wBACL,gBAAgB;qBACjB,CAAC;oBAEF,OAAO,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC7B,CAAC,CAAC,CACH,CAAmB,CAAC;gBACrB,IAAI,SAAS,GAAG,CAAC,CAAC;gBAClB,KAAK,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,OAAO,EAAE;oBAC1C,OAAO,CAAC,IAAI,EAAE,CAAC;oBACf,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;oBAChD,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBACjD,OAAO,CAAC,KAAK,EAAE,CAAC;oBAChB,SAAS,IAAI,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC;iBAClC;gBACD,IAAI,SAAS,GAAG,CAAC,EAAE;oBACjB,MAAM,KAAK,CAAC,yBAAyB,SAAS,iBAAiB,CAAC,CAAC;iBAClE;aACF;YAAC,OAAO,KAAK,EAAE;gBACd,OAAO,CAAC,IAAI,CAAC,0BAA0B,UAAU,UAAU,CAAC,CAAC;gBAC7D,IAAA,qBAAa,EAAC,KAAK,CAAC,CAAC;gBAErB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;aACjD;YACD,OAAO,CAAC,OAAO,CAAC,0BAA0B,UAAU,YAAY,CAAC,CAAC;YAElE,IAAI,cAAc,CAAC,aAAa,EAAE;gBAChC,OAAO,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC;gBAC9C,IAAI;oBACF,MAAM,IAAA,4CAA2B,EAC/B,WAAW,EACX,OAAO,CAAC,aAAa,EACrB,UAAU,EACV,cAAc,CAAC,QAAQ,IAAI,GAAG,EAC9B,cAAc,CAAC,cAAc,CAC9B,CAAC;iBACH;gBAAC,OAAO,KAAK,EAAE;oBACd,OAAO,CAAC,IAAI,CAAC,mCAAmC,CAAC,CAAC;oBAClD,IAAA,qBAAa,EAAC,KAAK,CAAC,CAAC;oBAErB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;iBACjD;gBACD,OAAO,CAAC,OAAO,CAAC,qCAAqC,CAAC,CAAC;aACxD;SACF;KACF;YAAS;QACR,KAAK,MAAM,CAAC,OAAO,EAAE,CAAC;KACvB;IAED,OAAO,aAAa,CAAC;AACvB,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,OAAO,CAC3B,OAAgC,EAChC,OAAuB;IAEvB,MAAM,aAAa,GAAG,IAAA,kCAAsB,EAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IACpE,MAAM,cAAc,GAAG,CAAC,MAAM,OAAO,CAAC,gBAAgB,CACpD,aAAa,CACd,CAAqC,CAAC;IACvC,MAAM,YAAY,GAChB,OAAO,cAAc,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IAEpF,MAAM,MAAM,GAAG,MAAM,IAAA,iBAAS,EAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IAC/D,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;QAClB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;KAC5D;IAED,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACvD,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC;IAC/D,IAAI,CAAC,OAAO,IAAI,CAAC,aAAa,IAAI,CAAC,YAAY,EAAE;QAC/C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAmB,CAAC;KAC5C;IAED,OAAO,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;AACxF,CAAC;AAvBD,0BAuBC;AAED,kBAAe,IAAA,yBAAa,EAAC,OAAO,CAAC,CAAC","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 {\n  BuilderContext,\n  BuilderOutput,\n  createBuilder,\n  targetFromTargetString,\n} from '@angular-devkit/architect';\nimport { json } from '@angular-devkit/core';\nimport * as fs from 'fs';\nimport ora from 'ora';\nimport * as path from 'path';\nimport Piscina from 'piscina';\nimport { normalizeOptimization } from '../../utils';\nimport { maxWorkers } from '../../utils/environment-options';\nimport { assertIsError } from '../../utils/error';\nimport { augmentAppWithServiceWorker } from '../../utils/service-worker';\nimport { BrowserBuilderOutput } from '../browser';\nimport { Schema as BrowserBuilderOptions } from '../browser/schema';\nimport { ServerBuilderOutput } from '../server';\nimport type { RenderOptions, RenderResult } from './render-worker';\nimport { Schema } from './schema';\nimport { getIndexOutputFile, getRoutes } from './utils';\n\ntype PrerenderBuilderOptions = Schema & json.JsonObject;\ntype PrerenderBuilderOutput = BuilderOutput;\n\n/**\n * Schedules the server and browser builds and returns their results if both builds are successful.\n */\nasync function _scheduleBuilds(\n  options: PrerenderBuilderOptions,\n  context: BuilderContext,\n): Promise<\n  BuilderOutput & {\n    serverResult?: ServerBuilderOutput;\n    browserResult?: BrowserBuilderOutput;\n  }\n> {\n  const browserTarget = targetFromTargetString(options.browserTarget);\n  const serverTarget = targetFromTargetString(options.serverTarget);\n\n  const browserTargetRun = await context.scheduleTarget(browserTarget, {\n    watch: false,\n    serviceWorker: false,\n    // todo: handle service worker augmentation\n  });\n  const serverTargetRun = await context.scheduleTarget(serverTarget, {\n    watch: false,\n  });\n\n  try {\n    const [browserResult, serverResult] = await Promise.all([\n      browserTargetRun.result as unknown as BrowserBuilderOutput,\n      serverTargetRun.result as unknown as ServerBuilderOutput,\n    ]);\n\n    const success =\n      browserResult.success && serverResult.success && browserResult.baseOutputPath !== undefined;\n    const error = browserResult.error || (serverResult.error as string);\n\n    return { success, error, browserResult, serverResult };\n  } catch (e) {\n    assertIsError(e);\n\n    return { success: false, error: e.message };\n  } finally {\n    await Promise.all([browserTargetRun.stop(), serverTargetRun.stop()]);\n  }\n}\n\n/**\n * Renders each route and writes them to\n * <route>/index.html for each output path in the browser result.\n */\nasync function _renderUniversal(\n  routes: string[],\n  context: BuilderContext,\n  browserResult: BrowserBuilderOutput,\n  serverResult: ServerBuilderOutput,\n  browserOptions: BrowserBuilderOptions,\n): Promise<PrerenderBuilderOutput> {\n  const projectName = context.target && context.target.project;\n  if (!projectName) {\n    throw new Error('The builder requires a target.');\n  }\n\n  const projectMetadata = await context.getProjectMetadata(projectName);\n  const projectRoot = path.join(\n    context.workspaceRoot,\n    (projectMetadata.root as string | undefined) ?? '',\n  );\n\n  // Users can specify a different base html file e.g. \"src/home.html\"\n  const indexFile = getIndexOutputFile(browserOptions);\n  const { styles: normalizedStylesOptimization } = normalizeOptimization(\n    browserOptions.optimization,\n  );\n\n  const zonePackage = require.resolve('zone.js', { paths: [context.workspaceRoot] });\n\n  const { baseOutputPath = '' } = serverResult;\n  const worker = new Piscina({\n    filename: path.join(__dirname, 'render-worker.js'),\n    maxThreads: maxWorkers,\n    workerData: { zonePackage },\n  });\n\n  try {\n    // We need to render the routes for each locale from the browser output.\n    for (const { path: outputPath } of browserResult.outputs) {\n      const localeDirectory = path.relative(browserResult.baseOutputPath, outputPath);\n      const serverBundlePath = path.join(baseOutputPath, localeDirectory, 'main.js');\n      if (!fs.existsSync(serverBundlePath)) {\n        throw new Error(`Could not find the main bundle: ${serverBundlePath}`);\n      }\n\n      const spinner = ora(`Prerendering ${routes.length} route(s) to ${outputPath}...`).start();\n\n      try {\n        const results = (await Promise.all(\n          routes.map((route) => {\n            const options: RenderOptions = {\n              indexFile,\n              deployUrl: browserOptions.deployUrl || '',\n              inlineCriticalCss: !!normalizedStylesOptimization.inlineCritical,\n              minifyCss: !!normalizedStylesOptimization.minify,\n              outputPath,\n              route,\n              serverBundlePath,\n            };\n\n            return worker.run(options);\n          }),\n        )) as RenderResult[];\n        let numErrors = 0;\n        for (const { errors, warnings } of results) {\n          spinner.stop();\n          errors?.forEach((e) => context.logger.error(e));\n          warnings?.forEach((e) => context.logger.warn(e));\n          spinner.start();\n          numErrors += errors?.length ?? 0;\n        }\n        if (numErrors > 0) {\n          throw Error(`Rendering failed with ${numErrors} worker errors.`);\n        }\n      } catch (error) {\n        spinner.fail(`Prerendering routes to ${outputPath} failed.`);\n        assertIsError(error);\n\n        return { success: false, error: error.message };\n      }\n      spinner.succeed(`Prerendering routes to ${outputPath} complete.`);\n\n      if (browserOptions.serviceWorker) {\n        spinner.start('Generating service worker...');\n        try {\n          await augmentAppWithServiceWorker(\n            projectRoot,\n            context.workspaceRoot,\n            outputPath,\n            browserOptions.baseHref || '/',\n            browserOptions.ngswConfigPath,\n          );\n        } catch (error) {\n          spinner.fail('Service worker generation failed.');\n          assertIsError(error);\n\n          return { success: false, error: error.message };\n        }\n        spinner.succeed('Service worker generation complete.');\n      }\n    }\n  } finally {\n    void worker.destroy();\n  }\n\n  return browserResult;\n}\n\n/**\n * Builds the browser and server, then renders each route in options.routes\n * and writes them to prerender/<route>/index.html for each output path in\n * the browser result.\n */\nexport async function execute(\n  options: PrerenderBuilderOptions,\n  context: BuilderContext,\n): Promise<PrerenderBuilderOutput> {\n  const browserTarget = targetFromTargetString(options.browserTarget);\n  const browserOptions = (await context.getTargetOptions(\n    browserTarget,\n  )) as unknown as BrowserBuilderOptions;\n  const tsConfigPath =\n    typeof browserOptions.tsConfig === 'string' ? browserOptions.tsConfig : undefined;\n\n  const routes = await getRoutes(options, tsConfigPath, context);\n  if (!routes.length) {\n    throw new Error(`Could not find any routes to prerender.`);\n  }\n\n  const result = await _scheduleBuilds(options, context);\n  const { success, error, browserResult, serverResult } = result;\n  if (!success || !browserResult || !serverResult) {\n    return { success, error } as BuilderOutput;\n  }\n\n  return _renderUniversal(routes, context, browserResult, serverResult, browserOptions);\n}\n\nexport default createBuilder(execute);\n"]}

package/src/builders/prerender/render-worker.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @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 interface RenderOptions {
+    indexFile: string;
+    deployUrl: string;
+    inlineCriticalCss: boolean;
+    minifyCss: boolean;
+    outputPath: string;
+    serverBundlePath: string;
+    route: string;
+}
+export interface RenderResult {
+    errors?: string[];
+    warnings?: string[];
+}
+/**
+ * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
+ */
+declare function render({ indexFile, deployUrl, minifyCss, outputPath, serverBundlePath, route, inlineCriticalCss, }: RenderOptions): Promise<RenderResult>;
+/**
+ * The default export will be the promise returned by the initialize function.
+ * This is awaited by piscina prior to using the Worker.
+ */
+declare const _default: Promise<typeof render>;
+export default _default;

package/src/builders/prerender/render-worker.js

@@ -0,0 +1,126 @@
+"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 });
+const node_assert_1 = __importDefault(require("node:assert"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_worker_threads_1 = require("node:worker_threads");
+const inline_critical_css_1 = require("../../utils/index-file/inline-critical-css");
+/**
+ * The fully resolved path to the zone.js package that will be loaded during worker initialization.
+ * This is passed as workerData when setting up the worker via the `piscina` package.
+ */
+const { zonePackage } = node_worker_threads_1.workerData;
+/**
+ * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
+ */
+async function render({ indexFile, deployUrl, minifyCss, outputPath, serverBundlePath, route, inlineCriticalCss, }) {
+    const result = {};
+    const browserIndexOutputPath = path.join(outputPath, indexFile);
+    const outputFolderPath = path.join(outputPath, route);
+    const outputIndexPath = path.join(outputFolderPath, 'index.html');
+    const { ɵSERVER_CONTEXT, AppServerModule, renderModule, renderApplication, default: bootstrapAppFn, } = (await Promise.resolve(`${serverBundlePath}`).then(s => __importStar(require(s))));
+    (0, node_assert_1.default)(ɵSERVER_CONTEXT, `ɵSERVER_CONTEXT was not exported from: ${serverBundlePath}.`);
+    const indexBaseName = fs.existsSync(path.join(outputPath, 'index.original.html'))
+        ? 'index.original.html'
+        : indexFile;
+    const browserIndexInputPath = path.join(outputPath, indexBaseName);
+    const document = await fs.promises.readFile(browserIndexInputPath, 'utf8');
+    const platformProviders = [
+        {
+            provide: ɵSERVER_CONTEXT,
+            useValue: 'ssg',
+        },
+    ];
+    let html;
+    // Render platform server module
+    if (isBootstrapFn(bootstrapAppFn)) {
+        (0, node_assert_1.default)(renderApplication, `renderApplication was not exported from: ${serverBundlePath}.`);
+        html = await renderApplication(bootstrapAppFn, {
+            document,
+            url: route,
+            platformProviders,
+        });
+    }
+    (0, node_assert_1.default)(AppServerModule, `Neither an AppServerModule nor a bootstrapping function was exported from: ${serverBundlePath}.`);
+    (0, node_assert_1.default)(renderModule, `renderModule was not exported from: ${serverBundlePath}.`);
+    html = await renderModule(AppServerModule, {
+        document,
+        url: route,
+        extraProviders: platformProviders,
+    });
+    if (inlineCriticalCss) {
+        const inlineCriticalCssProcessor = new inline_critical_css_1.InlineCriticalCssProcessor({
+            deployUrl: deployUrl,
+            minify: minifyCss,
+        });
+        const { content, warnings, errors } = await inlineCriticalCssProcessor.process(html, {
+            outputPath,
+        });
+        result.errors = errors;
+        result.warnings = warnings;
+        html = content;
+    }
+    // This case happens when we are prerendering "/".
+    if (browserIndexOutputPath === outputIndexPath) {
+        const browserIndexOutputPathOriginal = path.join(outputPath, 'index.original.html');
+        fs.renameSync(browserIndexOutputPath, browserIndexOutputPathOriginal);
+    }
+    fs.mkdirSync(outputFolderPath, { recursive: true });
+    fs.writeFileSync(outputIndexPath, html);
+    return result;
+}
+function isBootstrapFn(value) {
+    // We can differentiate between a module and a bootstrap function by reading `cmp`:
+    return typeof value === 'function' && !('ɵmod' in value);
+}
+/**
+ * Initializes the worker when it is first created by loading the Zone.js package
+ * into the worker instance.
+ *
+ * @returns A promise resolving to the render function of the worker.
+ */
+async function initialize() {
+    // Setup Zone.js
+    await Promise.resolve(`${zonePackage}`).then(s => __importStar(require(s)));
+    // Return the render function for use
+    return render;
+}
+/**
+ * The default export will be the promise returned by the initialize function.
+ * This is awaited by piscina prior to using the Worker.
+ */
+exports.default = initialize();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-worker.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/prerender/render-worker.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 { ApplicationRef, StaticProvider, Type } from '@angular/core';\nimport type { renderApplication, renderModule, ɵSERVER_CONTEXT } from '@angular/platform-server';\nimport assert from 'node:assert';\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport { workerData } from 'node:worker_threads';\nimport { InlineCriticalCssProcessor } from '../../utils/index-file/inline-critical-css';\n\nexport interface RenderOptions {\n  indexFile: string;\n  deployUrl: string;\n  inlineCriticalCss: boolean;\n  minifyCss: boolean;\n  outputPath: string;\n  serverBundlePath: string;\n  route: string;\n}\n\nexport interface RenderResult {\n  errors?: string[];\n  warnings?: string[];\n}\n\ninterface ServerBundleExports {\n  /** An internal token that allows providing extra information about the server context. */\n  ɵSERVER_CONTEXT?: typeof ɵSERVER_CONTEXT;\n\n  /** Render an NgModule application. */\n  renderModule?: typeof renderModule;\n\n  /** NgModule to render. */\n  AppServerModule?: Type<unknown>;\n\n  /** Method to render a standalone application. */\n  renderApplication?: typeof renderApplication;\n\n  /** Standalone application bootstrapping function. */\n  default?: () => Promise<ApplicationRef>;\n}\n\n/**\n * The fully resolved path to the zone.js package that will be loaded during worker initialization.\n * This is passed as workerData when setting up the worker via the `piscina` package.\n */\nconst { zonePackage } = workerData as {\n  zonePackage: string;\n};\n\n/**\n * Renders each route in routes and writes them to <outputPath>/<route>/index.html.\n */\nasync function render({\n  indexFile,\n  deployUrl,\n  minifyCss,\n  outputPath,\n  serverBundlePath,\n  route,\n  inlineCriticalCss,\n}: RenderOptions): Promise<RenderResult> {\n  const result = {} as RenderResult;\n  const browserIndexOutputPath = path.join(outputPath, indexFile);\n  const outputFolderPath = path.join(outputPath, route);\n  const outputIndexPath = path.join(outputFolderPath, 'index.html');\n\n  const {\n    ɵSERVER_CONTEXT,\n    AppServerModule,\n    renderModule,\n    renderApplication,\n    default: bootstrapAppFn,\n  } = (await import(serverBundlePath)) as ServerBundleExports;\n\n  assert(ɵSERVER_CONTEXT, `ɵSERVER_CONTEXT was not exported from: ${serverBundlePath}.`);\n\n  const indexBaseName = fs.existsSync(path.join(outputPath, 'index.original.html'))\n    ? 'index.original.html'\n    : indexFile;\n  const browserIndexInputPath = path.join(outputPath, indexBaseName);\n  const document = await fs.promises.readFile(browserIndexInputPath, 'utf8');\n\n  const platformProviders: StaticProvider[] = [\n    {\n      provide: ɵSERVER_CONTEXT,\n      useValue: 'ssg',\n    },\n  ];\n\n  let html: string;\n\n  // Render platform server module\n  if (isBootstrapFn(bootstrapAppFn)) {\n    assert(renderApplication, `renderApplication was not exported from: ${serverBundlePath}.`);\n\n    html = await renderApplication(bootstrapAppFn, {\n      document,\n      url: route,\n      platformProviders,\n    });\n  }\n\n  assert(\n    AppServerModule,\n    `Neither an AppServerModule nor a bootstrapping function was exported from: ${serverBundlePath}.`,\n  );\n  assert(renderModule, `renderModule was not exported from: ${serverBundlePath}.`);\n\n  html = await renderModule(AppServerModule, {\n    document,\n    url: route,\n    extraProviders: platformProviders,\n  });\n\n  if (inlineCriticalCss) {\n    const inlineCriticalCssProcessor = new InlineCriticalCssProcessor({\n      deployUrl: deployUrl,\n      minify: minifyCss,\n    });\n\n    const { content, warnings, errors } = await inlineCriticalCssProcessor.process(html, {\n      outputPath,\n    });\n    result.errors = errors;\n    result.warnings = warnings;\n    html = content;\n  }\n\n  // This case happens when we are prerendering \"/\".\n  if (browserIndexOutputPath === outputIndexPath) {\n    const browserIndexOutputPathOriginal = path.join(outputPath, 'index.original.html');\n    fs.renameSync(browserIndexOutputPath, browserIndexOutputPathOriginal);\n  }\n\n  fs.mkdirSync(outputFolderPath, { recursive: true });\n  fs.writeFileSync(outputIndexPath, html);\n\n  return result;\n}\n\nfunction isBootstrapFn(value: unknown): value is () => Promise<ApplicationRef> {\n  // We can differentiate between a module and a bootstrap function by reading `cmp`:\n  return typeof value === 'function' && !('ɵmod' in value);\n}\n\n/**\n * Initializes the worker when it is first created by loading the Zone.js package\n * into the worker instance.\n *\n * @returns A promise resolving to the render function of the worker.\n */\nasync function initialize() {\n  // Setup Zone.js\n  await import(zonePackage);\n\n  // Return the render function for use\n  return render;\n}\n\n/**\n * The default export will be the promise returned by the initialize function.\n * This is awaited by piscina prior to using the Worker.\n */\nexport default initialize();\n"]}

package/src/builders/prerender/schema.d.ts

@@ -0,0 +1,22 @@
+export interface Schema {
+    /**
+     * Target to build.
+     */
+    browserTarget: string;
+    /**
+     * Whether or not the builder should extract routes and guess which paths to render.
+     */
+    guessRoutes?: boolean;
+    /**
+     * The routes to render.
+     */
+    routes?: string[];
+    /**
+     * The path to a file containing routes separated by newlines.
+     */
+    routesFile?: string;
+    /**
+     * Server target to use for prerendering the app.
+     */
+    serverTarget: string;
+}

package/src/builders/prerender/schema.js

@@ -0,0 +1,5 @@
+"use strict";
+// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE
+// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvcHJlcmVuZGVyL3NjaGVtYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQ0EsbUZBQW1GO0FBQ25GLG9GQUFvRiIsInNvdXJjZXNDb250ZW50IjpbIlxuLy8gVEhJUyBGSUxFIElTIEFVVE9NQVRJQ0FMTFkgR0VORVJBVEVELiBUTyBVUERBVEUgVEhJUyBGSUxFIFlPVSBORUVEIFRPIENIQU5HRSBUSEVcbi8vIENPUlJFU1BPTkRJTkcgSlNPTiBTQ0hFTUEgRklMRSwgVEhFTiBSVU4gZGV2a2l0LWFkbWluIGJ1aWxkIChvciBiYXplbCBidWlsZCAuLi4pLlxuXG5leHBvcnQgaW50ZXJmYWNlIFNjaGVtYSB7XG4gICAgLyoqXG4gICAgICogVGFyZ2V0IHRvIGJ1aWxkLlxuICAgICAqL1xuICAgIGJyb3dzZXJUYXJnZXQ6IHN0cmluZztcbiAgICAvKipcbiAgICAgKiBXaGV0aGVyIG9yIG5vdCB0aGUgYnVpbGRlciBzaG91bGQgZXh0cmFjdCByb3V0ZXMgYW5kIGd1ZXNzIHdoaWNoIHBhdGhzIHRvIHJlbmRlci5cbiAgICAgKi9cbiAgICBndWVzc1JvdXRlcz86IGJvb2xlYW47XG4gICAgLyoqXG4gICAgICogVGhlIHJvdXRlcyB0byByZW5kZXIuXG4gICAgICovXG4gICAgcm91dGVzPzogc3RyaW5nW107XG4gICAgLyoqXG4gICAgICogVGhlIHBhdGggdG8gYSBmaWxlIGNvbnRhaW5pbmcgcm91dGVzIHNlcGFyYXRlZCBieSBuZXdsaW5lcy5cbiAgICAgKi9cbiAgICByb3V0ZXNGaWxlPzogc3RyaW5nO1xuICAgIC8qKlxuICAgICAqIFNlcnZlciB0YXJnZXQgdG8gdXNlIGZvciBwcmVyZW5kZXJpbmcgdGhlIGFwcC5cbiAgICAgKi9cbiAgICBzZXJ2ZXJUYXJnZXQ6IHN0cmluZztcbn1cbiJdfQ==