@angular/core 19.0.0-next.9 → 19.0.0-rc.1

package/schematics/bundles/{compiler_host-b4ba5a28.js → compiler_host-31afa4ed.js}

@@ -1,13 +1,13 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.9
+ * @license Angular v19.0.0-rc.1
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
-var checker = require('./checker-3b2ea20f.js');
+var checker = require('./checker-9ca42e51.js');
 require('os');
 var p = require('path');
 
@@ -83,11 +83,14 @@ class ChangeTracker {
     /**
      * Removes the text of an AST node from a file.
      * @param node Node whose text should be removed.
+     * @param useFullOffsets Whether to remove the node using its full offset (e.g. `getFullStart`
+     * rather than `fullStart`). This has the advantage of removing any comments that may be tied
+     * to the node, but can lead to too much code being deleted.
      */
-    removeNode(node) {
+    removeNode(node, useFullOffsets = false) {
         this._trackChange(node.getSourceFile(), {
-            start: node.getStart(),
-            removeLength: node.getWidth(),
+            start: useFullOffsets ? node.getFullStart() : node.getStart(),
+            removeLength: useFullOffsets ? node.getFullWidth() : node.getWidth(),
             text: '',
         });
     }

package/schematics/bundles/control-flow-migration.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.9
+ * @license Angular v19.0.0-rc.1
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10,8 +10,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var schematics = require('@angular-devkit/schematics');
 var p = require('path');
-var compiler_host = require('./compiler_host-b4ba5a28.js');
-var checker = require('./checker-3b2ea20f.js');
+var compiler_host = require('./compiler_host-31afa4ed.js');
+var checker = require('./checker-9ca42e51.js');
 var ts = require('typescript');
 require('os');
 require('fs');

package/schematics/bundles/explicit-standalone-flag.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.9
+ * @license Angular v19.0.0-rc.1
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -11,11 +11,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var schematics = require('@angular-devkit/schematics');
 var p = require('path');
 var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
-var compiler_host = require('./compiler_host-b4ba5a28.js');
+var compiler_host = require('./compiler_host-31afa4ed.js');
 var ts = require('typescript');
 var imports = require('./imports-4ac08251.js');
 require('@angular-devkit/core');
-require('./checker-3b2ea20f.js');
+require('./checker-9ca42e51.js');
 require('os');
 require('fs');
 require('module');
@@ -77,16 +77,23 @@ function migrateFile(sourceFile, rewriteFn) {
             }
             const properties = decoratorArgument.properties;
             const standaloneProp = getStandaloneProperty(properties);
-            // Need to take care of 3 cases
-            // - standalone: true  => remove the property
+            const hasImports = decoratorHasImports(decoratorArgument);
+            // We'll use the presence of imports to keep the migration idempotent
+            // We need to take care of 3 cases
+            // - standalone: true  => remove the property if we have imports
             // - standalone: false => nothing
-            // - No standalone property => add a standalone: false property
+            // - No standalone property => add a standalone: false property if there are no imports
             let newProperties;
             if (!standaloneProp) {
-                const standaloneFalseProperty = ts__default["default"].factory.createPropertyAssignment('standalone', ts__default["default"].factory.createFalse());
-                newProperties = [...properties, standaloneFalseProperty];
+                if (!hasImports) {
+                    const standaloneFalseProperty = ts__default["default"].factory.createPropertyAssignment('standalone', ts__default["default"].factory.createFalse());
+                    newProperties = [...properties, standaloneFalseProperty];
+                }
+            }
+            else if (standaloneProp.value === ts__default["default"].SyntaxKind.TrueKeyword && hasImports) {
+                // To keep the migration idempotent, we'll only remove the standalone prop when there are imports
+                newProperties = properties.filter((p) => p !== standaloneProp.property);
             }
-            else if (standaloneProp.value === ts__default["default"].SyntaxKind.TrueKeyword) ;
             if (newProperties) {
                 // At this point we know that we need to add standalone: false or
                 // remove an existing standalone: true property.
@@ -123,6 +130,19 @@ function getStandaloneProperty(properties) {
 function isStandaloneProperty(prop) {
     return (ts__default["default"].isPropertyAssignment(prop) && ts__default["default"].isIdentifier(prop.name) && prop.name.text === 'standalone');
 }
+function decoratorHasImports(decoratorArgument) {
+    for (const prop of decoratorArgument.properties) {
+        if (ts__default["default"].isPropertyAssignment(prop) &&
+            ts__default["default"].isIdentifier(prop.name) &&
+            prop.name.text === 'imports') {
+            if (prop.initializer.kind === ts__default["default"].SyntaxKind.ArrayLiteralExpression ||
+                prop.initializer.kind === ts__default["default"].SyntaxKind.Identifier) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 
 function migrate() {
     return async (tree) => {

package/schematics/bundles/imports-4ac08251.js

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

package/schematics/bundles/inject-migration.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.9
+ * @license Angular v19.0.0-rc.1
  * (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 compiler_host = require('./compiler_host-b4ba5a28.js');
+var compiler_host = require('./compiler_host-31afa4ed.js');
 var ts = require('typescript');
 var nodes = require('./nodes-0e7d45ca.js');
 var imports = require('./imports-4ac08251.js');
 var leading_space = require('./leading_space-d190b83b.js');
-require('./checker-3b2ea20f.js');
+require('./checker-9ca42e51.js');
 require('os');
 require('fs');
 require('module');
@@ -55,7 +55,7 @@ const DI_PARAM_SYMBOLS = new Set([
  * @param sourceFile File which to analyze.
  * @param localTypeChecker Type checker scoped to the specific file.
  */
-function analyzeFile(sourceFile, localTypeChecker) {
+function analyzeFile(sourceFile, localTypeChecker, options) {
     const coreSpecifiers = imports.getNamedImports(sourceFile, '@angular/core');
     // Exit early if there are no Angular imports.
     if (coreSpecifiers === null || coreSpecifiers.elements.length === 0) {
@@ -106,11 +106,14 @@ function analyzeFile(sourceFile, localTypeChecker) {
         }
         else if (ts__default["default"].isClassDeclaration(node)) {
             const decorators = nodes.getAngularDecorators(localTypeChecker, ts__default["default"].getDecorators(node) || []);
+            const isAbstract = !!node.modifiers?.some((m) => m.kind === ts__default["default"].SyntaxKind.AbstractKeyword);
             const supportsDI = decorators.some((dec) => DECORATORS_SUPPORTING_DI.has(dec.name));
             const constructorNode = node.members.find((member) => ts__default["default"].isConstructorDeclaration(member) &&
                 member.body != null &&
                 member.parameters.length > 0);
-            if (supportsDI && constructorNode) {
+            // Don't migrate abstract classes by default, because
+            // their parameters aren't guaranteed to be injectable.
+            if (supportsDI && constructorNode && (!isAbstract || options.migrateAbstractClasses)) {
                 classes.push({
                     node,
                     constructor: constructorNode,
@@ -145,7 +148,7 @@ function getConstructorUnusedParameters(declaration, localTypeChecker, removedSt
     }
     declaration.body.forEachChild(function walk(node) {
         // Don't descend into statements that were removed already.
-        if (removedStatements && ts__default["default"].isStatement(node) && removedStatements.has(node)) {
+        if (ts__default["default"].isStatement(node) && removedStatements.has(node)) {
             return;
         }
         if (!ts__default["default"].isIdentifier(node) || !topLevelParameterNames.has(node.text)) {
@@ -286,7 +289,8 @@ function findSuperCall(root) {
  * @param localTypeChecker Type checker scoped to the current file.
  */
 function findUninitializedPropertiesToCombine(node, constructor, localTypeChecker) {
-    let result = null;
+    let toCombine = null;
+    let toHoist = [];
     const membersToDeclarations = new Map();
     for (const member of node.members) {
         if (ts__default["default"].isPropertyDeclaration(member) &&
@@ -296,20 +300,110 @@ function findUninitializedPropertiesToCombine(node, constructor, localTypeChecke
         }
     }
     if (membersToDeclarations.size === 0) {
-        return result;
+        return null;
     }
     const memberInitializers = getMemberInitializers(constructor);
     if (memberInitializers === null) {
-        return result;
+        return null;
     }
-    for (const [name, initializer] of memberInitializers.entries()) {
-        if (membersToDeclarations.has(name) &&
-            !hasLocalReferences(initializer, constructor, localTypeChecker)) {
-            result = result || new Map();
-            result.set(membersToDeclarations.get(name), initializer);
+    for (const [name, decl] of membersToDeclarations.entries()) {
+        if (memberInitializers.has(name)) {
+            const initializer = memberInitializers.get(name);
+            if (!hasLocalReferences(initializer, constructor, localTypeChecker)) {
+                toCombine ??= [];
+                toCombine.push({ declaration: membersToDeclarations.get(name), initializer });
+            }
+        }
+        else {
+            // Mark members that have no initializers and can't be combined to be hoisted above the
+            // injected members. This is either a no-op or it allows us to avoid some patterns internally
+            // like the following:
+            // ```
+            // class Foo {
+            //   publicFoo: Foo;
+            //   private privateFoo: Foo;
+            //
+            //   constructor() {
+            //     this.initializePrivateFooSomehow();
+            //     this.publicFoo = this.privateFoo;
+            //   }
+            // }
+            // ```
+            toHoist.push(decl);
         }
     }
-    return result;
+    // If no members need to be combined, none need to be hoisted either.
+    return toCombine === null ? null : { toCombine, toHoist };
+}
+/**
+ * In some cases properties may be declared out of order, but initialized in the correct order.
+ * The internal-specific migration will combine such properties which will result in a compilation
+ * error, for example:
+ *
+ * ```
+ * class MyClass {
+ *   foo: Foo;
+ *   bar: Bar;
+ *
+ *   constructor(bar: Bar) {
+ *     this.bar = bar;
+ *     this.foo = this.bar.getFoo();
+ *   }
+ * }
+ * ```
+ *
+ * Will become:
+ *
+ * ```
+ * class MyClass {
+ *   foo: Foo = this.bar.getFoo();
+ *   bar: Bar = inject(Bar);
+ * }
+ * ```
+ *
+ * This function determines if cases like this can be saved by reordering the properties so their
+ * declaration order matches the order in which they're initialized.
+ *
+ * @param toCombine Properties that are candidates to be combined.
+ * @param constructor
+ */
+function shouldCombineInInitializationOrder(toCombine, constructor) {
+    let combinedMemberReferenceCount = 0;
+    let otherMemberReferenceCount = 0;
+    const injectedMemberNames = new Set();
+    const combinedMemberNames = new Set();
+    // Collect the name of constructor parameters that declare new properties.
+    // These can be ignored since they'll be hoisted above other properties.
+    constructor.parameters.forEach((param) => {
+        if (parameterDeclaresProperty(param) && ts__default["default"].isIdentifier(param.name)) {
+            injectedMemberNames.add(param.name.text);
+        }
+    });
+    // Collect the names of the properties being combined. We should only reorder
+    // the properties if at least one of them refers to another one.
+    toCombine.forEach(({ declaration: { name } }) => {
+        if (ts__default["default"].isStringLiteralLike(name) || ts__default["default"].isIdentifier(name)) {
+            combinedMemberNames.add(name.text);
+        }
+    });
+    // Visit all the initializers and check all the property reads in the form of `this.<name>`.
+    // Skip over the ones referring to injected parameters since they're going to be hoisted.
+    const walkInitializer = (node) => {
+        if (ts__default["default"].isPropertyAccessExpression(node) && node.expression.kind === ts__default["default"].SyntaxKind.ThisKeyword) {
+            if (combinedMemberNames.has(node.name.text)) {
+                combinedMemberReferenceCount++;
+            }
+            else if (!injectedMemberNames.has(node.name.text)) {
+                otherMemberReferenceCount++;
+            }
+        }
+        node.forEachChild(walkInitializer);
+    };
+    toCombine.forEach((candidate) => walkInitializer(candidate.initializer));
+    // If at the end there is at least one reference between a combined member and another,
+    // and there are no references to any other class members, we can safely reorder the
+    // properties based on how they were initialized.
+    return combinedMemberReferenceCount > 0 && otherMemberReferenceCount === 0;
 }
 /**
  * Finds the expressions from the constructor that initialize class members, for example:
@@ -366,7 +460,7 @@ function getMemberInitializers(constructor) {
 function hasLocalReferences(root, constructor, localTypeChecker) {
     const sourceFile = root.getSourceFile();
     let hasLocalRefs = false;
-    root.forEachChild(function walk(node) {
+    const walk = (node) => {
         // Stop searching if we know that it has local references.
         if (hasLocalRefs) {
             return;
@@ -396,7 +490,8 @@ function hasLocalReferences(root, constructor, localTypeChecker) {
         if (!hasLocalRefs) {
             node.forEachChild(walk);
         }
-    });
+    };
+    walk(root);
     return hasLocalRefs;
 }
 /**
@@ -437,28 +532,22 @@ function migrateFile(sourceFile, options) {
     // 2. All the necessary information for this migration is local so using a file-specific type
     //    checker should speed up the lookups.
     const localTypeChecker = getLocalTypeChecker(sourceFile);
-    const analysis = analyzeFile(sourceFile, localTypeChecker);
+    const analysis = analyzeFile(sourceFile, localTypeChecker, options);
     if (analysis === null || analysis.classes.length === 0) {
         return [];
     }
     const printer = ts__default["default"].createPrinter();
     const tracker = new compiler_host.ChangeTracker(printer);
     analysis.classes.forEach(({ node, constructor, superCall }) => {
-        let removedStatements = null;
+        const memberIndentation = leading_space.getLeadingLineWhitespaceOfNode(node.members[0]);
+        const prependToClass = [];
+        const afterInjectCalls = [];
+        const removedStatements = new Set();
+        const removedMembers = new Set();
         if (options._internalCombineMemberInitializers) {
-            findUninitializedPropertiesToCombine(node, constructor, localTypeChecker)?.forEach((initializer, property) => {
-                const statement = nodes.closestNode(initializer, ts__default["default"].isStatement);
-                if (!statement) {
-                    return;
-                }
-                const newProperty = ts__default["default"].factory.createPropertyDeclaration(cloneModifiers(property.modifiers), cloneName(property.name), property.questionToken, property.type, initializer);
-                tracker.replaceText(statement.getSourceFile(), statement.getFullStart(), statement.getFullWidth(), '');
-                tracker.replaceNode(property, newProperty);
-                removedStatements = removedStatements || new Set();
-                removedStatements.add(statement);
-            });
+            applyInternalOnlyChanges(node, constructor, localTypeChecker, tracker, printer, removedStatements, removedMembers, prependToClass, afterInjectCalls, memberIndentation);
         }
-        migrateClass(node, constructor, superCall, options, removedStatements, localTypeChecker, printer, tracker);
+        migrateClass(node, constructor, superCall, options, memberIndentation, prependToClass, afterInjectCalls, removedStatements, removedMembers, localTypeChecker, printer, tracker);
     });
     DI_PARAM_SYMBOLS.forEach((name) => {
         // Both zero and undefined are fine here.
@@ -474,61 +563,60 @@ function migrateFile(sourceFile, options) {
  * @param constructor Reference to the class' constructor node.
  * @param superCall Reference to the constructor's `super()` call, if any.
  * @param options Options used to configure the migration.
+ * @param memberIndentation Indentation string of the members of the class.
+ * @param prependToClass Text that should be prepended to the class.
+ * @param afterInjectCalls Text that will be inserted after the newly-added `inject` calls.
  * @param removedStatements Statements that have been removed from the constructor already.
+ * @param removedMembers Class members that have been removed by the migration.
  * @param localTypeChecker Type checker set up for the specific file.
  * @param printer Printer used to output AST nodes as strings.
  * @param tracker Object keeping track of the changes made to the file.
  */
-function migrateClass(node, constructor, superCall, options, removedStatements, localTypeChecker, printer, tracker) {
-    const isAbstract = !!node.modifiers?.some((m) => m.kind === ts__default["default"].SyntaxKind.AbstractKeyword);
-    // Don't migrate abstract classes by default, because
-    // their parameters aren't guaranteed to be injectable.
-    if (isAbstract && !options.migrateAbstractClasses) {
-        return;
-    }
+function migrateClass(node, constructor, superCall, options, memberIndentation, prependToClass, afterInjectCalls, removedStatements, removedMembers, localTypeChecker, printer, tracker) {
     const sourceFile = node.getSourceFile();
     const unusedParameters = getConstructorUnusedParameters(constructor, localTypeChecker, removedStatements);
     const superParameters = superCall
         ? getSuperParameters(constructor, superCall, localTypeChecker)
         : null;
-    const memberIndentation = leading_space.getLeadingLineWhitespaceOfNode(node.members[0]);
-    const removedStatementCount = removedStatements?.size || 0;
-    const innerReference = superCall ||
-        constructor.body?.statements.find((statement) => !removedStatements?.has(statement)) ||
-        constructor;
+    const removedStatementCount = removedStatements.size;
+    const firstConstructorStatement = constructor.body?.statements.find((statement) => !removedStatements.has(statement));
+    const innerReference = superCall || firstConstructorStatement || constructor;
     const innerIndentation = leading_space.getLeadingLineWhitespaceOfNode(innerReference);
-    const propsToAdd = [];
     const prependToConstructor = [];
     const afterSuper = [];
-    const removedMembers = new Set();
     for (const param of constructor.parameters) {
         const usedInSuper = superParameters !== null && superParameters.has(param);
         const usedInConstructor = !unusedParameters.has(param);
-        migrateParameter(param, options, localTypeChecker, printer, tracker, superCall, usedInSuper, usedInConstructor, memberIndentation, innerIndentation, prependToConstructor, propsToAdd, afterSuper);
+        migrateParameter(param, options, localTypeChecker, printer, tracker, superCall, usedInSuper, usedInConstructor, memberIndentation, innerIndentation, prependToConstructor, prependToClass, afterSuper);
     }
     // Delete all of the constructor overloads since below we're either going to
     // remove the implementation, or we're going to delete all of the parameters.
     for (const member of node.members) {
         if (ts__default["default"].isConstructorDeclaration(member) && member !== constructor) {
             removedMembers.add(member);
-            tracker.replaceText(sourceFile, member.getFullStart(), member.getFullWidth(), '');
+            tracker.removeNode(member, true);
         }
     }
     if (canRemoveConstructor(options, constructor, removedStatementCount, superCall)) {
         // Drop the constructor if it was empty.
         removedMembers.add(constructor);
-        tracker.replaceText(sourceFile, constructor.getFullStart(), constructor.getFullWidth(), '');
+        tracker.removeNode(constructor, true);
     }
     else {
         // If the constructor contains any statements, only remove the parameters.
         // We always do this no matter what is passed into `backwardsCompatibleConstructors`.
         stripConstructorParameters(constructor, tracker);
         if (prependToConstructor.length > 0) {
-            tracker.insertText(sourceFile, innerReference.getFullStart(), `\n${prependToConstructor.join('\n')}\n`);
+            tracker.insertText(sourceFile, (firstConstructorStatement || innerReference).getFullStart(), `\n${prependToConstructor.join('\n')}\n`);
         }
     }
     if (afterSuper.length > 0 && superCall !== null) {
-        tracker.insertText(sourceFile, superCall.getEnd() + 1, `\n${afterSuper.join('\n')}\n`);
+        // Note that if we can, we should insert before the next statement after the `super` call,
+        // rather than after the end of it. Otherwise the string buffering implementation may drop
+        // the text if the statement after the `super` call is being deleted. This appears to be because
+        // the full start of the next statement appears to always be the end of the `super` call plus 1.
+        const nextStatement = getNextPreservedStatement(superCall, removedStatements);
+        tracker.insertText(sourceFile, nextStatement ? nextStatement.getFullStart() : superCall.getEnd() + 1, `\n${afterSuper.join('\n')}\n`);
     }
     // Need to resolve this once all constructor signatures have been removed.
     const memberReference = node.members.find((m) => !removedMembers.has(m)) || node.members[0];
@@ -539,19 +627,22 @@ function migrateClass(node, constructor, superCall, options, removedStatements,
             `${memberIndentation}constructor(...args: unknown[]);`;
         // The new signature always has to be right before the constructor implementation.
         if (memberReference === constructor) {
-            propsToAdd.push(extraSignature);
+            prependToClass.push(extraSignature);
         }
         else {
             tracker.insertText(sourceFile, constructor.getFullStart(), '\n' + extraSignature);
         }
     }
-    if (propsToAdd.length > 0) {
+    // Push the block of code that should appear after the `inject`
+    // calls now once all the members have been generated.
+    prependToClass.push(...afterInjectCalls);
+    if (prependToClass.length > 0) {
         if (removedMembers.size === node.members.length) {
-            tracker.insertText(sourceFile, constructor.getEnd() + 1, `${propsToAdd.join('\n')}\n`);
+            tracker.insertText(sourceFile, constructor.getEnd() + 1, `${prependToClass.join('\n')}\n`);
         }
         else {
             // Insert the new properties after the first member that hasn't been deleted.
-            tracker.insertText(sourceFile, memberReference.getFullStart(), `\n${propsToAdd.join('\n')}\n`);
+            tracker.insertText(sourceFile, memberReference.getFullStart(), `\n${prependToClass.join('\n')}\n`);
         }
     }
 }
@@ -877,6 +968,83 @@ function canRemoveConstructor(options, constructor, removedStatementCount, super
     return (statementCount === 0 ||
         (statementCount === 1 && superCall !== null && superCall.arguments.length === 0));
 }
+/**
+ * Gets the next statement after a node that *won't* be deleted by the migration.
+ * @param startNode Node from which to start the search.
+ * @param removedStatements Statements that have been removed by the migration.
+ * @returns
+ */
+function getNextPreservedStatement(startNode, removedStatements) {
+    const body = nodes.closestNode(startNode, ts__default["default"].isBlock);
+    const closestStatement = nodes.closestNode(startNode, ts__default["default"].isStatement);
+    if (body === null || closestStatement === null) {
+        return null;
+    }
+    const index = body.statements.indexOf(closestStatement);
+    if (index === -1) {
+        return null;
+    }
+    for (let i = index + 1; i < body.statements.length; i++) {
+        if (!removedStatements.has(body.statements[i])) {
+            return body.statements[i];
+        }
+    }
+    return null;
+}
+/**
+ * Applies the internal-specific migrations to a class.
+ * @param node Class being migrated.
+ * @param constructor The migrated class' constructor.
+ * @param localTypeChecker File-specific type checker.
+ * @param tracker Object keeping track of the changes.
+ * @param printer Printer used to output AST nodes as text.
+ * @param removedStatements Statements that have been removed by the migration.
+ * @param removedMembers Class members that have been removed by the migration.
+ * @param prependToClass Text that will be prepended to a class.
+ * @param afterInjectCalls Text that will be inserted after the newly-added `inject` calls.
+ * @param memberIndentation Indentation string of the class' members.
+ */
+function applyInternalOnlyChanges(node, constructor, localTypeChecker, tracker, printer, removedStatements, removedMembers, prependToClass, afterInjectCalls, memberIndentation) {
+    const result = findUninitializedPropertiesToCombine(node, constructor, localTypeChecker);
+    if (result === null) {
+        return;
+    }
+    const preserveInitOrder = shouldCombineInInitializationOrder(result.toCombine, constructor);
+    // Sort the combined members based on the declaration order of their initializers, only if
+    // we've determined that would be safe. Note that `Array.prototype.sort` is in-place so we
+    // can just call it conditionally here.
+    if (preserveInitOrder) {
+        result.toCombine.sort((a, b) => a.initializer.getStart() - b.initializer.getStart());
+    }
+    result.toCombine.forEach(({ declaration, initializer }) => {
+        const initializerStatement = nodes.closestNode(initializer, ts__default["default"].isStatement);
+        const newProperty = ts__default["default"].factory.createPropertyDeclaration(cloneModifiers(declaration.modifiers), cloneName(declaration.name), declaration.questionToken, declaration.type, initializer);
+        // If the initialization order is being preserved, we have to remove the original
+        // declaration and re-declare it. Otherwise we can do the replacement in-place.
+        if (preserveInitOrder) {
+            tracker.removeNode(declaration, true);
+            removedMembers.add(declaration);
+            afterInjectCalls.push(memberIndentation +
+                printer.printNode(ts__default["default"].EmitHint.Unspecified, newProperty, declaration.getSourceFile()));
+        }
+        else {
+            tracker.replaceNode(declaration, newProperty);
+        }
+        // This should always be defined, but null check it just in case.
+        if (initializerStatement) {
+            tracker.removeNode(initializerStatement, true);
+            removedStatements.add(initializerStatement);
+        }
+    });
+    result.toHoist.forEach((decl) => {
+        prependToClass.push(memberIndentation + printer.printNode(ts__default["default"].EmitHint.Unspecified, decl, decl.getSourceFile()));
+        tracker.removeNode(decl, true);
+    });
+    // If we added any hoisted properties, separate them visually with a new line.
+    if (prependToClass.length > 0) {
+        prependToClass.push('');
+    }
+}
 
 function migrate(options) {
     return async (tree) => {

package/schematics/bundles/leading_space-d190b83b.js

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