@angular/build 19.0.5 → 19.1.0-next.1

package/src/tools/angular/compilation/factory.js

@@ -22,13 +22,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAngularCompilation = createAngularCompilation;
 const environment_options_1 = require("../../../utils/environment-options");
@@ -37,19 +47,20 @@ const environment_options_1 = require("../../../utils/environment-options");
  * compilation either for AOT or JIT mode. By default a parallel compilation is created
  * that uses a Node.js worker thread.
  * @param jit True, for Angular JIT compilation; False, for Angular AOT compilation.
+ * @param browserOnlyBuild True, for browser only builds; False, for browser and server builds.
  * @returns An instance of an Angular compilation object.
  */
-async function createAngularCompilation(jit) {
+async function createAngularCompilation(jit, browserOnlyBuild) {
     if (environment_options_1.useParallelTs) {
         const { ParallelCompilation } = await Promise.resolve().then(() => __importStar(require('./parallel-compilation')));
-        return new ParallelCompilation(jit);
+        return new ParallelCompilation(jit, browserOnlyBuild);
     }
     if (jit) {
         const { JitCompilation } = await Promise.resolve().then(() => __importStar(require('./jit-compilation')));
-        return new JitCompilation();
+        return new JitCompilation(browserOnlyBuild);
     }
     else {
         const { AotCompilation } = await Promise.resolve().then(() => __importStar(require('./aot-compilation')));
-        return new AotCompilation();
+        return new AotCompilation(browserOnlyBuild);
     }
 }

package/src/tools/angular/compilation/hmr-candidates.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @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.dev/license
+ */
+import type ng from '@angular/compiler-cli';
+import ts from 'typescript';
+/**
+ * Analyzes one or more modified files for changes to determine if any
+ * class declarations for Angular components are candidates for hot
+ * module replacement (HMR). If any source files are also modified but
+ * are not candidates then all candidates become invalid. This invalidation
+ * ensures that a full rebuild occurs and the running application stays
+ * synchronized with the code.
+ * @param modifiedFiles A set of modified files to analyze.
+ * @param param1 An Angular compiler instance
+ * @param staleSourceFiles A map of paths to previous source file instances.
+ * @returns A set of HMR candidate component class declarations.
+ */
+export declare function collectHmrCandidates(modifiedFiles: Set<string>, { compiler }: ng.NgtscProgram, staleSourceFiles: Map<string, ts.SourceFile> | undefined): Set<ts.ClassDeclaration>;

package/src/tools/angular/compilation/hmr-candidates.js

@@ -0,0 +1,238 @@
+"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.dev/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectHmrCandidates = collectHmrCandidates;
+const node_assert_1 = __importDefault(require("node:assert"));
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Analyzes one or more modified files for changes to determine if any
+ * class declarations for Angular components are candidates for hot
+ * module replacement (HMR). If any source files are also modified but
+ * are not candidates then all candidates become invalid. This invalidation
+ * ensures that a full rebuild occurs and the running application stays
+ * synchronized with the code.
+ * @param modifiedFiles A set of modified files to analyze.
+ * @param param1 An Angular compiler instance
+ * @param staleSourceFiles A map of paths to previous source file instances.
+ * @returns A set of HMR candidate component class declarations.
+ */
+function collectHmrCandidates(modifiedFiles, { compiler }, staleSourceFiles) {
+    const candidates = new Set();
+    for (const file of modifiedFiles) {
+        // If the file is a template for component(s), add component classes as candidates
+        const templateFileNodes = compiler.getComponentsWithTemplateFile(file);
+        if (templateFileNodes.size) {
+            templateFileNodes.forEach((node) => candidates.add(node));
+            continue;
+        }
+        // If the file is a style for component(s), add component classes as candidates
+        const styleFileNodes = compiler.getComponentsWithStyleFile(file);
+        if (styleFileNodes.size) {
+            styleFileNodes.forEach((node) => candidates.add(node));
+            continue;
+        }
+        const staleSource = staleSourceFiles?.get(file);
+        if (staleSource === undefined) {
+            // Unknown file requires a rebuild so clear out the candidates and stop collecting
+            candidates.clear();
+            break;
+        }
+        const updatedSource = compiler.getCurrentProgram().getSourceFile(file);
+        if (updatedSource === undefined) {
+            // No longer existing program file requires a rebuild so clear out the candidates and stop collecting
+            candidates.clear();
+            break;
+        }
+        // Analyze the stale and updated file for changes
+        const fileCandidates = analyzeFileUpdates(staleSource, updatedSource, compiler);
+        if (fileCandidates) {
+            fileCandidates.forEach((node) => candidates.add(node));
+        }
+        else {
+            // Unsupported HMR changes present
+            // Only template and style literal changes are allowed.
+            candidates.clear();
+            break;
+        }
+    }
+    return candidates;
+}
+/**
+ * Analyzes the updates of a source file for potential HMR component class candidates.
+ * A source file can contain candidates if only the Angular component metadata of a class
+ * has been changed and the metadata changes are only of supported fields.
+ * @param stale The stale (previous) source file instance.
+ * @param updated The updated source file instance.
+ * @param compiler An Angular compiler instance.
+ * @returns An array of candidate class declarations; or `null` if unsupported changes are present.
+ */
+function analyzeFileUpdates(stale, updated, compiler) {
+    if (stale.statements.length !== updated.statements.length) {
+        return null;
+    }
+    const candidates = [];
+    for (let i = 0; i < updated.statements.length; ++i) {
+        const updatedNode = updated.statements[i];
+        const staleNode = stale.statements[i];
+        if (typescript_1.default.isClassDeclaration(updatedNode)) {
+            if (!typescript_1.default.isClassDeclaration(staleNode)) {
+                return null;
+            }
+            // Check class declaration differences (name/heritage/modifiers)
+            if (updatedNode.name?.text !== staleNode.name?.text) {
+                return null;
+            }
+            if (!equalRangeText(updatedNode.heritageClauses, updated, staleNode.heritageClauses, stale)) {
+                return null;
+            }
+            const updatedModifiers = typescript_1.default.getModifiers(updatedNode);
+            const staleModifiers = typescript_1.default.getModifiers(staleNode);
+            if (updatedModifiers?.length !== staleModifiers?.length ||
+                !updatedModifiers?.every((updatedModifier) => staleModifiers?.some((staleModifier) => updatedModifier.kind === staleModifier.kind))) {
+                return null;
+            }
+            // Check for component class nodes
+            const meta = compiler.getMeta(updatedNode);
+            if (meta?.decorator && meta.isComponent === true) {
+                const updatedDecorators = typescript_1.default.getDecorators(updatedNode);
+                const staleDecorators = typescript_1.default.getDecorators(staleNode);
+                if (!staleDecorators || staleDecorators.length !== updatedDecorators?.length) {
+                    return null;
+                }
+                // TODO: Check other decorators instead of assuming all multi-decorator components are unsupported
+                if (staleDecorators.length > 1) {
+                    return null;
+                }
+                // Find index of component metadata decorator
+                const metaDecoratorIndex = updatedDecorators?.indexOf(meta.decorator);
+                (0, node_assert_1.default)(metaDecoratorIndex !== undefined, 'Component metadata decorator should always be present on component class.');
+                const updatedDecoratorExpression = meta.decorator.expression;
+                (0, node_assert_1.default)(typescript_1.default.isCallExpression(updatedDecoratorExpression) &&
+                    updatedDecoratorExpression.arguments.length === 1, 'Component metadata decorator should contain a call expression with a single argument.');
+                // Check the matching stale index for the component decorator
+                const staleDecoratorExpression = staleDecorators[metaDecoratorIndex]?.expression;
+                if (!staleDecoratorExpression ||
+                    !typescript_1.default.isCallExpression(staleDecoratorExpression) ||
+                    staleDecoratorExpression.arguments.length !== 1) {
+                    return null;
+                }
+                // Check decorator name/expression
+                // NOTE: This would typically be `Component` but can also be a property expression or some other alias.
+                // To avoid complex checks, this ensures the textual representation does not change. This has a low chance
+                // of a false positive if the expression is changed to still reference the `Component` type but has different
+                // text. However, it is rare for `Component` to not be used directly and additionally unlikely that it would
+                // be changed between edits. A false positive would also only lead to a difference of a full page reload versus
+                // an HMR update.
+                if (!equalRangeText(updatedDecoratorExpression.expression, updated, staleDecoratorExpression.expression, stale)) {
+                    return null;
+                }
+                // Compare component meta decorator object literals
+                if (hasUnsupportedMetaUpdates(staleDecoratorExpression, stale, updatedDecoratorExpression, updated)) {
+                    return null;
+                }
+                // Compare text of the member nodes to determine if any changes have occurred
+                if (!equalRangeText(updatedNode.members, updated, staleNode.members, stale)) {
+                    // A change to a member outside a component's metadata is unsupported
+                    return null;
+                }
+                // If all previous class checks passed, this class is supported for HMR updates
+                candidates.push(updatedNode);
+                continue;
+            }
+        }
+        // Compare text of the statement nodes to determine if any changes have occurred
+        // TODO: Consider expanding this to check semantic updates for each node kind
+        if (!equalRangeText(updatedNode, updated, staleNode, stale)) {
+            // A change to a statement outside a component's metadata is unsupported
+            return null;
+        }
+    }
+    return candidates;
+}
+/**
+ * The set of Angular component metadata fields that are supported by HMR updates.
+ */
+const SUPPORTED_FIELDS = new Set(['template', 'templateUrl', 'styles', 'styleUrl', 'stylesUrl']);
+/**
+ * Analyzes the metadata fields of a decorator call expression for unsupported HMR updates.
+ * Only updates to supported fields can be present for HMR to be viable.
+ * @param staleCall A call expression instance.
+ * @param staleSource The source file instance containing the stale call instance.
+ * @param updatedCall A call expression instance.
+ * @param updatedSource The source file instance containing the updated call instance.
+ * @returns true, if unsupported metadata updates are present; false, otherwise.
+ */
+function hasUnsupportedMetaUpdates(staleCall, staleSource, updatedCall, updatedSource) {
+    const staleObject = staleCall.arguments[0];
+    const updatedObject = updatedCall.arguments[0];
+    if (!typescript_1.default.isObjectLiteralExpression(staleObject) || !typescript_1.default.isObjectLiteralExpression(updatedObject)) {
+        return true;
+    }
+    const unsupportedFields = [];
+    for (const property of staleObject.properties) {
+        if (!typescript_1.default.isPropertyAssignment(property) || typescript_1.default.isComputedPropertyName(property.name)) {
+            // Unsupported object literal property
+            return true;
+        }
+        const name = property.name.text;
+        if (SUPPORTED_FIELDS.has(name)) {
+            continue;
+        }
+        unsupportedFields.push(property.initializer);
+    }
+    let i = 0;
+    for (const property of updatedObject.properties) {
+        if (!typescript_1.default.isPropertyAssignment(property) || typescript_1.default.isComputedPropertyName(property.name)) {
+            // Unsupported object literal property
+            return true;
+        }
+        const name = property.name.text;
+        if (SUPPORTED_FIELDS.has(name)) {
+            continue;
+        }
+        // Compare in order
+        if (!equalRangeText(property.initializer, updatedSource, unsupportedFields[i++], staleSource)) {
+            return true;
+        }
+    }
+    return i !== unsupportedFields.length;
+}
+/**
+ * Compares the text from a provided range in a source file to the text of a range in a second source file.
+ * The comparison avoids making any intermediate string copies.
+ * @param firstRange A text range within the first source file.
+ * @param firstSource A source file instance.
+ * @param secondRange A text range within the second source file.
+ * @param secondSource A source file instance.
+ * @returns true, if the text from both ranges is equal; false, otherwise.
+ */
+function equalRangeText(firstRange, firstSource, secondRange, secondSource) {
+    // Check matching undefined values
+    if (!firstRange || !secondRange) {
+        return firstRange === secondRange;
+    }
+    // Ensure lengths are equal
+    const firstLength = firstRange.end - firstRange.pos;
+    const secondLength = secondRange.end - secondRange.pos;
+    if (firstLength !== secondLength) {
+        return false;
+    }
+    // Check each character
+    for (let i = 0; i < firstLength; ++i) {
+        const firstChar = firstSource.text.charCodeAt(i + firstRange.pos);
+        const secondChar = secondSource.text.charCodeAt(i + secondRange.pos);
+        if (firstChar !== secondChar) {
+            return false;
+        }
+    }
+    return true;
+}

package/src/tools/angular/compilation/jit-compilation.d.ts

@@ -11,6 +11,8 @@ import { AngularHostOptions } from '../angular-host';
 import { AngularCompilation, DiagnosticModes, EmitFileResult } from './angular-compilation';
 export declare class JitCompilation extends AngularCompilation {
     #private;
+    private readonly browserOnlyBuild;
+    constructor(browserOnlyBuild: boolean);
     initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions): Promise<{
         affectedFiles: ReadonlySet<ts.SourceFile>;
         compilerOptions: ng.CompilerOptions;

package/src/tools/angular/compilation/jit-compilation.js

@@ -17,6 +17,7 @@ const load_esm_1 = require("../../../utils/load-esm");
 const profiling_1 = require("../../esbuild/profiling");
 const angular_host_1 = require("../angular-host");
 const jit_resource_transformer_1 = require("../transformers/jit-resource-transformer");
+const lazy_routes_transformer_1 = require("../transformers/lazy-routes-transformer");
 const web_worker_transformer_1 = require("../transformers/web-worker-transformer");
 const angular_compilation_1 = require("./angular-compilation");
 class JitCompilationState {
@@ -34,7 +35,12 @@ class JitCompilationState {
     }
 }
 class JitCompilation extends angular_compilation_1.AngularCompilation {
+    browserOnlyBuild;
     #state;
+    constructor(browserOnlyBuild) {
+        super();
+        this.browserOnlyBuild = browserOnlyBuild;
+    }
     async initialize(tsconfig, hostOptions, compilerOptionsTransformer) {
         // Dynamically load the Angular compiler CLI package
         const { constructorParametersDownlevelTransform } = await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/private/tooling');
@@ -71,7 +77,8 @@ class JitCompilation extends angular_compilation_1.AngularCompilation {
     emitAffectedFiles() {
         (0, node_assert_1.default)(this.#state, 'Compilation must be initialized prior to emitting files.');
         const { compilerHost, typeScriptProgram, constructorParametersDownlevelTransform, replaceResourcesTransform, webWorkerTransform, } = this.#state;
-        const buildInfoFilename = typeScriptProgram.getCompilerOptions().tsBuildInfoFile ?? '.tsbuildinfo';
+        const compilerOptions = typeScriptProgram.getCompilerOptions();
+        const buildInfoFilename = compilerOptions.tsBuildInfoFile ?? '.tsbuildinfo';
         const emittedFiles = [];
         const writeFileCallback = (filename, contents, _a, _b, sourceFiles) => {
             if (!sourceFiles?.length && filename.endsWith(buildInfoFilename)) {
@@ -89,6 +96,9 @@ class JitCompilation extends angular_compilation_1.AngularCompilation {
                 webWorkerTransform,
             ],
         };
+        if (!this.browserOnlyBuild) {
+            transformers.before.push((0, lazy_routes_transformer_1.lazyRoutesTransformer)(compilerOptions, compilerHost));
+        }
         // TypeScript will loop until there are no more affected files in the program
         while (typeScriptProgram.emitNextAffectedFile(writeFileCallback, undefined, undefined, transformers)) {
             /* empty */

package/src/tools/angular/compilation/parallel-compilation.d.ts

@@ -20,8 +20,9 @@ import { AngularCompilation, DiagnosticModes, EmitFileResult } from './angular-c
  */
 export declare class ParallelCompilation extends AngularCompilation {
     #private;
-    readonly jit: boolean;
-    constructor(jit: boolean);
+    private readonly jit;
+    private readonly browserOnlyBuild;
+    constructor(jit: boolean, browserOnlyBuild: boolean);
     initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: CompilerOptions) => CompilerOptions): Promise<{
         affectedFiles: ReadonlySet<SourceFile>;
         compilerOptions: CompilerOptions;

package/src/tools/angular/compilation/parallel-compilation.js

@@ -22,10 +22,12 @@ const angular_compilation_1 = require("./angular-compilation");
  */
 class ParallelCompilation extends angular_compilation_1.AngularCompilation {
     jit;
+    browserOnlyBuild;
     #worker;
-    constructor(jit) {
+    constructor(jit, browserOnlyBuild) {
         super();
         this.jit = jit;
+        this.browserOnlyBuild = browserOnlyBuild;
         // TODO: Convert to import.meta usage during ESM transition
         const localRequire = (0, node_module_1.createRequire)(__filename);
         this.#worker = new worker_pool_1.WorkerPool({
@@ -82,6 +84,7 @@ class ParallelCompilation extends angular_compilation_1.AngularCompilation {
             fileReplacements: hostOptions.fileReplacements,
             tsconfig,
             jit: this.jit,
+            browserOnlyBuild: this.browserOnlyBuild,
             stylesheetPort: stylesheetChannel.port2,
             optionsPort: optionsChannel.port2,
             optionsSignal,

package/src/tools/angular/compilation/parallel-worker.d.ts

@@ -10,6 +10,7 @@ import { type MessagePort } from 'node:worker_threads';
 import type { DiagnosticModes } from './angular-compilation';
 export interface InitRequest {
     jit: boolean;
+    browserOnlyBuild: boolean;
     tsconfig: string;
     fileReplacements?: Record<string, string>;
     stylesheetPort: MessagePort;

package/src/tools/angular/compilation/parallel-worker.js

@@ -23,7 +23,9 @@ const jit_compilation_1 = require("./jit-compilation");
 let compilation;
 const sourceFileCache = new source_file_cache_1.SourceFileCache();
 async function initialize(request) {
-    compilation ??= request.jit ? new jit_compilation_1.JitCompilation() : new aot_compilation_1.AotCompilation();
+    compilation ??= request.jit
+        ? new jit_compilation_1.JitCompilation(request.browserOnlyBuild)
+        : new aot_compilation_1.AotCompilation(request.browserOnlyBuild);
     const stylesheetRequests = new Map();
     request.stylesheetPort.on('message', ({ requestId, value, error }) => {
         if (error) {

package/src/tools/angular/transformers/lazy-routes-transformer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @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.dev/license
+ */
+import ts from 'typescript';
+/**
+ * A transformer factory that adds a property to the lazy-loaded route object.
+ * This property is used to allow for the retrieval of the module path during SSR.
+ *
+ * @param compilerOptions The compiler options.
+ * @param compilerHost The compiler host.
+ * @returns A transformer factory.
+ *
+ * @example
+ * **Before:**
+ * ```ts
+ * const routes: Routes = [
+ *   {
+ *     path: 'lazy',
+ *     loadChildren: () => import('./lazy/lazy.module').then(m => m.LazyModule)
+ *   }
+ * ];
+ * ```
+ *
+ * **After:**
+ * ```ts
+ * const routes: Routes = [
+ *   {
+ *     path: 'lazy',
+ *     loadChildren: () => import('./lazy/lazy.module').then(m => m.LazyModule),
+ *     ...(typeof ngServerMode !== "undefined" && ngServerMode ? { ɵentryName: "./lazy/lazy.module.ts" }: {})
+ *   }
+ * ];
+ * ```
+ */
+export declare function lazyRoutesTransformer(compilerOptions: ts.CompilerOptions, compilerHost: ts.CompilerHost): ts.TransformerFactory<ts.SourceFile>;

package/src/tools/angular/transformers/lazy-routes-transformer.js

@@ -0,0 +1,163 @@
+"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.dev/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyRoutesTransformer = lazyRoutesTransformer;
+const node_assert_1 = __importDefault(require("node:assert"));
+const posix_1 = require("node:path/posix");
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * A transformer factory that adds a property to the lazy-loaded route object.
+ * This property is used to allow for the retrieval of the module path during SSR.
+ *
+ * @param compilerOptions The compiler options.
+ * @param compilerHost The compiler host.
+ * @returns A transformer factory.
+ *
+ * @example
+ * **Before:**
+ * ```ts
+ * const routes: Routes = [
+ *   {
+ *     path: 'lazy',
+ *     loadChildren: () => import('./lazy/lazy.module').then(m => m.LazyModule)
+ *   }
+ * ];
+ * ```
+ *
+ * **After:**
+ * ```ts
+ * const routes: Routes = [
+ *   {
+ *     path: 'lazy',
+ *     loadChildren: () => import('./lazy/lazy.module').then(m => m.LazyModule),
+ *     ...(typeof ngServerMode !== "undefined" && ngServerMode ? { ɵentryName: "./lazy/lazy.module.ts" }: {})
+ *   }
+ * ];
+ * ```
+ */
+function lazyRoutesTransformer(compilerOptions, compilerHost) {
+    const moduleResolutionCache = compilerHost.getModuleResolutionCache?.();
+    (0, node_assert_1.default)(typeof compilerOptions.basePath === 'string', 'compilerOptions.basePath should be a string.');
+    const basePath = compilerOptions.basePath;
+    return (context) => {
+        const factory = context.factory;
+        const visitor = (node) => {
+            if (!typescript_1.default.isObjectLiteralExpression(node)) {
+                // Not an object literal, so skip it.
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            const loadFunction = getLoadComponentOrChildrenProperty(node)?.initializer;
+            // Check if the initializer is an arrow function or a function expression
+            if (!loadFunction ||
+                (!typescript_1.default.isArrowFunction(loadFunction) && !typescript_1.default.isFunctionExpression(loadFunction))) {
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            let callExpression;
+            if (typescript_1.default.isArrowFunction(loadFunction)) {
+                // Handle arrow functions: body can either be a block or a direct call expression
+                const body = loadFunction.body;
+                if (typescript_1.default.isBlock(body)) {
+                    // Arrow function with a block: check the first statement for a return call expression
+                    const firstStatement = body.statements[0];
+                    if (firstStatement &&
+                        typescript_1.default.isReturnStatement(firstStatement) &&
+                        firstStatement.expression &&
+                        typescript_1.default.isCallExpression(firstStatement.expression)) {
+                        callExpression = firstStatement.expression;
+                    }
+                }
+                else if (typescript_1.default.isCallExpression(body)) {
+                    // Arrow function with a direct call expression as its body
+                    callExpression = body;
+                }
+            }
+            else if (typescript_1.default.isFunctionExpression(loadFunction)) {
+                // Handle function expressions: check for a return statement with a call expression
+                const returnExpression = loadFunction.body.statements.find(typescript_1.default.isReturnStatement)?.expression;
+                if (returnExpression && typescript_1.default.isCallExpression(returnExpression)) {
+                    callExpression = returnExpression;
+                }
+            }
+            if (!callExpression) {
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            // Optionally check for the 'then' property access expression
+            const expression = callExpression.expression;
+            if (!typescript_1.default.isCallExpression(expression) &&
+                typescript_1.default.isPropertyAccessExpression(expression) &&
+                expression.name.text !== 'then') {
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            const importExpression = typescript_1.default.isPropertyAccessExpression(expression)
+                ? expression.expression // Navigate to the underlying expression for 'then'
+                : callExpression;
+            // Ensure the underlying expression is an import call
+            if (!typescript_1.default.isCallExpression(importExpression) ||
+                importExpression.expression.kind !== typescript_1.default.SyntaxKind.ImportKeyword) {
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            // Check if the argument to the import call is a string literal
+            const callExpressionArgument = importExpression.arguments[0];
+            if (!typescript_1.default.isStringLiteralLike(callExpressionArgument)) {
+                // Not a string literal, so skip it.
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            const resolvedPath = typescript_1.default.resolveModuleName(callExpressionArgument.text, node.getSourceFile().fileName, compilerOptions, compilerHost, moduleResolutionCache)?.resolvedModule?.resolvedFileName;
+            if (!resolvedPath) {
+                // Could not resolve the module, so skip it.
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            const resolvedRelativePath = (0, posix_1.relative)(basePath, resolvedPath);
+            // Create the new property
+            // Example: `...(typeof ngServerMode !== "undefined" && ngServerMode ? { ɵentryName: "src/home.ts" }: {})`
+            const newProperty = factory.createSpreadAssignment(factory.createParenthesizedExpression(factory.createConditionalExpression(factory.createBinaryExpression(factory.createBinaryExpression(factory.createTypeOfExpression(factory.createIdentifier('ngServerMode')), factory.createToken(typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken), factory.createStringLiteral('undefined')), factory.createToken(typescript_1.default.SyntaxKind.AmpersandAmpersandToken), factory.createIdentifier('ngServerMode')), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), factory.createObjectLiteralExpression([
+                factory.createPropertyAssignment(factory.createIdentifier('ɵentryName'), factory.createStringLiteral(resolvedRelativePath)),
+            ]), factory.createToken(typescript_1.default.SyntaxKind.ColonToken), factory.createObjectLiteralExpression([]))));
+            // Add the new property to the object literal.
+            return factory.updateObjectLiteralExpression(node, [...node.properties, newProperty]);
+        };
+        return (sourceFile) => {
+            const text = sourceFile.text;
+            if (!text.includes('loadC')) {
+                // Fast check for 'loadComponent' and 'loadChildren'.
+                return sourceFile;
+            }
+            return typescript_1.default.visitEachChild(sourceFile, visitor, context);
+        };
+    };
+}
+/**
+ * Retrieves the property assignment for the `loadComponent` or `loadChildren` property of a route object.
+ *
+ * @param node The object literal expression to search.
+ * @returns The property assignment if found, otherwise `undefined`.
+ */
+function getLoadComponentOrChildrenProperty(node) {
+    let hasPathProperty = false;
+    let loadComponentOrChildrenProperty;
+    for (const prop of node.properties) {
+        if (!typescript_1.default.isPropertyAssignment(prop) || !typescript_1.default.isIdentifier(prop.name)) {
+            continue;
+        }
+        const propertyNameText = prop.name.text;
+        if (propertyNameText === 'path') {
+            hasPathProperty = true;
+        }
+        else if (propertyNameText === 'loadComponent' || propertyNameText === 'loadChildren') {
+            loadComponentOrChildrenProperty = prop;
+        }
+        if (hasPathProperty && loadComponentOrChildrenProperty) {
+            break;
+        }
+    }
+    return loadComponentOrChildrenProperty;
+}

package/src/tools/babel/plugins/pure-toplevel-functions.js

@@ -22,13 +22,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };