@angular/core 20.0.0-next.0 → 20.0.0-next.2

package/schematics/bundles/cleanup-unused-imports.js

@@ -1,36 +1,30 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var schematics = require('@angular-devkit/schematics');
-var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
-var project_paths = require('./project_paths-7d2daa1e.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-CDVxT6Ov.js');
+var project_paths = require('./project_paths-Jtbi76Bs.js');
 require('os');
 var ts = require('typescript');
-var checker = require('./checker-cf6f7980.js');
-var program = require('./program-362689f0.js');
+var checker = require('./checker-DF8ZaFW5.js');
+var program = require('./program-BZk27Ndu.js');
 require('path');
-require('./index-6675d6bc.js');
-var apply_import_manager = require('./apply_import_manager-0959b78c.js');
+require('./index-vGJcp5M7.js');
+var apply_import_manager = require('./apply_import_manager-CyRT0UvU.js');
 require('@angular-devkit/core');
 require('node:path/posix');
 require('fs');
 require('module');
 require('url');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-
 /** Migration that cleans up unused imports from a project. */
 class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
-    printer = ts__default["default"].createPrinter();
+    printer = ts.createPrinter();
     createProgram(tsconfigAbsPath, fs) {
         return super.createProgram(tsconfigAbsPath, fs, {
             extendedDiagnostics: {
@@ -133,7 +127,7 @@ class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
             allRemovedIdentifiers: new Set(),
         };
         const walk = (node) => {
-            if (!ts__default["default"].isIdentifier(node)) {
+            if (!ts.isIdentifier(node)) {
                 node.forEachChild(walk);
                 return;
             }
@@ -145,17 +139,17 @@ class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
             if (locations.has(this.getNodeID(node.getStart(), node.getWidth()))) {
                 // When the entire array needs to be cleared, the diagnostic is
                 // reported on the property assignment, rather than an array element.
-                if (ts__default["default"].isPropertyAssignment(parent) &&
+                if (ts.isPropertyAssignment(parent) &&
                     parent.name === node &&
-                    ts__default["default"].isArrayLiteralExpression(parent.initializer)) {
+                    ts.isArrayLiteralExpression(parent.initializer)) {
                     result.fullRemovals.add(parent.initializer);
                     parent.initializer.elements.forEach((element) => {
-                        if (ts__default["default"].isIdentifier(element)) {
+                        if (ts.isIdentifier(element)) {
                             result.allRemovedIdentifiers.add(element);
                         }
                     });
                 }
-                else if (ts__default["default"].isArrayLiteralExpression(parent)) {
+                else if (ts.isArrayLiteralExpression(parent)) {
                     if (!result.partialRemovals.has(parent)) {
                         result.partialRemovals.set(parent, new Set());
                     }
@@ -179,24 +173,24 @@ class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
             identifierCounts: new Map(),
         };
         const walk = (node) => {
-            if (ts__default["default"].isIdentifier(node) &&
+            if (ts.isIdentifier(node) &&
                 node.parent &&
                 // Don't track individual identifiers marked for removal.
-                (!ts__default["default"].isArrayLiteralExpression(node.parent) ||
+                (!ts.isArrayLiteralExpression(node.parent) ||
                     !partialRemovals.has(node.parent) ||
                     !partialRemovals.get(node.parent).has(node))) {
                 result.identifierCounts.set(node.text, (result.identifierCounts.get(node.text) ?? 0) + 1);
             }
             // Don't track identifiers in array literals that are about to be removed.
-            if (ts__default["default"].isArrayLiteralExpression(node) && fullRemovals.has(node)) {
+            if (ts.isArrayLiteralExpression(node) && fullRemovals.has(node)) {
                 return;
             }
-            if (ts__default["default"].isImportDeclaration(node)) {
+            if (ts.isImportDeclaration(node)) {
                 const namedBindings = node.importClause?.namedBindings;
-                const moduleName = ts__default["default"].isStringLiteral(node.moduleSpecifier)
+                const moduleName = ts.isStringLiteral(node.moduleSpecifier)
                     ? node.moduleSpecifier.text
                     : null;
-                if (namedBindings && ts__default["default"].isNamedImports(namedBindings) && moduleName !== null) {
+                if (namedBindings && ts.isNamedImports(namedBindings) && moduleName !== null) {
                     namedBindings.elements.forEach((imp) => {
                         if (!result.importedSymbols.has(moduleName)) {
                             result.importedSymbols.set(moduleName, new Map());
@@ -237,11 +231,11 @@ class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
         });
         // Filter out the unused identifiers from an array.
         partialRemovals.forEach((toRemove, node) => {
-            const newNode = ts__default["default"].factory.updateArrayLiteralExpression(node, node.elements.filter((el) => !toRemove.has(el)));
+            const newNode = ts.factory.updateArrayLiteralExpression(node, node.elements.filter((el) => !toRemove.has(el)));
             replacements.push(new project_paths.Replacement(project_paths.projectFile(sourceFile, info), new project_paths.TextUpdate({
                 position: node.getStart(),
                 end: node.getEnd(),
-                toInsert: this.printer.printNode(ts__default["default"].EmitHint.Unspecified, newNode, sourceFile),
+                toInsert: this.printer.printNode(ts.EmitHint.Unspecified, newNode, sourceFile),
             })));
         });
         // Attempt to clean up unused import declarations. Note that this isn't foolproof, because we

package/schematics/bundles/{compiler_host-cc1379e9.js → compiler_host-Da636uJ8.js}

@@ -1,20 +1,17 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
-var checker = require('./checker-cf6f7980.js');
+var checker = require('./checker-DF8ZaFW5.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;
+function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
         Object.keys(e).forEach(function (k) {
@@ -27,12 +24,11 @@ function _interopNamespace(e) {
             }
         });
     }
-    n["default"] = e;
+    n.default = e;
     return Object.freeze(n);
 }
 
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-var p__namespace = /*#__PURE__*/_interopNamespace(p);
+var p__namespace = /*#__PURE__*/_interopNamespaceDefault(p);
 
 /** Tracks changes that have to be made for specific files. */
 class ChangeTracker {
@@ -76,7 +72,7 @@ class ChangeTracker {
      * 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) {
+    replaceNode(oldNode, newNode, emitHint = ts.EmitHint.Unspecified, sourceFileWhenPrinting) {
         const sourceFile = oldNode.getSourceFile();
         this.replaceText(sourceFile, oldNode.getStart(), oldNode.getWidth(), this._printer.printNode(emitHint, newNode, sourceFileWhenPrinting || sourceFile));
     }
@@ -179,7 +175,7 @@ class ChangeTracker {
         }
         let kind = 0 /* QuoteKind.SINGLE */;
         for (const statement of sourceFile.statements) {
-            if (ts__default["default"].isImportDeclaration(statement) && ts__default["default"].isStringLiteral(statement.moduleSpecifier)) {
+            if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
                 kind = statement.moduleSpecifier.getText()[0] === '"' ? 1 /* QuoteKind.DOUBLE */ : 0 /* QuoteKind.SINGLE */;
                 this._quotesCache.set(sourceFile, kind);
                 break;
@@ -204,12 +200,12 @@ class ChangeTracker {
             const importLines = [];
             let lastImport = null;
             for (const statement of sourceFile.statements) {
-                if (ts__default["default"].isImportDeclaration(statement)) {
+                if (ts.isImportDeclaration(statement)) {
                     lastImport = statement;
                 }
             }
             for (const decl of importsToAdd) {
-                importLines.push(this._printer.printNode(ts__default["default"].EmitHint.Unspecified, decl, sourceFile));
+                importLines.push(this._printer.printNode(ts.EmitHint.Unspecified, decl, sourceFile));
             }
             this.insertText(sourceFile, lastImport ? lastImport.getEnd() : 0, (lastImport ? '\n' : '') + importLines.join('\n'));
         }
@@ -221,12 +217,12 @@ function normalizePath(path) {
 }
 
 function parseTsconfigFile(tsconfigPath, basePath) {
-    const { config } = ts__default["default"].readConfigFile(tsconfigPath, ts__default["default"].sys.readFile);
+    const { config } = ts.readConfigFile(tsconfigPath, ts.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,
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+        fileExists: ts.sys.fileExists,
+        readDirectory: ts.sys.readDirectory,
+        readFile: ts.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.
@@ -234,7 +230,7 @@ function parseTsconfigFile(tsconfigPath, basePath) {
     if (!p__namespace.isAbsolute(basePath)) {
         throw Error('Unexpected relative base path has been specified.');
     }
-    return ts__default["default"].parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
+    return ts.parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
 }
 
 /**
@@ -248,8 +244,8 @@ function parseTsconfigFile(tsconfigPath, basePath) {
  * @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);
+    const { rootNames, options, host } = createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead);
+    return ts.createProgram(rootNames, options, host);
 }
 /**
  * Creates the options necessary to instantiate a TypeScript program.
@@ -269,10 +265,10 @@ function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additi
     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 };
+    return { rootNames: parsed.fileNames.concat([]), options, host };
 }
 function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
-    const host = ts__default["default"].createCompilerHost(options, true);
+    const host = ts.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

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

@@ -1,34 +1,28 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var schematics = require('@angular-devkit/schematics');
 var p = require('path');
-var compiler_host = require('./compiler_host-cc1379e9.js');
-var checker = require('./checker-cf6f7980.js');
+var compiler_host = require('./compiler_host-Da636uJ8.js');
+var checker = require('./checker-DF8ZaFW5.js');
 var ts = require('typescript');
 require('os');
 require('fs');
 require('module');
 require('url');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-
 function lookupIdentifiersInSourceFile(sourceFile, names) {
     const results = new Set();
     const visit = (node) => {
-        if (ts__default["default"].isIdentifier(node) && names.includes(node.text)) {
+        if (ts.isIdentifier(node) && names.includes(node.text)) {
             results.add(node);
         }
-        ts__default["default"].forEachChild(node, visit);
+        ts.forEachChild(node, visit);
     };
     visit(sourceFile);
     return results;
@@ -421,7 +415,7 @@ const replaceMarkerRegex = new RegExp(`${startMarker}|${endMarker}`, 'gm');
  */
 function analyze(sourceFile, analyzedFiles) {
     forEachClass(sourceFile, (node) => {
-        if (ts__default["default"].isClassDeclaration(node)) {
+        if (ts.isClassDeclaration(node)) {
             analyzeDecorators(node, sourceFile, analyzedFiles);
         }
         else {
@@ -440,7 +434,7 @@ function checkIfShouldChange(decl, file) {
     const clause = decl.getChildAt(1);
     return !(!file.removeCommonModule &&
         clause.namedBindings &&
-        ts__default["default"].isNamedImports(clause.namedBindings) &&
+        ts.isNamedImports(clause.namedBindings) &&
         clause.namedBindings.elements.length === 1 &&
         clause.namedBindings.elements[0].getText() === 'CommonModule');
 }
@@ -454,46 +448,46 @@ function updateImportDeclaration(decl, removeCommonModule) {
     // when the import declaration is at the top of the file, but right after a comment
     // without this, the comment gets duplicated when the declaration is updated.
     // the typescript AST includes that preceding comment as part of the import declaration full text.
-    const printer = ts__default["default"].createPrinter({
+    const printer = ts.createPrinter({
         removeComments: true,
     });
-    const updated = ts__default["default"].factory.updateImportDeclaration(decl, decl.modifiers, updatedClause, decl.moduleSpecifier, undefined);
-    return printer.printNode(ts__default["default"].EmitHint.Unspecified, updated, clause.getSourceFile());
+    const updated = ts.factory.updateImportDeclaration(decl, decl.modifiers, updatedClause, decl.moduleSpecifier, undefined);
+    return printer.printNode(ts.EmitHint.Unspecified, updated, clause.getSourceFile());
 }
 function updateImportClause(clause, removeCommonModule) {
-    if (clause.namedBindings && ts__default["default"].isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
         const removals = removeCommonModule ? importWithCommonRemovals : importRemovals;
         const elements = clause.namedBindings.elements.filter((el) => !removals.includes(el.getText()));
         if (elements.length === 0) {
             return null;
         }
-        clause = ts__default["default"].factory.updateImportClause(clause, clause.isTypeOnly, clause.name, ts__default["default"].factory.createNamedImports(elements));
+        clause = ts.factory.updateImportClause(clause, clause.isTypeOnly, clause.name, ts.factory.createNamedImports(elements));
     }
     return clause;
 }
 function updateClassImports(propAssignment, removeCommonModule) {
-    const printer = ts__default["default"].createPrinter();
+    const printer = ts.createPrinter();
     const importList = propAssignment.initializer;
     // Can't change non-array literals.
-    if (!ts__default["default"].isArrayLiteralExpression(importList)) {
+    if (!ts.isArrayLiteralExpression(importList)) {
         return null;
     }
     const removals = removeCommonModule ? importWithCommonRemovals : importRemovals;
-    const elements = importList.elements.filter((el) => !ts__default["default"].isIdentifier(el) || !removals.includes(el.text));
+    const elements = importList.elements.filter((el) => !ts.isIdentifier(el) || !removals.includes(el.text));
     if (elements.length === importList.elements.length) {
         // nothing changed
         return null;
     }
-    const updatedElements = ts__default["default"].factory.updateArrayLiteralExpression(importList, elements);
-    const updatedAssignment = ts__default["default"].factory.updatePropertyAssignment(propAssignment, propAssignment.name, updatedElements);
-    return printer.printNode(ts__default["default"].EmitHint.Unspecified, updatedAssignment, updatedAssignment.getSourceFile());
+    const updatedElements = ts.factory.updateArrayLiteralExpression(importList, elements);
+    const updatedAssignment = ts.factory.updatePropertyAssignment(propAssignment, propAssignment.name, updatedElements);
+    return printer.printNode(ts.EmitHint.Unspecified, updatedAssignment, updatedAssignment.getSourceFile());
 }
 function analyzeImportDeclarations(node, sourceFile, analyzedFiles) {
     if (node.getText().indexOf('@angular/common') === -1) {
         return;
     }
     const clause = node.getChildAt(1);
-    if (clause.namedBindings && ts__default["default"].isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
         const elements = clause.namedBindings.elements.filter((el) => importWithCommonRemovals.includes(el.getText()));
         if (elements.length > 0) {
             AnalyzedFile.addRange(sourceFile.fileName, sourceFile, analyzedFiles, {
@@ -510,14 +504,14 @@ function analyzeDecorators(node, sourceFile, analyzedFiles) {
     // Note: we have a utility to resolve the Angular decorators from a class declaration already.
     // We don't use it here, because it requires access to the type checker which makes it more
     // time-consuming to run internally.
-    const decorator = ts__default["default"].getDecorators(node)?.find((dec) => {
-        return (ts__default["default"].isCallExpression(dec.expression) &&
-            ts__default["default"].isIdentifier(dec.expression.expression) &&
+    const decorator = ts.getDecorators(node)?.find((dec) => {
+        return (ts.isCallExpression(dec.expression) &&
+            ts.isIdentifier(dec.expression.expression) &&
             dec.expression.expression.text === 'Component');
     });
     const metadata = decorator &&
         decorator.expression.arguments.length > 0 &&
-        ts__default["default"].isObjectLiteralExpression(decorator.expression.arguments[0])
+        ts.isObjectLiteralExpression(decorator.expression.arguments[0])
         ? decorator.expression.arguments[0]
         : null;
     if (!metadata) {
@@ -526,8 +520,8 @@ function analyzeDecorators(node, sourceFile, analyzedFiles) {
     for (const prop of metadata.properties) {
         // All the properties we care about should have static
         // names and be initialized to a static string.
-        if (!ts__default["default"].isPropertyAssignment(prop) ||
-            (!ts__default["default"].isIdentifier(prop.name) && !ts__default["default"].isStringLiteralLike(prop.name))) {
+        if (!ts.isPropertyAssignment(prop) ||
+            (!ts.isIdentifier(prop.name) && !ts.isStringLiteralLike(prop.name))) {
             continue;
         }
         switch (prop.name.text) {
@@ -552,7 +546,7 @@ function analyzeDecorators(node, sourceFile, analyzedFiles) {
                 break;
             case 'templateUrl':
                 // Leave the end as undefined which means that the range is until the end of the file.
-                if (ts__default["default"].isStringLiteralLike(prop.initializer)) {
+                if (ts.isStringLiteralLike(prop.initializer)) {
                     const path = p.join(p.dirname(sourceFile.fileName), prop.initializer.text);
                     AnalyzedFile.addRange(path, sourceFile, analyzedFiles, {
                         start: 0,
@@ -747,7 +741,7 @@ function generatei18nContainer(i18nAttr, middle) {
 /**
  * Counts, replaces, and removes any necessary ng-templates post control flow migration
  */
-function processNgTemplates(template) {
+function processNgTemplates(template, sourceFile) {
     // count usage
     try {
         const templates = getTemplates(template);
@@ -780,7 +774,18 @@ function processNgTemplates(template) {
                 }
                 // the +1 accounts for the t.count's counting of the original template
                 if (t.count === matches.length + 1 && safeToRemove) {
-                    template = template.replace(t.contents, `${startMarker}${endMarker}`);
+                    const refsInComponentFile = getViewChildOrViewChildrenNames(sourceFile);
+                    if (refsInComponentFile?.length > 0) {
+                        const templateRefs = getTemplateReferences(template);
+                        for (const ref of refsInComponentFile) {
+                            if (!templateRefs.includes(ref)) {
+                                template = template.replace(t.contents, `${startMarker}${endMarker}`);
+                            }
+                        }
+                    }
+                    else {
+                        template = template.replace(t.contents, `${startMarker}${endMarker}`);
+                    }
                 }
                 // templates may have changed structure from nested replaced templates
                 // so we need to reprocess them before the next loop.
@@ -798,6 +803,44 @@ function processNgTemplates(template) {
         return { migrated: template, err: err };
     }
 }
+function getViewChildOrViewChildrenNames(sourceFile) {
+    const names = [];
+    function visit(node) {
+        if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
+            const expr = node.expression;
+            if (ts.isIdentifier(expr.expression) &&
+                (expr.expression.text === 'ViewChild' || expr.expression.text === 'ViewChildren')) {
+                const firstArg = expr.arguments[0];
+                if (firstArg && ts.isStringLiteral(firstArg)) {
+                    names.push(firstArg.text);
+                }
+                return;
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return names;
+}
+function getTemplateReferences(template) {
+    const parsed = parseTemplate(template);
+    if (parsed.tree === undefined) {
+        return [];
+    }
+    const references = [];
+    function visitNodes(nodes) {
+        for (const node of nodes) {
+            if (node?.name === 'ng-template') {
+                references.push(...node.attrs?.map((ref) => ref?.name?.slice(1)));
+            }
+            if (node.children) {
+                visitNodes(node.children);
+            }
+        }
+    }
+    visitNodes(parsed.tree.rootNodes);
+    return references;
+}
 function replaceRemainingPlaceholders(template) {
     const pattern = '.*';
     const placeholderPattern = getPlaceholder(pattern);
@@ -828,11 +871,11 @@ function canRemoveCommonModule(template) {
  * removes imports from template imports and import declarations
  */
 function removeImports(template, node, file) {
-    if (template.startsWith('imports') && ts__default["default"].isPropertyAssignment(node)) {
+    if (template.startsWith('imports') && ts.isPropertyAssignment(node)) {
         const updatedImport = updateClassImports(node, file.removeCommonModule);
         return updatedImport ?? template;
     }
-    else if (ts__default["default"].isImportDeclaration(node) && checkIfShouldChange(node, file)) {
+    else if (ts.isImportDeclaration(node) && checkIfShouldChange(node, file)) {
         return updateImportDeclaration(node, file.removeCommonModule);
     }
     return template;
@@ -1119,7 +1162,7 @@ function formatTemplate(tmpl, templateType) {
 /** Executes a callback on each class declaration in a file. */
 function forEachClass(sourceFile, callback) {
     sourceFile.forEachChild(function walk(node) {
-        if (ts__default["default"].isClassDeclaration(node) || ts__default["default"].isImportDeclaration(node)) {
+        if (ts.isClassDeclaration(node) || ts.isImportDeclaration(node)) {
             callback(node);
         }
         node.forEachChild(walk);
@@ -1719,7 +1762,7 @@ function migrateTemplate(template, templateType, node, file, format = true, anal
             return { migrated: template, errors: switchResult.errors };
         }
         const caseResult = migrateCase(switchResult.migrated);
-        const templateResult = processNgTemplates(caseResult.migrated);
+        const templateResult = processNgTemplates(caseResult.migrated, file.sourceFile);
         if (templateResult.err !== undefined) {
             return { migrated: template, errors: [{ type: 'template', error: templateResult.err }] };
         }

package/schematics/bundles/{imports-31a38653.js → imports-CIX-JgAN.js}

@@ -1,17 +1,13 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-
 /** Gets import information about the specified identifier by using the Type checker. */
 function getImportOfIdentifier(typeChecker, node) {
     const symbol = typeChecker.getSymbolAtLocation(node);
@@ -19,11 +15,11 @@ function getImportOfIdentifier(typeChecker, node) {
         return null;
     }
     const decl = symbol.declarations[0];
-    if (!ts__default["default"].isImportSpecifier(decl)) {
+    if (!ts.isImportSpecifier(decl)) {
         return null;
     }
     const importDecl = decl.parent.parent.parent;
-    if (!ts__default["default"].isImportDeclaration(importDecl) || !ts__default["default"].isStringLiteral(importDecl.moduleSpecifier)) {
+    if (!ts.isImportDeclaration(importDecl) || !ts.isStringLiteral(importDecl.moduleSpecifier)) {
         return null;
     }
     return {
@@ -56,14 +52,14 @@ function getImportSpecifier(sourceFile, moduleName, specifierName) {
 function getImportSpecifiers(sourceFile, moduleName, specifierOrSpecifiers) {
     const matches = [];
     for (const node of sourceFile.statements) {
-        if (!ts__default["default"].isImportDeclaration(node) || !ts__default["default"].isStringLiteral(node.moduleSpecifier)) {
+        if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier)) {
             continue;
         }
         const namedBindings = node.importClause?.namedBindings;
         const isMatch = typeof moduleName === 'string'
             ? node.moduleSpecifier.text === moduleName
             : moduleName.test(node.moduleSpecifier.text);
-        if (!isMatch || !namedBindings || !ts__default["default"].isNamedImports(namedBindings)) {
+        if (!isMatch || !namedBindings || !ts.isNamedImports(namedBindings)) {
             continue;
         }
         if (typeof specifierOrSpecifiers === 'string') {
@@ -85,12 +81,11 @@ function getImportSpecifiers(sourceFile, moduleName, specifierOrSpecifiers) {
 }
 function getNamedImports(sourceFile, moduleName) {
     for (const node of sourceFile.statements) {
-        if (ts__default["default"].isImportDeclaration(node) && ts__default["default"].isStringLiteral(node.moduleSpecifier)) {
-            const isMatch = typeof moduleName === 'string'
-                ? node.moduleSpecifier.text === moduleName
-                : moduleName.test(node.moduleSpecifier.text);
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const isMatch = node.moduleSpecifier.text === moduleName
+                ;
             const namedBindings = node.importClause?.namedBindings;
-            if (isMatch && namedBindings && ts__default["default"].isNamedImports(namedBindings)) {
+            if (isMatch && namedBindings && ts.isNamedImports(namedBindings)) {
                 return namedBindings;
             }
         }