@angular/core 19.0.0-next.5 → 19.0.0-next.7

package/schematics/bundles/compiler_host-1e62b899.js

@@ -0,0 +1,320 @@
+'use strict';
+/**
+ * @license Angular v19.0.0-next.7
+ * (c) 2010-2024 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+var ts = require('typescript');
+var checker = require('./checker-637eee78.js');
+require('os');
+var p = require('path');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+var p__namespace = /*#__PURE__*/_interopNamespace(p);
+
+/** Tracks changes that have to be made for specific files. */
+class ChangeTracker {
+    _printer;
+    _importRemapper;
+    _changes = new Map();
+    _importManager;
+    _quotesCache = new WeakMap();
+    constructor(_printer, _importRemapper) {
+        this._printer = _printer;
+        this._importRemapper = _importRemapper;
+        this._importManager = new checker.ImportManager({
+            shouldUseSingleQuotes: (file) => this._getQuoteKind(file) === 0 /* QuoteKind.SINGLE */,
+        });
+    }
+    /**
+     * Tracks the insertion of some text.
+     * @param sourceFile File in which the text is being inserted.
+     * @param start Index at which the text is insert.
+     * @param text Text to be inserted.
+     */
+    insertText(sourceFile, index, text) {
+        this._trackChange(sourceFile, { start: index, text });
+    }
+    /**
+     * Replaces text within a file.
+     * @param sourceFile File in which to replace the text.
+     * @param start Index from which to replace the text.
+     * @param removeLength Length of the text being replaced.
+     * @param text Text to be inserted instead of the old one.
+     */
+    replaceText(sourceFile, start, removeLength, text) {
+        this._trackChange(sourceFile, { start, removeLength, text });
+    }
+    /**
+     * Replaces the text of an AST node with a new one.
+     * @param oldNode Node to be replaced.
+     * @param newNode New node to be inserted.
+     * @param emitHint Hint when formatting the text of the new node.
+     * @param sourceFileWhenPrinting File to use when printing out the new node. This is important
+     * when copying nodes from one file to another, because TypeScript might not output literal nodes
+     * without it.
+     */
+    replaceNode(oldNode, newNode, emitHint = ts__default["default"].EmitHint.Unspecified, sourceFileWhenPrinting) {
+        const sourceFile = oldNode.getSourceFile();
+        this.replaceText(sourceFile, oldNode.getStart(), oldNode.getWidth(), this._printer.printNode(emitHint, newNode, sourceFileWhenPrinting || sourceFile));
+    }
+    /**
+     * Removes the text of an AST node from a file.
+     * @param node Node whose text should be removed.
+     */
+    removeNode(node) {
+        this._trackChange(node.getSourceFile(), {
+            start: node.getStart(),
+            removeLength: node.getWidth(),
+            text: '',
+        });
+    }
+    /**
+     * Adds an import to a file.
+     * @param sourceFile File to which to add the import.
+     * @param symbolName Symbol being imported.
+     * @param moduleName Module from which the symbol is imported.
+     * @param alias Alias to use for the import.
+     */
+    addImport(sourceFile, symbolName, moduleName, alias) {
+        if (this._importRemapper) {
+            moduleName = this._importRemapper(moduleName, sourceFile.fileName);
+        }
+        // It's common for paths to be manipulated with Node's `path` utilties which
+        // can yield a path with back slashes. Normalize them since outputting such
+        // paths will also cause TS to escape the forward slashes.
+        moduleName = normalizePath(moduleName);
+        if (!this._changes.has(sourceFile)) {
+            this._changes.set(sourceFile, []);
+        }
+        return this._importManager.addImport({
+            requestedFile: sourceFile,
+            exportSymbolName: symbolName,
+            exportModuleSpecifier: moduleName,
+            unsafeAliasOverride: alias,
+        });
+    }
+    /**
+     * Removes an import from a file.
+     * @param sourceFile File from which to remove the import.
+     * @param symbolName Original name of the symbol to be removed. Used even if the import is aliased.
+     * @param moduleName Module from which the symbol is imported.
+     */
+    removeImport(sourceFile, symbolName, moduleName) {
+        // It's common for paths to be manipulated with Node's `path` utilties which
+        // can yield a path with back slashes. Normalize them since outputting such
+        // paths will also cause TS to escape the forward slashes.
+        moduleName = normalizePath(moduleName);
+        if (!this._changes.has(sourceFile)) {
+            this._changes.set(sourceFile, []);
+        }
+        this._importManager.removeImport(sourceFile, symbolName, moduleName);
+    }
+    /**
+     * Gets the changes that should be applied to all the files in the migration.
+     * The changes are sorted in the order in which they should be applied.
+     */
+    recordChanges() {
+        this._recordImports();
+        return this._changes;
+    }
+    /**
+     * Clear the tracked changes
+     */
+    clearChanges() {
+        this._changes.clear();
+    }
+    /**
+     * Adds a change to a `ChangesByFile` map.
+     * @param file File that the change is associated with.
+     * @param change Change to be added.
+     */
+    _trackChange(file, change) {
+        const changes = this._changes.get(file);
+        if (changes) {
+            // Insert the changes in reverse so that they're applied in reverse order.
+            // This ensures that the offsets of subsequent changes aren't affected by
+            // previous changes changing the file's text.
+            const insertIndex = changes.findIndex((current) => current.start <= change.start);
+            if (insertIndex === -1) {
+                changes.push(change);
+            }
+            else {
+                changes.splice(insertIndex, 0, change);
+            }
+        }
+        else {
+            this._changes.set(file, [change]);
+        }
+    }
+    /** Determines what kind of quotes to use for a specific file. */
+    _getQuoteKind(sourceFile) {
+        if (this._quotesCache.has(sourceFile)) {
+            return this._quotesCache.get(sourceFile);
+        }
+        let kind = 0 /* QuoteKind.SINGLE */;
+        for (const statement of sourceFile.statements) {
+            if (ts__default["default"].isImportDeclaration(statement) && ts__default["default"].isStringLiteral(statement.moduleSpecifier)) {
+                kind = statement.moduleSpecifier.getText()[0] === '"' ? 1 /* QuoteKind.DOUBLE */ : 0 /* QuoteKind.SINGLE */;
+                this._quotesCache.set(sourceFile, kind);
+                break;
+            }
+        }
+        return kind;
+    }
+    /** Records the pending import changes from the import manager. */
+    _recordImports() {
+        const { newImports, updatedImports, deletedImports } = this._importManager.finalize();
+        for (const [original, replacement] of updatedImports) {
+            this.replaceNode(original, replacement);
+        }
+        for (const node of deletedImports) {
+            this.removeNode(node);
+        }
+        for (const [sourceFile] of this._changes) {
+            const importsToAdd = newImports.get(sourceFile.fileName);
+            if (!importsToAdd) {
+                continue;
+            }
+            const importLines = [];
+            let lastImport = null;
+            for (const statement of sourceFile.statements) {
+                if (ts__default["default"].isImportDeclaration(statement)) {
+                    lastImport = statement;
+                }
+            }
+            for (const decl of importsToAdd) {
+                importLines.push(this._printer.printNode(ts__default["default"].EmitHint.Unspecified, decl, sourceFile));
+            }
+            this.insertText(sourceFile, lastImport ? lastImport.getEnd() : 0, (lastImport ? '\n' : '') + importLines.join('\n'));
+        }
+    }
+}
+/** Normalizes a path to use posix separators. */
+function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
+
+function parseTsconfigFile(tsconfigPath, basePath) {
+    const { config } = ts__default["default"].readConfigFile(tsconfigPath, ts__default["default"].sys.readFile);
+    const parseConfigHost = {
+        useCaseSensitiveFileNames: ts__default["default"].sys.useCaseSensitiveFileNames,
+        fileExists: ts__default["default"].sys.fileExists,
+        readDirectory: ts__default["default"].sys.readDirectory,
+        readFile: ts__default["default"].sys.readFile,
+    };
+    // Throw if incorrect arguments are passed to this function. Passing relative base paths
+    // results in root directories not being resolved and in later type checking runtime errors.
+    // More details can be found here: https://github.com/microsoft/TypeScript/issues/37731.
+    if (!p__namespace.isAbsolute(basePath)) {
+        throw Error('Unexpected relative base path has been specified.');
+    }
+    return ts__default["default"].parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
+}
+
+/**
+ * Creates a TypeScript program instance for a TypeScript project within
+ * the virtual file system tree.
+ * @param tree Virtual file system tree that contains the source files.
+ * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
+ * @param basePath Base path for the virtual file system tree.
+ * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
+ *   the TypeScript program, or to add in-memory files (e.g. to add global types).
+ * @param additionalFiles Additional file paths that should be added to the program.
+ */
+function createMigrationProgram(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles) {
+    const { rootNames, options, host } = createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles);
+    return ts__default["default"].createProgram(rootNames, options, host);
+}
+/**
+ * Creates the options necessary to instantiate a TypeScript program.
+ * @param tree Virtual file system tree that contains the source files.
+ * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
+ * @param basePath Base path for the virtual file system tree.
+ * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
+ *   the TypeScript program, or to add in-memory files (e.g. to add global types).
+ * @param additionalFiles Additional file paths that should be added to the program.
+ * @param optionOverrides Overrides of the parsed compiler options.
+ */
+function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles, optionOverrides) {
+    // Resolve the tsconfig path to an absolute path. This is needed as TypeScript otherwise
+    // is not able to resolve root directories in the given tsconfig. More details can be found
+    // in the following issue: https://github.com/microsoft/TypeScript/issues/37731.
+    tsconfigPath = p.resolve(basePath, tsconfigPath);
+    const parsed = parseTsconfigFile(tsconfigPath, p.dirname(tsconfigPath));
+    const options = optionOverrides ? { ...parsed.options, ...optionOverrides } : parsed.options;
+    const host = createMigrationCompilerHost(tree, options, basePath, fakeFileRead);
+    return { rootNames: parsed.fileNames.concat(additionalFiles || []), options, host };
+}
+function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
+    const host = ts__default["default"].createCompilerHost(options, true);
+    const defaultReadFile = host.readFile;
+    // We need to overwrite the host "readFile" method, as we want the TypeScript
+    // program to be based on the file contents in the virtual file tree. Otherwise
+    // if we run multiple migrations we might have intersecting changes and
+    // source files.
+    host.readFile = (fileName) => {
+        const treeRelativePath = p.relative(basePath, fileName);
+        let result = fakeRead?.(treeRelativePath);
+        if (typeof result !== 'string') {
+            // If the relative path resolved to somewhere outside of the tree, fall back to
+            // TypeScript's default file reading function since the `tree` will throw an error.
+            result = treeRelativePath.startsWith('..')
+                ? defaultReadFile.call(host, fileName)
+                : tree.read(treeRelativePath)?.toString();
+        }
+        // Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset,
+        // which breaks the CLI UpdateRecorder.
+        // See: https://github.com/angular/angular/pull/30719
+        return typeof result === 'string' ? result.replace(/^\uFEFF/, '') : undefined;
+    };
+    return host;
+}
+/**
+ * Checks whether a file can be migrate by our automated migrations.
+ * @param basePath Absolute path to the project.
+ * @param sourceFile File being checked.
+ * @param program Program that includes the source file.
+ */
+function canMigrateFile(basePath, sourceFile, program) {
+    // We shouldn't migrate .d.ts files, files from an external library or type checking files.
+    if (sourceFile.fileName.endsWith('.ngtypecheck.ts') ||
+        sourceFile.isDeclarationFile ||
+        program.isSourceFileFromExternalLibrary(sourceFile)) {
+        return false;
+    }
+    // Our migrations are set up to create a `Program` from the project's tsconfig and to migrate all
+    // the files within the program. This can include files that are outside of the Angular CLI
+    // project. We can't migrate files outside of the project, because our file system interactions
+    // go through the CLI's `Tree` which assumes that all files are within the project. See:
+    // https://github.com/angular/angular-cli/blob/0b0961c9c233a825b6e4bb59ab7f0790f9b14676/packages/angular_devkit/schematics/src/tree/host-tree.ts#L131
+    return !p.relative(basePath, sourceFile.fileName).startsWith('..');
+}
+
+exports.ChangeTracker = ChangeTracker;
+exports.canMigrateFile = canMigrateFile;
+exports.createMigrationProgram = createMigrationProgram;
+exports.createProgramOptions = createProgramOptions;
+exports.normalizePath = normalizePath;

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

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.5
+ * @license Angular v19.0.0-next.7
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10,7 +10,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var schematics = require('@angular-devkit/schematics');
 var p = require('path');
-var compiler_host = require('./compiler_host-ca7ba733.js');
+var compiler_host = require('./compiler_host-1e62b899.js');
+var checker = require('./checker-637eee78.js');
 var ts = require('typescript');
 require('os');
 require('fs');
@@ -278,7 +279,7 @@ class AnalyzedFile {
     }
 }
 /** Finds all non-control flow elements from common module. */
-class CommonCollector extends compiler_host.RecursiveVisitor {
+class CommonCollector extends checker.RecursiveVisitor {
     count = 0;
     visitElement(el) {
         if (el.attrs.length > 0) {
@@ -310,7 +311,7 @@ class CommonCollector extends compiler_host.RecursiveVisitor {
     }
 }
 /** Finds all elements that represent i18n blocks. */
-class i18nCollector extends compiler_host.RecursiveVisitor {
+class i18nCollector extends checker.RecursiveVisitor {
     elements = [];
     visitElement(el) {
         if (el.attrs.find((a) => a.name === 'i18n') !== undefined) {
@@ -320,7 +321,7 @@ class i18nCollector extends compiler_host.RecursiveVisitor {
     }
 }
 /** Finds all elements with ngif structural directives. */
-class ElementCollector extends compiler_host.RecursiveVisitor {
+class ElementCollector extends checker.RecursiveVisitor {
     _attributes;
     elements = [];
     constructor(_attributes = []) {
@@ -373,7 +374,7 @@ class ElementCollector extends compiler_host.RecursiveVisitor {
     }
 }
 /** Finds all elements with ngif structural directives. */
-class TemplateCollector extends compiler_host.RecursiveVisitor {
+class TemplateCollector extends checker.RecursiveVisitor {
     elements = [];
     templates = new Map();
     visitElement(el) {
@@ -587,7 +588,7 @@ function parseTemplate(template) {
         // interpolated text as text nodes containing a mixture of interpolation tokens and text tokens,
         // rather than turning them into `BoundText` nodes like the Ivy AST does. This allows us to
         // easily get the text-only ranges without having to reconstruct the original text.
-        parsed = new compiler_host.HtmlParser().parse(template, '', {
+        parsed = new checker.HtmlParser().parse(template, '', {
             // Allows for ICUs to be parsed.
             tokenizeExpansionForms: true,
             // Explicitly disable blocks so that their characters are treated as plain text.
@@ -625,7 +626,7 @@ function validateMigratedTemplate(migrated, fileName) {
 }
 function validateI18nStructure(parsed, fileName) {
     const visitor = new i18nCollector();
-    compiler_host.visitAll(visitor, parsed.rootNodes);
+    checker.visitAll(visitor, parsed.rootNodes);
     const parents = visitor.elements.filter((el) => el.children.length > 0);
     for (const p of parents) {
         for (const el of visitor.elements) {
@@ -708,7 +709,7 @@ function getTemplates(template) {
     const parsed = parseTemplate(template);
     if (parsed.tree !== undefined) {
         const visitor = new TemplateCollector();
-        compiler_host.visitAll(visitor, parsed.tree.rootNodes);
+        checker.visitAll(visitor, parsed.tree.rootNodes);
         // count usages of each ng-template
         for (let [key, tmpl] of visitor.templates) {
             const escapeKey = escapeRegExp(key.slice(1));
@@ -811,7 +812,7 @@ function canRemoveCommonModule(template) {
     let removeCommonModule = false;
     if (parsed.tree !== undefined) {
         const visitor = new CommonCollector();
-        compiler_host.visitAll(visitor, parsed.tree.rootNodes);
+        checker.visitAll(visitor, parsed.tree.rootNodes);
         removeCommonModule = visitor.count === 0;
     }
     return removeCommonModule;
@@ -934,7 +935,7 @@ function generateI18nMarkers(tmpl) {
     let parsed = parseTemplate(tmpl);
     if (parsed.tree !== undefined) {
         const visitor = new i18nCollector();
-        compiler_host.visitAll(visitor, parsed.tree.rootNodes);
+        checker.visitAll(visitor, parsed.tree.rootNodes);
         for (const [ix, el] of visitor.elements.entries()) {
             // we only care about elements with children and i18n tags
             // elements without children have nothing to translate
@@ -1136,7 +1137,7 @@ function migrateCase(template) {
     }
     let result = template;
     const visitor = new ElementCollector(cases);
-    compiler_host.visitAll(visitor, parsed.tree.rootNodes);
+    checker.visitAll(visitor, parsed.tree.rootNodes);
     calculateNesting(visitor, hasLineBreaks(template));
     // this tracks the character shift from different lengths of blocks from
     // the prior directives so as to adjust for nested block replacement during
@@ -1233,7 +1234,7 @@ function migrateFor(template) {
     }
     let result = template;
     const visitor = new ElementCollector(fors);
-    compiler_host.visitAll(visitor, parsed.tree.rootNodes);
+    checker.visitAll(visitor, parsed.tree.rootNodes);
     calculateNesting(visitor, hasLineBreaks(template));
     // this tracks the character shift from different lengths of blocks from
     // the prior directives so as to adjust for nested block replacement during
@@ -1438,7 +1439,7 @@ function migrateIf(template) {
     }
     let result = template;
     const visitor = new ElementCollector(ifs);
-    compiler_host.visitAll(visitor, parsed.tree.rootNodes);
+    checker.visitAll(visitor, parsed.tree.rootNodes);
     calculateNesting(visitor, hasLineBreaks(template));
     // this tracks the character shift from different lengths of blocks from
     // the prior directives so as to adjust for nested block replacement during
@@ -1631,7 +1632,7 @@ function migrateSwitch(template) {
     }
     let result = template;
     const visitor = new ElementCollector(switches);
-    compiler_host.visitAll(visitor, parsed.tree.rootNodes);
+    checker.visitAll(visitor, parsed.tree.rootNodes);
     calculateNesting(visitor, hasLineBreaks(template));
     // this tracks the character shift from different lengths of blocks from
     // the prior directives so as to adjust for nested block replacement during
@@ -1662,11 +1663,11 @@ function migrateSwitch(template) {
 }
 function assertValidSwitchStructure(children) {
     for (const child of children) {
-        if (child instanceof compiler_host.Text && child.value.trim() !== '') {
+        if (child instanceof checker.Text && child.value.trim() !== '') {
             throw new Error(`Text node: "${child.value}" would result in invalid migrated @switch block structure. ` +
                 `@switch can only have @case or @default as children.`);
         }
-        else if (child instanceof compiler_host.Element) {
+        else if (child instanceof checker.Element) {
             let hasCase = false;
             for (const attr of child.attrs) {
                 if (cases.includes(attr.name)) {

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

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.5
+ * @license Angular v19.0.0-next.7
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10,11 +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-e9ccccbf.js');
-var compiler_host = require('./compiler_host-ca7ba733.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
+var compiler_host = require('./compiler_host-1e62b899.js');
 var ts = require('typescript');
-var imports = require('./imports-4ac08251.js');
+var imports = require('./imports-44987700.js');
 require('@angular-devkit/core');
+require('./checker-637eee78.js');
 require('os');
 require('fs');
 require('module');
@@ -70,11 +71,11 @@ function migrateFile(sourceFile, rewriteFn) {
                     // It's not a decorator to migrate
                     return;
             }
-            const [firstArg] = callExpression.arguments;
-            if (!firstArg || !ts__default["default"].isObjectLiteralExpression(firstArg)) {
+            const [decoratorArgument] = callExpression.arguments;
+            if (!decoratorArgument || !ts__default["default"].isObjectLiteralExpression(decoratorArgument)) {
                 return;
             }
-            const properties = firstArg.properties;
+            const properties = decoratorArgument.properties;
             const standaloneProp = getStandaloneProperty(properties);
             // Need to take care of 3 cases
             // - standalone: true  => remove the property
@@ -85,15 +86,13 @@ function migrateFile(sourceFile, rewriteFn) {
                 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) {
-                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.
                 const newPropsArr = ts__default["default"].factory.createNodeArray(newProperties);
                 const newFirstArg = ts__default["default"].factory.createObjectLiteralExpression(newPropsArr, true);
-                changeTracker.replaceNode(firstArg, newFirstArg);
+                changeTracker.replaceNode(decoratorArgument, newFirstArg);
             }
         });
     });
@@ -106,16 +105,24 @@ function migrateFile(sourceFile, rewriteFn) {
 }
 function getStandaloneProperty(properties) {
     for (const prop of properties) {
-        if (ts__default["default"].isPropertyAssignment(prop) &&
-            ts__default["default"].isIdentifier(prop.name) &&
-            prop.name.text === 'standalone' &&
-            (prop.initializer.kind === ts__default["default"].SyntaxKind.TrueKeyword ||
-                prop.initializer.kind === ts__default["default"].SyntaxKind.FalseKeyword)) {
-            return { property: prop, value: prop.initializer.kind };
+        if (ts__default["default"].isShorthandPropertyAssignment(prop) && prop.name.text) {
+            return { property: prop, value: prop.objectAssignmentInitializer };
+        }
+        if (isStandaloneProperty(prop)) {
+            if (prop.initializer.kind === ts__default["default"].SyntaxKind.TrueKeyword ||
+                prop.initializer.kind === ts__default["default"].SyntaxKind.FalseKeyword) {
+                return { property: prop, value: prop.initializer.kind };
+            }
+            else {
+                return { property: prop, value: prop.initializer };
+            }
         }
     }
     return undefined;
 }
+function isStandaloneProperty(prop) {
+    return (ts__default["default"].isPropertyAssignment(prop) && ts__default["default"].isIdentifier(prop.name) && prop.name.text === 'standalone');
+}
 
 function migrate() {
     return async (tree) => {
@@ -123,7 +130,7 @@ function migrate() {
         const basePath = process.cwd();
         const allPaths = [...buildPaths, ...testPaths];
         if (!allPaths.length) {
-            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run the standalone:false migration.');
+            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run the explicit-standalone-flag migration.');
         }
         for (const tsconfigPath of allPaths) {
             runMigration(tree, tsconfigPath, basePath);

package/schematics/bundles/{imports-4ac08251.js → imports-44987700.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.5
+ * @license Angular v19.0.0-next.7
  * (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.5
+ * @license Angular v19.0.0-next.7
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10,10 +10,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var schematics = require('@angular-devkit/schematics');
 var p = require('path');
-var compiler_host = require('./compiler_host-ca7ba733.js');
+var compiler_host = require('./compiler_host-1e62b899.js');
 var ts = require('typescript');
-var nodes = require('./nodes-0e7d45ca.js');
-var imports = require('./imports-4ac08251.js');
+var nodes = require('./nodes-b12e919a.js');
+var imports = require('./imports-44987700.js');
+var leading_space = require('./leading_space-6e7a8ec6.js');
+require('./checker-637eee78.js');
 require('os');
 require('fs');
 require('module');
@@ -28,7 +30,7 @@ var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /** Names of decorators that enable DI on a class declaration. */
 const DECORATORS_SUPPORTING_DI = new Set([
@@ -205,27 +207,6 @@ function getSuperParameters(declaration, superCall, localTypeChecker) {
     });
     return usedParams;
 }
-/**
- * Gets the indentation text of a node. Can be used to
- * output text with the same level of indentation.
- * @param node Node for which to get the indentation level.
- */
-function getNodeIndentation(node) {
-    const fullText = node.getFullText();
-    const end = fullText.indexOf(node.getText());
-    let result = '';
-    for (let i = end - 1; i > -1; i--) {
-        // Note: LF line endings are `\n` while CRLF are `\r\n`. This logic should cover both, because
-        // we start from the beginning of the node and go backwards so will always hit `\n` first.
-        if (fullText[i] !== '\n') {
-            result = fullText[i] + result;
-        }
-        else {
-            break;
-        }
-    }
-    return result;
-}
 /** Checks whether a parameter node declares a property on its class. */
 function parameterDeclaresProperty(node) {
     return !!node.modifiers?.some(({ kind }) => kind === ts__default["default"].SyntaxKind.PublicKeyword ||
@@ -283,7 +264,7 @@ function findSuperCall(root) {
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * Finds class property declarations without initializers whose constructor-based initialization
@@ -510,12 +491,12 @@ function migrateClass(node, constructor, superCall, options, removedStatements,
     const superParameters = superCall
         ? getSuperParameters(constructor, superCall, localTypeChecker)
         : null;
-    const memberIndentation = getNodeIndentation(node.members[0]);
+    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 innerIndentation = getNodeIndentation(innerReference);
+    const innerIndentation = leading_space.getLeadingLineWhitespaceOfNode(innerReference);
     const propsToAdd = [];
     const prependToConstructor = [];
     const afterSuper = [];