@angular/core 20.0.0-next.1 → 20.0.0-next.3

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

@@ -1,42 +1,35 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (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-b558633b.js');
-var project_paths = require('./project_paths-17dc204d.js');
-require('os');
 var ts = require('typescript');
-var checker = require('./checker-af521da6.js');
-var program = require('./program-a449f9bf.js');
+require('os');
+var checker = require('./checker-BHb19MHt.js');
+var index = require('./index-I8VbxQcO.js');
 require('path');
-require('./index-ef1bffbb.js');
-var apply_import_manager = require('./apply_import_manager-e2a7fe5b.js');
+var run_in_devkit = require('./run_in_devkit-C0JPtK2u.js');
+var apply_import_manager = require('./apply_import_manager-BXQEjo09.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);
+require('@angular-devkit/schematics');
+require('./project_tsconfig_paths-CDVxT6Ov.js');
 
 /** Migration that cleans up unused imports from a project. */
-class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
-    printer = ts__default["default"].createPrinter();
+class UnusedImportsMigration extends run_in_devkit.TsurgeFunnelMigration {
+    printer = ts.createPrinter();
     createProgram(tsconfigAbsPath, fs) {
         return super.createProgram(tsconfigAbsPath, fs, {
             extendedDiagnostics: {
                 checks: {
                     // Ensure that the diagnostic is enabled.
-                    unusedStandaloneImports: program.DiagnosticCategoryLabel.Warning,
+                    unusedStandaloneImports: index.DiagnosticCategoryLabel.Warning,
                 },
             },
         });
@@ -68,10 +61,10 @@ class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
             }
             this.generateReplacements(sourceFile, resolvedLocations, usageAnalysis, info, replacements);
         });
-        return project_paths.confirmAsSerializable({ replacements, removedIdentifiers, changedFiles });
+        return run_in_devkit.confirmAsSerializable({ replacements, removedIdentifiers, changedFiles });
     }
     async migrate(globalData) {
-        return project_paths.confirmAsSerializable(globalData);
+        return run_in_devkit.confirmAsSerializable(globalData);
     }
     async combine(unitA, unitB) {
         const combinedReplacements = [];
@@ -95,14 +88,14 @@ class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
                 }
             }
         });
-        return project_paths.confirmAsSerializable({
+        return run_in_devkit.confirmAsSerializable({
             replacements: combinedReplacements,
             removedIdentifiers: combinedRemovedIdentifiers,
             changedFiles: changedFileIds.size,
         });
     }
     async globalMeta(combinedData) {
-        return project_paths.confirmAsSerializable(combinedData);
+        return run_in_devkit.confirmAsSerializable(combinedData);
     }
     async stats(globalMetadata) {
         return {
@@ -133,7 +126,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 +138,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 +172,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());
@@ -229,7 +222,7 @@ class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
         const importManager = new checker.ImportManager();
         // Replace full arrays with empty ones. This allows preserves more of the user's formatting.
         fullRemovals.forEach((node) => {
-            replacements.push(new project_paths.Replacement(project_paths.projectFile(sourceFile, info), new project_paths.TextUpdate({
+            replacements.push(new run_in_devkit.Replacement(run_in_devkit.projectFile(sourceFile, info), new run_in_devkit.TextUpdate({
                 position: node.getStart(),
                 end: node.getEnd(),
                 toInsert: '[]',
@@ -237,11 +230,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)));
-            replacements.push(new project_paths.Replacement(project_paths.projectFile(sourceFile, info), new project_paths.TextUpdate({
+            const newNode = ts.factory.updateArrayLiteralExpression(node, node.elements.filter((el) => !toRemove.has(el)));
+            replacements.push(new run_in_devkit.Replacement(run_in_devkit.projectFile(sourceFile, info), new run_in_devkit.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
@@ -270,59 +263,33 @@ class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
 
 function migrate() {
     return async (tree, context) => {
-        const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(tree);
-        if (!buildPaths.length && !testPaths.length) {
-            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot clean up unused imports.');
-        }
-        const fs = new project_paths.DevkitMigrationFilesystem(tree);
-        checker.setFileSystem(fs);
-        const migration = new UnusedImportsMigration();
-        const unitResults = [];
-        const programInfos = [...buildPaths, ...testPaths].map((tsconfigPath) => {
-            context.logger.info(`Preparing analysis for ${tsconfigPath}`);
-            const baseInfo = migration.createProgram(tsconfigPath, fs);
-            const info = migration.prepareProgram(baseInfo);
-            return { info, tsconfigPath };
+        await run_in_devkit.runMigrationInDevkit({
+            getMigration: () => new UnusedImportsMigration(),
+            tree,
+            beforeProgramCreation: (tsconfigPath) => {
+                context.logger.info(`Preparing analysis for ${tsconfigPath}`);
+            },
+            beforeUnitAnalysis: (tsconfigPath) => {
+                context.logger.info(`Scanning for unused imports using ${tsconfigPath}`);
+            },
+            afterAnalysisFailure: () => {
+                context.logger.error('Schematic failed unexpectedly with no analysis data');
+            },
+            whenDone: (stats) => {
+                const { removedImports, changedFiles } = stats.counters;
+                let statsMessage;
+                if (removedImports === 0) {
+                    statsMessage = 'Schematic could not find unused imports in the project';
+                }
+                else {
+                    statsMessage =
+                        `Removed ${removedImports} import${removedImports !== 1 ? 's' : ''} ` +
+                            `in ${changedFiles} file${changedFiles !== 1 ? 's' : ''}`;
+                }
+                context.logger.info('');
+                context.logger.info(statsMessage);
+            },
         });
-        for (const { info, tsconfigPath } of programInfos) {
-            context.logger.info(`Scanning for unused imports using ${tsconfigPath}`);
-            unitResults.push(await migration.analyze(info));
-        }
-        const combined = await project_paths.synchronouslyCombineUnitData(migration, unitResults);
-        if (combined === null) {
-            context.logger.error('Schematic failed unexpectedly with no analysis data');
-            return;
-        }
-        const globalMeta = await migration.globalMeta(combined);
-        const replacementsPerFile = new Map();
-        const { replacements } = await migration.migrate(globalMeta);
-        const changesPerFile = project_paths.groupReplacementsByFile(replacements);
-        for (const [file, changes] of changesPerFile) {
-            if (!replacementsPerFile.has(file)) {
-                replacementsPerFile.set(file, changes);
-            }
-        }
-        for (const [file, changes] of replacementsPerFile) {
-            const recorder = tree.beginUpdate(file);
-            for (const c of changes) {
-                recorder
-                    .remove(c.data.position, c.data.end - c.data.position)
-                    .insertRight(c.data.position, c.data.toInsert);
-            }
-            tree.commitUpdate(recorder);
-        }
-        const { counters: { removedImports, changedFiles }, } = await migration.stats(globalMeta);
-        let statsMessage;
-        if (removedImports === 0) {
-            statsMessage = 'Schematic could not find unused imports in the project';
-        }
-        else {
-            statsMessage =
-                `Removed ${removedImports} import${removedImports !== 1 ? 's' : ''} ` +
-                    `in ${changedFiles} file${changedFiles !== 1 ? 's' : ''}`;
-        }
-        context.logger.info('');
-        context.logger.info(statsMessage);
     };
 }
 

package/schematics/bundles/{compiler_host-5a29293c.js → compiler_host-Bk3repE2.js}

@@ -1,20 +1,17 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
-var checker = require('./checker-af521da6.js');
+var checker = require('./checker-BHb19MHt.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.1
+ * @license Angular v20.0.0-next.3
  * (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-5a29293c.js');
-var checker = require('./checker-af521da6.js');
+var compiler_host = require('./compiler_host-Bk3repE2.js');
+var checker = require('./checker-BHb19MHt.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 }] };
         }