@angular/core 21.0.0-next.8 → 21.0.0-rc.0

package/schematics/bundles/common-to-standalone-migration.cjs

@@ -0,0 +1,381 @@
+'use strict';
+/**
+ * @license Angular v21.0.0-rc.0
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+var ts = require('typescript');
+require('@angular/compiler-cli');
+var migrations = require('@angular/compiler-cli/private/migrations');
+require('node:path');
+var project_paths = require('./project_paths-DvD50ouC.cjs');
+var ng_component_template = require('./ng_component_template-Dsuq1Lw7.cjs');
+var ng_decorators = require('./ng_decorators-DSFlWYQY.cjs');
+var apply_import_manager = require('./apply_import_manager-1Zs_gpB6.cjs');
+var imports = require('./imports-DP72APSx.cjs');
+require('@angular-devkit/core');
+require('node:path/posix');
+require('@angular-devkit/schematics');
+require('./project_tsconfig_paths-CDVxT6Ov.cjs');
+require('./property_name-BBwFuqMe.cjs');
+
+const commonModuleStr = 'CommonModule';
+const angularCommonStr = '@angular/common';
+const PATTERN_IMPORTS = [
+    // Structural directives
+    { pattern: /\*ngIf\b/g, imports: ['NgIf'] },
+    { pattern: /\*ngFor\b/g, imports: ['NgFor'] },
+    { pattern: /\[ngForOf]\b/g, imports: ['NgForOf'] },
+    { pattern: /\[ngPlural\]/g, imports: ['NgPlural'] },
+    // Match ngPluralCase as structural (*ngPluralCase) or attribute (ngPluralCase="value")
+    { pattern: /(\*ngPluralCase\b|\s+ngPluralCase\s*=)/g, imports: ['NgPluralCase'] },
+    // Match ngSwitchCase as structural (*ngSwitchCase) or attribute (ngSwitchCase="value")
+    { pattern: /(\*ngSwitchCase\b|\s+ngSwitchCase\s*=)/g, imports: ['NgSwitchCase'] },
+    // Match ngSwitchDefault as structural (*ngSwitchDefault) or standalone attribute (ngSwitchDefault>)
+    { pattern: /(\*ngSwitchDefault\b|\s+ngSwitchDefault(?=\s*>))/g, imports: ['NgSwitchDefault'] },
+    { pattern: /\[ngClass\]/g, imports: ['NgClass'] },
+    { pattern: /\[ngStyle\]/g, imports: ['NgStyle'] },
+    // Match ngSwitch as property binding [ngSwitch] or attribute ngSwitch="value"
+    { pattern: /(\[ngSwitch\]|\s+ngSwitch\s*=)/g, imports: ['NgSwitch'] },
+    { pattern: /\[ngTemplateOutlet\]/g, imports: ['NgTemplateOutlet'] },
+    { pattern: /\[ngComponentOutlet\]/g, imports: ['NgComponentOutlet'] },
+    // Common pipes
+    { pattern: /\|\s*async\b/g, imports: ['AsyncPipe'] },
+    { pattern: /\|\s*json\b/g, imports: ['JsonPipe'] },
+    { pattern: /\|\s*date\b/g, imports: ['DatePipe'] },
+    { pattern: /\|\s*currency\b/g, imports: ['CurrencyPipe'] },
+    { pattern: /\|\s*number\b/g, imports: ['DecimalPipe'] },
+    { pattern: /\|\s*percent\b/g, imports: ['PercentPipe'] },
+    { pattern: /\|\s*lowercase\b/g, imports: ['LowerCasePipe'] },
+    { pattern: /\|\s*uppercase\b/g, imports: ['UpperCasePipe'] },
+    { pattern: /\|\s*titlecase\b/g, imports: ['TitleCasePipe'] },
+    { pattern: /\|\s*slice\b/g, imports: ['SlicePipe'] },
+    { pattern: /\|\s*keyvalue\b/g, imports: ['KeyValuePipe'] },
+    { pattern: /\|\s*i18nPlural\b/g, imports: ['I18nPluralPipe'] },
+    { pattern: /\|\s*i18nSelect\b/g, imports: ['I18nSelectPipe'] },
+];
+function analyzeTemplateWithRegex(template, neededImports) {
+    PATTERN_IMPORTS.forEach(({ pattern, imports }) => {
+        // Reset regex lastIndex to avoid state issues with global flag
+        pattern.lastIndex = 0;
+        if (pattern.test(template)) {
+            imports.forEach((imp) => neededImports.add(imp));
+        }
+    });
+}
+function migrateCommonModuleUsage(template, componentNode, typeChecker) {
+    const analysis = analyzeTemplateContent(template);
+    const hasCommonModule = hasCommonModuleInImports(componentNode, typeChecker);
+    return {
+        migrated: template,
+        changed: hasCommonModule,
+        replacementCount: hasCommonModule ? 1 : 0,
+        canRemoveCommonModule: hasCommonModule,
+        neededImports: Array.from(analysis.neededImports),
+    };
+}
+function createCommonModuleImportsArrayRemoval(classNode, file, typeChecker, neededImports) {
+    const reflector = new migrations.TypeScriptReflectionHost(typeChecker);
+    const decorators = reflector.getDecoratorsOfDeclaration(classNode);
+    if (!decorators) {
+        return null;
+    }
+    const decorator = decorators.find((decorator) => decorator.name === 'Component');
+    if (!decorator?.node) {
+        return null;
+    }
+    const decoratorNode = decorator.node;
+    if (!ts.isDecorator(decoratorNode) ||
+        !ts.isCallExpression(decoratorNode.expression) ||
+        decoratorNode.expression.arguments.length === 0 ||
+        !ts.isObjectLiteralExpression(decoratorNode.expression.arguments[0])) {
+        return null;
+    }
+    const metadata = decoratorNode.expression.arguments[0];
+    const importsProperty = metadata.properties.find((p) => ts.isPropertyAssignment(p) && p.name?.getText() === 'imports');
+    if (!importsProperty || !ts.isArrayLiteralExpression(importsProperty.initializer)) {
+        return null;
+    }
+    const importsArray = importsProperty.initializer;
+    const originalElements = importsArray.elements;
+    const filteredElements = originalElements.filter((el) => {
+        if (!ts.isIdentifier(el))
+            return true;
+        return !isCommonModuleFromAngularCommon(typeChecker, el);
+    });
+    const newElements = [
+        ...filteredElements,
+        ...neededImports.sort().map((imp) => ts.factory.createIdentifier(imp)),
+    ];
+    if (newElements.length === originalElements.length && neededImports.length === 0) {
+        return null;
+    }
+    if (newElements.length === 0) {
+        // For standalone components, keep imports: [] instead of removing the property entirely
+        const printer = ts.createPrinter();
+        const emptyArray = ts.factory.createArrayLiteralExpression([]);
+        const newText = printer.printNode(ts.EmitHint.Unspecified, emptyArray, classNode.getSourceFile());
+        return new project_paths.Replacement(file, new project_paths.TextUpdate({
+            position: importsArray.getStart(),
+            end: importsArray.getEnd(),
+            toInsert: newText,
+        }));
+    }
+    const printer = ts.createPrinter();
+    const newArray = ts.factory.updateArrayLiteralExpression(importsArray, newElements);
+    const newText = printer.printNode(ts.EmitHint.Unspecified, newArray, classNode.getSourceFile());
+    return new project_paths.Replacement(file, new project_paths.TextUpdate({
+        position: importsArray.getStart(),
+        end: importsArray.getEnd(),
+        toInsert: newText,
+    }));
+}
+function analyzeTemplateContent(templateContent) {
+    const neededImports = new Set();
+    const errors = [];
+    try {
+        analyzeTemplateWithRegex(templateContent, neededImports);
+    }
+    catch (error) {
+        errors.push(`Failed to analyze template: ${error}`);
+    }
+    return { neededImports, errors };
+}
+function hasCommonModuleInImports(componentNode, typeChecker) {
+    // First check if there's a CommonModule in the imports array
+    const reflector = new migrations.TypeScriptReflectionHost(typeChecker);
+    const decorators = reflector.getDecoratorsOfDeclaration(componentNode);
+    if (!decorators) {
+        return false;
+    }
+    const decorator = decorators.find((decorator) => decorator.name === 'Component');
+    if (!decorator?.node) {
+        return false;
+    }
+    const decoratorNode = decorator.node;
+    if (!ts.isDecorator(decoratorNode) ||
+        !ts.isCallExpression(decoratorNode.expression) ||
+        decoratorNode.expression.arguments.length === 0 ||
+        !ts.isObjectLiteralExpression(decoratorNode.expression.arguments[0])) {
+        return false;
+    }
+    const metadata = decoratorNode.expression.arguments[0];
+    const importsProperty = metadata.properties.find((p) => ts.isPropertyAssignment(p) && p.name?.getText() === 'imports');
+    if (!importsProperty || !ts.isArrayLiteralExpression(importsProperty.initializer)) {
+        return false;
+    }
+    const importsArray = importsProperty.initializer;
+    return importsArray.elements.some((el) => {
+        if (!ts.isIdentifier(el))
+            return false;
+        return isCommonModuleFromAngularCommon(typeChecker, el);
+    });
+}
+function isCommonModuleFromAngularCommon(typeChecker, identifier) {
+    const importInfo = imports.getImportOfIdentifier(typeChecker, identifier);
+    return (importInfo !== null &&
+        importInfo.name === commonModuleStr &&
+        importInfo.importModule === angularCommonStr);
+}
+function processResolvedTemplate(template, componentNode, info, typeChecker, replacements, filesWithNeededImports) {
+    const result = migrateCommonModuleUsage(template.content, componentNode, typeChecker);
+    if (result.changed) {
+        const sourceFile = componentNode.getSourceFile();
+        const file = project_paths.projectFile(sourceFile, info);
+        filesWithNeededImports.set(sourceFile.fileName, result.neededImports);
+        const replacement = createCommonModuleImportsArrayRemoval(componentNode, file, typeChecker, result.neededImports);
+        if (replacement) {
+            replacements.push(replacement);
+        }
+        const importManager = new migrations.ImportManager({
+            shouldUseSingleQuotes: () => true,
+        });
+        // Always remove 'CommonModule' regardless of whether it's aliased or not
+        // ImportManager handles removing the correct import specifier
+        importManager.removeImport(sourceFile, commonModuleStr, angularCommonStr);
+        if (result.neededImports.length > 0) {
+            result.neededImports.forEach((importName) => {
+                importManager.addImport({
+                    exportSymbolName: importName,
+                    exportModuleSpecifier: angularCommonStr,
+                    requestedFile: sourceFile,
+                });
+            });
+        }
+        const importReplacements = [];
+        apply_import_manager.applyImportManagerChanges(importManager, importReplacements, [sourceFile], info);
+        replacements.push(...importReplacements);
+    }
+}
+
+/**
+ * Angular Common to Standalone migration.
+ *
+ * This migration converts standalone components and Angular modules from using
+ * CommonModule to importing individual directives and pipes.
+ */
+class CommonToStandaloneMigration extends project_paths.TsurgeFunnelMigration {
+    config;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    async analyze(info) {
+        const fileReplacements = [];
+        const references = [];
+        const filesWithNeededImports = new Map();
+        for (const sf of info.sourceFiles) {
+            const file = project_paths.projectFile(sf, info);
+            if (this.config.shouldMigrate && !this.config.shouldMigrate(file)) {
+                continue;
+            }
+            this.visitSourceFile(sf, info, fileReplacements, references, filesWithNeededImports);
+        }
+        return project_paths.confirmAsSerializable({
+            replacements: fileReplacements,
+            references,
+            filesWithNeededImports,
+        });
+    }
+    visitSourceFile(sourceFile, info, replacements, references, filesWithNeededImports) {
+        const typeChecker = info.program.getTypeChecker();
+        const visit = (node) => {
+            const hasNode = ts.isClassDeclaration(node) && node.name;
+            if (!hasNode) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const nodeDecorators = ts.getDecorators(node);
+            if (!nodeDecorators) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const decorators = ng_decorators.getAngularDecorators(typeChecker, nodeDecorators);
+            const hasComponentDecorator = decorators.some((d) => d.name === 'Component');
+            if (!hasComponentDecorator) {
+                return;
+            }
+            const ref = this.analyzeClass(node, typeChecker);
+            if (!ref) {
+                return;
+            }
+            references.push(ref);
+            const templateVisitor = new ng_component_template.NgComponentTemplateVisitor(typeChecker);
+            templateVisitor.visitNode(node);
+            for (const template of templateVisitor.resolvedTemplates) {
+                processResolvedTemplate(template, node, info, typeChecker, replacements, filesWithNeededImports);
+            }
+            // Component has CommonModule in imports but no template content to analyze
+            // We still need to process these cases to remove unused CommonModule imports
+            if (templateVisitor.resolvedTemplates.length === 0) {
+                processResolvedTemplate({ content: ''}, node, info, typeChecker, replacements, filesWithNeededImports);
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    analyzeClass(node, typeChecker) {
+        const nodeDecorators = ts.getDecorators(node);
+        if (!nodeDecorators)
+            return null;
+        const decorators = ng_decorators.getAngularDecorators(typeChecker, nodeDecorators);
+        // Only process Component decorators, not Directive or other Angular decorators
+        for (const decorator of decorators) {
+            if (decorator.name === 'Component') {
+                return this.analyzeComponentDecorator(node, decorator, typeChecker);
+            }
+        }
+        return null;
+    }
+    analyzeComponentDecorator(node, decorator, typeChecker) {
+        const decoratorNode = decorator.node;
+        if (!ts.isCallExpression(decoratorNode.expression)) {
+            return null;
+        }
+        const config = decoratorNode.expression.arguments[0];
+        if (!ts.isObjectLiteralExpression(config)) {
+            return null;
+        }
+        if (hasCommonModuleInImports(node, typeChecker)) {
+            return { node };
+        }
+        return null;
+    }
+    async combine(unitA, unitB) {
+        const combinedFilesWithNeededImports = new Map(unitA.filesWithNeededImports);
+        for (const [fileName, imports] of unitB.filesWithNeededImports) {
+            if (combinedFilesWithNeededImports.has(fileName)) {
+                const existingImports = combinedFilesWithNeededImports.get(fileName) || [];
+                const mergedImports = Array.from(new Set([...existingImports, ...imports]));
+                combinedFilesWithNeededImports.set(fileName, mergedImports);
+            }
+            else {
+                combinedFilesWithNeededImports.set(fileName, imports);
+            }
+        }
+        return project_paths.confirmAsSerializable({
+            replacements: [...unitA.replacements, ...unitB.replacements],
+            references: [...unitA.references, ...unitB.references],
+            filesWithNeededImports: combinedFilesWithNeededImports,
+        });
+    }
+    async globalMeta(combinedData) {
+        return project_paths.confirmAsSerializable(combinedData);
+    }
+    async stats(globalMetadata) {
+        const stats = {
+            counters: {
+                replacements: globalMetadata.replacements.length,
+                references: globalMetadata.references.length,
+            },
+        };
+        return stats;
+    }
+    async migrate(globalData) {
+        return {
+            replacements: globalData.replacements,
+        };
+    }
+}
+
+function migrate(options) {
+    return async (tree, context) => {
+        await project_paths.runMigrationInDevkit({
+            tree,
+            getMigration: (fs) => new CommonToStandaloneMigration({
+                shouldMigrate: (file) => {
+                    return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
+                        !/(^|\/)node_modules\//.test(file.rootRelativePath));
+                },
+            }),
+            beforeProgramCreation: (tsconfigPath, stage) => {
+                if (stage === project_paths.MigrationStage.Analysis) {
+                    context.logger.info(`Preparing analysis for: ${tsconfigPath}...`);
+                }
+                else {
+                    context.logger.info(`Running migration for: ${tsconfigPath}...`);
+                }
+            },
+            beforeUnitAnalysis: (tsconfigPath) => {
+                context.logger.info(`Scanning for CommonModule usage: ${tsconfigPath}...`);
+            },
+            afterAllAnalyzed: () => {
+                context.logger.info(``);
+                context.logger.info(`Processing analysis data between targets...`);
+                context.logger.info(``);
+            },
+            afterAnalysisFailure: () => {
+                context.logger.error('Migration failed unexpectedly with no analysis data');
+            },
+            whenDone: (stats) => {
+                context.logger.info('');
+                context.logger.info(`Successfully migrated CommonModule to standalone imports 🎉`);
+                context.logger.info(`  -> Migrated ${stats.counters.replacements} CommonModule references affecting ${stats.counters.references} components.`);
+            },
+        });
+    };
+}
+
+exports.migrate = migrate;

package/schematics/bundles/{compiler_host-T6xncpiw.cjs → compiler_host-DBwYMlTo.cjs}

@@ -1,15 +1,14 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.8
+ * @license Angular v21.0.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
-var project_tsconfig_paths = require('./project_tsconfig_paths-CdhVNYMk.cjs');
-require('os');
-var p = require('path');
+var migrations = require('@angular/compiler-cli/private/migrations');
+var path = require('path');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -28,7 +27,7 @@ function _interopNamespaceDefault(e) {
     return Object.freeze(n);
 }
 
-var p__namespace = /*#__PURE__*/_interopNamespaceDefault(p);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 /** Tracks changes that have to be made for specific files. */
 class ChangeTracker {
@@ -40,7 +39,7 @@ class ChangeTracker {
     constructor(_printer, _importRemapper) {
         this._printer = _printer;
         this._importRemapper = _importRemapper;
-        this._importManager = new project_tsconfig_paths.ImportManager({
+        this._importManager = new migrations.ImportManager({
             shouldUseSingleQuotes: (file) => this._getQuoteKind(file) === 0 /* QuoteKind.SINGLE */,
         });
     }
@@ -227,7 +226,7 @@ function parseTsconfigFile(tsconfigPath, basePath) {
     // 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)) {
+    if (!path__namespace.isAbsolute(basePath)) {
         throw Error('Unexpected relative base path has been specified.');
     }
     return ts.parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
@@ -261,8 +260,8 @@ function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additi
     // 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));
+    tsconfigPath = path.resolve(basePath, tsconfigPath);
+    const parsed = parseTsconfigFile(tsconfigPath, path.dirname(tsconfigPath));
     const options = optionOverrides ? { ...parsed.options, ...optionOverrides } : parsed.options;
     const host = createMigrationCompilerHost(tree, options, basePath, fakeFileRead);
     return { rootNames: parsed.fileNames.concat([]), options, host };
@@ -275,7 +274,7 @@ function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
     // if we run multiple migrations we might have intersecting changes and
     // source files.
     host.readFile = (fileName) => {
-        const treeRelativePath = p.relative(basePath, fileName);
+        const treeRelativePath = path.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
@@ -309,7 +308,7 @@ function canMigrateFile(basePath, sourceFile, program) {
     // 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('..');
+    return !path.relative(basePath, sourceFile.fileName).startsWith('..');
 }
 
 exports.ChangeTracker = ChangeTracker;

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

@@ -1,21 +1,19 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.8
+ * @license Angular v21.0.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var schematics = require('@angular-devkit/schematics');
-var p = require('path');
-var compiler_host = require('./compiler_host-T6xncpiw.cjs');
-var project_tsconfig_paths = require('./project_tsconfig_paths-CdhVNYMk.cjs');
+var path = require('path');
+var compiler_host = require('./compiler_host-DBwYMlTo.cjs');
+var compiler = require('@angular/compiler');
 var ts = require('typescript');
-var parse_html = require('./parse_html-C97tKKp3.cjs');
-require('os');
-require('fs');
-require('module');
-require('url');
+var parse_html = require('./parse_html-8VLCL37B.cjs');
+var project_tsconfig_paths = require('./project_tsconfig_paths-CDVxT6Ov.cjs');
+require('@angular/compiler-cli/private/migrations');
 require('@angular-devkit/core');
 
 function lookupIdentifiersInSourceFile(sourceFile, names) {
@@ -275,7 +273,7 @@ class AnalyzedFile {
     }
 }
 /** Finds all non-control flow elements from common module. */
-class CommonCollector extends project_tsconfig_paths.RecursiveVisitor$1 {
+class CommonCollector extends compiler.RecursiveVisitor {
     count = 0;
     visitElement(el) {
         if (el.attrs.length > 0) {
@@ -314,7 +312,7 @@ class CommonCollector extends project_tsconfig_paths.RecursiveVisitor$1 {
     }
 }
 /** Finds all elements that represent i18n blocks. */
-class i18nCollector extends project_tsconfig_paths.RecursiveVisitor$1 {
+class i18nCollector extends compiler.RecursiveVisitor {
     elements = [];
     visitElement(el) {
         if (el.attrs.find((a) => a.name === 'i18n') !== undefined) {
@@ -324,7 +322,7 @@ class i18nCollector extends project_tsconfig_paths.RecursiveVisitor$1 {
     }
 }
 /** Finds all elements with ngif structural directives. */
-class ElementCollector extends project_tsconfig_paths.RecursiveVisitor$1 {
+class ElementCollector extends compiler.RecursiveVisitor {
     _attributes;
     elements = [];
     constructor(_attributes = []) {
@@ -377,7 +375,7 @@ class ElementCollector extends project_tsconfig_paths.RecursiveVisitor$1 {
     }
 }
 /** Finds all elements with ngif structural directives. */
-class TemplateCollector extends project_tsconfig_paths.RecursiveVisitor$1 {
+class TemplateCollector extends compiler.RecursiveVisitor {
     elements = [];
     templates = new Map();
     visitElement(el) {
@@ -550,8 +548,8 @@ function analyzeDecorators(node, sourceFile, analyzedFiles) {
             case 'templateUrl':
                 // Leave the end as undefined which means that the range is until the end of the file.
                 if (ts.isStringLiteralLike(prop.initializer)) {
-                    const path = p.join(p.dirname(sourceFile.fileName), prop.initializer.text);
-                    AnalyzedFile.addRange(path, sourceFile, analyzedFiles, {
+                    const path$1 = path.join(path.dirname(sourceFile.fileName), prop.initializer.text);
+                    AnalyzedFile.addRange(path$1, sourceFile, analyzedFiles, {
                         start: 0,
                         node: prop,
                         type: 'templateUrl',
@@ -601,7 +599,7 @@ function validateMigratedTemplate(migrated, fileName) {
 }
 function validateI18nStructure(parsed, fileName) {
     const visitor = new i18nCollector();
-    project_tsconfig_paths.visitAll$1(visitor, parsed.rootNodes);
+    compiler.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) {
@@ -681,7 +679,7 @@ function getTemplates(template) {
     const parsed = parse_html.parseTemplate(template);
     if (parsed.tree !== undefined) {
         const visitor = new TemplateCollector();
-        project_tsconfig_paths.visitAll$1(visitor, parsed.tree.rootNodes);
+        compiler.visitAll(visitor, parsed.tree.rootNodes);
         for (let [key, tmpl] of visitor.templates) {
             tmpl.count = countTemplateUsage(parsed.tree.rootNodes, key);
             tmpl.generateContents(template);
@@ -785,7 +783,7 @@ function analyzeTemplateUsage(nodes, templateName) {
             if (node.attrs) {
                 for (const attr of node.attrs) {
                     if ((attr.name === '*ngTemplateOutlet' || attr.name === '[ngTemplateOutlet]') &&
-                        attr.value === templateName) {
+                        attr.value?.split(';')[0] === templateName) {
                         isReferencedInTemplateOutlet = true;
                     }
                     if (attr.name.trim() === templateNameWithHash) {
@@ -888,7 +886,7 @@ function canRemoveCommonModule(template) {
     let removeCommonModule = false;
     if (parsed.tree !== undefined) {
         const visitor = new CommonCollector();
-        project_tsconfig_paths.visitAll$1(visitor, parsed.tree.rootNodes);
+        compiler.visitAll(visitor, parsed.tree.rootNodes);
         removeCommonModule = visitor.count === 0;
     }
     return removeCommonModule;
@@ -1011,7 +1009,7 @@ function generateI18nMarkers(tmpl) {
     let parsed = parse_html.parseTemplate(tmpl);
     if (parsed.tree !== undefined) {
         const visitor = new i18nCollector();
-        project_tsconfig_paths.visitAll$1(visitor, parsed.tree.rootNodes);
+        compiler.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
@@ -1213,7 +1211,7 @@ function migrateCase(template) {
     }
     let result = template;
     const visitor = new ElementCollector(cases);
-    project_tsconfig_paths.visitAll$1(visitor, parsed.tree.rootNodes);
+    compiler.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
@@ -1310,7 +1308,7 @@ function migrateFor(template) {
     }
     let result = template;
     const visitor = new ElementCollector(fors);
-    project_tsconfig_paths.visitAll$1(visitor, parsed.tree.rootNodes);
+    compiler.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
@@ -1515,7 +1513,7 @@ function migrateIf(template) {
     }
     let result = template;
     const visitor = new ElementCollector(ifs);
-    project_tsconfig_paths.visitAll$1(visitor, parsed.tree.rootNodes);
+    compiler.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
@@ -1708,7 +1706,7 @@ function migrateSwitch(template) {
     }
     let result = template;
     const visitor = new ElementCollector(switches);
-    project_tsconfig_paths.visitAll$1(visitor, parsed.tree.rootNodes);
+    compiler.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
@@ -1739,11 +1737,11 @@ function migrateSwitch(template) {
 }
 function assertValidSwitchStructure(children) {
     for (const child of children) {
-        if (child instanceof project_tsconfig_paths.Text && child.value.trim() !== '') {
+        if (child instanceof compiler.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 project_tsconfig_paths.Element) {
+        else if (child instanceof compiler.Element) {
             let hasCase = false;
             for (const attr of child.attrs) {
                 if (cases.includes(attr.name)) {
@@ -1850,7 +1848,7 @@ function migrate(options) {
             if (options.path.startsWith('..')) {
                 throw new schematics.SchematicsException('Cannot run control flow migration outside of the current project.');
             }
-            pathToMigrate = compiler_host.normalizePath(p.join(basePath, options.path));
+            pathToMigrate = compiler_host.normalizePath(path.join(basePath, options.path));
             if (pathToMigrate.trim() !== '') {
                 allPaths.push(pathToMigrate);
             }
@@ -1893,10 +1891,10 @@ function runControlFlowMigration(tree, sourceFiles, basePath, schematicOptions)
     // sort files with .html files first
     // this ensures class files know if it's safe to remove CommonModule
     const paths = sortFilePaths([...analysis.keys()]);
-    for (const path of paths) {
-        const file = analysis.get(path);
+    for (const path$1 of paths) {
+        const file = analysis.get(path$1);
         const ranges = file.getSortedRanges();
-        const relativePath = p.relative(basePath, path);
+        const relativePath = path.relative(basePath, path$1);
         const content = tree.readText(relativePath);
         const update = tree.beginUpdate(relativePath);
         for (const { start, end, node, type } of ranges) {
@@ -1908,7 +1906,7 @@ function runControlFlowMigration(tree, sourceFiles, basePath, schematicOptions)
                 update.insertLeft(start, migrated);
             }
             if (errors.length > 0) {
-                migrateErrors.set(path, errors);
+                migrateErrors.set(path$1, errors);
             }
         }
         tree.commitUpdate(update);