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

package/src/utils/server-rendering/prerender.js

@@ -0,0 +1,127 @@
+"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.prerenderPages = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const piscina_1 = __importDefault(require("piscina"));
+async function prerenderPages(tsConfigPath, appShellOptions = {}, prerenderOptions = {}, outputFiles, document, inlineCriticalCss, maxThreads = 1) {
+    const allRoutes = await getAllRoutes(tsConfigPath, appShellOptions, prerenderOptions);
+    const outputFilesForWorker = {};
+    for (const { text, path } of outputFiles) {
+        switch ((0, node_path_1.extname)(path)) {
+            case '.mjs': // Contains the server runnable application code.
+            case '.css': // Global styles for critical CSS inlining.
+                outputFilesForWorker[path] = text;
+                break;
+        }
+    }
+    const renderWorker = new piscina_1.default({
+        filename: require.resolve('./render-worker'),
+        maxThreads: Math.min(allRoutes.size, maxThreads),
+        workerData: {
+            outputFiles: outputFilesForWorker,
+            inlineCriticalCss,
+            document,
+        },
+        execArgv: [
+            '--no-warnings',
+            '--loader',
+            require.resolve('./esm-in-memory-file-loader.js'),
+        ],
+    });
+    const output = {};
+    const warnings = [];
+    const errors = [];
+    try {
+        const renderingPromises = [];
+        for (const route of allRoutes) {
+            const isAppShellRoute = appShellOptions.route === route;
+            const serverContext = isAppShellRoute ? 'app-shell' : 'ssg';
+            const render = renderWorker.run({ route, serverContext });
+            const renderResult = render.then(({ content, warnings, errors }) => {
+                if (content !== undefined) {
+                    const outPath = isAppShellRoute ? 'index.html' : node_path_1.posix.join(route, 'index.html');
+                    output[outPath] = content;
+                }
+                if (warnings) {
+                    warnings.push(...warnings);
+                }
+                if (errors) {
+                    errors.push(...errors);
+                }
+            });
+            renderingPromises.push(renderResult);
+        }
+        await Promise.all(renderingPromises);
+    }
+    finally {
+        void renderWorker.destroy();
+    }
+    return {
+        errors,
+        warnings,
+        output,
+    };
+}
+exports.prerenderPages = prerenderPages;
+async function getAllRoutes(tsConfigPath, appShellOptions, prerenderOptions) {
+    const { routesFile, discoverRoutes, routes: existingRoutes } = prerenderOptions;
+    const routes = new Set(existingRoutes);
+    const { route: appShellRoute } = appShellOptions;
+    if (appShellRoute !== undefined) {
+        routes.add(appShellRoute);
+    }
+    if (routesFile) {
+        const routesFromFile = (await (0, promises_1.readFile)(routesFile, 'utf8')).split(/\r?\n/);
+        for (let route of routesFromFile) {
+            route = route.trim();
+            if (route) {
+                routes.add(route);
+            }
+        }
+    }
+    if (discoverRoutes) {
+        const { parseAngularRoutes } = await Promise.resolve().then(() => __importStar(require('guess-parser')));
+        for (const { path } of parseAngularRoutes(tsConfigPath)) {
+            // Exclude dynamic routes as these cannot be pre-rendered.
+            if (!/[*:]/.test(path)) {
+                routes.add(path);
+            }
+        }
+    }
+    return routes;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prerender.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/utils/server-rendering/prerender.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 { OutputFile } from 'esbuild';\nimport { readFile } from 'node:fs/promises';\nimport { extname, posix } from 'node:path';\nimport Piscina from 'piscina';\nimport type { RenderResult, ServerContext } from './render-page';\nimport type { WorkerData } from './render-worker';\n\ninterface PrerenderOptions {\n  routesFile?: string;\n  discoverRoutes?: boolean;\n  routes?: string[];\n}\n\ninterface AppShellOptions {\n  route?: string;\n}\n\nexport async function prerenderPages(\n  tsConfigPath: string,\n  appShellOptions: AppShellOptions = {},\n  prerenderOptions: PrerenderOptions = {},\n  outputFiles: Readonly<OutputFile[]>,\n  document: string,\n  inlineCriticalCss?: boolean,\n  maxThreads = 1,\n): Promise<{\n  output: Record<string, string>;\n  warnings: string[];\n  errors: string[];\n}> {\n  const allRoutes = await getAllRoutes(tsConfigPath, appShellOptions, prerenderOptions);\n  const outputFilesForWorker: Record<string, string> = {};\n\n  for (const { text, path } of outputFiles) {\n    switch (extname(path)) {\n      case '.mjs': // Contains the server runnable application code.\n      case '.css': // Global styles for critical CSS inlining.\n        outputFilesForWorker[path] = text;\n        break;\n    }\n  }\n\n  const renderWorker = new Piscina({\n    filename: require.resolve('./render-worker'),\n    maxThreads: Math.min(allRoutes.size, maxThreads),\n    workerData: {\n      outputFiles: outputFilesForWorker,\n      inlineCriticalCss,\n      document,\n    } as WorkerData,\n    execArgv: [\n      '--no-warnings', // Suppress `ExperimentalWarning: Custom ESM Loaders is an experimental feature...`.\n      '--loader',\n      require.resolve('./esm-in-memory-file-loader.js'),\n    ],\n  });\n\n  const output: Record<string, string> = {};\n  const warnings: string[] = [];\n  const errors: string[] = [];\n\n  try {\n    const renderingPromises: Promise<void>[] = [];\n\n    for (const route of allRoutes) {\n      const isAppShellRoute = appShellOptions.route === route;\n      const serverContext: ServerContext = isAppShellRoute ? 'app-shell' : 'ssg';\n\n      const render: Promise<RenderResult> = renderWorker.run({ route, serverContext });\n      const renderResult: Promise<void> = render.then(({ content, warnings, errors }) => {\n        if (content !== undefined) {\n          const outPath = isAppShellRoute ? 'index.html' : posix.join(route, 'index.html');\n          output[outPath] = content;\n        }\n\n        if (warnings) {\n          warnings.push(...warnings);\n        }\n\n        if (errors) {\n          errors.push(...errors);\n        }\n      });\n\n      renderingPromises.push(renderResult);\n    }\n\n    await Promise.all(renderingPromises);\n  } finally {\n    void renderWorker.destroy();\n  }\n\n  return {\n    errors,\n    warnings,\n    output,\n  };\n}\n\nasync function getAllRoutes(\n  tsConfigPath: string,\n  appShellOptions: AppShellOptions,\n  prerenderOptions: PrerenderOptions,\n): Promise<Set<string>> {\n  const { routesFile, discoverRoutes, routes: existingRoutes } = prerenderOptions;\n  const routes = new Set(existingRoutes);\n\n  const { route: appShellRoute } = appShellOptions;\n  if (appShellRoute !== undefined) {\n    routes.add(appShellRoute);\n  }\n\n  if (routesFile) {\n    const routesFromFile = (await readFile(routesFile, 'utf8')).split(/\\r?\\n/);\n    for (let route of routesFromFile) {\n      route = route.trim();\n      if (route) {\n        routes.add(route);\n      }\n    }\n  }\n\n  if (discoverRoutes) {\n    const { parseAngularRoutes } = await import('guess-parser');\n    for (const { path } of parseAngularRoutes(tsConfigPath)) {\n      // Exclude dynamic routes as these cannot be pre-rendered.\n      if (!/[*:]/.test(path)) {\n        routes.add(path);\n      }\n    }\n  }\n\n  return routes;\n}\n"]}

package/src/utils/server-rendering/render-page.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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 { ApplicationRef, Type } from '@angular/core';
+import type { renderApplication, renderModule, ɵSERVER_CONTEXT } from '@angular/platform-server';
+export interface RenderOptions {
+    route: string;
+    serverContext: ServerContext;
+    outputFiles: Record<string, string>;
+    document: string;
+    inlineCriticalCss?: boolean;
+    loadBundle?: (path: string) => Promise<MainServerBundleExports>;
+}
+export interface RenderResult {
+    errors?: string[];
+    warnings?: string[];
+    content?: string;
+}
+export type ServerContext = 'app-shell' | 'ssg' | 'ssr';
+interface MainServerBundleExports {
+    /** An internal token that allows providing extra information about the server context. */
+    ɵSERVER_CONTEXT: typeof ɵSERVER_CONTEXT;
+    /** Render an NgModule application. */
+    renderModule: typeof renderModule;
+    /** Method to render a standalone application. */
+    renderApplication: typeof renderApplication;
+    /** Standalone application bootstrapping function. */
+    default: (() => Promise<ApplicationRef>) | Type<unknown>;
+}
+/**
+ * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
+ */
+export declare function renderPage({ route, serverContext, document, inlineCriticalCss, outputFiles, loadBundle, }: RenderOptions): Promise<RenderResult>;
+export {};

package/src/utils/server-rendering/render-page.js

@@ -0,0 +1,63 @@
+"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.renderPage = void 0;
+const node_path_1 = require("node:path");
+const inline_critical_css_1 = require("../index-file/inline-critical-css");
+const load_esm_1 = require("../load-esm");
+/**
+ * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
+ */
+async function renderPage({ route, serverContext, document, inlineCriticalCss, outputFiles, loadBundle = load_esm_1.loadEsmModule, }) {
+    const { default: bootstrapAppFnOrModule, ɵSERVER_CONTEXT, renderModule, renderApplication, } = await loadBundle('./main.server.mjs');
+    const platformProviders = [
+        {
+            provide: ɵSERVER_CONTEXT,
+            useValue: serverContext,
+        },
+    ];
+    let html;
+    if (isBootstrapFn(bootstrapAppFnOrModule)) {
+        html = await renderApplication(bootstrapAppFnOrModule, {
+            document,
+            url: route,
+            platformProviders,
+        });
+    }
+    else {
+        html = await renderModule(bootstrapAppFnOrModule, {
+            document,
+            url: route,
+            extraProviders: platformProviders,
+        });
+    }
+    if (inlineCriticalCss) {
+        const inlineCriticalCssProcessor = new inline_critical_css_1.InlineCriticalCssProcessor({
+            minify: false,
+            readAsset: async (filePath) => {
+                filePath = (0, node_path_1.basename)(filePath);
+                const content = outputFiles[filePath];
+                if (content === undefined) {
+                    throw new Error(`Output file does not exist: ${filePath}`);
+                }
+                return content;
+            },
+        });
+        return inlineCriticalCssProcessor.process(html, { outputPath: '' });
+    }
+    return {
+        content: html,
+    };
+}
+exports.renderPage = renderPage;
+function isBootstrapFn(value) {
+    // We can differentiate between a module and a bootstrap function by reading `cmp`:
+    return typeof value === 'function' && !('ɵmod' in value);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/utils/server-rendering/render-worker.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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 { RenderResult, ServerContext } from './render-page';
+export interface WorkerData {
+    outputFiles: Record<string, string>;
+    document: string;
+    inlineCriticalCss?: boolean;
+}
+export interface RenderOptions {
+    route: string;
+    serverContext: ServerContext;
+}
+export default function (options: RenderOptions): Promise<RenderResult>;

package/src/utils/server-rendering/render-worker.js

@@ -0,0 +1,20 @@
+"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 });
+const node_worker_threads_1 = require("node:worker_threads");
+const render_page_1 = require("./render-page");
+/**
+ * This is passed as workerData when setting up the worker via the `piscina` package.
+ */
+const { outputFiles, document, inlineCriticalCss } = node_worker_threads_1.workerData;
+function default_1(options) {
+    return (0, render_page_1.renderPage)({ ...options, outputFiles, document, inlineCriticalCss });
+}
+exports.default = default_1;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVuZGVyLXdvcmtlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2J1aWxkX2FuZ3VsYXIvc3JjL3V0aWxzL3NlcnZlci1yZW5kZXJpbmcvcmVuZGVyLXdvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOztBQUVILDZEQUFpRDtBQUNqRCwrQ0FBd0U7QUFheEU7O0dBRUc7QUFDSCxNQUFNLEVBQUUsV0FBVyxFQUFFLFFBQVEsRUFBRSxpQkFBaUIsRUFBRSxHQUFHLGdDQUF3QixDQUFDO0FBRTlFLG1CQUF5QixPQUFzQjtJQUM3QyxPQUFPLElBQUEsd0JBQVUsRUFBQyxFQUFFLEdBQUcsT0FBTyxFQUFFLFdBQVcsRUFBRSxRQUFRLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyxDQUFDO0FBQzlFLENBQUM7QUFGRCw0QkFFQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgeyB3b3JrZXJEYXRhIH0gZnJvbSAnbm9kZTp3b3JrZXJfdGhyZWFkcyc7XG5pbXBvcnQgeyBSZW5kZXJSZXN1bHQsIFNlcnZlckNvbnRleHQsIHJlbmRlclBhZ2UgfSBmcm9tICcuL3JlbmRlci1wYWdlJztcblxuZXhwb3J0IGludGVyZmFjZSBXb3JrZXJEYXRhIHtcbiAgb3V0cHV0RmlsZXM6IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG4gIGRvY3VtZW50OiBzdHJpbmc7XG4gIGlubGluZUNyaXRpY2FsQ3NzPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZW5kZXJPcHRpb25zIHtcbiAgcm91dGU6IHN0cmluZztcbiAgc2VydmVyQ29udGV4dDogU2VydmVyQ29udGV4dDtcbn1cblxuLyoqXG4gKiBUaGlzIGlzIHBhc3NlZCBhcyB3b3JrZXJEYXRhIHdoZW4gc2V0dGluZyB1cCB0aGUgd29ya2VyIHZpYSB0aGUgYHBpc2NpbmFgIHBhY2thZ2UuXG4gKi9cbmNvbnN0IHsgb3V0cHV0RmlsZXMsIGRvY3VtZW50LCBpbmxpbmVDcml0aWNhbENzcyB9ID0gd29ya2VyRGF0YSBhcyBXb3JrZXJEYXRhO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiAob3B0aW9uczogUmVuZGVyT3B0aW9ucyk6IFByb21pc2U8UmVuZGVyUmVzdWx0PiB7XG4gIHJldHVybiByZW5kZXJQYWdlKHsgLi4ub3B0aW9ucywgb3V0cHV0RmlsZXMsIGRvY3VtZW50LCBpbmxpbmVDcml0aWNhbENzcyB9KTtcbn1cbiJdfQ==