@angular/build 18.0.0-next.3

package/src/utils/purge-cache.js

@@ -0,0 +1,40 @@
+"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.purgeStaleBuildCache = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const normalize_cache_1 = require("./normalize-cache");
+/** Delete stale cache directories used by previous versions of build-angular. */
+async function purgeStaleBuildCache(context) {
+    const projectName = context.target?.project;
+    if (!projectName) {
+        return;
+    }
+    const metadata = await context.getProjectMetadata(projectName);
+    const { basePath, path, enabled } = (0, normalize_cache_1.normalizeCacheOptions)(metadata, context.workspaceRoot);
+    if (!enabled) {
+        return;
+    }
+    let baseEntries;
+    try {
+        baseEntries = await (0, promises_1.readdir)(basePath, { withFileTypes: true });
+    }
+    catch {
+        // No purging possible if base path does not exist or cannot otherwise be accessed
+        return;
+    }
+    const entriesToDelete = baseEntries
+        .filter((d) => d.isDirectory())
+        .map((d) => (0, node_path_1.join)(basePath, d.name))
+        .filter((cachePath) => cachePath !== path)
+        .map((stalePath) => (0, promises_1.rm)(stalePath, { force: true, recursive: true, maxRetries: 3 }));
+    await Promise.allSettled(entriesToDelete);
+}
+exports.purgeStaleBuildCache = purgeStaleBuildCache;

package/src/utils/resolve-assets.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
+ */
+export declare function resolveAssets(entries: {
+    glob: string;
+    ignore?: string[];
+    input: string;
+    output: string;
+    flatten?: boolean;
+    followSymlinks?: boolean;
+}[], root: string): Promise<{
+    source: string;
+    destination: string;
+}[]>;

package/src/utils/resolve-assets.js

@@ -0,0 +1,35 @@
+"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.resolveAssets = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const node_path_1 = __importDefault(require("node:path"));
+async function resolveAssets(entries, root) {
+    const defaultIgnore = ['.gitkeep', '**/.DS_Store', '**/Thumbs.db'];
+    const outputFiles = [];
+    for (const entry of entries) {
+        const cwd = node_path_1.default.resolve(root, entry.input);
+        const files = await (0, fast_glob_1.default)(entry.glob, {
+            cwd,
+            dot: true,
+            ignore: entry.ignore ? defaultIgnore.concat(entry.ignore) : defaultIgnore,
+            followSymbolicLinks: entry.followSymlinks,
+        });
+        for (const file of files) {
+            const src = node_path_1.default.join(cwd, file);
+            const filePath = entry.flatten ? node_path_1.default.basename(file) : file;
+            outputFiles.push({ source: src, destination: node_path_1.default.join(entry.output, filePath) });
+        }
+    }
+    return outputFiles;
+}
+exports.resolveAssets = resolveAssets;

package/src/utils/routes-extractor/extractor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 { ApplicationRef, Type } from '@angular/core';
+interface RouterResult {
+    route: string;
+    success: boolean;
+    redirect: boolean;
+}
+export declare function extractRoutes(bootstrapAppFnOrModule: (() => Promise<ApplicationRef>) | Type<unknown>, document: string): AsyncIterableIterator<RouterResult>;
+export {};

package/src/utils/routes-extractor/extractor.js

@@ -0,0 +1,97 @@
+/**
+ * @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 { ApplicationRef, Compiler, createPlatformFactory, platformCore, ɵwhenStable as whenStable, ɵConsole, } from '@angular/core';
+import { INITIAL_CONFIG, ɵINTERNAL_SERVER_PLATFORM_PROVIDERS as INTERNAL_SERVER_PLATFORM_PROVIDERS, } from '@angular/platform-server';
+import { Router, ɵloadChildren as loadChildrenHelper } from '@angular/router';
+async function* getRoutesFromRouterConfig(routes, compiler, parentInjector, parentRoute = '') {
+    for (const route of routes) {
+        const { path, redirectTo, loadChildren, children } = route;
+        if (path === undefined) {
+            continue;
+        }
+        const currentRoutePath = buildRoutePath(parentRoute, path);
+        if (redirectTo !== undefined) {
+            // TODO: handle `redirectTo`.
+            yield { route: currentRoutePath, success: false, redirect: true };
+            continue;
+        }
+        if (/[:*]/.test(path)) {
+            // TODO: handle parameterized routes population.
+            yield { route: currentRoutePath, success: false, redirect: false };
+            continue;
+        }
+        yield { route: currentRoutePath, success: true, redirect: false };
+        if (children?.length) {
+            yield* getRoutesFromRouterConfig(children, compiler, parentInjector, currentRoutePath);
+        }
+        if (loadChildren) {
+            const loadedChildRoutes = await loadChildrenHelper(route, compiler, parentInjector).toPromise();
+            if (loadedChildRoutes) {
+                const { routes: childRoutes, injector = parentInjector } = loadedChildRoutes;
+                yield* getRoutesFromRouterConfig(childRoutes, compiler, injector, currentRoutePath);
+            }
+        }
+    }
+}
+export async function* extractRoutes(bootstrapAppFnOrModule, document) {
+    const platformRef = createPlatformFactory(platformCore, 'server', [
+        {
+            provide: INITIAL_CONFIG,
+            useValue: { document, url: '' },
+        },
+        {
+            provide: ɵConsole,
+            /** An Angular Console Provider that does not print a set of predefined logs. */
+            useFactory: () => {
+                class Console extends ɵConsole {
+                    ignoredLogs = new Set(['Angular is running in development mode.']);
+                    log(message) {
+                        if (!this.ignoredLogs.has(message)) {
+                            super.log(message);
+                        }
+                    }
+                }
+                return new Console();
+            },
+        },
+        ...INTERNAL_SERVER_PLATFORM_PROVIDERS,
+    ])();
+    try {
+        let applicationRef;
+        if (isBootstrapFn(bootstrapAppFnOrModule)) {
+            applicationRef = await bootstrapAppFnOrModule();
+        }
+        else {
+            const moduleRef = await platformRef.bootstrapModule(bootstrapAppFnOrModule);
+            applicationRef = moduleRef.injector.get(ApplicationRef);
+        }
+        // Wait until the application is stable.
+        await whenStable(applicationRef);
+        const injector = applicationRef.injector;
+        const router = injector.get(Router);
+        if (router.config.length === 0) {
+            // In case there are no routes available
+            yield { route: '', success: true, redirect: false };
+        }
+        else {
+            const compiler = injector.get(Compiler);
+            // Extract all the routes from the config.
+            yield* getRoutesFromRouterConfig(router.config, compiler, injector);
+        }
+    }
+    finally {
+        platformRef.destroy();
+    }
+}
+function isBootstrapFn(value) {
+    // We can differentiate between a module and a bootstrap function by reading compiler-generated `ɵmod` static property:
+    return typeof value === 'function' && !('ɵmod' in value);
+}
+function buildRoutePath(...routeParts) {
+    return routeParts.filter(Boolean).join('/');
+}

package/src/utils/server-rendering/esm-in-memory-loader/loader-hooks.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
+ */
+export interface ESMInMemoryFileLoaderWorkerData {
+    outputFiles: Record<string, string>;
+    workspaceRoot: string;
+}
+export declare function initialize(data: ESMInMemoryFileLoaderWorkerData): void;
+export declare function resolve(specifier: string, context: {
+    parentURL: undefined | string;
+}, nextResolve: Function): any;
+export declare function load(url: string, context: {
+    format?: string | null;
+}, nextLoad: Function): Promise<any>;

package/src/utils/server-rendering/esm-in-memory-loader/loader-hooks.js

@@ -0,0 +1,129 @@
+"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.load = exports.resolve = exports.initialize = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const url_1 = require("url");
+const javascript_transformer_1 = require("../../../tools/esbuild/javascript-transformer");
+/**
+ * Node.js ESM loader to redirect imports to in memory files.
+ * @see: https://nodejs.org/api/esm.html#loaders for more information about loaders.
+ */
+const MEMORY_URL_SCHEME = 'memory://';
+let memoryVirtualRootUrl;
+let outputFiles;
+const javascriptTransformer = new javascript_transformer_1.JavaScriptTransformer(
+// Always enable JIT linking to support applications built with and without AOT.
+// In a development environment the additional scope information does not
+// have a negative effect unlike production where final output size is relevant.
+{ sourcemap: true, jit: true }, 1);
+function initialize(data) {
+    // This path does not actually exist but is used to overlay the in memory files with the
+    // actual filesystem for resolution purposes.
+    // A custom URL schema (such as `memory://`) cannot be used for the resolve output because
+    // the in-memory files may use `import.meta.url` in ways that assume a file URL.
+    // `createRequire` is one example of this usage.
+    memoryVirtualRootUrl = (0, node_url_1.pathToFileURL)((0, node_path_1.join)(data.workspaceRoot, `.angular/prerender-root/${(0, node_crypto_1.randomUUID)()}/`)).href;
+    outputFiles = data.outputFiles;
+}
+exports.initialize = initialize;
+function resolve(specifier, context, nextResolve) {
+    // In-memory files loaded from external code will contain a memory scheme
+    if (specifier.startsWith(MEMORY_URL_SCHEME)) {
+        let memoryUrl;
+        try {
+            memoryUrl = new URL(specifier);
+        }
+        catch {
+            node_assert_1.default.fail('External code attempted to use malformed memory scheme: ' + specifier);
+        }
+        // Resolve with a URL based from the virtual filesystem root
+        return {
+            format: 'module',
+            shortCircuit: true,
+            url: new URL(memoryUrl.pathname.slice(1), memoryVirtualRootUrl).href,
+        };
+    }
+    // Use next/default resolve if the parent is not from the virtual root
+    if (!context.parentURL?.startsWith(memoryVirtualRootUrl)) {
+        return nextResolve(specifier, context);
+    }
+    // Check for `./` and `../` relative specifiers
+    const isRelative = specifier[0] === '.' &&
+        (specifier[1] === '/' || (specifier[1] === '.' && specifier[2] === '/'));
+    // Relative specifiers from memory file should be based from the parent memory location
+    if (isRelative) {
+        let specifierUrl;
+        try {
+            specifierUrl = new URL(specifier, context.parentURL);
+        }
+        catch { }
+        if (specifierUrl?.pathname &&
+            Object.hasOwn(outputFiles, specifierUrl.href.slice(memoryVirtualRootUrl.length))) {
+            return {
+                format: 'module',
+                shortCircuit: true,
+                url: specifierUrl.href,
+            };
+        }
+        node_assert_1.default.fail(`In-memory ESM relative file should always exist: '${context.parentURL}' --> '${specifier}'`);
+    }
+    // Update the parent URL to allow for module resolution for the workspace.
+    // This handles bare specifiers (npm packages) and absolute paths.
+    // Defer to the next hook in the chain, which would be the
+    // Node.js default resolve if this is the last user-specified loader.
+    return nextResolve(specifier, {
+        ...context,
+        parentURL: new URL('index.js', memoryVirtualRootUrl).href,
+    });
+}
+exports.resolve = resolve;
+async function load(url, context, nextLoad) {
+    const { format } = context;
+    // Load the file from memory if the URL is based in the virtual root
+    if (url.startsWith(memoryVirtualRootUrl)) {
+        const source = outputFiles[url.slice(memoryVirtualRootUrl.length)];
+        (0, node_assert_1.default)(source !== undefined, 'Resolved in-memory ESM file should always exist: ' + url);
+        // In-memory files have already been transformer during bundling and can be returned directly
+        return {
+            format,
+            shortCircuit: true,
+            source,
+        };
+    }
+    // Only module files potentially require transformation. Angular libraries that would
+    // need linking are ESM only.
+    if (format === 'module' && isFileProtocol(url)) {
+        const filePath = (0, url_1.fileURLToPath)(url);
+        const source = await javascriptTransformer.transformFile(filePath);
+        return {
+            format,
+            shortCircuit: true,
+            source,
+        };
+    }
+    // Let Node.js handle all other URLs.
+    return nextLoad(url);
+}
+exports.load = load;
+function isFileProtocol(url) {
+    return url.startsWith('file://');
+}
+function handleProcessExit() {
+    void javascriptTransformer.close();
+}
+process.once('exit', handleProcessExit);
+process.once('SIGINT', handleProcessExit);
+process.once('uncaughtException', handleProcessExit);

package/src/utils/server-rendering/esm-in-memory-loader/register-hooks.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export {};

package/src/utils/server-rendering/esm-in-memory-loader/register-hooks.js

@@ -0,0 +1,13 @@
+"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_module_1 = require("node:module");
+const node_url_1 = require("node:url");
+const node_worker_threads_1 = require("node:worker_threads");
+(0, node_module_1.register)('./loader-hooks.js', { parentURL: (0, node_url_1.pathToFileURL)(__filename), data: node_worker_threads_1.workerData });

package/src/utils/server-rendering/fetch-patch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare function patchFetchToLoadInMemoryAssets(): void;

package/src/utils/server-rendering/fetch-patch.js

@@ -0,0 +1,66 @@
+"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.patchFetchToLoadInMemoryAssets = void 0;
+const mrmime_1 = require("mrmime");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_worker_threads_1 = require("node:worker_threads");
+const undici_1 = require("undici");
+/**
+ * This is passed as workerData when setting up the worker via the `piscina` package.
+ */
+const { assetFiles } = node_worker_threads_1.workerData;
+const assetsCache = new Map();
+const RESOLVE_PROTOCOL = 'resolve:';
+function patchFetchToLoadInMemoryAssets() {
+    const global = globalThis;
+    const originalFetch = global.fetch;
+    const patchedFetch = async (input, init) => {
+        let url;
+        if (input instanceof URL) {
+            url = input;
+        }
+        else if (typeof input === 'string') {
+            url = new URL(input, RESOLVE_PROTOCOL + '//');
+        }
+        else if (typeof input === 'object' && 'url' in input) {
+            url = new URL(input.url, RESOLVE_PROTOCOL + '//');
+        }
+        else {
+            return originalFetch(input, init);
+        }
+        const { pathname, protocol } = url;
+        if (protocol !== RESOLVE_PROTOCOL || !assetFiles[pathname]) {
+            // Only handle relative requests or files that are in assets.
+            return originalFetch(input, init);
+        }
+        const cachedAsset = assetsCache.get(pathname);
+        if (cachedAsset) {
+            const { content, headers } = cachedAsset;
+            return new undici_1.Response(content, {
+                headers,
+            });
+        }
+        const extension = (0, node_path_1.extname)(pathname);
+        const mimeType = (0, mrmime_1.lookup)(extension);
+        const content = await (0, promises_1.readFile)(assetFiles[pathname]);
+        const headers = mimeType
+            ? {
+                'Content-Type': mimeType,
+            }
+            : undefined;
+        assetsCache.set(pathname, { headers, content });
+        return new undici_1.Response(content, {
+            headers,
+        });
+    };
+    global.fetch = patchedFetch;
+}
+exports.patchFetchToLoadInMemoryAssets = patchFetchToLoadInMemoryAssets;

package/src/utils/server-rendering/load-esm-from-memory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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 { MainServerBundleExports, RenderUtilsServerBundleExports } from './main-bundle-exports';
+export declare function loadEsmModuleFromMemory(path: './main.server.mjs'): Promise<MainServerBundleExports>;
+export declare function loadEsmModuleFromMemory(path: './render-utils.server.mjs'): Promise<RenderUtilsServerBundleExports>;

package/src/utils/server-rendering/load-esm-from-memory.js

@@ -0,0 +1,26 @@
+"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.loadEsmModuleFromMemory = void 0;
+const error_1 = require("../error");
+const load_esm_1 = require("../load-esm");
+function loadEsmModuleFromMemory(path) {
+    return (0, load_esm_1.loadEsmModule)(new URL(path, 'memory://')).catch((e) => {
+        (0, error_1.assertIsError)(e);
+        // While the error is an 'instanceof Error', it is extended with non transferable properties
+        // and cannot be transferred from a worker when using `--import`. This results in the error object
+        // displaying as '[Object object]' when read outside of the worker. Therefore, we reconstruct the error message here.
+        const error = new Error(e.message);
+        error.stack = e.stack;
+        error.name = e.name;
+        error.code = e.code;
+        throw error;
+    });
+}
+exports.loadEsmModuleFromMemory = loadEsmModuleFromMemory;

package/src/utils/server-rendering/main-bundle-exports.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import type { ApplicationRef, Type, ɵConsole } from '@angular/core';
+import type { renderApplication, renderModule, ɵSERVER_CONTEXT } from '@angular/platform-server';
+import type { extractRoutes } from '../routes-extractor/extractor';
+export interface MainServerBundleExports {
+    /** Standalone application bootstrapping function. */
+    default: (() => Promise<ApplicationRef>) | Type<unknown>;
+}
+export interface RenderUtilsServerBundleExports {
+    /** 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;
+    /** Method to extract routes from the router config. */
+    extractRoutes: typeof extractRoutes;
+    ɵresetCompiledComponents?: () => void;
+    /** Angular Console token/class. */
+    ɵConsole: typeof ɵConsole;
+}

package/src/utils/server-rendering/main-bundle-exports.js

@@ -0,0 +1,9 @@
+"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 });

package/src/utils/server-rendering/prerender.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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 { BuildOutputFile } from '../../tools/esbuild/bundler-context';
+import { BuildOutputAsset } from '../../tools/esbuild/bundler-execution-result';
+interface PrerenderOptions {
+    routesFile?: string;
+    discoverRoutes?: boolean;
+}
+interface AppShellOptions {
+    route?: string;
+}
+export declare function prerenderPages(workspaceRoot: string, appShellOptions: AppShellOptions | undefined, prerenderOptions: PrerenderOptions | undefined, outputFiles: Readonly<BuildOutputFile[]>, assets: Readonly<BuildOutputAsset[]>, document: string, sourcemap?: boolean, inlineCriticalCss?: boolean, maxThreads?: number, verbose?: boolean): Promise<{
+    output: Record<string, string>;
+    warnings: string[];
+    errors: string[];
+    prerenderedRoutes: Set<string>;
+}>;
+export {};