@angular/core 19.0.0-rc.0 → 19.0.0-rc.2

package/schematics/bundles/pending-tasks.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-rc.0
+ * @license Angular v19.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10,12 +10,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var schematics = require('@angular-devkit/schematics');
 var p = require('path');
-var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
-var compiler_host = require('./compiler_host-f54f8309.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
+var compiler_host = require('./compiler_host-40e8d55f.js');
 var ts = require('typescript');
-var imports = require('./imports-44987700.js');
+var imports = require('./imports-4ac08251.js');
 require('@angular-devkit/core');
-require('./checker-2451e7c5.js');
+require('./checker-cd95ebda.js');
 require('os');
 require('fs');
 require('module');

package/schematics/bundles/{program-58424797.js → program-8f30df93.js}

@@ -1,12 +1,12 @@
 'use strict';
 /**
- * @license Angular v19.0.0-rc.0
+ * @license Angular v19.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-var checker = require('./checker-2451e7c5.js');
+var checker = require('./checker-cd95ebda.js');
 var ts = require('typescript');
 var p = require('path');
 require('os');
@@ -898,33 +898,57 @@ function compileHmrInitializer(meta) {
     const urlPartial = `/@ng/component?c=${id}&t=`;
     const moduleName = 'm';
     const dataName = 'd';
+    const timestampName = 't';
+    const importCallbackName = `${meta.className}_HmrLoad`;
     const locals = meta.locals.map((localName) => checker.variable(localName));
+    // m.default
+    const defaultRead = checker.variable(moduleName).prop('default');
     // ɵɵreplaceMetadata(Comp, m.default, [...]);
-    const replaceMetadata = checker.importExpr(checker.Identifiers.replaceMetadata)
-        .callFn([meta.type, checker.variable(moduleName).prop('default'), checker.literalArr(locals)]);
-    // (m) => ɵɵreplaceMetadata(...)
-    const replaceCallback = checker.arrowFn([new checker.FnParam(moduleName)], replaceMetadata);
-    // '<urlPartial>' + encodeURIComponent(d.timestamp)
+    const replaceCall = checker.importExpr(checker.Identifiers.replaceMetadata)
+        .callFn([meta.type, defaultRead, new checker.ExternalExpr(checker.Identifiers.core), checker.literalArr(locals)]);
+    // (m) => m.default && ɵɵreplaceMetadata(...)
+    const replaceCallback = checker.arrowFn([new checker.FnParam(moduleName)], defaultRead.and(replaceCall));
+    // '<urlPartial>' + encodeURIComponent(t)
     const urlValue = checker.literal(urlPartial)
-        .plus(checker.variable('encodeURIComponent').callFn([checker.variable(dataName).prop('timestamp')]));
-    // import(/* @vite-ignore */ url).then(() => replaceMetadata(...));
-    // The vite-ignore special comment is required to avoid Vite from generating a superfluous
-    // warning for each usage within the development code. If Vite provides a method to
-    // programmatically avoid this warning in the future, this added comment can be removed here.
-    const dynamicImport = new checker.DynamicImportExpr(urlValue, null, '@vite-ignore')
-        .prop('then')
-        .callFn([replaceCallback]);
-    // (d) => { if (d.id === <id>) { replaceMetadata(...) } }
-    const listenerCallback = checker.arrowFn([new checker.FnParam(dataName)], [checker.ifStmt(checker.variable(dataName).prop('id').equals(checker.literal(id)), [dynamicImport.toStmt()])]);
+        .plus(checker.variable('encodeURIComponent').callFn([checker.variable(timestampName)]));
+    // function Cmp_HmrLoad(t) {
+    //   import(/* @vite-ignore */ url).then((m) => m.default && replaceMetadata(...));
+    // }
+    const importCallback = new checker.DeclareFunctionStmt(importCallbackName, [new checker.FnParam(timestampName)], [
+        // The vite-ignore special comment is required to prevent Vite from generating a superfluous
+        // warning for each usage within the development code. If Vite provides a method to
+        // programmatically avoid this warning in the future, this added comment can be removed here.
+        new checker.DynamicImportExpr(urlValue, null, '@vite-ignore')
+            .prop('then')
+            .callFn([replaceCallback])
+            .toStmt(),
+    ], null, checker.StmtModifier.Final);
+    // (d) => d.id === <id> && Cmp_HmrLoad(d.timestamp)
+    const updateCallback = checker.arrowFn([new checker.FnParam(dataName)], checker.variable(dataName)
+        .prop('id')
+        .identical(checker.literal(id))
+        .and(checker.variable(importCallbackName).callFn([checker.variable(dataName).prop('timestamp')])));
+    // Cmp_HmrLoad(Date.now());
+    // Initial call to kick off the loading in order to avoid edge cases with components
+    // coming from lazy chunks that change before the chunk has loaded.
+    const initialCall = checker.variable(importCallbackName)
+        .callFn([checker.variable('Date').prop('now').callFn([])]);
     // import.meta.hot
     const hotRead = checker.variable('import').prop('meta').prop('hot');
     // import.meta.hot.on('angular:component-update', () => ...);
     const hotListener = hotRead
         .clone()
         .prop('on')
-        .callFn([checker.literal('angular:component-update'), listenerCallback]);
-    // import.meta.hot && import.meta.hot.on(...)
-    return checker.arrowFn([], [checker.devOnlyGuardedExpression(hotRead.and(hotListener)).toStmt()]).callFn([]);
+        .callFn([checker.literal('angular:component-update'), updateCallback]);
+    return checker.arrowFn([], [
+        // function Cmp_HmrLoad() {...}.
+        importCallback,
+        // ngDevMode && Cmp_HmrLoad(Date.now());
+        checker.devOnlyGuardedExpression(initialCall).toStmt(),
+        // ngDevMode && import.meta.hot && import.meta.hot.on(...)
+        checker.devOnlyGuardedExpression(hotRead.and(hotListener)).toStmt(),
+    ])
+        .callFn([]);
 }
 /**
  * Compiles the HMR update callback for a class.
@@ -963,7 +987,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', checker.literal('19.0.0-rc.0'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.2'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -981,7 +1005,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
     callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? checker.literal(null));
     callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? checker.literal(null));
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-    definitionMap.set('version', checker.literal('19.0.0-rc.0'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.2'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -1076,7 +1100,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', checker.literal(minVersion));
-    definitionMap.set('version', checker.literal('19.0.0-rc.0'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.2'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -1492,7 +1516,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', checker.literal('19.0.0-rc.0'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.2'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -1527,7 +1551,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', checker.literal('19.0.0-rc.0'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.2'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -1578,7 +1602,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', checker.literal('19.0.0-rc.0'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.2'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -1611,7 +1635,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', checker.literal('19.0.0-rc.0'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.2'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -1662,7 +1686,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', checker.literal('19.0.0-rc.0'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.2'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -1814,7 +1838,7 @@ class AliasStrategy {
             return null;
         }
         return {
-            kind: 0 /* ReferenceEmitKind.Success */,
+            kind: checker.ReferenceEmitKind.Success,
             expression: ref.alias,
             importedFile: 'unknown',
         };
@@ -2701,12 +2725,21 @@ class DtsMetadataReader {
         }
         // Read the ModuleData out of the type arguments.
         const [_, declarationMetadata, importMetadata, exportMetadata] = ngModuleDef.type.typeArguments;
+        const declarations = checker.extractReferencesFromType(this.checker, declarationMetadata, ref.bestGuessOwningModule);
+        const exports = checker.extractReferencesFromType(this.checker, exportMetadata, ref.bestGuessOwningModule);
+        const imports = checker.extractReferencesFromType(this.checker, importMetadata, ref.bestGuessOwningModule);
+        // The module is considered poisoned if it's exports couldn't be
+        // resolved completely. This would make the module not necessarily
+        // usable for scope computation relying on this module; so we propagate
+        // this "incompleteness" information to the caller.
+        const isPoisoned = exports.isIncomplete;
         return {
             kind: checker.MetaKind.NgModule,
             ref,
-            declarations: checker.extractReferencesFromType(this.checker, declarationMetadata, ref.bestGuessOwningModule),
-            exports: checker.extractReferencesFromType(this.checker, exportMetadata, ref.bestGuessOwningModule),
-            imports: checker.extractReferencesFromType(this.checker, importMetadata, ref.bestGuessOwningModule),
+            declarations: declarations.result,
+            isPoisoned,
+            exports: exports.result,
+            imports: imports.result,
             schemas: [],
             rawDeclarations: null,
             rawImports: null,
@@ -2758,6 +2791,10 @@ class DtsMetadataReader {
             ? readHostDirectivesType(this.checker, def.type.typeArguments[8], ref.bestGuessOwningModule)
             : null;
         const isSignal = def.type.typeArguments.length > 9 && (checker.readBooleanType(def.type.typeArguments[9]) ?? false);
+        // At this point in time, the `.d.ts` may not be fully extractable when
+        // trying to resolve host directive types to their declarations.
+        // If this cannot be done completely, the metadata is incomplete and "poisoned".
+        const isPoisoned = hostDirectives !== null && hostDirectives?.isIncomplete;
         return {
             kind: checker.MetaKind.Directive,
             matchSource: checker.MatchSource.Selector,
@@ -2768,11 +2805,11 @@ class DtsMetadataReader {
             exportAs: checker.readStringArrayType(def.type.typeArguments[2]),
             inputs,
             outputs,
-            hostDirectives,
+            hostDirectives: hostDirectives?.result ?? null,
             queries: checker.readStringArrayType(def.type.typeArguments[5]),
             ...checker.extractDirectiveTypeCheckMeta(clazz, inputs, this.reflector),
             baseClass: readBaseClass(clazz, this.checker, this.reflector),
-            isPoisoned: false,
+            isPoisoned,
             isStructural,
             animationTriggerNames: null,
             ngContentSelectors,
@@ -2914,21 +2951,27 @@ function readHostDirectivesType(checker$1, type, bestGuessOwningModule) {
         return null;
     }
     const result = [];
+    let isIncomplete = false;
     for (const hostDirectiveType of type.elements) {
         const { directive, inputs, outputs } = checker.readMapType(hostDirectiveType, (type) => type);
         if (directive) {
             if (!ts__default["default"].isTypeQueryNode(directive)) {
                 throw new Error(`Expected TypeQueryNode: ${checker.nodeDebugInfo(directive)}`);
             }
+            const ref = checker.extraReferenceFromTypeQuery(checker$1, directive, type, bestGuessOwningModule);
+            if (ref === null) {
+                isIncomplete = true;
+                continue;
+            }
             result.push({
-                directive: checker.extraReferenceFromTypeQuery(checker$1, directive, type, bestGuessOwningModule),
+                directive: ref,
                 isForwardReference: false,
                 inputs: checker.readMapType(inputs, checker.readStringType),
                 outputs: checker.readMapType(outputs, checker.readStringType),
             });
         }
     }
-    return result.length > 0 ? result : null;
+    return result.length > 0 ? { result, isIncomplete } : null;
 }
 
 /**
@@ -5985,7 +6028,7 @@ class MetadataDtsModuleScopeResolver {
         const exportScope = {
             exported: {
                 dependencies,
-                isPoisoned: false,
+                isPoisoned: meta.isPoisoned,
             },
         };
         this.cache.set(clazz, exportScope);
@@ -8656,6 +8699,7 @@ class NgModuleDecoratorHandler {
             rawExports: analysis.rawExports,
             decorator: analysis.decorator,
             mayDeclareProviders: analysis.providers !== null,
+            isPoisoned: false,
         });
         this.injectableRegistry.registerInjectable(node, {
             ctorDeps: analysis.fac.deps,
@@ -13888,22 +13932,18 @@ class ClassExtractor {
     /** The result only contains properties, method implementations and abstracts */
     filterMethodOverloads(declarations) {
         return declarations.filter((declaration, index) => {
+            // Check if the declaration is a function or method
             if (ts__default["default"].isFunctionDeclaration(declaration) || ts__default["default"].isMethodDeclaration(declaration)) {
-                if (ts__default["default"].getCombinedModifierFlags(declaration) & ts__default["default"].ModifierFlags.Abstract) {
-                    // TS enforces that all declarations of an abstract method are consecutive
-                    const previousDeclaration = declarations[index - 1];
-                    const samePreviousAbstractMethod = previousDeclaration &&
-                        ts__default["default"].isMethodDeclaration(previousDeclaration) &&
-                        ts__default["default"].getCombinedModifierFlags(previousDeclaration) & ts__default["default"].ModifierFlags.Abstract &&
-                        previousDeclaration.name.getText() === declaration.name?.getText();
-                    // We just need a reference to one member
-                    // In the case of Abstract Methods we only want to return the first abstract.
-                    // Others with the same name are considered as overloads
-                    // Later on, the function extractor will handle overloads and implementation detection
-                    return !samePreviousAbstractMethod;
-                }
-                return !!declaration.body;
-            }
+                // TypeScript ensures that all declarations for a given abstract method appear consecutively.
+                const nextDeclaration = declarations[index + 1];
+                const isNextAbstractMethodWithSameName = nextDeclaration &&
+                    ts__default["default"].isMethodDeclaration(nextDeclaration) &&
+                    nextDeclaration.name.getText() === declaration.name?.getText();
+                // Return only the last occurrence of an abstract method to avoid overload duplication.
+                // Subsequent overloads or implementations are handled separately by the function extractor.
+                return !isNextAbstractMethodWithSameName;
+            }
+            // Include non-method declarations, such as properties, without filtering.
             return true;
         });
     }
@@ -14474,6 +14514,7 @@ function extractTypeAlias(declaration) {
         name: declaration.name.getText(),
         type: declaration.type.getText(),
         entryType: EntryType.TypeAlias,
+        generics: extractGenerics(declaration),
         rawComment: extractRawJsDoc(declaration),
         description: extractJsDocDescription(declaration),
         jsdocTags: extractJsDocTags(declaration),
@@ -17251,13 +17292,19 @@ class UnusedStandaloneImportsRule {
         if (unused === null) {
             return null;
         }
+        const propertyAssignment = closestNode(metadata.rawImports, ts__default["default"].isPropertyAssignment);
         const category = this.typeCheckingConfig.unusedStandaloneImports === 'error'
             ? ts__default["default"].DiagnosticCategory.Error
             : ts__default["default"].DiagnosticCategory.Warning;
-        if (unused.length === metadata.imports.length) {
-            return checker.makeDiagnostic(checker.ErrorCode.UNUSED_STANDALONE_IMPORTS, metadata.rawImports, 'All imports are unused', undefined, category);
-        }
-        return checker.makeDiagnostic(checker.ErrorCode.UNUSED_STANDALONE_IMPORTS, metadata.rawImports, 'Imports array contains unused imports', unused.map(([ref, type, name]) => checker.makeRelatedInformation(ref.getOriginForDiagnostics(metadata.rawImports), `${type} "${name}" is not used within the template`)), category);
+        if (unused.length === metadata.imports.length && propertyAssignment !== null) {
+            return checker.makeDiagnostic(checker.ErrorCode.UNUSED_STANDALONE_IMPORTS, propertyAssignment.name, 'All imports are unused', undefined, category);
+        }
+        return unused.map((ref) => {
+            const diagnosticNode = ref.getIdentityInExpression(metadata.rawImports) ||
+                ref.getIdentityIn(node.getSourceFile()) ||
+                metadata.rawImports;
+            return checker.makeDiagnostic(checker.ErrorCode.UNUSED_STANDALONE_IMPORTS, diagnosticNode, `${ref.node.name.text} is not used within the template of ${metadata.name}`, undefined, category);
+        });
     }
     getUnusedSymbols(metadata, usedDirectives, usedPipes) {
         const { imports, rawImports } = metadata;
@@ -17273,7 +17320,7 @@ class UnusedStandaloneImportsRule {
                     !usedDirectives.has(currentNode) &&
                     !this.isPotentialSharedReference(current, rawImports)) {
                     unused ??= [];
-                    unused.push([current, dirMeta.isComponent ? 'Component' : 'Directive', dirMeta.name]);
+                    unused.push(current);
                 }
                 continue;
             }
@@ -17283,7 +17330,7 @@ class UnusedStandaloneImportsRule {
                 !usedPipes.has(pipeMeta.name) &&
                 !this.isPotentialSharedReference(current, rawImports)) {
                 unused ??= [];
-                unused.push([current, 'Pipe', pipeMeta.ref.node.name.text]);
+                unused.push(current);
             }
         }
         return unused;
@@ -17316,6 +17363,19 @@ class UnusedStandaloneImportsRule {
         return true;
     }
 }
+/** Gets the closest parent node of a certain type. */
+function closestNode(start, predicate) {
+    let current = start.parent;
+    while (current) {
+        if (predicate(current)) {
+            return current;
+        }
+        else {
+            current = current.parent;
+        }
+    }
+    return null;
+}
 
 /*!
  * @license
@@ -20060,7 +20120,7 @@ var semver = /*@__PURE__*/getDefaultExportFromCjs(semverExports);
  * @param minVersion Minimum required version for the feature.
  */
 function coreVersionSupportsFeature(coreVersion, minVersion) {
-    // A version of `19.0.0-rc.0` usually means that core is at head so it supports
+    // A version of `19.0.0-rc.2` usually means that core is at head so it supports
     // all features. Use string interpolation prevent the placeholder from being replaced
     // with the current version during build time.
     if (coreVersion === `0.0.0-${'PLACEHOLDER'}`) {

package/schematics/bundles/{project_tsconfig_paths-6c9cde78.js → project_tsconfig_paths-e9ccccbf.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-rc.0
+ * @license Angular v19.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */

package/schematics/bundles/provide-initializer.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-rc.0
+ * @license Angular v19.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10,13 +10,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var schematics = require('@angular-devkit/schematics');
 var p = require('path');
-var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
-var compiler_host = require('./compiler_host-f54f8309.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
+var compiler_host = require('./compiler_host-40e8d55f.js');
 var ts = require('typescript');
-var imports = require('./imports-44987700.js');
-var nodes = require('./nodes-ffdce442.js');
+var imports = require('./imports-4ac08251.js');
 require('@angular-devkit/core');
-require('./checker-2451e7c5.js');
+require('./checker-cd95ebda.js');
 require('os');
 require('fs');
 require('module');
@@ -32,9 +31,9 @@ function migrateFile(sourceFile, rewriteFn) {
         const provider = tryParseProviderExpression(node);
         if (provider) {
             replaceProviderWithNewApi({
-                sourceFile: sourceFile,
-                node: node,
-                provider: provider,
+                sourceFile,
+                node,
+                provider,
                 changeTracker,
             });
             return;
@@ -55,24 +54,14 @@ function replaceProviderWithNewApi({ sourceFile, node, provider, changeTracker,
     }
     // Replace the provider with the new provide function.
     changeTracker.replaceText(sourceFile, node.getStart(), node.getWidth(), `${provideInitializerFunctionName}(${initializerCode})`);
-    // Import declaration and named imports are necessarily there.
-    const namedImports = nodes.closestNode(initializerTokenSpecifier, ts__default["default"].isNamedImports);
-    // `provide*Initializer` function is already imported.
-    const hasProvideInitializeFunction = namedImports.elements.some((element) => element.name.getText() === provideInitializerFunctionName);
-    const newNamedImports = ts__default["default"].factory.updateNamedImports(namedImports, [
-        // Remove the `*_INITIALIZER` token from imports.
-        ...namedImports.elements.filter((element) => element !== initializerTokenSpecifier),
-        // Add the `inject` function to imports if needed.
-        ...(importInject ? [createImportSpecifier('inject')] : []),
-        // Add the `provide*Initializer` function to imports.
-        ...(!hasProvideInitializeFunction
-            ? [createImportSpecifier(provideInitializerFunctionName)]
-            : []),
-    ]);
-    changeTracker.replaceNode(namedImports, newNamedImports);
-}
-function createImportSpecifier(name) {
-    return ts__default["default"].factory.createImportSpecifier(false, undefined, ts__default["default"].factory.createIdentifier(name));
+    // Remove the `*_INITIALIZER` token from imports.
+    changeTracker.removeImport(sourceFile, initializerToken, angularCoreModule);
+    // Add the `inject` function to imports if needed.
+    if (importInject) {
+        changeTracker.addImport(sourceFile, 'inject', angularCoreModule);
+    }
+    // Add the `provide*Initializer` function to imports.
+    changeTracker.addImport(sourceFile, provideInitializerFunctionName, angularCoreModule);
 }
 function tryParseProviderExpression(node) {
     if (!ts__default["default"].isObjectLiteralExpression(node)) {
@@ -135,7 +124,7 @@ function tryParseProviderExpression(node) {
         return {
             ...info,
             importInject: deps.length > 0,
-            initializerCode: `() => { return (${useFactory.getText()})(${args.join(', ')}); }`,
+            initializerCode: `(${useFactory.getText()})(${args.join(', ')})`,
         };
     }
     if (useValue) {

package/schematics/bundles/route-lazy-loading.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-rc.0
+ * @license Angular v19.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -11,10 +11,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var schematics = require('@angular-devkit/schematics');
 var fs = require('fs');
 var p = require('path');
-var compiler_host = require('./compiler_host-f54f8309.js');
-var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
+var compiler_host = require('./compiler_host-40e8d55f.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
 var ts = require('typescript');
-require('./checker-2451e7c5.js');
+require('./checker-cd95ebda.js');
 require('os');
 require('module');
 require('url');
@@ -61,7 +61,12 @@ function isStandaloneComponent(node) {
         const arg = decorator.expression.arguments[0];
         if (ts__default["default"].isObjectLiteralExpression(arg)) {
             const property = findLiteralProperty(arg, 'standalone');
-            return property ? property.initializer.getText() === 'true' : false;
+            if (property) {
+                return property.initializer.getText() === 'true';
+            }
+            else {
+                return true; // standalone is true by default in v19
+            }
         }
     }
     return false;