Primeiro commit do projeto Angular

This commit is contained in:
2026-03-14 20:41:55 +00:00
parent 9bebe1de72
commit 94f4f46395
22413 changed files with 3221690 additions and 0 deletions
@@ -0,0 +1,117 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
require('@angular-devkit/core');
require('node:path/posix');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
var migrations = require('@angular/compiler-cli/private/migrations');
var ts = require('typescript');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
require('@angular/compiler-cli');
require('node:path');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
function findArrowFunction(node) {
let current = node;
while (current) {
if (ts.isArrowFunction(current)) {
return current;
}
current = current.parent;
}
return undefined;
}
class AddBootstrapContextToServerMainMigration extends project_paths.TsurgeFunnelMigration {
async analyze(info) {
const replacements = [];
let importManager = null;
for (const sourceFile of info.sourceFiles) {
if (!sourceFile.fileName.endsWith('main.server.ts')) {
continue;
}
const bootstrapAppCalls = [];
ts.forEachChild(sourceFile, function findCalls(node) {
if (ts.isCallExpression(node) &&
ts.isIdentifier(node.expression) &&
node.expression.text === 'bootstrapApplication' &&
node.arguments.length < 3) {
bootstrapAppCalls.push(node);
}
ts.forEachChild(node, findCalls);
});
if (bootstrapAppCalls.length === 0) {
continue;
}
for (const node of bootstrapAppCalls) {
const end = node.arguments[node.arguments.length - 1].getEnd();
replacements.push(new project_paths.Replacement(project_paths.projectFile(sourceFile, info), new project_paths.TextUpdate({
position: end,
end: end,
toInsert: ', context',
})));
const arrowFunction = findArrowFunction(node);
if (arrowFunction && arrowFunction.parameters.length === 0) {
replacements.push(new project_paths.Replacement(project_paths.projectFile(sourceFile, info), new project_paths.TextUpdate({
position: arrowFunction.parameters.end,
end: arrowFunction.parameters.end,
toInsert: 'context: BootstrapContext',
})));
}
}
importManager ??= new migrations.ImportManager({
generateUniqueIdentifier: () => null,
shouldUseSingleQuotes: () => true,
});
importManager.addImport({
exportSymbolName: 'BootstrapContext',
exportModuleSpecifier: '@angular/platform-browser',
requestedFile: sourceFile,
});
}
if (importManager !== null) {
apply_import_manager.applyImportManagerChanges(importManager, replacements, info.sourceFiles, info);
}
return project_paths.confirmAsSerializable({ replacements });
}
async migrate(globalData) {
return project_paths.confirmAsSerializable(globalData);
}
async combine(unitA, unitB) {
const seen = new Set();
const combined = [];
[unitA.replacements, unitB.replacements].forEach((replacements) => {
replacements.forEach((current) => {
const { position, end, toInsert } = current.update.data;
const key = current.projectFile.id + '/' + position + '/' + end + '/' + toInsert;
if (!seen.has(key)) {
seen.add(key);
combined.push(current);
}
});
});
return project_paths.confirmAsSerializable({ replacements: combined });
}
async globalMeta(combinedData) {
return project_paths.confirmAsSerializable(combinedData);
}
async stats() {
return project_paths.confirmAsSerializable({});
}
}
function migrate() {
return async (tree) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: () => new AddBootstrapContextToServerMainMigration(),
});
};
}
exports.migrate = migrate;
@@ -0,0 +1,84 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var migrations = require('@angular/compiler-cli/private/migrations');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
require('@angular/compiler-cli');
require('typescript');
require('node:path');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
var imports = require('./imports-CVmcbVA9.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
/** Migration that moves the import of `ApplicationConfig` from `platform-browser` to `core`. */
class ApplicationConfigCoreMigration extends project_paths.TsurgeFunnelMigration {
async analyze(info) {
const replacements = [];
let importManager = null;
for (const sourceFile of info.sourceFiles) {
const specifier = imports.getImportSpecifier(sourceFile, '@angular/platform-browser', 'ApplicationConfig');
if (!specifier) {
continue;
}
importManager ??= new migrations.ImportManager({
// Prevent the manager from trying to generate a non-conflicting import.
generateUniqueIdentifier: () => null,
shouldUseSingleQuotes: () => true,
});
importManager.removeImport(sourceFile, 'ApplicationConfig', '@angular/platform-browser');
importManager.addImport({
exportSymbolName: 'ApplicationConfig',
exportModuleSpecifier: '@angular/core',
requestedFile: sourceFile,
unsafeAliasOverride: specifier.propertyName ? specifier.name.text : undefined,
});
}
if (importManager !== null) {
apply_import_manager.applyImportManagerChanges(importManager, replacements, info.sourceFiles, info);
}
return project_paths.confirmAsSerializable({ replacements });
}
async migrate(globalData) {
return project_paths.confirmAsSerializable(globalData);
}
async combine(unitA, unitB) {
const seen = new Set();
const combined = [];
[unitA.replacements, unitB.replacements].forEach((replacements) => {
replacements.forEach((current) => {
const { position, end, toInsert } = current.update.data;
const key = current.projectFile.id + '/' + position + '/' + end + '/' + toInsert;
if (!seen.has(key)) {
seen.add(key);
combined.push(current);
}
});
});
return project_paths.confirmAsSerializable({ replacements: combined });
}
async globalMeta(combinedData) {
return project_paths.confirmAsSerializable(combinedData);
}
async stats() {
return project_paths.confirmAsSerializable({});
}
}
function migrate() {
return async (tree) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: () => new ApplicationConfigCoreMigration(),
});
};
}
exports.migrate = migrate;
@@ -0,0 +1,66 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
var compilerCli = require('@angular/compiler-cli');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
/**
* Applies import manager changes, and writes them as replacements the
* given result array.
*/
function applyImportManagerChanges(importManager, replacements, sourceFiles, info) {
const { newImports, updatedImports, deletedImports } = importManager.finalize();
const printer = ts.createPrinter({});
const pathToFile = new Map(sourceFiles.map((s) => [s.fileName, s]));
// Capture new imports
newImports.forEach((newImports, fileName) => {
newImports.forEach((newImport) => {
const printedImport = printer.printNode(ts.EmitHint.Unspecified, newImport, pathToFile.get(fileName));
replacements.push(new project_paths.Replacement(project_paths.projectFile(compilerCli.absoluteFrom(fileName), info), new project_paths.TextUpdate({ position: 0, end: 0, toInsert: `${printedImport}\n` })));
});
});
// Capture updated imports
for (const [oldBindings, newBindings] of updatedImports.entries()) {
// The import will be generated as multi-line if it already is multi-line,
// or if the number of elements significantly increased and it previously
// consisted of very few specifiers.
const isMultiline = oldBindings.getText().includes('\n') ||
(newBindings.elements.length >= 6 && oldBindings.elements.length <= 3);
const hasSpaceBetweenBraces = oldBindings.getText().startsWith('{ ');
let formatFlags = ts.ListFormat.NamedImportsOrExportsElements |
ts.ListFormat.Indented |
ts.ListFormat.Braces |
ts.ListFormat.PreserveLines |
(isMultiline ? ts.ListFormat.MultiLine : ts.ListFormat.SingleLine);
if (hasSpaceBetweenBraces) {
formatFlags |= ts.ListFormat.SpaceBetweenBraces;
}
else {
formatFlags &= ~ts.ListFormat.SpaceBetweenBraces;
}
const printedBindings = printer.printList(formatFlags, newBindings.elements, oldBindings.getSourceFile());
replacements.push(new project_paths.Replacement(project_paths.projectFile(oldBindings.getSourceFile(), info), new project_paths.TextUpdate({
position: oldBindings.getStart(),
end: oldBindings.getEnd(),
// TS uses four spaces as indent. We migrate to two spaces as we
// assume this to be more common.
toInsert: printedBindings.replace(/^ {4}/gm, ' '),
})));
}
// Update removed imports
for (const removedImport of deletedImports) {
replacements.push(new project_paths.Replacement(project_paths.projectFile(removedImport.getSourceFile(), info), new project_paths.TextUpdate({
position: removedImport.getStart(),
end: removedImport.getEnd(),
toInsert: '',
})));
}
}
exports.applyImportManagerChanges = applyImportManagerChanges;
@@ -0,0 +1,644 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
require('@angular-devkit/core');
require('node:path/posix');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
require('@angular/compiler-cli');
var migrations = require('@angular/compiler-cli/private/migrations');
var ts = require('typescript');
require('node:path');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
var property_name = require('./property_name-BCpALNpZ.cjs');
var imports = require('./imports-CVmcbVA9.cjs');
var symbol = require('./symbol-DZeHSR-V.cjs');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
const CORE_PACKAGE = '@angular/core';
const PROVIDE_ZONE_CHANGE_DETECTION = 'provideZoneChangeDetection';
const ZONE_CD_PROVIDER = `${PROVIDE_ZONE_CHANGE_DETECTION}()`;
const SAFE_TO_REMOVE_OPTIONS = [
'ignoreChangesOutsideZone',
'ngZoneRunCoalescing',
'ngZoneEventCoalescing',
];
const BOOTSTRAP_OPTIONS = ['ngZone', ...SAFE_TO_REMOVE_OPTIONS];
class BootstrapOptionsMigration extends project_paths.TsurgeFunnelMigration {
async analyze(info) {
let replacements = [];
const importManager = new migrations.ImportManager();
for (const sourceFile of info.sourceFiles) {
// We need to migration either
// * `bootstrapApplication(App)
// * `platformBrowser().bootstrapModule(AppModule)`
// * `platformBrowserDynamic().bootstrapModule(AppModule)`
// * `TestBed.initTestEnvironment([AppModule], platformBrowserTesting())`
// * `getTestBed.initTestEnvironment([AppModule], platformBrowserTesting())`
const specifiers = getSpecifiers(sourceFile);
// If none of the imports related to bootstraping are present, we can skip the file.
if (specifiers === null)
continue;
const { bootstrapAppSpecifier, testBedSpecifier, createApplicationSpecifier, getTestBedSpecifier, } = specifiers;
const typeChecker = info.program.getTypeChecker();
const isCreateApplicationNode = (node) => {
return (ts.isCallExpression(node) &&
createApplicationSpecifier !== null &&
symbol.isReferenceToImport(typeChecker, node.expression, createApplicationSpecifier));
};
const isBootstrapAppNode = (node) => {
return (ts.isCallExpression(node) &&
bootstrapAppSpecifier !== null &&
symbol.isReferenceToImport(typeChecker, node.expression, bootstrapAppSpecifier));
};
const isBootstrapModuleNode = (node) => {
return (ts.isCallExpression(node) &&
ts.isPropertyAccessExpression(node.expression) &&
node.expression.name.text === 'bootstrapModule' &&
node.arguments.length > 0);
};
const isTestBedInitEnvironmentNode = (node) => {
return (ts.isCallExpression(node) &&
ts.isPropertyAccessExpression(node.expression) &&
node.expression.name.text === 'initTestEnvironment' &&
(symbol.isReferenceToImport(typeChecker, node.expression.expression, testBedSpecifier) ||
symbol.isReferenceToImport(typeChecker, node.expression.expression, getTestBedSpecifier)));
};
const reflector = new migrations.TypeScriptReflectionHost(typeChecker);
const evaluator = new migrations.PartialEvaluator(reflector, typeChecker, null);
const walk = (node) => {
if (isBootstrapAppNode(node)) {
this.analyzeBootstrapApplication(node, sourceFile, info, typeChecker, importManager, replacements);
}
else if (isCreateApplicationNode(node)) {
this.analyzeCreateApplication(node, sourceFile, info, typeChecker, importManager, replacements);
}
else if (isBootstrapModuleNode(node)) {
this.analyzeBootstrapModule(node, sourceFile, reflector, evaluator, info, typeChecker, importManager, replacements);
}
else if (isTestBedInitEnvironmentNode(node)) {
this.analyzeTestBedInitEnvironment(node, sourceFile, info, typeChecker, importManager, replacements);
}
node.forEachChild(walk);
};
sourceFile.forEachChild(walk);
}
apply_import_manager.applyImportManagerChanges(importManager, replacements, info.sourceFiles, info);
return project_paths.confirmAsSerializable({ replacements });
}
async combine(unitA, unitB) {
const combined = [...unitA.replacements, ...unitB.replacements];
return project_paths.confirmAsSerializable({ replacements: combined });
}
async globalMeta(data) {
return project_paths.confirmAsSerializable(data);
}
async stats(data) {
return project_paths.confirmAsSerializable({});
}
async migrate(data) {
return { replacements: data.replacements };
}
analyzeBootstrapApplication(node, sourceFile, info, typeChecker, importManager, replacements) {
const hasExistingChangeDetectionProvider = hasChangeDetectionProvider(node, typeChecker);
if (hasExistingChangeDetectionProvider)
return;
const providerFn = 'provideZoneChangeDetection()';
const optionsNode = node.arguments[1];
const currentProjectFile = project_paths.projectFile(sourceFile, info);
if (optionsNode) {
let optionProjectFile = currentProjectFile;
let optionLiteral;
if (ts.isObjectLiteralExpression(optionsNode)) {
optionLiteral = optionsNode;
addProvidersToBootstrapOption(optionProjectFile, optionLiteral, providerFn, replacements);
}
else if (this.isServerConfigZoneless(optionsNode, typeChecker)) {
// Nothing to migrate for the SSR bootstrap
return;
}
else if (ts.isIdentifier(optionsNode)) {
const text = `{...${optionsNode.getText()}, providers: [${providerFn}, ...${optionsNode.getText()}.providers]}`;
replacements.push(new project_paths.Replacement(currentProjectFile, new project_paths.TextUpdate({
position: optionsNode.getStart(),
end: optionsNode.getEnd(),
toInsert: text,
})));
}
else {
throw new Error('unsupported optionsNode: ' + optionsNode.getText());
}
}
else {
// No options object, add it.
const text = `, {providers: [${providerFn}]}`;
const component = node.arguments[0];
replacements.push(new project_paths.Replacement(currentProjectFile, new project_paths.TextUpdate({ position: component.getEnd(), end: component.getEnd(), toInsert: text })));
}
importManager.addImport({
exportModuleSpecifier: CORE_PACKAGE,
exportSymbolName: 'provideZoneChangeDetection',
requestedFile: sourceFile,
});
}
/**
* The optionsNode can be a appConfig built with mergeApplicationConfig
* In this case we need to analyze if the base config uses provideZonelessChangeDetection
*/
isServerConfigZoneless(optionsNode, typeChecker) {
// Check if optionsNode is a result of mergeApplicationConfig
let symbol = typeChecker.getSymbolAtLocation(optionsNode);
if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {
symbol = typeChecker.getAliasedSymbol(symbol);
}
const optionDeclaration = symbol?.getDeclarations()?.[0];
if (!optionDeclaration) {
return false;
}
if (!ts.isVariableDeclaration(optionDeclaration) ||
!optionDeclaration.initializer ||
!ts.isCallExpression(optionDeclaration.initializer) ||
!ts.isIdentifier(optionDeclaration.initializer.expression) ||
optionDeclaration.initializer.expression.text !== 'mergeApplicationConfig') {
// We didn't find a mergeApplicationConfig call, this isn't a server config
return false;
}
let maybeAppConfig = optionDeclaration.initializer.arguments[0];
if (ts.isIdentifier(maybeAppConfig)) {
const resolved = getObjectLiteralFromIdentifier(maybeAppConfig, typeChecker);
if (resolved) {
maybeAppConfig = resolved;
}
}
if (maybeAppConfig && ts.isObjectLiteralExpression(maybeAppConfig)) {
for (const prop of maybeAppConfig.properties) {
if (ts.isPropertyAssignment(prop) &&
ts.isIdentifier(prop.name) &&
prop.name.text === 'providers' &&
ts.isArrayLiteralExpression(prop.initializer)) {
for (const el of prop.initializer.elements) {
if (ts.isCallExpression(el) &&
ts.isIdentifier(el.expression) &&
el.expression.text === 'provideZonelessChangeDetection') {
return true;
}
}
}
}
}
return false;
}
analyzeCreateApplication(node, sourceFile, info, typeChecker, importManager, replacements) {
const hasExistingChangeDetectionProvider = hasChangeDetectionProvider(node, typeChecker);
if (hasExistingChangeDetectionProvider)
return;
const providerFn = 'provideZoneChangeDetection()';
const optionsNode = node.arguments[0];
const currentProjectFile = project_paths.projectFile(sourceFile, info);
if (optionsNode) {
let optionProjectFile = currentProjectFile;
let optionLiteral;
if (ts.isObjectLiteralExpression(optionsNode)) {
optionLiteral = optionsNode;
addProvidersToBootstrapOption(optionProjectFile, optionLiteral, providerFn, replacements);
}
else if (ts.isIdentifier(optionsNode) ||
ts.isCallExpression(optionsNode) ||
ts.isPropertyAccessExpression(optionsNode)) {
// This is tricky case to handle, in G3 we're might not be able to resolve the identifier's value
// Our best alternative is to assume there is no CD providers set and add the ZoneChangeDetection provider
// In the cases where it is, we'll just override the zone provider we just set by re-used inthe appConfig providers
// TODO: Should we insert a TODO to clean this up ?
const text = `{...${optionsNode.getText()}, providers: [${providerFn}, ...${optionsNode.getText()}.providers]}`;
replacements.push(new project_paths.Replacement(currentProjectFile, new project_paths.TextUpdate({
position: optionsNode.getStart(),
end: optionsNode.getEnd(),
toInsert: text,
})));
}
else {
throw new Error('unsupported optionsNode: ' + optionsNode.getText());
}
}
else {
// No options object, add it.
const text = `{providers: [${providerFn}]}`;
replacements.push(new project_paths.Replacement(currentProjectFile, new project_paths.TextUpdate({
position: node.expression.getEnd() + 1,
end: node.expression.getEnd() + 1,
toInsert: text,
})));
}
importManager.addImport({
exportModuleSpecifier: CORE_PACKAGE,
exportSymbolName: 'provideZoneChangeDetection',
requestedFile: sourceFile,
});
}
analyzeBootstrapModule(node, sourceFile, reflector, evaluator, info, typeChecker, importManager, replacements) {
const moduleIdentifier = node.arguments[0];
const moduleType = evaluator.evaluate(moduleIdentifier);
if (!(moduleType instanceof migrations.Reference) || !ts.isClassDeclaration(moduleType.node)) {
return;
}
const moduleClass = moduleType.node;
const ngModule = findNgModule(moduleClass, reflector);
if (!ngModule) {
return;
}
const optionsNode = node.arguments[1];
const file = project_paths.projectFile(sourceFile, info);
replacements.push(new project_paths.Replacement(file, new project_paths.TextUpdate({
position: moduleIdentifier.getEnd(),
end: node.getEnd() - 1,
toInsert: '',
})));
const hasExistingChangeDetectionProvider = hasChangeDetectionProvider(ngModule, typeChecker);
if (hasExistingChangeDetectionProvider) {
return;
}
// Let's try to understand the bootstrap options.
let options = optionsNode ? evaluator.evaluate(optionsNode) : null;
let extraOptions = new Map();
let zoneCdProvider = ZONE_CD_PROVIDER;
let zoneInstanceProvider = null;
if (Array.isArray(options)) {
const mergedOptions = options.reduce((acc, item) => {
if (item instanceof Map) {
for (const [k, v] of item) {
acc.set(k, v);
if (!SAFE_TO_REMOVE_OPTIONS.includes(k)) {
extraOptions.set(k, v);
}
}
}
return acc;
}, new Map());
options = mergedOptions;
}
if (options instanceof Map) {
[...options.entries()].forEach(([k, v]) => {
if (!BOOTSTRAP_OPTIONS.includes(k) && typeof v !== 'string') {
extraOptions.set(k, v);
}
});
if (options.has('ngZoneRunCoalescing') || options.has('ngZoneEventCoalescing')) {
const config = [];
if (options.get('ngZoneRunCoalescing')) {
config.push('runCoalescing: true');
}
if (options.get('ngZoneEventCoalescing')) {
config.push('eventCoalescing: true');
}
zoneCdProvider = `${PROVIDE_ZONE_CHANGE_DETECTION}(${config.length > 0 ? `{ ${config.join(', ')} }` : ''})`;
}
const ngZoneOption = options.get('ngZone');
if (ngZoneOption instanceof migrations.Reference) {
const clazz = ngZoneOption.node;
if (ts.isClassDeclaration(clazz) && clazz.name) {
zoneInstanceProvider = `{provide: NgZone, useClass: ${clazz.name.text}}`;
removePropertiesFromLiteral(file, optionsNode, ['ngZone'], replacements);
}
}
else if (typeof ngZoneOption === 'string') {
if (ngZoneOption === 'noop') {
return;
}
}
else if (ngZoneOption && typeof ngZoneOption !== 'string') {
// This is a case where we're not able to migrate automatically
// The migration fails gracefully, keeps the ngZone option and adds a TODO.
let ngZoneValue;
optionsNode.properties.forEach((p) => {
if (ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === 'ngZone') {
ngZoneValue = p.initializer.getText();
}
else if (ts.isShorthandPropertyAssignment(p) && p.name.text === 'ngZone') {
ngZoneValue = p.name.text;
}
});
if (ngZoneValue) {
// We re-add the ngZone option
extraOptions.set('ngZone', ngZoneValue);
}
replacements.push(new project_paths.Replacement(project_paths.projectFile(sourceFile, info), new project_paths.TextUpdate({
position: node.getStart() - 1,
end: node.getStart() - 1,
toInsert: '// TODO: BootstrapOptions are deprecated & ignored. Configure NgZone in the providers array of the application module instead.',
})));
}
}
const providers = [zoneCdProvider];
if (zoneInstanceProvider) {
providers.push(zoneInstanceProvider);
}
importManager.addImport({
exportModuleSpecifier: CORE_PACKAGE,
exportSymbolName: PROVIDE_ZONE_CHANGE_DETECTION,
requestedFile: sourceFile,
});
// if we only use the key, we use the a shorthand asignment
const extraOptionsStr = [...extraOptions.entries()]
.map(([k, v]) => (k != v ? `${k}: ${v},` : `${k},`))
.join(', ');
replacements.push(new project_paths.Replacement(file, new project_paths.TextUpdate({
position: moduleIdentifier.end,
end: moduleIdentifier.end,
toInsert: `, { applicationProviders: [${providers.join(', ')}], ${extraOptionsStr}}`,
})));
}
analyzeTestBedInitEnvironment(callExpr, sourceFile, info, typeChecker, importManager, replacements) {
const hasExistingChangeDetectionProvider = hasChangeDetectionProvider(callExpr, typeChecker);
if (hasExistingChangeDetectionProvider)
return;
const ngModules = callExpr.arguments[0];
const moduleProjectFile = project_paths.projectFile(sourceFile, info);
importManager.addImport({
exportModuleSpecifier: CORE_PACKAGE,
exportSymbolName: PROVIDE_ZONE_CHANGE_DETECTION,
requestedFile: sourceFile,
});
let tmpNode = callExpr;
let insertPosition = 0;
while (tmpNode.parent.kind !== ts.SyntaxKind.SourceFile) {
insertPosition = tmpNode.parent.getStart(sourceFile, true) - 1;
tmpNode = tmpNode.parent;
}
importManager.addImport({
exportModuleSpecifier: CORE_PACKAGE,
exportSymbolName: 'NgModule',
requestedFile: sourceFile,
});
addZoneCDModule(ZONE_CD_PROVIDER, moduleProjectFile, insertPosition, replacements);
insertZoneCDModule(ngModules, moduleProjectFile, replacements, 'ZoneChangeDetectionModule');
}
}
function addZoneCDModule(providersText, projectFile, location, replacements) {
const newModuleText = `\n@NgModule({ providers: [ ${providersText} ] })
export class ZoneChangeDetectionModule {}\n\n`;
if (replacementsHaveZoneCdModule(projectFile.rootRelativePath, replacements, newModuleText)) {
return;
}
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: location,
end: location,
toInsert: newModuleText,
})));
}
function insertZoneCDModule(node, projectFile, replacements, importedModule) {
if (ts.isArrayLiteralExpression(node)) {
const literal = node;
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: literal.elements[0]?.getStart() ?? literal.getEnd() - 1,
end: literal.elements[0]?.getStart() ?? literal.getEnd() - 1,
toInsert: importedModule + ',',
})));
}
else if (ts.isIdentifier(node)) {
// This should be a good enough heuristic to determine if the identifier is not array
let isArray = !node.text.endsWith('Module');
// Because if it's an array, we need to spread it
const newImports = `[${importedModule}, ${isArray ? '...' : ''}${node.text}]`;
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: node.getStart(),
end: node.getEnd(),
toInsert: newImports,
})));
}
else {
throw new Error('unsupported importsNode: ' + node.getText());
}
}
function addProvidersToBootstrapOption(projectFile, optionsNode, providersText, replacements) {
const providersProp = property_name.findLiteralProperty(optionsNode, 'providers');
if (providersProp && ts.isPropertyAssignment(providersProp)) {
// Can be bootstrap(App, {providers: [...]}), bootstrap(App, {providers}), bootstrap(App, {...appConfig, providers}) etc.
if (ts.isArrayLiteralExpression(providersProp.initializer)) {
const initializer = providersProp.initializer;
const text = `${providersText},`;
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: initializer.elements[0]?.getStart() ?? initializer.getEnd() - 1,
end: initializer.elements[0]?.getStart() ?? initializer.getEnd() - 1,
toInsert: text,
})));
}
else if (ts.isIdentifier(providersProp.initializer)) {
const newProviders = `[${providersText}, ...${providersProp.initializer.text}]`;
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: providersProp.initializer.getStart(),
end: providersProp.initializer.getEnd(),
toInsert: newProviders,
})));
}
else {
const newProviders = `[${providersText}, ...`;
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: providersProp.initializer.getStart(),
end: providersProp.initializer.getStart(),
toInsert: newProviders,
})));
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: providersProp.initializer.getEnd(),
end: providersProp.initializer.getEnd(),
toInsert: ']',
})));
}
}
else if (providersProp && ts.isShorthandPropertyAssignment(providersProp)) {
const newProviders = `providers: [${providersText}, ...${providersProp.name.text}]`;
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: providersProp.getStart(),
end: providersProp.getEnd(),
toInsert: newProviders,
})));
}
else if (optionsNode.properties.length === 1 &&
ts.isSpreadAssignment(optionsNode.properties[0])) {
const spread = optionsNode.properties[0];
const newProviders = `, providers: [${providersText}, ...${spread.expression.getText()}.providers]`;
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position: spread.getEnd(),
end: spread.getEnd(),
toInsert: newProviders,
})));
}
else {
const text = `providers: [${providersText}]`;
let toInsert;
let position;
if (optionsNode.properties.length > 0) {
const lastProperty = optionsNode.properties[optionsNode.properties.length - 1];
toInsert = `,\n ${text}`;
position = lastProperty.getEnd();
}
else {
toInsert = `\n ${text}\n`;
position = optionsNode.getStart() + 1;
}
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({
position,
end: position,
toInsert,
})));
}
}
function findNgModule(node, reflector) {
const decorators = reflector.getDecoratorsOfDeclaration(node);
if (decorators) {
const ngModuleDecorator = migrations.getAngularDecorators(decorators, ['NgModule'], true)[0];
if (ngModuleDecorator &&
ngModuleDecorator.args &&
ngModuleDecorator.args.length > 0 &&
ts.isObjectLiteralExpression(ngModuleDecorator.args[0])) {
return ngModuleDecorator.args[0];
}
}
return null;
}
function hasChangeDetectionProvider(expression, // either the bootstrapApplication or platformBrowserDynamic().bootstrapModule()
typeChecker) {
let literal;
if (ts.isCallExpression(expression)) {
let optionsNode = expression.arguments[1];
if (!optionsNode &&
symbol.isReferenceToImport(typeChecker, expression.expression, imports.getImportSpecifier(expression.getSourceFile(), '@angular/core', 'createApplication'))) {
optionsNode = expression.arguments[0];
}
if (!optionsNode)
return false;
if (ts.isIdentifier(optionsNode)) {
literal = getObjectLiteralFromIdentifier(optionsNode, typeChecker);
}
else {
literal = optionsNode;
}
}
else {
literal = expression;
}
if (!literal) {
return false;
}
const provideZoneCdSpecifier = imports.getImportSpecifier(literal.getSourceFile(), '@angular/core', 'provideZoneChangeDetection');
const provideZonelessCdSpecifier = imports.getImportSpecifier(literal.getSourceFile(), '@angular/core', 'provideZonelessChangeDetection');
if (provideZoneCdSpecifier === null && provideZonelessCdSpecifier === null) {
return false;
}
const found = ts.forEachChild(literal, function walk(node) {
if (ts.isCallExpression(node)) {
if (provideZonelessCdSpecifier &&
node.getText().includes(provideZonelessCdSpecifier.getText())) {
return true;
}
if (provideZoneCdSpecifier && node.getText().includes(provideZoneCdSpecifier.getText())) {
return true;
}
}
return ts.forEachChild(node, walk);
});
return !!found;
}
function getObjectLiteralFromIdentifier(identifier, typeChecker) {
let symbol = typeChecker.getSymbolAtLocation(identifier);
if (!symbol)
return;
// Follow aliases (for imported symbols)
if ((symbol.flags & ts.SymbolFlags.Alias) !== 0) {
symbol = typeChecker.getAliasedSymbol(symbol);
}
const declarations = symbol.getDeclarations();
if (!declarations)
return;
for (const decl of declarations) {
if (ts.isVariableDeclaration(decl) &&
decl.initializer &&
ts.isObjectLiteralExpression(decl.initializer)) {
return decl.initializer;
}
}
return;
}
/**
* Extracts the import specifiers related to bootstraping from the source file.
* Returns null if no relevant specifiers are found.
*/
function getSpecifiers(sourceFile) {
const createApplicationSpecifier = imports.getImportSpecifier(sourceFile, '@angular/core', 'createApplication');
const bootstrapAppSpecifier = imports.getImportSpecifier(sourceFile, '@angular/platform-browser', 'bootstrapApplication');
const platformBrowserDynamicSpecifier = imports.getImportSpecifier(sourceFile, '@angular/platform-browser-dynamic', 'platformBrowserDynamic');
const platformBrowserSpecifier = imports.getImportSpecifier(sourceFile, '@angular/platform-browser', 'platformBrowser');
const testBedSpecifier = imports.getImportSpecifier(sourceFile, '@angular/core/testing', 'TestBed');
const getTestBedSpecifier = imports.getImportSpecifier(sourceFile, '@angular/core/testing', 'getTestBed');
const ngModuleSpecifier = imports.getImportSpecifier(sourceFile, '@angular/core', 'NgModule');
if (!createApplicationSpecifier &&
!bootstrapAppSpecifier &&
!platformBrowserSpecifier &&
!platformBrowserDynamicSpecifier &&
!testBedSpecifier &&
!ngModuleSpecifier &&
!getTestBedSpecifier) {
return null;
}
return {
createApplicationSpecifier,
bootstrapAppSpecifier,
platformBrowserDynamicSpecifier,
platformBrowserSpecifier,
testBedSpecifier,
ngModuleSpecifier,
getTestBedSpecifier,
};
}
/**
* In the case we're looking to insert a new ZoneChangeDetectionModule, we need to check if we already inserted one.
*
* This function also checks if the existing one has fewer options (shorter text length), which means the previous migration strategy inserted one
* but the following one is more complete and we should still add it (the dedup function will take care of the cleanup).
*/
function replacementsHaveZoneCdModule(rootRelativePath, replacements, text) {
return replacements.some((replacement) => {
const exisitingText = replacement.update.data.toInsert;
const isSameFile = replacement.projectFile.rootRelativePath === rootRelativePath;
return (isSameFile &&
text.includes('ZoneChangeDetectionModule') &&
exisitingText.length >= text.length);
});
}
function removePropertiesFromLiteral(projectFile, literal, propertyNames, replacements) {
const syntaxList = literal.getChildren().find((ch) => ch.kind === ts.SyntaxKind.SyntaxList);
const optionsElements = syntaxList.getChildren();
const optionsToRemove = [];
optionsElements.forEach((node, i, children) => {
if (ts.isPropertyAssignment(node) &&
ts.isIdentifier(node.name) &&
propertyNames.includes(node.name.text)) {
// Look ahead for comma
const next = children[i + 1];
if (next && next.kind === ts.SyntaxKind.CommaToken) {
optionsToRemove.push({ start: node.getStart(), end: next.getEnd() });
}
else {
optionsToRemove.push({ start: node.getStart(), end: node.getEnd() });
}
}
});
optionsToRemove.forEach((toRemove) => {
replacements.push(new project_paths.Replacement(projectFile, new project_paths.TextUpdate({ position: toRemove.start, end: toRemove.end, toInsert: '' })));
});
}
function migrate() {
return async (tree) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: () => new BootstrapOptionsMigration(),
});
};
}
exports.migrate = migrate;
@@ -0,0 +1,321 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
require('@angular-devkit/core');
require('node:path/posix');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
var ts = require('typescript');
var compilerCli = require('@angular/compiler-cli');
var migrations = require('@angular/compiler-cli/private/migrations');
require('node:path');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
/** Migration that cleans up unused imports from a project. */
class UnusedImportsMigration extends project_paths.TsurgeFunnelMigration {
printer = ts.createPrinter();
createProgram(tsconfigAbsPath, fs) {
return super.createProgram(tsconfigAbsPath, fs, {
extendedDiagnostics: {
checks: {
// Ensure that the diagnostic is enabled.
unusedStandaloneImports: migrations.DiagnosticCategoryLabel.Warning,
},
},
});
}
async analyze(info) {
const nodePositions = new Map();
const replacements = [];
let removedImports = 0;
let changedFiles = 0;
info.ngCompiler?.getDiagnostics().forEach((diag) => {
if (diag.file !== undefined &&
diag.start !== undefined &&
diag.length !== undefined &&
diag.code === compilerCli.ngErrorCode(compilerCli.ErrorCode.UNUSED_STANDALONE_IMPORTS)) {
// Skip files that aren't owned by this compilation unit.
if (!info.sourceFiles.includes(diag.file)) {
return;
}
if (!nodePositions.has(diag.file)) {
nodePositions.set(diag.file, new Set());
}
nodePositions.get(diag.file).add(this.getNodeKey(diag.start, diag.length));
}
});
nodePositions.forEach((locations, sourceFile) => {
const resolvedLocations = this.resolveRemovalLocations(sourceFile, locations);
const usageAnalysis = this.analyzeUsages(sourceFile, resolvedLocations);
if (resolvedLocations.allRemovedIdentifiers.size > 0) {
removedImports += resolvedLocations.allRemovedIdentifiers.size;
changedFiles++;
}
this.generateReplacements(sourceFile, resolvedLocations, usageAnalysis, info, replacements);
});
return project_paths.confirmAsSerializable({ replacements, removedImports, changedFiles });
}
async migrate(globalData) {
return project_paths.confirmAsSerializable(globalData);
}
async combine(unitA, unitB) {
return project_paths.confirmAsSerializable({
replacements: [...unitA.replacements, ...unitB.replacements],
removedImports: unitA.removedImports + unitB.removedImports,
changedFiles: unitA.changedFiles + unitB.changedFiles,
});
}
async globalMeta(combinedData) {
return project_paths.confirmAsSerializable(combinedData);
}
async stats(globalMetadata) {
return project_paths.confirmAsSerializable({
removedImports: globalMetadata.removedImports,
changedFiles: globalMetadata.changedFiles,
});
}
/** Gets a key that can be used to look up a node based on its location. */
getNodeKey(start, length) {
return `${start}/${length}`;
}
/**
* Resolves a set of node locations to the actual AST nodes that need to be migrated.
* @param sourceFile File in which to resolve the locations.
* @param locations Location keys that should be resolved.
*/
resolveRemovalLocations(sourceFile, locations) {
const result = {
fullRemovals: new Set(),
partialRemovals: new Map(),
allRemovedIdentifiers: new Set(),
};
const walk = (node) => {
if (!ts.isIdentifier(node)) {
node.forEachChild(walk);
return;
}
// The TS typings don't reflect that the parent can be undefined.
const parent = node.parent;
if (!parent) {
return;
}
if (locations.has(this.getNodeKey(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.isPropertyAssignment(parent) &&
parent.name === node &&
ts.isArrayLiteralExpression(parent.initializer)) {
result.fullRemovals.add(parent.initializer);
parent.initializer.elements.forEach((element) => {
if (ts.isIdentifier(element)) {
result.allRemovedIdentifiers.add(element.text);
}
});
}
else if (ts.isArrayLiteralExpression(parent)) {
if (!result.partialRemovals.has(parent)) {
result.partialRemovals.set(parent, new Set());
}
result.partialRemovals.get(parent).add(node);
result.allRemovedIdentifiers.add(node.text);
}
}
};
walk(sourceFile);
return result;
}
/**
* Analyzes how identifiers are used across a file.
* @param sourceFile File to be analyzed.
* @param locations Locations that will be changed as a part of this migration.
*/
analyzeUsages(sourceFile, locations) {
const { partialRemovals, fullRemovals } = locations;
const result = {
importedSymbols: new Map(),
identifierCounts: new Map(),
};
const walk = (node) => {
if (ts.isIdentifier(node) &&
node.parent &&
// Don't track individual identifiers marked for removal.
(!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.isArrayLiteralExpression(node) && fullRemovals.has(node)) {
return;
}
if (ts.isImportDeclaration(node)) {
const namedBindings = node.importClause?.namedBindings;
const moduleName = ts.isStringLiteral(node.moduleSpecifier)
? node.moduleSpecifier.text
: null;
if (namedBindings && ts.isNamedImports(namedBindings) && moduleName !== null) {
namedBindings.elements.forEach((imp) => {
if (!result.importedSymbols.has(moduleName)) {
result.importedSymbols.set(moduleName, new Map());
}
const symbolName = (imp.propertyName || imp.name).text;
const localName = imp.name.text;
result.importedSymbols.get(moduleName).set(localName, symbolName);
});
}
// Don't track identifiers in imports.
return;
}
// Track identifiers in all other node kinds.
node.forEachChild(walk);
};
walk(sourceFile);
return result;
}
/**
* Generates text replacements based on the data produced by the migration.
* @param sourceFile File being migrated.
* @param removalLocations Data about nodes being removed.
* @param usages Data about identifier usage.
* @param info Information about the current program.
* @param replacements Array tracking all text replacements.
*/
generateReplacements(sourceFile, removalLocations, usages, info, replacements) {
const { fullRemovals, partialRemovals, allRemovedIdentifiers } = removalLocations;
const { importedSymbols, identifierCounts } = usages;
const importManager = new migrations.ImportManager();
const sourceText = sourceFile.getFullText();
// 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({
position: node.getStart(),
end: node.getEnd(),
toInsert: '[]',
})));
});
// Filter out the unused identifiers from an array.
partialRemovals.forEach((toRemove, parent) => {
toRemove.forEach((node) => {
replacements.push(new project_paths.Replacement(project_paths.projectFile(sourceFile, info), getArrayElementRemovalUpdate(node, sourceText)));
});
stripTrailingSameLineCommas(parent, toRemove, sourceText)?.forEach((update) => {
replacements.push(new project_paths.Replacement(project_paths.projectFile(sourceFile, info), update));
});
});
// Attempt to clean up unused import declarations. Note that this isn't foolproof, because we
// do the matching based on identifier text, rather than going through the type checker which
// can be expensive. This should be enough for the vast majority of cases in this schematic
// since we're dealing exclusively with directive/pipe class names which tend to be very
// specific. In the worst case we may end up not removing an import declaration which would
// still be valid code that the user can clean up themselves.
importedSymbols.forEach((names, moduleName) => {
names.forEach((symbolName, localName) => {
// Note that in the `identifierCounts` lookup both zero and undefined
// are valid and mean that the identifiers isn't being used anymore.
if (allRemovedIdentifiers.has(localName) && !identifierCounts.get(localName)) {
importManager.removeImport(sourceFile, symbolName, moduleName);
}
});
});
apply_import_manager.applyImportManagerChanges(importManager, replacements, [sourceFile], info);
}
}
/** Generates a `TextUpdate` for the removal of an array element. */
function getArrayElementRemovalUpdate(node, sourceText) {
let position = node.getStart();
let end = node.getEnd();
let toInsert = '';
const whitespaceOrLineFeed = /\s/;
// Usually the way we'd remove the nodes would be to recreate the `parent` while excluding
// the nodes that should be removed. The problem with this is that it'll strip out comments
// inside the array which can have special meaning internally. We work around it by removing
// only the node's own offsets. This comes with another problem in that it won't remove the commas
// that separate array elements which in turn can look weird if left in place (e.g.
// `[One, Two, Three, Four]` can turn into `[One,,Four]`). To account for them, we start with the
// node's end offset and then expand it to include trailing commas, whitespace and line breaks.
for (let i = end; i < sourceText.length; i++) {
if (sourceText[i] === ',' || whitespaceOrLineFeed.test(sourceText[i])) {
end++;
}
else {
break;
}
}
return new project_paths.TextUpdate({ position, end, toInsert });
}
/** Returns `TextUpdate`s that will remove any leftover trailing commas on the same line. */
function stripTrailingSameLineCommas(node, toRemove, sourceText) {
let updates = null;
for (let i = 0; i < node.elements.length; i++) {
// Skip over elements that are being removed already.
if (toRemove.has(node.elements[i])) {
continue;
}
// An element might have a trailing comma if all elements after it have been removed.
const mightHaveTrailingComma = node.elements.slice(i + 1).every((e) => toRemove.has(e));
if (!mightHaveTrailingComma) {
continue;
}
const position = node.elements[i].getEnd();
let end = position;
// If the item might have a trailing comma, start looking after it until we hit a line break.
for (let charIndex = position; charIndex < node.getEnd(); charIndex++) {
const char = sourceText[charIndex];
if (char === ',' || char === ' ') {
end++;
}
else {
if (char !== '\n' && position !== end) {
updates ??= [];
updates.push(new project_paths.TextUpdate({ position, end, toInsert: '' }));
}
break;
}
}
}
return updates;
}
function migrate() {
return async (tree, context) => {
await project_paths.runMigrationInDevkit({
getMigration: () => new UnusedImportsMigration(),
tree,
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 unused imports using ${tsconfigPath}`);
},
afterAnalysisFailure: () => {
context.logger.error('Schematic failed unexpectedly with no analysis data');
},
whenDone: ({ removedImports, changedFiles }) => {
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);
},
});
};
}
exports.migrate = migrate;
@@ -0,0 +1,387 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* 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-D2V-Uh2L.cjs');
var ng_component_template = require('./ng_component_template-BOuKAnQd.cjs');
var ng_decorators = require('./ng_decorators-DYy6II6x.cjs');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
var imports = require('./imports-CVmcbVA9.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
require('./property_name-BCpALNpZ.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'] },
// Match ngTemplateOutlet as structural (*ngTemplateOutlet) or property binding [ngTemplateOutlet]
{ pattern: /(\*ngTemplateOutlet\b|\[ngTemplateOutlet\])/g, imports: ['NgTemplateOutlet'] },
// Match ngComponentOutlet as structural (*ngComponentOutlet) or property binding [ngComponentOutlet]
{ pattern: /(\*ngComponentOutlet\b|\[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);
});
// Get existing import names to avoid duplicates
const existingImportNames = new Set(filteredElements.filter((el) => ts.isIdentifier(el)).map((el) => el.getText()));
// Only add imports that don't already exist
const importsToAdd = neededImports
.filter((imp) => !existingImportNames.has(imp))
.sort()
.map((imp) => ts.factory.createIdentifier(imp));
const newElements = [...filteredElements, ...importsToAdd];
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;
@@ -0,0 +1,318 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
var migrations = require('@angular/compiler-cli/private/migrations');
var path = require('path');
function _interopNamespaceDefault(e) {
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
/** Tracks changes that have to be made for specific files. */
class ChangeTracker {
_printer;
_importRemapper;
_changes = new Map();
_importManager;
_quotesCache = new WeakMap();
constructor(_printer, _importRemapper) {
this._printer = _printer;
this._importRemapper = _importRemapper;
this._importManager = new migrations.ImportManager({
shouldUseSingleQuotes: (file) => this._getQuoteKind(file) === 0 /* QuoteKind.SINGLE */,
});
}
/**
* Tracks the insertion of some text.
* @param sourceFile File in which the text is being inserted.
* @param start Index at which the text is insert.
* @param text Text to be inserted.
*/
insertText(sourceFile, index, text) {
this._trackChange(sourceFile, { start: index, text });
}
/**
* Replaces text within a file.
* @param sourceFile File in which to replace the text.
* @param start Index from which to replace the text.
* @param removeLength Length of the text being replaced.
* @param text Text to be inserted instead of the old one.
*/
replaceText(sourceFile, start, removeLength, text) {
this._trackChange(sourceFile, { start, removeLength, text });
}
/**
* Replaces the text of an AST node with a new one.
* @param oldNode Node to be replaced.
* @param newNode New node to be inserted.
* @param emitHint Hint when formatting the text of the new node.
* @param sourceFileWhenPrinting File to use when printing out the new node. This is important
* when copying nodes from one file to another, because TypeScript might not output literal nodes
* without it.
*/
replaceNode(oldNode, newNode, emitHint = ts.EmitHint.Unspecified, sourceFileWhenPrinting) {
const sourceFile = oldNode.getSourceFile();
this.replaceText(sourceFile, oldNode.getStart(), oldNode.getWidth(), this._printer.printNode(emitHint, newNode, sourceFileWhenPrinting || sourceFile));
}
/**
* Removes the text of an AST node from a file.
* @param node Node whose text should be removed.
* @param useFullOffsets Whether to remove the node using its full offset (e.g. `getFullStart`
* rather than `fullStart`). This has the advantage of removing any comments that may be tied
* to the node, but can lead to too much code being deleted.
*/
removeNode(node, useFullOffsets = false) {
this._trackChange(node.getSourceFile(), {
start: useFullOffsets ? node.getFullStart() : node.getStart(),
removeLength: useFullOffsets ? node.getFullWidth() : node.getWidth(),
text: '',
});
}
/**
* Adds an import to a file.
* @param sourceFile File to which to add the import.
* @param symbolName Symbol being imported.
* @param moduleName Module from which the symbol is imported.
* @param alias Alias to use for the import.
*/
addImport(sourceFile, symbolName, moduleName, alias) {
if (this._importRemapper) {
moduleName = this._importRemapper(moduleName, sourceFile.fileName);
}
// It's common for paths to be manipulated with Node's `path` utilties which
// can yield a path with back slashes. Normalize them since outputting such
// paths will also cause TS to escape the forward slashes.
moduleName = normalizePath(moduleName);
if (!this._changes.has(sourceFile)) {
this._changes.set(sourceFile, []);
}
return this._importManager.addImport({
requestedFile: sourceFile,
exportSymbolName: symbolName,
exportModuleSpecifier: moduleName,
unsafeAliasOverride: alias,
});
}
/**
* Removes an import from a file.
* @param sourceFile File from which to remove the import.
* @param symbolName Original name of the symbol to be removed. Used even if the import is aliased.
* @param moduleName Module from which the symbol is imported.
*/
removeImport(sourceFile, symbolName, moduleName) {
// It's common for paths to be manipulated with Node's `path` utilties which
// can yield a path with back slashes. Normalize them since outputting such
// paths will also cause TS to escape the forward slashes.
moduleName = normalizePath(moduleName);
if (!this._changes.has(sourceFile)) {
this._changes.set(sourceFile, []);
}
this._importManager.removeImport(sourceFile, symbolName, moduleName);
}
/**
* Gets the changes that should be applied to all the files in the migration.
* The changes are sorted in the order in which they should be applied.
*/
recordChanges() {
this._recordImports();
return this._changes;
}
/**
* Clear the tracked changes
*/
clearChanges() {
this._changes.clear();
}
/**
* Adds a change to a `ChangesByFile` map.
* @param file File that the change is associated with.
* @param change Change to be added.
*/
_trackChange(file, change) {
const changes = this._changes.get(file);
if (changes) {
// Insert the changes in reverse so that they're applied in reverse order.
// This ensures that the offsets of subsequent changes aren't affected by
// previous changes changing the file's text.
const insertIndex = changes.findIndex((current) => current.start <= change.start);
if (insertIndex === -1) {
changes.push(change);
}
else {
changes.splice(insertIndex, 0, change);
}
}
else {
this._changes.set(file, [change]);
}
}
/** Determines what kind of quotes to use for a specific file. */
_getQuoteKind(sourceFile) {
if (this._quotesCache.has(sourceFile)) {
return this._quotesCache.get(sourceFile);
}
let kind = 0 /* QuoteKind.SINGLE */;
for (const statement of sourceFile.statements) {
if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
kind = statement.moduleSpecifier.getText()[0] === '"' ? 1 /* QuoteKind.DOUBLE */ : 0 /* QuoteKind.SINGLE */;
this._quotesCache.set(sourceFile, kind);
break;
}
}
return kind;
}
/** Records the pending import changes from the import manager. */
_recordImports() {
const { newImports, updatedImports, deletedImports } = this._importManager.finalize();
for (const [original, replacement] of updatedImports) {
this.replaceNode(original, replacement);
}
for (const node of deletedImports) {
this.removeNode(node);
}
for (const [sourceFile] of this._changes) {
const importsToAdd = newImports.get(sourceFile.fileName);
if (!importsToAdd) {
continue;
}
const importLines = [];
let lastImport = null;
for (const statement of sourceFile.statements) {
if (ts.isImportDeclaration(statement)) {
lastImport = statement;
}
}
for (const decl of importsToAdd) {
importLines.push(this._printer.printNode(ts.EmitHint.Unspecified, decl, sourceFile));
}
this.insertText(sourceFile, lastImport ? lastImport.getEnd() : 0, (lastImport ? '\n' : '') + importLines.join('\n'));
}
}
}
/** Normalizes a path to use posix separators. */
function normalizePath(path) {
return path.replace(/\\/g, '/');
}
function parseTsconfigFile(tsconfigPath, basePath) {
const { config } = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
const parseConfigHost = {
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.
// More details can be found here: https://github.com/microsoft/TypeScript/issues/37731.
if (!path__namespace.isAbsolute(basePath)) {
throw Error('Unexpected relative base path has been specified.');
}
return ts.parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
}
/**
* Creates a TypeScript program instance for a TypeScript project within
* the virtual file system tree.
* @param tree Virtual file system tree that contains the source files.
* @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
* @param basePath Base path for the virtual file system tree.
* @param fakeFileRead Optional file reader function. Can be used to overwrite files in
* the TypeScript program, or to add in-memory files (e.g. to add global types).
* @param additionalFiles Additional file paths that should be added to the program.
*/
function createMigrationProgram(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles) {
const { rootNames, options, host } = createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead);
return ts.createProgram(rootNames, options, host);
}
/**
* Creates the options necessary to instantiate a TypeScript program.
* @param tree Virtual file system tree that contains the source files.
* @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
* @param basePath Base path for the virtual file system tree.
* @param fakeFileRead Optional file reader function. Can be used to overwrite files in
* the TypeScript program, or to add in-memory files (e.g. to add global types).
* @param additionalFiles Additional file paths that should be added to the program.
* @param optionOverrides Overrides of the parsed compiler options.
*/
function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles, optionOverrides) {
// Resolve the tsconfig path to an absolute path. This is needed as TypeScript otherwise
// is not able to resolve root directories in the given tsconfig. More details can be found
// in the following issue: https://github.com/microsoft/TypeScript/issues/37731.
tsconfigPath = 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 };
}
function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
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
// if we run multiple migrations we might have intersecting changes and
// source files.
host.readFile = (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
// TypeScript's default file reading function since the `tree` will throw an error.
result = treeRelativePath.startsWith('..')
? defaultReadFile.call(host, fileName)
: tree.read(treeRelativePath)?.toString();
}
// Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset,
// which breaks the CLI UpdateRecorder.
// See: https://github.com/angular/angular/pull/30719
return typeof result === 'string' ? result.replace(/^\uFEFF/, '') : undefined;
};
return host;
}
/**
* Checks whether a file can be migrate by our automated migrations.
* @param basePath Absolute path to the project.
* @param sourceFile File being checked.
* @param program Program that includes the source file.
*/
function canMigrateFile(basePath, sourceFile, program) {
// We shouldn't migrate .d.ts files, files from an external library or type checking files.
if (sourceFile.fileName.endsWith('.ngtypecheck.ts') ||
sourceFile.isDeclarationFile ||
program.isSourceFileFromExternalLibrary(sourceFile)) {
return false;
}
// Our migrations are set up to create a `Program` from the project's tsconfig and to migrate all
// the files within the program. This can include files that are outside of the Angular CLI
// project. We can't migrate files outside of the project, because our file system interactions
// go through the CLI's `Tree` which assumes that all files are within the project. See:
// https://github.com/angular/angular-cli/blob/0b0961c9c233a825b6e4bb59ab7f0790f9b14676/packages/angular_devkit/schematics/src/tree/host-tree.ts#L131
return !path.relative(basePath, sourceFile.fileName).startsWith('..');
}
exports.ChangeTracker = ChangeTracker;
exports.canMigrateFile = canMigrateFile;
exports.createMigrationProgram = createMigrationProgram;
exports.createProgramOptions = createProgramOptions;
exports.normalizePath = normalizePath;
File diff suppressed because it is too large Load Diff
+110
View File
@@ -0,0 +1,110 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
/** Gets import information about the specified identifier by using the Type checker. */
function getImportOfIdentifier(typeChecker, node) {
const symbol = typeChecker.getSymbolAtLocation(node);
if (!symbol || symbol.declarations === undefined || !symbol.declarations.length) {
return null;
}
const decl = symbol.declarations[0];
if (!ts.isImportSpecifier(decl)) {
return null;
}
const importDecl = decl.parent.parent.parent;
if (!ts.isImportDeclaration(importDecl) || !ts.isStringLiteral(importDecl.moduleSpecifier)) {
return null;
}
return {
// Handles aliased imports: e.g. "import {Component as myComp} from ...";
name: decl.propertyName ? decl.propertyName.text : decl.name.text,
importModule: importDecl.moduleSpecifier.text,
node: importDecl,
};
}
/**
* Gets a top-level import specifier with a specific name that is imported from a particular module.
* E.g. given a file that looks like:
*
* ```ts
* import { Component, Directive } from '@angular/core';
* import { Foo } from './foo';
* ```
*
* Calling `getImportSpecifier(sourceFile, '@angular/core', 'Directive')` will yield the node
* referring to `Directive` in the top import.
*
* @param sourceFile File in which to look for imports.
* @param moduleName Name of the import's module.
* @param specifierName Original name of the specifier to look for. Aliases will be resolved to
* their original name.
*/
function getImportSpecifier(sourceFile, moduleName, specifierName) {
return getImportSpecifiers(sourceFile, moduleName, specifierName)[0] ?? null;
}
/**
* Note: returns only matching imports specifiers,
* Unmatched imports will be ignored (you won't get undefined), but a shorter array.
*/
function getImportSpecifiers(sourceFile, moduleName, specifierOrSpecifiers) {
const matches = [];
for (const node of sourceFile.statements) {
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.isNamedImports(namedBindings)) {
continue;
}
if (typeof specifierOrSpecifiers === 'string') {
const match = findImportSpecifier(namedBindings.elements, specifierOrSpecifiers);
if (match) {
matches.push(match);
}
}
else {
for (const specifierName of specifierOrSpecifiers) {
const match = findImportSpecifier(namedBindings.elements, specifierName);
if (match) {
matches.push(match);
}
}
}
}
return matches;
}
function getNamedImports(sourceFile, moduleName) {
for (const node of sourceFile.statements) {
if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
const isMatch = node.moduleSpecifier.text === moduleName
;
const namedBindings = node.importClause?.namedBindings;
if (isMatch && namedBindings && ts.isNamedImports(namedBindings)) {
return namedBindings;
}
}
}
return null;
}
/** Finds an import specifier with a particular name. */
function findImportSpecifier(nodes, specifierName) {
return nodes.find((element) => {
const { name, propertyName } = element;
return propertyName ? propertyName.text === specifierName : name.text === specifierName;
});
}
exports.getImportOfIdentifier = getImportOfIdentifier;
exports.getImportSpecifier = getImportSpecifier;
exports.getImportSpecifiers = getImportSpecifiers;
exports.getNamedImports = getNamedImports;
+998
View File
@@ -0,0 +1,998 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
var compilerCli = require('@angular/compiler-cli');
var migrations = require('@angular/compiler-cli/private/migrations');
require('node:path');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
var compiler = require('@angular/compiler');
function getMemberName(member) {
if (member.name === undefined) {
return null;
}
if (ts.isIdentifier(member.name) || ts.isStringLiteralLike(member.name)) {
return member.name.text;
}
if (ts.isPrivateIdentifier(member.name)) {
return `#${member.name.text}`;
}
return null;
}
/** Checks whether the given node can be an `@Input()` declaration node. */
function isInputContainerNode(node) {
return (((ts.isAccessor(node) && ts.isClassDeclaration(node.parent)) ||
ts.isPropertyDeclaration(node)) &&
getMemberName(node) !== null);
}
/**
* Detects `query(By.directive(T)).componentInstance` patterns and enhances
* them with information of `T`. This is important because `.componentInstance`
* is currently typed as `any` and may cause runtime test failures after input
* migrations then.
*
* The reference resolution pass leverages information from this pattern
* recognizer.
*/
class DebugElementComponentInstance {
checker;
cache = new WeakMap();
constructor(checker) {
this.checker = checker;
}
detect(node) {
if (this.cache.has(node)) {
return this.cache.get(node);
}
if (!ts.isPropertyAccessExpression(node)) {
return null;
}
// Check for `<>.componentInstance`.
if (!ts.isIdentifier(node.name) || node.name.text !== 'componentInstance') {
return null;
}
// Check for `<>.query(..).<>`.
if (!ts.isCallExpression(node.expression) ||
!ts.isPropertyAccessExpression(node.expression.expression) ||
!ts.isIdentifier(node.expression.expression.name) ||
node.expression.expression.name.text !== 'query') {
return null;
}
const queryCall = node.expression;
if (queryCall.arguments.length !== 1) {
return null;
}
const queryArg = queryCall.arguments[0];
let typeExpr;
if (ts.isCallExpression(queryArg) &&
queryArg.arguments.length === 1 &&
ts.isIdentifier(queryArg.arguments[0])) {
// Detect references, like: `query(By.directive(T))`.
typeExpr = queryArg.arguments[0];
}
else if (ts.isIdentifier(queryArg)) {
// Detect references, like: `harness.query(T)`.
typeExpr = queryArg;
}
else {
return null;
}
const symbol = this.checker.getSymbolAtLocation(typeExpr);
if (symbol?.valueDeclaration === undefined ||
!ts.isClassDeclaration(symbol?.valueDeclaration)) {
// Cache this as we use the expensive type checker.
this.cache.set(node, null);
return null;
}
const type = this.checker.getTypeAtLocation(symbol.valueDeclaration);
this.cache.set(node, type);
return type;
}
}
/**
* Recognizes `Partial<T>` instances in Catalyst tests. Those type queries
* are likely used for typing property initialization values for the given class `T`
* and we have a few scenarios:
*
* 1. The API does not unwrap signal inputs. In which case, the values are likely no
* longer assignable to an `InputSignal`.
* 2. The API does unwrap signal inputs, in which case we need to unwrap the `Partial`
* because the values are raw initial values, like they were before.
*
* We can enable this heuristic when we detect Catalyst as we know it supports unwrapping.
*/
class PartialDirectiveTypeInCatalystTests {
checker;
knownFields;
constructor(checker, knownFields) {
this.checker = checker;
this.knownFields = knownFields;
}
detect(node) {
// Detect `Partial<...>`
if (!ts.isTypeReferenceNode(node) ||
!ts.isIdentifier(node.typeName) ||
node.typeName.text !== 'Partial') {
return null;
}
// Ignore if the source file doesn't reference Catalyst.
if (!node.getSourceFile().text.includes('angular2/testing/catalyst')) {
return null;
}
// Extract T of `Partial<T>`.
const cmpTypeArg = node.typeArguments?.[0];
if (!cmpTypeArg ||
!ts.isTypeReferenceNode(cmpTypeArg) ||
!ts.isIdentifier(cmpTypeArg.typeName)) {
return null;
}
const cmpType = cmpTypeArg.typeName;
const symbol = this.checker.getSymbolAtLocation(cmpType);
// Note: Technically the class might be derived of an input-containing class,
// but this is out of scope for now. We can expand if we see it's a common case.
if (symbol?.valueDeclaration === undefined ||
!ts.isClassDeclaration(symbol.valueDeclaration) ||
!this.knownFields.shouldTrackClassReference(symbol.valueDeclaration)) {
return null;
}
return { referenceNode: node, targetClass: symbol.valueDeclaration };
}
}
/**
* Attempts to look up the given property access chain using
* the type checker.
*
* Notably this is not as safe as using the type checker directly to
* retrieve symbols of a given identifier, but in some cases this is
* a necessary approach to compensate e.g. for a lack of TCB information
* when processing Angular templates.
*
* The path is a list of properties to be accessed sequentially on the
* given type.
*/
function lookupPropertyAccess(checker, type, path, options = {}) {
let symbol = null;
for (const propName of path) {
// Note: We support assuming `NonNullable` for the pathl This is necessary
// in some situations as otherwise the lookups would fail to resolve the target
// symbol just because of e.g. a ternary. This is used in the signal input migration
// for host bindings.
type = options.ignoreNullability ? type.getNonNullableType() : type;
const propSymbol = type.getProperty(propName);
if (propSymbol === undefined) {
return null;
}
symbol = propSymbol;
type = checker.getTypeOfSymbol(propSymbol);
}
if (symbol === null) {
return null;
}
return { symbol, type };
}
/**
* AST visitor that iterates through a template and finds all
* input references.
*
* This resolution is important to be able to migrate references to inputs
* that will be migrated to signal inputs.
*/
class TemplateReferenceVisitor extends compiler.TmplAstRecursiveVisitor {
result = [];
/**
* Whether we are currently descending into HTML AST nodes
* where all bound attributes are considered potentially narrowing.
*
* Keeps track of all referenced inputs in such attribute expressions.
*/
templateAttributeReferencedFields = null;
expressionVisitor;
seenKnownFieldsCount = new Map();
constructor(typeChecker, templateTypeChecker, componentClass, knownFields, fieldNamesToConsiderForReferenceLookup) {
super();
this.expressionVisitor = new TemplateExpressionReferenceVisitor(typeChecker, templateTypeChecker, componentClass, knownFields, fieldNamesToConsiderForReferenceLookup);
}
checkExpressionForReferencedFields(activeNode, expressionNode) {
const referencedFields = this.expressionVisitor.checkTemplateExpression(activeNode, expressionNode);
// Add all references to the overall visitor result.
this.result.push(...referencedFields);
// Count usages of seen input references. We'll use this to make decisions
// based on whether inputs are potentially narrowed or not.
for (const input of referencedFields) {
this.seenKnownFieldsCount.set(input.targetField.key, (this.seenKnownFieldsCount.get(input.targetField.key) ?? 0) + 1);
}
return referencedFields;
}
descendAndCheckForNarrowedSimilarReferences(potentiallyNarrowedInputs, descend) {
const inputs = potentiallyNarrowedInputs.map((i) => ({
ref: i,
key: i.targetField.key,
pastCount: this.seenKnownFieldsCount.get(i.targetField.key) ?? 0,
}));
descend();
for (const input of inputs) {
// Input was referenced inside a narrowable spot, and is used in child nodes.
// This is a sign for the input to be narrowed. Mark it as such.
if ((this.seenKnownFieldsCount.get(input.key) ?? 0) > input.pastCount) {
input.ref.isLikelyNarrowed = true;
}
}
}
visitTemplate(template) {
// Note: We assume all bound expressions for templates may be subject
// to TCB narrowing. This is relevant for now until we support narrowing
// of signal calls in templates.
// TODO: Remove with: https://github.com/angular/angular/pull/55456.
this.templateAttributeReferencedFields = [];
compiler.tmplAstVisitAll(this, template.attributes);
compiler.tmplAstVisitAll(this, template.templateAttrs);
// If we are dealing with a microsyntax template, do not check
// inputs and outputs as those are already passed to the children.
// Template attributes may contain relevant expressions though.
if (template.tagName === 'ng-template') {
compiler.tmplAstVisitAll(this, template.inputs);
compiler.tmplAstVisitAll(this, template.outputs);
}
const referencedInputs = this.templateAttributeReferencedFields;
this.templateAttributeReferencedFields = null;
this.descendAndCheckForNarrowedSimilarReferences(referencedInputs, () => {
compiler.tmplAstVisitAll(this, template.children);
compiler.tmplAstVisitAll(this, template.references);
compiler.tmplAstVisitAll(this, template.variables);
});
}
visitIfBlockBranch(block) {
if (block.expression) {
const referencedFields = this.checkExpressionForReferencedFields(block, block.expression);
this.descendAndCheckForNarrowedSimilarReferences(referencedFields, () => {
super.visitIfBlockBranch(block);
});
}
else {
super.visitIfBlockBranch(block);
}
}
visitForLoopBlock(block) {
this.checkExpressionForReferencedFields(block, block.expression);
this.checkExpressionForReferencedFields(block, block.trackBy);
super.visitForLoopBlock(block);
}
visitSwitchBlock(block) {
const referencedFields = this.checkExpressionForReferencedFields(block, block.expression);
this.descendAndCheckForNarrowedSimilarReferences(referencedFields, () => {
super.visitSwitchBlock(block);
});
}
visitSwitchBlockCase(block) {
if (block.expression) {
const referencedFields = this.checkExpressionForReferencedFields(block, block.expression);
this.descendAndCheckForNarrowedSimilarReferences(referencedFields, () => {
super.visitSwitchBlockCase(block);
});
}
else {
super.visitSwitchBlockCase(block);
}
}
visitDeferredBlock(deferred) {
if (deferred.triggers.when) {
this.checkExpressionForReferencedFields(deferred, deferred.triggers.when.value);
}
if (deferred.prefetchTriggers.when) {
this.checkExpressionForReferencedFields(deferred, deferred.prefetchTriggers.when.value);
}
super.visitDeferredBlock(deferred);
}
visitBoundText(text) {
this.checkExpressionForReferencedFields(text, text.value);
}
visitBoundEvent(attribute) {
this.checkExpressionForReferencedFields(attribute, attribute.handler);
}
visitBoundAttribute(attribute) {
const referencedFields = this.checkExpressionForReferencedFields(attribute, attribute.value);
// Attributes inside templates are potentially "narrowed" and hence we
// keep track of all referenced inputs to see if they actually are.
if (this.templateAttributeReferencedFields !== null) {
this.templateAttributeReferencedFields.push(...referencedFields);
}
}
}
/**
* Expression AST visitor that checks whether a given expression references
* a known `@Input()`.
*
* This resolution is important to be able to migrate references to inputs
* that will be migrated to signal inputs.
*/
class TemplateExpressionReferenceVisitor extends compiler.RecursiveAstVisitor {
typeChecker;
templateTypeChecker;
componentClass;
knownFields;
fieldNamesToConsiderForReferenceLookup;
activeTmplAstNode = null;
detectedInputReferences = [];
isInsideObjectShorthandExpression = false;
insideConditionalExpressionsWithReads = [];
constructor(typeChecker, templateTypeChecker, componentClass, knownFields, fieldNamesToConsiderForReferenceLookup) {
super();
this.typeChecker = typeChecker;
this.templateTypeChecker = templateTypeChecker;
this.componentClass = componentClass;
this.knownFields = knownFields;
this.fieldNamesToConsiderForReferenceLookup = fieldNamesToConsiderForReferenceLookup;
}
/** Checks the given AST expression. */
checkTemplateExpression(activeNode, expressionNode) {
this.detectedInputReferences = [];
this.activeTmplAstNode = activeNode;
expressionNode.visit(this, []);
return this.detectedInputReferences;
}
visit(ast, context) {
super.visit(ast, [...context, ast]);
}
// Keep track when we are inside an object shorthand expression. This is
// necessary as we need to expand the shorthand to invoke a potential new signal.
// E.g. `{bla}` may be transformed to `{bla: bla()}`.
visitLiteralMap(ast, context) {
for (const [idx, key] of ast.keys.entries()) {
this.isInsideObjectShorthandExpression =
key.kind === 'property' && !!key.isShorthandInitialized;
ast.values[idx].visit(this, context);
this.isInsideObjectShorthandExpression = false;
}
}
visitPropertyRead(ast, context) {
this._inspectPropertyAccess(ast, false, context);
super.visitPropertyRead(ast, context);
}
visitSafePropertyRead(ast, context) {
this._inspectPropertyAccess(ast, false, context);
super.visitPropertyRead(ast, context);
}
visitBinary(ast, context) {
if (ast.operation === '=' && ast.left instanceof compiler.PropertyRead) {
this._inspectPropertyAccess(ast.left, true, [...context, ast, ast.left]);
}
else {
super.visitBinary(ast, context);
}
}
visitConditional(ast, context) {
this.visit(ast.condition, context);
this.insideConditionalExpressionsWithReads.push(ast.condition);
this.visit(ast.trueExp, context);
this.visit(ast.falseExp, context);
this.insideConditionalExpressionsWithReads.pop();
}
/**
* Inspects the property access and attempts to resolve whether they access
* a known field. If so, the result is captured.
*/
_inspectPropertyAccess(ast, isAssignment, astPath) {
if (this.fieldNamesToConsiderForReferenceLookup !== null &&
!this.fieldNamesToConsiderForReferenceLookup.has(ast.name)) {
return;
}
const isWrite = !!(isAssignment ||
(this.activeTmplAstNode && isTwoWayBindingNode(this.activeTmplAstNode)));
this._checkAccessViaTemplateTypeCheckBlock(ast, isWrite, astPath) ||
this._checkAccessViaOwningComponentClassType(ast, isWrite, astPath);
}
/**
* Checks whether the node refers to an input using the TCB information.
* Type check block may not exist for e.g. test components, so this can return `null`.
*/
_checkAccessViaTemplateTypeCheckBlock(ast, isWrite, astPath) {
// There might be no template type checker. E.g. if we check host bindings.
if (this.templateTypeChecker === null) {
return false;
}
const symbol = this.templateTypeChecker.getSymbolOfNode(ast, this.componentClass);
if (symbol?.kind !== migrations.SymbolKind.Expression || symbol.tsSymbol === null) {
return false;
}
// Dangerous: Type checking symbol retrieval is a totally different `ts.Program`,
// than the one where we analyzed `knownInputs`.
// --> Find the input via its input id.
const targetInput = this.knownFields.attemptRetrieveDescriptorFromSymbol(symbol.tsSymbol);
if (targetInput === null) {
return false;
}
this.detectedInputReferences.push({
targetNode: targetInput.node,
targetField: targetInput,
read: ast,
readAstPath: astPath,
context: this.activeTmplAstNode,
isLikelyNarrowed: this._isPartOfNarrowingTernary(ast),
isObjectShorthandExpression: this.isInsideObjectShorthandExpression,
isWrite,
});
return true;
}
/**
* Simple resolution checking whether the given AST refers to a known input.
* This is a fallback for when there is no type checking information (e.g. in host bindings).
*
* It attempts to resolve references by traversing accesses of the "component class" type.
* e.g. `this.bla` is resolved via `CompType#bla` and further.
*/
_checkAccessViaOwningComponentClassType(ast, isWrite, astPath) {
// We might check host bindings, which can never point to template variables or local refs.
const expressionTemplateTarget = this.templateTypeChecker === null
? null
: this.templateTypeChecker.getExpressionTarget(ast, this.componentClass);
// Skip checking if:
// - the reference resolves to a template variable or local ref. No way to resolve without TCB.
// - the owning component does not have a name (should not happen technically).
if (expressionTemplateTarget !== null || this.componentClass.name === undefined) {
return;
}
const property = traverseReceiverAndLookupSymbol(ast, this.componentClass, this.typeChecker);
if (property === null) {
return;
}
const matchingTarget = this.knownFields.attemptRetrieveDescriptorFromSymbol(property);
if (matchingTarget === null) {
return;
}
this.detectedInputReferences.push({
targetNode: matchingTarget.node,
targetField: matchingTarget,
read: ast,
readAstPath: astPath,
context: this.activeTmplAstNode,
isLikelyNarrowed: this._isPartOfNarrowingTernary(ast),
isObjectShorthandExpression: this.isInsideObjectShorthandExpression,
isWrite,
});
}
_isPartOfNarrowingTernary(read) {
// Note: We do not safe check that the reads are fully matching 1:1. This is acceptable
// as worst case we just skip an input from being migrated. This is very unlikely too.
return this.insideConditionalExpressionsWithReads.some((r) => (r instanceof compiler.PropertyRead || r instanceof compiler.SafePropertyRead) && r.name === read.name);
}
}
/**
* Emulates an access to a given field using the TypeScript `ts.Type`
* of the given class. The resolved symbol of the access is returned.
*/
function traverseReceiverAndLookupSymbol(readOrWrite, componentClass, checker) {
const path = [readOrWrite.name];
let node = readOrWrite;
while (node.receiver instanceof compiler.PropertyRead) {
node = node.receiver;
path.unshift(node.name);
}
if (!(node.receiver instanceof compiler.ImplicitReceiver)) {
return null;
}
const classType = checker.getTypeAtLocation(componentClass.name);
return (lookupPropertyAccess(checker, classType, path, {
// Necessary to avoid breaking the resolution if there is
// some narrowing involved. E.g. `myClass ? myClass.input`.
ignoreNullability: true,
})?.symbol ?? null);
}
/** Whether the given node refers to a two-way binding AST node. */
function isTwoWayBindingNode(node) {
return ((node instanceof compiler.TmplAstBoundAttribute && node.type === compiler.BindingType.TwoWay) ||
(node instanceof compiler.TmplAstBoundEvent && node.type === compiler.ParsedEventType.TwoWay));
}
/** Possible types of references to known fields detected. */
exports.ReferenceKind = void 0;
(function (ReferenceKind) {
ReferenceKind[ReferenceKind["InTemplate"] = 0] = "InTemplate";
ReferenceKind[ReferenceKind["InHostBinding"] = 1] = "InHostBinding";
ReferenceKind[ReferenceKind["TsReference"] = 2] = "TsReference";
ReferenceKind[ReferenceKind["TsClassTypeReference"] = 3] = "TsClassTypeReference";
})(exports.ReferenceKind || (exports.ReferenceKind = {}));
/** Whether the given reference is a TypeScript reference. */
function isTsReference(ref) {
return ref.kind === exports.ReferenceKind.TsReference;
}
/** Whether the given reference is a template reference. */
function isTemplateReference(ref) {
return ref.kind === exports.ReferenceKind.InTemplate;
}
/** Whether the given reference is a host binding reference. */
function isHostBindingReference(ref) {
return ref.kind === exports.ReferenceKind.InHostBinding;
}
/**
* Whether the given reference is a TypeScript `ts.Type` reference
* to a class containing known fields.
*/
function isTsClassTypeReference(ref) {
return ref.kind === exports.ReferenceKind.TsClassTypeReference;
}
/**
* Checks host bindings of the given class and tracks all
* references to inputs within bindings.
*/
function identifyHostBindingReferences(node, programInfo, checker, reflector, result, knownFields, fieldNamesToConsiderForReferenceLookup) {
if (node.name === undefined) {
return;
}
const decorators = reflector.getDecoratorsOfDeclaration(node);
if (decorators === null) {
return;
}
const angularDecorators = migrations.getAngularDecorators(decorators, ['Directive', 'Component'],
/* isAngularCore */ false);
if (angularDecorators.length === 0) {
return;
}
// Assume only one Angular decorator per class.
const ngDecorator = angularDecorators[0];
if (ngDecorator.args?.length !== 1) {
return;
}
const metadataNode = migrations.unwrapExpression(ngDecorator.args[0]);
if (!ts.isObjectLiteralExpression(metadataNode)) {
return;
}
const metadata = migrations.reflectObjectLiteral(metadataNode);
if (!metadata.has('host')) {
return;
}
let hostField = migrations.unwrapExpression(metadata.get('host'));
// Special-case in case host bindings are shared via a variable.
// e.g. Material button shares host bindings as a constant in the same target.
if (ts.isIdentifier(hostField)) {
let symbol = checker.getSymbolAtLocation(hostField);
// Plain identifier references can point to alias symbols (e.g. imports).
if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
symbol = checker.getAliasedSymbol(symbol);
}
if (symbol !== undefined &&
symbol.valueDeclaration !== undefined &&
ts.isVariableDeclaration(symbol.valueDeclaration)) {
hostField = symbol?.valueDeclaration.initializer;
}
}
if (hostField === undefined || !ts.isObjectLiteralExpression(hostField)) {
return;
}
const hostMap = migrations.reflectObjectLiteral(hostField);
const expressionResult = [];
const expressionVisitor = new TemplateExpressionReferenceVisitor(checker, null, node, knownFields, fieldNamesToConsiderForReferenceLookup);
for (const [rawName, expression] of hostMap.entries()) {
if (!ts.isStringLiteralLike(expression)) {
continue;
}
const isEventBinding = rawName.startsWith('(');
const isPropertyBinding = rawName.startsWith('[');
// Only migrate property or event bindings.
if (!isPropertyBinding && !isEventBinding) {
continue;
}
const parser = compiler.makeBindingParser();
const sourceSpan = new compiler.ParseSourceSpan(
// Fake source span to keep parsing offsets zero-based.
// We then later combine these with the expression TS node offsets.
new compiler.ParseLocation({ content: '', url: '' }, 0, 0, 0), new compiler.ParseLocation({ content: '', url: '' }, 0, 0, 0));
const name = rawName.substring(1, rawName.length - 1);
let parsed = undefined;
if (isEventBinding) {
const result = [];
parser.parseEvent(name.substring(1, name.length - 1), expression.text, false, sourceSpan, sourceSpan, [], result, sourceSpan);
parsed = result[0].handler;
}
else {
const result = [];
parser.parsePropertyBinding(name, expression.text, true,
/* isTwoWayBinding */ false, sourceSpan, 0, sourceSpan, [], result, sourceSpan);
parsed = result[0].expression;
}
if (parsed != null) {
expressionResult.push(...expressionVisitor.checkTemplateExpression(expression, parsed));
}
}
for (const ref of expressionResult) {
result.references.push({
kind: exports.ReferenceKind.InHostBinding,
from: {
read: ref.read,
readAstPath: ref.readAstPath,
isObjectShorthandExpression: ref.isObjectShorthandExpression,
isWrite: ref.isWrite,
file: project_paths.projectFile(ref.context.getSourceFile(), programInfo),
hostPropertyNode: ref.context,
},
target: ref.targetField,
});
}
}
/**
* Attempts to extract the `TemplateDefinition` for the given
* class, if possible.
*
* The definition can then be used with the Angular compiler to
* load/parse the given template.
*/
function attemptExtractTemplateDefinition(node, checker, reflector, resourceLoader) {
const classDecorators = reflector.getDecoratorsOfDeclaration(node);
const evaluator = new migrations.PartialEvaluator(reflector, checker, null);
const ngDecorators = classDecorators !== null
? migrations.getAngularDecorators(classDecorators, ['Component'], /* isAngularCore */ false)
: [];
if (ngDecorators.length === 0 ||
ngDecorators[0].args === null ||
ngDecorators[0].args.length === 0 ||
!ts.isObjectLiteralExpression(ngDecorators[0].args[0])) {
return null;
}
const properties = migrations.reflectObjectLiteral(ngDecorators[0].args[0]);
const templateProp = properties.get('template');
const templateUrlProp = properties.get('templateUrl');
const containingFile = node.getSourceFile().fileName;
// inline template.
if (templateProp !== undefined) {
const templateStr = evaluator.evaluate(templateProp);
if (typeof templateStr === 'string') {
return {
isInline: true,
expression: templateProp,
preserveWhitespaces: false,
resolvedTemplateUrl: containingFile,
templateUrl: containingFile,
};
}
}
try {
// external template.
if (templateUrlProp !== undefined) {
const templateUrl = evaluator.evaluate(templateUrlProp);
if (typeof templateUrl === 'string') {
return {
isInline: false,
preserveWhitespaces: false,
templateUrlExpression: templateUrlProp,
templateUrl,
resolvedTemplateUrl: resourceLoader.resolve(templateUrl, containingFile),
};
}
}
}
catch (e) {
console.error(`Could not parse external template: ${e}`);
}
return null;
}
/**
* Checks whether the given class has an Angular template, and resolves
* all of the references to inputs.
*/
function identifyTemplateReferences(programInfo, node, reflector, checker, evaluator, templateTypeChecker, resourceLoader, options, result, knownFields, fieldNamesToConsiderForReferenceLookup) {
const template = templateTypeChecker.getTemplate(node, compilerCli.OptimizeFor.WholeProgram) ??
// If there is no template registered in the TCB or compiler, the template may
// be skipped due to an explicit `jit: true` setting. We try to detect this case
// and parse the template manually.
extractTemplateWithoutCompilerAnalysis(node, checker, reflector, resourceLoader, evaluator, options);
if (template !== null) {
const visitor = new TemplateReferenceVisitor(checker, templateTypeChecker, node, knownFields, fieldNamesToConsiderForReferenceLookup);
template.forEach((node) => node.visit(visitor));
for (const res of visitor.result) {
const templateFilePath = res.context.sourceSpan.start.file.url;
// Templates without an URL are non-mappable artifacts of e.g.
// string concatenated templates. See the `indirect` template
// source mapping concept in the compiler. We skip such references
// as those cannot be migrated, but print an error for now.
if (templateFilePath === '') {
// TODO: Incorporate a TODO potentially.
console.error(`Found reference to field ${res.targetField.key} that cannot be ` +
`migrated because the template cannot be parsed with source map information ` +
`(in file: ${node.getSourceFile().fileName}).`);
continue;
}
result.references.push({
kind: exports.ReferenceKind.InTemplate,
from: {
read: res.read,
readAstPath: res.readAstPath,
node: res.context,
isObjectShorthandExpression: res.isObjectShorthandExpression,
originatingTsFile: project_paths.projectFile(node.getSourceFile(), programInfo),
templateFile: project_paths.projectFile(compilerCli.absoluteFrom(templateFilePath), programInfo),
isLikelyPartOfNarrowing: res.isLikelyNarrowed,
isWrite: res.isWrite,
},
target: res.targetField,
});
}
}
}
/**
* Attempts to extract a `@Component` template from the given class,
* without relying on the `NgCompiler` program analysis.
*
* This is useful for JIT components using `jit: true` which were not
* processed by the Angular compiler, but may still have templates that
* contain references to inputs that we can resolve via the fallback
* reference resolutions (that does not use the type check block).
*/
function extractTemplateWithoutCompilerAnalysis(node, checker, reflector, resourceLoader, evaluator, options) {
if (node.name === undefined) {
return null;
}
const tmplDef = attemptExtractTemplateDefinition(node, checker, reflector, resourceLoader);
if (tmplDef === null) {
return null;
}
return migrations.extractTemplate(node, tmplDef, evaluator, null, resourceLoader, {
enableBlockSyntax: true,
enableLetSyntax: true,
usePoisonedData: true,
enableI18nLegacyMessageIdFormat: options.enableI18nLegacyMessageIdFormat !== false,
i18nNormalizeLineEndingsInICUs: options.i18nNormalizeLineEndingsInICUs === true,
enableSelectorless: false,
}, migrations.CompilationMode.FULL).nodes;
}
/** Gets the pattern and property name for a given binding element. */
function resolveBindingElement(node) {
const name = node.propertyName ?? node.name;
// If we are discovering a non-analyzable element in the path, abort.
if (!ts.isStringLiteralLike(name) && !ts.isIdentifier(name)) {
return null;
}
return {
pattern: node.parent,
propertyName: name.text,
};
}
/** Gets the declaration node of the given binding element. */
function getBindingElementDeclaration(node) {
while (true) {
if (ts.isBindingElement(node.parent.parent)) {
node = node.parent.parent;
}
else {
return node.parent.parent;
}
}
}
/**
* Expands the given reference to its containing expression, capturing
* the full context.
*
* E.g. `traverseAccess(ref<`bla`>)` may return `this.bla`
* or `traverseAccess(ref<`bla`>)` may return `this.someObj.a.b.c.bla`.
*
* This helper is useful as we will replace the full access with a temporary
* variable for narrowing. Replacing just the identifier is wrong.
*/
function traverseAccess(access) {
if (ts.isPropertyAccessExpression(access.parent) && access.parent.name === access) {
return access.parent;
}
else if (ts.isElementAccessExpression(access.parent) &&
access.parent.argumentExpression === access) {
return access.parent;
}
return access;
}
/**
* Unwraps the parent of the given node, if it's a
* parenthesized expression or `as` expression.
*/
function unwrapParent(node) {
if (ts.isParenthesizedExpression(node.parent)) {
return unwrapParent(node.parent);
}
else if (ts.isAsExpression(node.parent)) {
return unwrapParent(node.parent);
}
return node;
}
/**
* List of binary operators that indicate a write operation.
*
* Useful for figuring out whether an expression assigns to
* something or not.
*/
const writeBinaryOperators = [
ts.SyntaxKind.EqualsToken,
ts.SyntaxKind.BarBarEqualsToken,
ts.SyntaxKind.BarEqualsToken,
ts.SyntaxKind.AmpersandEqualsToken,
ts.SyntaxKind.AmpersandAmpersandEqualsToken,
ts.SyntaxKind.SlashEqualsToken,
ts.SyntaxKind.MinusEqualsToken,
ts.SyntaxKind.PlusEqualsToken,
ts.SyntaxKind.CaretEqualsToken,
ts.SyntaxKind.PercentEqualsToken,
ts.SyntaxKind.AsteriskEqualsToken,
ts.SyntaxKind.ExclamationEqualsToken,
];
/**
* Checks whether given TypeScript reference refers to an Angular input, and captures
* the reference if possible.
*
* @param fieldNamesToConsiderForReferenceLookup List of field names that should be
* respected when expensively looking up references to known fields.
* May be null if all identifiers should be inspected.
*/
function identifyPotentialTypeScriptReference(node, programInfo, checker, knownFields, result, fieldNamesToConsiderForReferenceLookup, advisors) {
// Skip all identifiers that never can point to a migrated field.
// TODO: Capture these assumptions and performance optimizations in the design doc.
if (fieldNamesToConsiderForReferenceLookup !== null &&
!fieldNamesToConsiderForReferenceLookup.has(node.text)) {
return;
}
let target = undefined;
try {
// Resolve binding elements to their declaration symbol.
// Commonly inputs are accessed via object expansion. e.g. `const {input} = this;`.
if (ts.isBindingElement(node.parent)) {
// Skip binding elements that are using spread.
if (node.parent.dotDotDotToken !== undefined) {
return;
}
const bindingInfo = resolveBindingElement(node.parent);
if (bindingInfo === null) {
// The declaration could not be resolved. Skip analyzing this.
return;
}
const bindingType = checker.getTypeAtLocation(bindingInfo.pattern);
const resolved = lookupPropertyAccess(checker, bindingType, [bindingInfo.propertyName]);
target = resolved?.symbol;
}
else {
target = checker.getSymbolAtLocation(node);
}
}
catch (e) {
console.error('Unexpected error while trying to resolve identifier reference:');
console.error(e);
// Gracefully skip analyzing. This can happen when e.g. a reference is named similar
// to an input, but is dependant on `.d.ts` that is not necessarily available (clutz dts).
return;
}
noTargetSymbolCheck: if (target === undefined) {
if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
const propAccessSymbol = checker.getSymbolAtLocation(node.parent.expression);
if (propAccessSymbol !== undefined &&
propAccessSymbol.valueDeclaration !== undefined &&
ts.isVariableDeclaration(propAccessSymbol.valueDeclaration) &&
propAccessSymbol.valueDeclaration.initializer !== undefined) {
target = advisors.debugElComponentInstanceTracker
.detect(propAccessSymbol.valueDeclaration.initializer)
?.getProperty(node.text);
// We found a target in the fallback path. Break out.
if (target !== undefined) {
break noTargetSymbolCheck;
}
}
}
return;
}
let targetInput = knownFields.attemptRetrieveDescriptorFromSymbol(target);
if (targetInput === null) {
return;
}
const access = unwrapParent(traverseAccess(node));
const accessParent = access.parent;
const isWriteReference = ts.isBinaryExpression(accessParent) &&
accessParent.left === access &&
writeBinaryOperators.includes(accessParent.operatorToken.kind);
// track accesses from source files to known fields.
result.references.push({
kind: exports.ReferenceKind.TsReference,
from: {
node,
file: project_paths.projectFile(node.getSourceFile(), programInfo),
isWrite: isWriteReference,
isPartOfElementBinding: ts.isBindingElement(node.parent),
},
target: targetInput,
});
}
/**
* Phase where we iterate through all source file references and
* detect references to known fields (e.g. commonly inputs).
*
* This is useful, for example in the signal input migration whe
* references need to be migrated to unwrap signals, given that
* their target properties is no longer holding a raw value, but
* instead an `InputSignal`.
*
* This phase detects references in all types of locations:
* - TS source files
* - Angular templates (inline or external)
* - Host binding expressions.
*/
function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, knownFields, fieldNamesToConsiderForReferenceLookup, result) {
const debugElComponentInstanceTracker = new DebugElementComponentInstance(checker);
const partialDirectiveCatalystTracker = new PartialDirectiveTypeInCatalystTests(checker, knownFields);
const perfCounters = {
template: 0,
hostBindings: 0,
tsReferences: 0,
tsTypes: 0,
};
// Schematic NodeJS execution may not have `global.performance` defined.
const currentTimeInMs = () => typeof global.performance !== 'undefined' ? global.performance.now() : Date.now();
const visitor = (node) => {
let lastTime = currentTimeInMs();
// Note: If there is no template type checker and resource loader, we aren't processing
// an Angular program, and can skip template detection.
if (ts.isClassDeclaration(node) && templateTypeChecker !== null && resourceLoader !== null) {
identifyTemplateReferences(programInfo, node, reflector, checker, evaluator, templateTypeChecker, resourceLoader, programInfo.userOptions, result, knownFields, fieldNamesToConsiderForReferenceLookup);
perfCounters.template += (currentTimeInMs() - lastTime) / 1000;
lastTime = currentTimeInMs();
identifyHostBindingReferences(node, programInfo, checker, reflector, result, knownFields, fieldNamesToConsiderForReferenceLookup);
perfCounters.hostBindings += (currentTimeInMs() - lastTime) / 1000;
lastTime = currentTimeInMs();
}
lastTime = currentTimeInMs();
// find references, but do not capture input declarations itself.
if (ts.isIdentifier(node) &&
!(isInputContainerNode(node.parent) && node.parent.name === node)) {
identifyPotentialTypeScriptReference(node, programInfo, checker, knownFields, result, fieldNamesToConsiderForReferenceLookup, {
debugElComponentInstanceTracker,
});
}
perfCounters.tsReferences += (currentTimeInMs() - lastTime) / 1000;
lastTime = currentTimeInMs();
// Detect `Partial<T>` references.
// Those are relevant to be tracked as they may be updated in Catalyst to
// unwrap signal inputs. Commonly people use `Partial` in Catalyst to type
// some "component initial values".
const partialDirectiveInCatalyst = partialDirectiveCatalystTracker.detect(node);
if (partialDirectiveInCatalyst !== null) {
result.references.push({
kind: exports.ReferenceKind.TsClassTypeReference,
from: {
file: project_paths.projectFile(partialDirectiveInCatalyst.referenceNode.getSourceFile(), programInfo),
node: partialDirectiveInCatalyst.referenceNode,
},
isPartialReference: true,
isPartOfCatalystFile: true,
target: partialDirectiveInCatalyst.targetClass,
});
}
perfCounters.tsTypes += (currentTimeInMs() - lastTime) / 1000;
};
return {
visitor,
debugPrintMetrics: () => {
console.info('Source file analysis performance', perfCounters);
},
};
}
exports.createFindAllSourceFileReferencesVisitor = createFindAllSourceFileReferencesVisitor;
exports.getBindingElementDeclaration = getBindingElementDeclaration;
exports.getMemberName = getMemberName;
exports.isHostBindingReference = isHostBindingReference;
exports.isInputContainerNode = isInputContainerNode;
exports.isTemplateReference = isTemplateReference;
exports.isTsClassTypeReference = isTsClassTypeReference;
exports.isTsReference = isTsReference;
exports.traverseAccess = traverseAccess;
exports.unwrapParent = unwrapParent;
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,30 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
/**
* Gets the leading line whitespace of a given node.
*
* Useful for inserting e.g. TODOs without breaking indentation.
*/
function getLeadingLineWhitespaceOfNode(node) {
const fullText = node.getFullText().substring(0, node.getStart() - node.getFullStart());
let result = '';
for (let i = fullText.length - 1; i > -1; i--) {
// Note: LF line endings are `\n` while CRLF are `\r\n`. This logic should cover both, because
// we start from the beginning of the node and go backwards so will always hit `\n` first.
if (fullText[i] !== '\n') {
result = fullText[i] + result;
}
else {
break;
}
}
return result;
}
exports.getLeadingLineWhitespaceOfNode = getLeadingLineWhitespaceOfNode;
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,185 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
var compilerCli = require('@angular/compiler-cli');
var ng_decorators = require('./ng_decorators-DYy6II6x.cjs');
var property_name = require('./property_name-BCpALNpZ.cjs');
/**
* Unwraps a given expression TypeScript node. Expressions can be wrapped within multiple
* parentheses or as expression. e.g. "(((({exp}))))()". The function should return the
* TypeScript node referring to the inner expression. e.g "exp".
*/
function unwrapExpression(node) {
if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node)) {
return unwrapExpression(node.expression);
}
else {
return node;
}
}
/** Extracts `@Directive` or `@Component` metadata from the given class. */
function extractAngularClassMetadata(typeChecker, node) {
const decorators = ts.getDecorators(node);
if (!decorators || !decorators.length) {
return null;
}
const ngDecorators = ng_decorators.getAngularDecorators(typeChecker, decorators);
const componentDecorator = ngDecorators.find((dec) => dec.name === 'Component');
const directiveDecorator = ngDecorators.find((dec) => dec.name === 'Directive');
const decorator = componentDecorator ?? directiveDecorator;
// In case no decorator could be found on the current class, skip.
if (!decorator) {
return null;
}
const decoratorCall = decorator.node.expression;
// In case the decorator call is not valid, skip this class declaration.
if (decoratorCall.arguments.length !== 1) {
return null;
}
const metadata = unwrapExpression(decoratorCall.arguments[0]);
// Ensure that the metadata is an object literal expression.
if (!ts.isObjectLiteralExpression(metadata)) {
return null;
}
return {
type: componentDecorator ? 'component' : 'directive',
node: metadata,
};
}
const LF_CHAR = 10;
const CR_CHAR = 13;
const LINE_SEP_CHAR = 8232;
const PARAGRAPH_CHAR = 8233;
/** Gets the line and character for the given position from the line starts map. */
function getLineAndCharacterFromPosition(lineStartsMap, position) {
const lineIndex = findClosestLineStartPosition(lineStartsMap, position);
return { character: position - lineStartsMap[lineIndex], line: lineIndex };
}
/**
* Computes the line start map of the given text. This can be used in order to
* retrieve the line and character of a given text position index.
*/
function computeLineStartsMap(text) {
const result = [0];
let pos = 0;
while (pos < text.length) {
const char = text.charCodeAt(pos++);
// Handles the "CRLF" line break. In that case we peek the character
// after the "CR" and check if it is a line feed.
if (char === CR_CHAR) {
if (text.charCodeAt(pos) === LF_CHAR) {
pos++;
}
result.push(pos);
}
else if (char === LF_CHAR || char === LINE_SEP_CHAR || char === PARAGRAPH_CHAR) {
result.push(pos);
}
}
result.push(pos);
return result;
}
/** Finds the closest line start for the given position. */
function findClosestLineStartPosition(linesMap, position, low = 0, high = linesMap.length - 1) {
while (low <= high) {
const pivotIdx = Math.floor((low + high) / 2);
const pivotEl = linesMap[pivotIdx];
if (pivotEl === position) {
return pivotIdx;
}
else if (position > pivotEl) {
low = pivotIdx + 1;
}
else {
high = pivotIdx - 1;
}
}
// In case there was no exact match, return the closest "lower" line index. We also
// subtract the index by one because want the index of the previous line start.
return low - 1;
}
/**
* Visitor that can be used to determine Angular templates referenced within given
* TypeScript source files (inline templates or external referenced templates)
*/
class NgComponentTemplateVisitor {
typeChecker;
resolvedTemplates = [];
fs = compilerCli.getFileSystem();
constructor(typeChecker) {
this.typeChecker = typeChecker;
}
visitNode(node) {
if (node.kind === ts.SyntaxKind.ClassDeclaration) {
this.visitClassDeclaration(node);
}
ts.forEachChild(node, (n) => this.visitNode(n));
}
visitClassDeclaration(node) {
const metadata = extractAngularClassMetadata(this.typeChecker, node);
if (metadata === null || metadata.type !== 'component') {
return;
}
const sourceFile = node.getSourceFile();
const sourceFileName = sourceFile.fileName;
// Walk through all component metadata properties and determine the referenced
// HTML templates (either external or inline)
metadata.node.properties.forEach((property) => {
if (!ts.isPropertyAssignment(property)) {
return;
}
const propertyName = property_name.getPropertyNameText(property.name);
// In case there is an inline template specified, ensure that the value is statically
// analyzable by checking if the initializer is a string literal-like node.
if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {
// Need to add an offset of one to the start because the template quotes are
// not part of the template content.
// The `getText()` method gives us the original raw text.
// We could have used the `text` property, but if the template is defined as a backtick
// string then the `text` property contains a "cooked" version of the string. Such cooked
// strings will have converted CRLF characters to only LF. This messes up string
// replacements in template migrations.
// The raw text returned by `getText()` includes the enclosing quotes so we change the
// `content` and `start` values accordingly.
const content = property.initializer.getText().slice(1, -1);
const start = property.initializer.getStart() + 1;
this.resolvedTemplates.push({
filePath: sourceFileName,
container: node,
content,
inline: true,
start: start,
getCharacterAndLineOfPosition: (pos) => ts.getLineAndCharacterOfPosition(sourceFile, pos + start),
});
}
if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {
const absolutePath = this.fs.resolve(this.fs.dirname(sourceFileName), property.initializer.text);
if (!this.fs.exists(absolutePath)) {
return;
}
const fileContent = this.fs.readFile(absolutePath);
const lineStartsMap = computeLineStartsMap(fileContent);
this.resolvedTemplates.push({
filePath: absolutePath,
container: node,
content: fileContent,
inline: false,
start: 0,
getCharacterAndLineOfPosition: (pos) => getLineAndCharacterFromPosition(lineStartsMap, pos),
});
}
});
}
}
exports.NgComponentTemplateVisitor = NgComponentTemplateVisitor;
@@ -0,0 +1,39 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
var imports = require('./imports-CVmcbVA9.cjs');
function getCallDecoratorImport(typeChecker, decorator) {
// Note that this does not cover the edge case where decorators are called from
// a namespace import: e.g. "@core.Component()". This is not handled by Ngtsc either.
if (!ts.isCallExpression(decorator.expression) ||
!ts.isIdentifier(decorator.expression.expression)) {
return null;
}
const identifier = decorator.expression.expression;
return imports.getImportOfIdentifier(typeChecker, identifier);
}
/**
* Gets all decorators which are imported from an Angular package (e.g. "@angular/core")
* from a list of decorators.
*/
function getAngularDecorators(typeChecker, decorators) {
return decorators
.map((node) => ({ node, importData: getCallDecoratorImport(typeChecker, node) }))
.filter(({ importData }) => importData && importData.importModule.startsWith('@angular/'))
.map(({ node, importData }) => ({
node: node,
name: importData.name,
moduleName: importData.importModule,
importNode: importData.node,
}));
}
exports.getAngularDecorators = getAngularDecorators;
@@ -0,0 +1,542 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* 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-D2V-Uh2L.cjs');
var compiler = require('@angular/compiler');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
var imports = require('./imports-CVmcbVA9.cjs');
var parse_html = require('./parse_html-C8eKA9px.cjs');
var ng_component_template = require('./ng_component_template-BOuKAnQd.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
require('./ng_decorators-DYy6II6x.cjs');
require('./property_name-BCpALNpZ.cjs');
const ngClassStr = 'NgClass';
const commonModuleStr = '@angular/common';
const commonModuleImportsStr = 'CommonModule';
function migrateNgClassBindings(template, config, componentNode, typeChecker) {
const parsed = parse_html.parseTemplate(template);
if (!parsed.tree || !parsed.tree.rootNodes.length) {
return { migrated: template, changed: false, replacementCount: 0, canRemoveCommonModule: false };
}
const visitor = new NgClassCollector(template, componentNode, typeChecker);
compiler.visitAll(visitor, parsed.tree.rootNodes, config);
let newTemplate = template;
let changedOffset = 0;
let replacementCount = 0;
for (const { start, end, replacement } of visitor.replacements) {
const currentLength = newTemplate.length;
newTemplate = replaceTemplate(newTemplate, replacement, start, end, changedOffset);
changedOffset += newTemplate.length - currentLength;
replacementCount++;
}
const changed = newTemplate !== template;
return {
migrated: newTemplate,
changed,
replacementCount,
canRemoveCommonModule: changed ? parse_html.canRemoveCommonModule(newTemplate) : false,
};
}
/**
* Creates a Replacement to remove `NgClass` from a component's `imports` array.
* Uses ReflectionHost + PartialEvaluator for robust AST analysis.
*/
function createNgClassImportsArrayRemoval(classNode, file, typeChecker, removeCommonModule) {
const reflector = new migrations.TypeScriptReflectionHost(typeChecker);
const evaluator = new migrations.PartialEvaluator(reflector, typeChecker, null);
// Use ReflectionHost to get decorators instead of manual AST traversal
const decorators = reflector.getDecoratorsOfDeclaration(classNode);
if (!decorators) {
return null;
}
// Find @Component decorator using ReflectionHost
const componentDecorator = decorators.find((decorator) => decorator.name === 'Component');
if (!componentDecorator || !componentDecorator.args || componentDecorator.args.length === 0) {
return null;
}
// Use PartialEvaluator to evaluate the decorator metadata
const decoratorMetadata = evaluator.evaluate(componentDecorator.args[0]);
if (!decoratorMetadata || typeof decoratorMetadata !== 'object') {
return null;
}
// Get the actual AST node for the imports property
const componentDecoratorNode = componentDecorator.node;
if (!ts.isDecorator(componentDecoratorNode) ||
!ts.isCallExpression(componentDecoratorNode.expression) ||
!ts.isObjectLiteralExpression(componentDecoratorNode.expression.arguments[0])) {
return null;
}
const objLiteral = componentDecoratorNode.expression.arguments[0];
const importsProperty = objLiteral.properties.find((p) => ts.isPropertyAssignment(p) &&
p.name.getText() === 'imports' &&
ts.isArrayLiteralExpression(p.initializer));
if (!importsProperty || !ts.isArrayLiteralExpression(importsProperty.initializer)) {
return null;
}
const importsArray = importsProperty.initializer;
const elementsToRemove = new Set([ngClassStr]);
if (removeCommonModule) {
elementsToRemove.add(commonModuleImportsStr);
}
const originalElements = importsArray.elements;
const filteredElements = originalElements.filter((el) => !ts.isIdentifier(el) || !elementsToRemove.has(el.text));
if (filteredElements.length === originalElements.length) {
return null; // No changes needed.
}
// If the array becomes empty, remove the entire `imports` property.
if (filteredElements.length === 0) {
const removalRange = getPropertyRemovalRange(importsProperty);
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: removalRange.start,
end: removalRange.end,
toInsert: '',
}));
}
const printer = ts.createPrinter();
const newArray = ts.factory.updateArrayLiteralExpression(importsArray, filteredElements);
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 getPropertyRemovalRange(property) {
const parent = property.parent;
if (!ts.isObjectLiteralExpression(parent)) {
return { start: property.getStart(), end: property.getEnd() };
}
const properties = parent.properties;
const propertyIndex = properties.indexOf(property);
const end = property.getEnd();
if (propertyIndex < properties.length - 1) {
const nextProperty = properties[propertyIndex + 1];
return { start: property.getStart(), end: nextProperty.getStart() };
}
return { start: property.getStart(), end };
}
function calculateImportReplacements(info, sourceFiles, filesToRemoveCommonModule) {
const importReplacements = {};
const importManager = new migrations.ImportManager();
for (const sf of sourceFiles) {
const file = project_paths.projectFile(sf, info);
// Always remove NgClass if it's imported directly.
importManager.removeImport(sf, ngClassStr, commonModuleStr);
// Conditionally remove CommonModule if it's no longer needed.
if (filesToRemoveCommonModule.has(file.id)) {
importManager.removeImport(sf, commonModuleImportsStr, commonModuleStr);
}
const addRemove = [];
apply_import_manager.applyImportManagerChanges(importManager, addRemove, [sf], info);
if (addRemove.length > 0) {
importReplacements[file.id] = {
add: [],
addAndRemove: addRemove,
};
}
}
return importReplacements;
}
function replaceTemplate(template, replaceValue, start, end, offset) {
return template.slice(0, start + offset) + replaceValue + template.slice(end + offset);
}
/**
* Visitor class that scans Angular templates and collects replacements
* for [ngClass] bindings that use static object literals.
*/
class NgClassCollector extends compiler.RecursiveVisitor {
componentNode;
typeChecker;
replacements = [];
originalTemplate;
isNgClassImported = true; // Default to true (permissive)
constructor(template, componentNode, typeChecker) {
super();
this.componentNode = componentNode;
this.typeChecker = typeChecker;
this.originalTemplate = template;
// If we have enough information, check if NgClass is actually imported.
// If not, we can confidently disable the migration for this component.
if (componentNode && typeChecker) {
const imports$1 = imports.getImportSpecifiers(componentNode.getSourceFile(), commonModuleStr, [
ngClassStr,
commonModuleImportsStr,
]);
if (imports$1.length === 0) {
this.isNgClassImported = false;
}
}
}
visitElement(element, config) {
// If NgClass is not imported, do not attempt to migrate.
if (!this.isNgClassImported) {
return;
}
for (const attr of element.attrs) {
if (attr.name === '[ngClass]' && attr.valueSpan) {
const expr = this.originalTemplate.slice(attr.valueSpan.start.offset, attr.valueSpan.end.offset);
const staticMatch = tryParseStaticObjectLiteral(expr);
if (staticMatch === null) {
continue;
}
let replacement;
if (staticMatch.length === 0) {
replacement = '[class]=""';
}
else if (staticMatch.length === 1) {
const { key, value } = staticMatch[0];
// Special case: If the key is an empty string, use [class]=""
if (key === '') {
replacement = '[class]=""';
}
else {
// Normal single condition: use [class.className]="condition"
replacement = `[class.${key}]="${value}"`;
}
}
else {
// Check if all entries have the same value (condition)
const allSameValue = staticMatch.every((entry) => entry.value === staticMatch[0].value);
if (allSameValue &&
staticMatch.length > 1 &&
// Check if this was originally a single key with multiple classes
expr.includes('{') &&
expr.includes('}') &&
expr.split(':').length === 2) {
// Multiple classes with the same condition: use [class.class1]="condition" [class.class2]="condition"
if (config.migrateSpaceSeparatedKey) {
replacement = staticMatch
.map(({ key, value }) => `[class.${key}]="${value}"`)
.join(' ');
}
else {
continue;
}
}
else {
// Multiple conditions with different values: use [class]="{'class1': condition1, 'class2': condition2}"
replacement = `[class]="${expr}"`;
}
}
this.replacements.push({
start: attr.sourceSpan.start.offset,
end: attr.sourceSpan.end.offset,
replacement,
});
continue;
}
if (attr.name === 'ngClass' && attr.value) {
this.replacements.push({
start: attr.sourceSpan.start.offset,
end: attr.sourceSpan.end.offset,
replacement: `class="${attr.value}"`,
});
}
}
return super.visitElement(element, config);
}
}
function tryParseStaticObjectLiteral(expr) {
const trimmedExpr = expr.trim();
if (trimmedExpr === '{}' || trimmedExpr === '[]') {
return [];
}
if (!isObjectLiteralSyntax(trimmedExpr)) {
return null;
}
try {
const objectLiteral = parseAsObjectLiteral(trimmedExpr);
if (!objectLiteral) {
return null;
}
return extractClassBindings(objectLiteral);
}
catch {
return null;
}
}
/**
* Validates basic object literal syntax
*/
function isObjectLiteralSyntax(expr) {
return expr.startsWith('{') && expr.endsWith('}');
}
/**
* Parses expression as TypeScript object literal
*/
function parseAsObjectLiteral(expr) {
try {
const sourceFile = ts.createSourceFile('temp.ts', `const obj = ${expr}`, ts.ScriptTarget.Latest, true);
const variableStatement = sourceFile.statements[0];
if (!ts.isVariableStatement(variableStatement)) {
return null;
}
const declaration = variableStatement.declarationList.declarations[0];
if (!declaration.initializer || !ts.isObjectLiteralExpression(declaration.initializer)) {
return null;
}
// Manage invalid syntax ngClass="{class1 class2}"
const content = expr.slice(1, -1).trim();
if (content && !content.includes(':') && content.includes(' ') && !content.includes(',')) {
return null;
}
return declaration.initializer;
}
catch (error) {
return null;
}
}
/**
* Extracts class bindings from object literal properties
*/
function extractClassBindings(objectLiteral) {
const result = [];
for (const property of objectLiteral.properties) {
if (ts.isShorthandPropertyAssignment(property)) {
const key = property.name.getText();
if (key.includes(' ')) {
return null;
}
result.push({ key, value: key });
}
else if (ts.isPropertyAssignment(property)) {
const keyText = extractPropertyKey(property.name);
const valueText = extractPropertyValue(property.initializer);
if (keyText === '' && valueText) {
result.push({ key: '', value: valueText });
}
else {
if (!keyText || !valueText) {
return null;
}
// Handle multiple CSS classes in single key (e.g., 'class1 class2': condition)
const classNames = keyText.split(/\s+/).filter(Boolean);
for (const className of classNames) {
result.push({ key: className, value: valueText });
}
}
}
else {
return null;
}
}
return result;
}
/**
* Extracts text from property key (name)
*/
function extractPropertyKey(name) {
if (ts.isIdentifier(name)) {
return name.text;
}
if (ts.isStringLiteral(name)) {
return name.text;
}
if (ts.isNumericLiteral(name)) {
return name.text;
}
return null;
}
/**
* Extracts text from property value
*/
function extractPropertyValue(initializer) {
// String literals: 'value' or "value"
if (ts.isStringLiteral(initializer)) {
return `'${initializer.text}'`;
}
// Numeric literals: 42, 3.14
if (ts.isNumericLiteral(initializer)) {
return initializer.text;
}
// Boolean and null keywords
if (initializer.kind === ts.SyntaxKind.TrueKeyword) {
return 'true';
}
if (initializer.kind === ts.SyntaxKind.FalseKeyword) {
return 'false';
}
if (initializer.kind === ts.SyntaxKind.NullKeyword) {
return 'null';
}
// Identifiers: isActive, condition, etc.
if (ts.isIdentifier(initializer)) {
return initializer.text;
}
return initializer.getText();
}
class NgClassMigration extends project_paths.TsurgeFunnelMigration {
config;
constructor(config = {}) {
super();
this.config = config;
}
processTemplate(template, node, file, info, typeChecker) {
const { migrated, changed, replacementCount, canRemoveCommonModule } = migrateNgClassBindings(template.content, this.config, node, typeChecker);
if (!changed) {
return null;
}
const fileToMigrate = template.inline
? file
: project_paths.projectFile(template.filePath, info);
const end = template.start + template.content.length;
return {
replacements: [prepareTextReplacement(fileToMigrate, migrated, template.start, end)],
replacementCount,
canRemoveCommonModule,
};
}
async analyze(info) {
const { sourceFiles, program } = info;
const typeChecker = program.getTypeChecker();
const ngClassReplacements = [];
const filesWithNgClassDeclarations = new Set();
const filesToRemoveCommonModule = new Set();
for (const sf of sourceFiles) {
ts.forEachChild(sf, (node) => {
if (!ts.isClassDeclaration(node)) {
return;
}
const file = project_paths.projectFile(sf, info);
if (this.config.shouldMigrate && !this.config.shouldMigrate(file)) {
return;
}
const templateVisitor = new ng_component_template.NgComponentTemplateVisitor(typeChecker);
templateVisitor.visitNode(node);
const replacementsForClass = [];
let replacementCountForClass = 0;
let canRemoveCommonModuleForFile = true;
for (const template of templateVisitor.resolvedTemplates) {
const result = this.processTemplate(template, node, file, info, typeChecker);
if (result) {
replacementsForClass.push(...result.replacements);
replacementCountForClass += result.replacementCount;
if (!result.canRemoveCommonModule) {
canRemoveCommonModuleForFile = false;
}
}
}
if (replacementsForClass.length > 0) {
if (canRemoveCommonModuleForFile) {
filesToRemoveCommonModule.add(file.id);
}
// Handle the `@Component({ imports: [...] })` array.
const importsRemoval = createNgClassImportsArrayRemoval(node, file, typeChecker, canRemoveCommonModuleForFile);
if (importsRemoval) {
replacementsForClass.push(importsRemoval);
}
ngClassReplacements.push({
file,
replacementCount: replacementCountForClass,
replacements: replacementsForClass,
});
filesWithNgClassDeclarations.add(sf);
}
});
}
const importReplacements = calculateImportReplacements(info, filesWithNgClassDeclarations, filesToRemoveCommonModule);
return project_paths.confirmAsSerializable({
ngClassReplacements,
importReplacements,
});
}
async combine(unitA, unitB) {
const importReplacements = {};
for (const unit of [unitA, unitB]) {
for (const fileIDStr of Object.keys(unit.importReplacements)) {
const fileID = fileIDStr;
importReplacements[fileID] = unit.importReplacements[fileID];
}
}
return project_paths.confirmAsSerializable({
ngClassReplacements: [...unitA.ngClassReplacements, ...unitB.ngClassReplacements],
importReplacements,
});
}
async globalMeta(combinedData) {
return project_paths.confirmAsSerializable({
ngClassReplacements: combinedData.ngClassReplacements,
importReplacements: combinedData.importReplacements,
});
}
async stats(globalMetadata) {
const touchedFilesCount = globalMetadata.ngClassReplacements.length;
const replacementCount = globalMetadata.ngClassReplacements.reduce((acc, cur) => acc + cur.replacementCount, 0);
return project_paths.confirmAsSerializable({
touchedFilesCount,
replacementCount,
});
}
async migrate(globalData) {
const replacements = [];
replacements.push(...globalData.ngClassReplacements.flatMap(({ replacements }) => replacements));
for (const fileIDStr of Object.keys(globalData.importReplacements)) {
const fileID = fileIDStr;
const importReplacements = globalData.importReplacements[fileID];
replacements.push(...importReplacements.addAndRemove);
}
return { replacements };
}
}
function prepareTextReplacement(file, replacement, start, end) {
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: start,
end: end,
toInsert: replacement,
}));
}
function migrate(options) {
return async (tree, context) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: (fs) => new NgClassMigration({
migrateSpaceSeparatedKey: options.migrateSpaceSeparatedKey,
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 ngClass bindings: ${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: ({ touchedFilesCount, replacementCount, }) => {
context.logger.info('');
context.logger.info(`Successfully migrated to class from ngClass 🎉`);
context.logger.info(` -> Migrated ${replacementCount} ngClass to class in ${touchedFilesCount} files.`);
},
});
};
}
exports.migrate = migrate;
@@ -0,0 +1,487 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* 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-D2V-Uh2L.cjs');
var compiler = require('@angular/compiler');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
var imports = require('./imports-CVmcbVA9.cjs');
var parse_html = require('./parse_html-C8eKA9px.cjs');
var ng_component_template = require('./ng_component_template-BOuKAnQd.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
require('./ng_decorators-DYy6II6x.cjs');
require('./property_name-BCpALNpZ.cjs');
const ngStyleStr = 'NgStyle';
const commonModuleStr = '@angular/common';
const commonModuleImportsStr = 'CommonModule';
function migrateNgStyleBindings(template, config, componentNode, typeChecker) {
const parsed = parse_html.parseTemplate(template);
if (!parsed.tree || !parsed.tree.rootNodes.length) {
return { migrated: template, changed: false, replacementCount: 0, canRemoveCommonModule: false };
}
const visitor = new NgStyleCollector(template, componentNode, typeChecker);
compiler.visitAll(visitor, parsed.tree.rootNodes, config);
let newTemplate = template;
let changedOffset = 0;
let replacementCount = 0;
for (const { start, end, replacement } of visitor.replacements) {
const currentLength = newTemplate.length;
newTemplate = replaceTemplate(newTemplate, replacement, start, end, changedOffset);
changedOffset += newTemplate.length - currentLength;
replacementCount++;
}
const changed = newTemplate !== template;
return {
migrated: newTemplate,
changed,
replacementCount,
canRemoveCommonModule: changed ? parse_html.canRemoveCommonModule(newTemplate) : false,
};
}
/**
* Creates a Replacement to remove `NgStyle` from a component's `imports` array.
* Uses ReflectionHost + PartialEvaluator for robust AST analysis.
*/
function createNgStyleImportsArrayRemoval(classNode, file, typeChecker, removeCommonModule) {
const reflector = new migrations.TypeScriptReflectionHost(typeChecker);
const decorators = reflector.getDecoratorsOfDeclaration(classNode);
if (!decorators) {
return null;
}
const componentDecorator = decorators.find((decorator) => decorator.name === 'Component');
if (!componentDecorator?.node) {
return null;
}
const decoratorNode = componentDecorator.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 elementsToRemove = new Set([ngStyleStr]);
if (removeCommonModule) {
elementsToRemove.add(commonModuleImportsStr);
}
const originalElements = importsArray.elements;
const filteredElements = originalElements.filter((el) => !ts.isIdentifier(el) || !elementsToRemove.has(el.text));
if (filteredElements.length === originalElements.length) {
return null; // No changes needed.
}
// If the array becomes empty, remove the entire `imports` property.
if (filteredElements.length === 0) {
const removalRange = getPropertyRemovalRange(importsProperty);
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: removalRange.start,
end: removalRange.end,
toInsert: '',
}));
}
const printer = ts.createPrinter();
const newArray = ts.factory.updateArrayLiteralExpression(importsArray, filteredElements);
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,
}));
}
/**
* Calculates the removal range for a property in an object literal,
* including the trailing comma if it's not the last property.
*/
function getPropertyRemovalRange(property) {
const parent = property.parent;
if (!ts.isObjectLiteralExpression(parent)) {
return { start: property.getStart(), end: property.getEnd() };
}
const properties = parent.properties;
const propertyIndex = properties.indexOf(property);
const end = property.getEnd();
if (propertyIndex < properties.length - 1) {
const nextProperty = properties[propertyIndex + 1];
return { start: property.getStart(), end: nextProperty.getStart() };
}
return { start: property.getStart(), end };
}
function calculateImportReplacements(info, sourceFiles, filesToRemoveCommonModule) {
const importReplacements = {};
const importManager = new migrations.ImportManager();
for (const sf of sourceFiles) {
const file = project_paths.projectFile(sf, info);
// Always remove NgStyle if it's imported directly.
importManager.removeImport(sf, ngStyleStr, commonModuleStr);
// Conditionally remove CommonModule if it's no longer needed.
if (filesToRemoveCommonModule.has(file.id)) {
importManager.removeImport(sf, commonModuleImportsStr, commonModuleStr);
}
const addRemove = [];
apply_import_manager.applyImportManagerChanges(importManager, addRemove, [sf], info);
if (addRemove.length > 0) {
importReplacements[file.id] = {
add: [],
addAndRemove: addRemove,
};
}
}
return importReplacements;
}
function replaceTemplate(template, replaceValue, start, end, offset) {
return template.slice(0, start + offset) + replaceValue + template.slice(end + offset);
}
/**
* Visitor class that scans Angular templates and collects replacements
* for [ngStyle] bindings that use static object literals.
*/
class NgStyleCollector extends compiler.RecursiveVisitor {
originalTemplate;
replacements = [];
isNgStyleImported = true; // Default to true (permissive)
constructor(originalTemplate, componentNode, typeChecker) {
super();
this.originalTemplate = originalTemplate;
// If we have enough information, check if NgStyle is actually imported.
// If not, we can confidently disable the migration for this component.
if (componentNode && typeChecker) {
const imports$1 = imports.getImportSpecifiers(componentNode.getSourceFile(), commonModuleStr, [
ngStyleStr,
commonModuleImportsStr,
]);
if (imports$1.length === 0) {
this.isNgStyleImported = false;
}
}
}
visitElement(element, config) {
// If NgStyle is not imported, do not attempt to migrate.
if (!this.isNgStyleImported) {
return;
}
for (const attr of element.attrs) {
if (attr.name !== '[ngStyle]' && attr.name !== 'ngStyle') {
continue;
}
if (attr.name === '[ngStyle]' && attr.valueSpan) {
const expr = this.originalTemplate.slice(attr.valueSpan.start.offset, attr.valueSpan.end.offset);
const staticMatch = parseStaticObjectLiteral(expr);
if (staticMatch === null) {
if (config.bestEffortMode && !isObjectLiteralSyntax(expr.trim())) {
const keyReplacement = this.originalTemplate
.slice(attr.sourceSpan.start.offset, attr.valueSpan.start.offset)
.replace('[ngStyle]', '[style]');
this.replacements.push({
start: attr.sourceSpan.start.offset,
end: attr.valueSpan.start.offset,
replacement: keyReplacement,
});
}
continue;
}
let replacement;
if (staticMatch.length === 0) {
replacement = '';
}
else if (staticMatch.length === 1) {
const { key, value } = staticMatch[0];
// Special case: If the key is an empty string, use [style]=""
if (key === '') {
replacement = '';
}
else {
// Normal single condition: use [style.styleName]="condition"
replacement = `[style.${key}]="${value}"`;
}
}
else {
replacement = `[style]="${expr}"`;
}
this.replacements.push({
start: attr.sourceSpan.start.offset,
end: attr.sourceSpan.end.offset,
replacement,
});
continue;
}
if (attr.name === 'ngStyle' && attr.value) {
this.replacements.push({
start: attr.sourceSpan.start.offset,
end: attr.sourceSpan.end.offset,
replacement: `style="${attr.value}"`,
});
}
}
return super.visitElement(element, config);
}
}
function parseStaticObjectLiteral(expr) {
const trimmedExpr = expr.trim();
if (trimmedExpr === '{}' || trimmedExpr === '[]') {
return [];
}
if (!isObjectLiteralSyntax(trimmedExpr)) {
return null;
}
const objectLiteral = parseAsObjectLiteral(trimmedExpr);
if (!objectLiteral) {
return null;
}
return extractStyleBindings(objectLiteral);
}
/**
* Validates basic object literal syntax
*/
function isObjectLiteralSyntax(expr) {
return expr.startsWith('{') && expr.endsWith('}');
}
/**
* Parses expression as TypeScript object literal
*/
function parseAsObjectLiteral(expr) {
const sourceFile = ts.createSourceFile('temp.ts', `const obj = ${expr}`, ts.ScriptTarget.Latest, true);
const variableStatement = sourceFile.statements[0];
if (!ts.isVariableStatement(variableStatement)) {
return null;
}
const declaration = variableStatement.declarationList.declarations[0];
if (!declaration.initializer || !ts.isObjectLiteralExpression(declaration.initializer)) {
return null;
}
return declaration.initializer;
}
function extractStyleBindings(objectLiteral) {
const result = [];
for (const property of objectLiteral.properties) {
if (ts.isShorthandPropertyAssignment(property)) {
return null;
}
else if (ts.isPropertyAssignment(property)) {
const keyText = extractPropertyKey(property.name);
const valueText = extractPropertyValue(property.initializer);
if (keyText === '' && valueText) {
result.push({ key: '', value: valueText });
continue;
}
if (!keyText || !valueText) {
return null;
}
result.push({ key: keyText, value: valueText });
}
else {
return null;
}
}
return result;
}
/**
* Extracts text from property key (name)
*/
function extractPropertyKey(name) {
if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
return name.text;
}
return null;
}
/**
* Extracts text from property value
*/
function extractPropertyValue(initializer) {
// String literals: 'value' or "value"
if (ts.isStringLiteral(initializer)) {
return `'${initializer.text}'`;
}
// Numeric literals: 42, 3.14
if (ts.isNumericLiteral(initializer) || ts.isIdentifier(initializer)) {
return initializer.text;
}
// Boolean and null keywords
if (initializer.kind === ts.SyntaxKind.TrueKeyword) {
return 'true';
}
if (initializer.kind === ts.SyntaxKind.FalseKeyword) {
return 'false';
}
if (initializer.kind === ts.SyntaxKind.NullKeyword) {
return 'null';
}
return initializer.getText();
}
class NgStyleMigration extends project_paths.TsurgeFunnelMigration {
config;
constructor(config = {}) {
super();
this.config = config;
}
processTemplate(template, node, file, info, typeChecker) {
const { migrated, changed, replacementCount, canRemoveCommonModule } = migrateNgStyleBindings(template.content, this.config, node, typeChecker);
if (!changed) {
return null;
}
const fileToMigrate = template.inline
? file
: project_paths.projectFile(template.filePath, info);
const end = template.start + template.content.length;
return {
replacements: [prepareTextReplacement(fileToMigrate, migrated, template.start, end)],
replacementCount,
canRemoveCommonModule,
};
}
async analyze(info) {
const { sourceFiles, program } = info;
const typeChecker = program.getTypeChecker();
const ngStyleReplacements = [];
const filesWithNgStyleDeclarations = new Set();
const filesToRemoveCommonModule = new Set();
for (const sf of sourceFiles) {
ts.forEachChild(sf, (node) => {
if (!ts.isClassDeclaration(node)) {
return;
}
const file = project_paths.projectFile(sf, info);
if (this.config.shouldMigrate && !this.config.shouldMigrate(file)) {
return;
}
const templateVisitor = new ng_component_template.NgComponentTemplateVisitor(typeChecker);
templateVisitor.visitNode(node);
const replacementsForStyle = [];
let replacementCountForStyle = 0;
let canRemoveCommonModuleForFile = true;
for (const template of templateVisitor.resolvedTemplates) {
const result = this.processTemplate(template, node, file, info, typeChecker);
if (result) {
replacementsForStyle.push(...result.replacements);
replacementCountForStyle += result.replacementCount;
if (!result.canRemoveCommonModule) {
canRemoveCommonModuleForFile = false;
}
}
}
if (replacementsForStyle.length > 0) {
if (canRemoveCommonModuleForFile) {
filesToRemoveCommonModule.add(file.id);
}
// Handle the `@Component({ imports: [...] })` array.
const importsRemoval = createNgStyleImportsArrayRemoval(node, file, typeChecker, canRemoveCommonModuleForFile);
if (importsRemoval) {
replacementsForStyle.push(importsRemoval);
}
ngStyleReplacements.push({
file,
replacementCount: replacementCountForStyle,
replacements: replacementsForStyle,
});
filesWithNgStyleDeclarations.add(sf);
}
});
}
const importReplacements = calculateImportReplacements(info, filesWithNgStyleDeclarations, filesToRemoveCommonModule);
return project_paths.confirmAsSerializable({
ngStyleReplacements,
importReplacements,
});
}
async combine(unitA, unitB) {
const importReplacements = {};
for (const unit of [unitA, unitB]) {
for (const fileIDStr of Object.keys(unit.importReplacements)) {
const fileID = fileIDStr;
importReplacements[fileID] = unit.importReplacements[fileID];
}
}
return project_paths.confirmAsSerializable({
ngStyleReplacements: [...unitA.ngStyleReplacements, ...unitB.ngStyleReplacements],
importReplacements,
});
}
async globalMeta(combinedData) {
return project_paths.confirmAsSerializable({
ngStyleReplacements: combinedData.ngStyleReplacements,
importReplacements: combinedData.importReplacements,
});
}
async stats(globalMetadata) {
const touchedFilesCount = globalMetadata.ngStyleReplacements.length;
const replacementCount = globalMetadata.ngStyleReplacements.reduce((acc, cur) => acc + cur.replacementCount, 0);
return project_paths.confirmAsSerializable({
touchedFilesCount,
replacementCount,
});
}
async migrate(globalData) {
const replacements = [];
replacements.push(...globalData.ngStyleReplacements.flatMap(({ replacements }) => replacements));
for (const fileIDStr of Object.keys(globalData.importReplacements)) {
const fileID = fileIDStr;
const importReplacements = globalData.importReplacements[fileID];
replacements.push(...importReplacements.addAndRemove);
}
return { replacements };
}
}
function prepareTextReplacement(file, replacement, start, end) {
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: start,
end: end,
toInsert: replacement,
}));
}
function migrate(options) {
return async (tree, context) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: (fs) => new NgStyleMigration({
bestEffortMode: options.bestEffortMode,
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 component tags: ${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: ({ touchedFilesCount, replacementCount, }) => {
context.logger.info('');
context.logger.info(`Successfully migrated to style bindings from ngStyle 🎉`);
context.logger.info(` -> Migrated ${replacementCount} ngStyle to style bindings in ${touchedFilesCount} files.`);
},
});
};
}
exports.migrate = migrate;
+23
View File
@@ -0,0 +1,23 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
/** Find the closest parent node of a particular kind. */
function closestNode(node, predicate) {
let current = node.parent;
while (current && !ts.isSourceFile(current)) {
if (predicate(current)) {
return current;
}
current = current.parent;
}
return null;
}
exports.closestNode = closestNode;
+602
View File
@@ -0,0 +1,602 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* 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-D2V-Uh2L.cjs');
var compiler = require('@angular/compiler');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
var index = require('./index-BtLcQH8g.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
function isOutputDeclarationEligibleForMigration(node) {
return (node.initializer !== undefined &&
ts.isNewExpression(node.initializer) &&
ts.isIdentifier(node.initializer.expression) &&
node.initializer.expression.text === 'EventEmitter');
}
function isPotentialOutputCallUsage(node, name) {
if (ts.isCallExpression(node) &&
ts.isPropertyAccessExpression(node.expression) &&
ts.isIdentifier(node.expression.name)) {
return node.expression?.name.text === name;
}
else {
return false;
}
}
function isPotentialPipeCallUsage(node) {
return isPotentialOutputCallUsage(node, 'pipe');
}
function isPotentialNextCallUsage(node) {
return isPotentialOutputCallUsage(node, 'next');
}
function isPotentialCompleteCallUsage(node) {
return isPotentialOutputCallUsage(node, 'complete');
}
function isTargetOutputDeclaration(node, checker, reflector, dtsReader) {
const targetSymbol = checker.getSymbolAtLocation(node);
if (targetSymbol !== undefined) {
const propertyDeclaration = getTargetPropertyDeclaration(targetSymbol);
if (propertyDeclaration !== null &&
isOutputDeclaration(propertyDeclaration, reflector, dtsReader)) {
return propertyDeclaration;
}
}
return null;
}
/** Gets whether the given property is an Angular `@Output`. */
function isOutputDeclaration(node, reflector, dtsReader) {
// `.d.ts` file, so we check the `static ecmp` metadata on the `declare class`.
if (node.getSourceFile().isDeclarationFile) {
if (!ts.isIdentifier(node.name) ||
!ts.isClassDeclaration(node.parent) ||
node.parent.name === undefined) {
return false;
}
const ref = new migrations.Reference(node.parent);
const directiveMeta = dtsReader.getDirectiveMetadata(ref);
return !!directiveMeta?.outputs.getByClassPropertyName(node.name.text);
}
// `.ts` file, so we check for the `@Output()` decorator.
return getOutputDecorator(node, reflector) !== null;
}
function getTargetPropertyDeclaration(targetSymbol) {
const valDeclaration = targetSymbol.valueDeclaration;
if (valDeclaration !== undefined && ts.isPropertyDeclaration(valDeclaration)) {
return valDeclaration;
}
return null;
}
/** Returns Angular `@Output` decorator or null when a given property declaration is not an @Output */
function getOutputDecorator(node, reflector) {
const decorators = reflector.getDecoratorsOfDeclaration(node);
const ngDecorators = decorators !== null ? migrations.getAngularDecorators(decorators, ['Output'], /* isCore */ false) : [];
return ngDecorators.length > 0 ? ngDecorators[0] : null;
}
// THINK: this utility + type is not specific to @Output, really, maybe move it to tsurge?
/** Computes an unique ID for a given Angular `@Output` property. */
function getUniqueIdForProperty(info, prop) {
const { id } = project_paths.projectFile(prop.getSourceFile(), info);
id.replace(/\.d\.ts$/, '.ts');
return `${id}@@${prop.parent.name ?? 'unknown-class'}@@${prop.name.getText()}`;
}
function isTestRunnerImport(node) {
if (ts.isImportDeclaration(node)) {
const moduleSpecifier = node.moduleSpecifier.getText();
return moduleSpecifier.includes('jasmine') || moduleSpecifier.includes('catalyst');
}
return false;
}
// TODO: code duplication with signals migration - sort it out
/**
* Gets whether the given read is used to access
* the specified field.
*
* E.g. whether `<my-read>.toArray` is detected.
*/
function checkNonTsReferenceAccessesField(ref, fieldName) {
const readFromPath = ref.from.readAstPath.at(-1);
const parentRead = ref.from.readAstPath.at(-2);
if (ref.from.read !== readFromPath) {
return null;
}
if (!(parentRead instanceof compiler.PropertyRead) || parentRead.name !== fieldName) {
return null;
}
return parentRead;
}
/**
* Gets whether the given reference is accessed to call the
* specified function on it.
*
* E.g. whether `<my-read>.toArray()` is detected.
*/
function checkNonTsReferenceCallsField(ref, fieldName) {
const propertyAccess = checkNonTsReferenceAccessesField(ref, fieldName);
if (propertyAccess === null) {
return null;
}
const accessIdx = ref.from.readAstPath.indexOf(propertyAccess);
if (accessIdx === -1) {
return null;
}
const potentialRead = ref.from.readAstPath[accessIdx];
if (potentialRead === undefined) {
return null;
}
return potentialRead;
}
const printer = ts.createPrinter();
function calculateDeclarationReplacement(info, node, aliasParam) {
const sf = node.getSourceFile();
let payloadTypes;
if (node.initializer && ts.isNewExpression(node.initializer) && node.initializer.typeArguments) {
payloadTypes = node.initializer.typeArguments;
}
else if (node.type && ts.isTypeReferenceNode(node.type) && node.type.typeArguments) {
payloadTypes = ts.factory.createNodeArray(node.type.typeArguments);
}
const outputCall = ts.factory.createCallExpression(ts.factory.createIdentifier('output'), payloadTypes, aliasParam !== undefined
? [
ts.factory.createObjectLiteralExpression([
ts.factory.createPropertyAssignment('alias', ts.factory.createStringLiteral(aliasParam, true)),
], false),
]
: []);
const existingModifiers = (node.modifiers ?? []).filter((modifier) => !ts.isDecorator(modifier) && modifier.kind !== ts.SyntaxKind.ReadonlyKeyword);
const updatedOutputDeclaration = ts.factory.createPropertyDeclaration(
// Think: this logic of dealing with modifiers is applicable to all signal-based migrations
ts.factory.createNodeArray([
...existingModifiers,
ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword),
]), node.name, undefined, undefined, outputCall);
return prepareTextReplacementForNode(info, node, printer.printNode(ts.EmitHint.Unspecified, updatedOutputDeclaration, sf));
}
function calculateImportReplacements(info, sourceFiles) {
const importReplacements = {};
for (const sf of sourceFiles) {
const importManager = new migrations.ImportManager();
const addOnly = [];
const addRemove = [];
const file = project_paths.projectFile(sf, info);
importManager.addImport({
requestedFile: sf,
exportModuleSpecifier: '@angular/core',
exportSymbolName: 'output',
});
apply_import_manager.applyImportManagerChanges(importManager, addOnly, [sf], info);
importManager.removeImport(sf, 'Output', '@angular/core');
importManager.removeImport(sf, 'EventEmitter', '@angular/core');
apply_import_manager.applyImportManagerChanges(importManager, addRemove, [sf], info);
importReplacements[file.id] = {
add: addOnly,
addAndRemove: addRemove,
};
}
return importReplacements;
}
function calculateNextFnReplacement(info, node) {
return prepareTextReplacementForNode(info, node, 'emit');
}
function calculateNextFnReplacementInTemplate(file, span) {
return prepareTextReplacement(file, 'emit', span.start, span.end);
}
function calculateNextFnReplacementInHostBinding(file, offset, span) {
return prepareTextReplacement(file, 'emit', offset + span.start, offset + span.end);
}
function calculateCompleteCallReplacement(info, node) {
return prepareTextReplacementForNode(info, node, '', node.getFullStart());
}
function calculatePipeCallReplacement(info, node) {
if (ts.isPropertyAccessExpression(node.expression)) {
const sf = node.getSourceFile();
const importManager = new migrations.ImportManager();
const outputToObservableIdent = importManager.addImport({
requestedFile: sf,
exportModuleSpecifier: '@angular/core/rxjs-interop',
exportSymbolName: 'outputToObservable',
});
const toObsCallExp = ts.factory.createCallExpression(outputToObservableIdent, undefined, [
node.expression.expression,
]);
const pipePropAccessExp = ts.factory.updatePropertyAccessExpression(node.expression, toObsCallExp, node.expression.name);
const pipeCallExp = ts.factory.updateCallExpression(node, pipePropAccessExp, [], node.arguments);
const replacements = [
prepareTextReplacementForNode(info, node, printer.printNode(ts.EmitHint.Unspecified, pipeCallExp, sf)),
];
apply_import_manager.applyImportManagerChanges(importManager, replacements, [sf], info);
return replacements;
}
else {
// TODO: assert instead?
throw new Error(`Unexpected call expression for .pipe - expected a property access but got "${node.getText()}"`);
}
}
function prepareTextReplacementForNode(info, node, replacement, start) {
const sf = node.getSourceFile();
return new project_paths.Replacement(project_paths.projectFile(sf, info), new project_paths.TextUpdate({
position: start ?? node.getStart(),
end: node.getEnd(),
toInsert: replacement,
}));
}
function prepareTextReplacement(file, replacement, start, end) {
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: start,
end: end,
toInsert: replacement,
}));
}
class OutputMigration extends project_paths.TsurgeFunnelMigration {
config;
constructor(config = {}) {
super();
this.config = config;
}
async analyze(info) {
const { sourceFiles, program } = info;
const outputFieldReplacements = {};
const problematicUsages = {};
let problematicDeclarationCount = 0;
const filesWithOutputDeclarations = new Set();
const checker = program.getTypeChecker();
const reflector = new migrations.TypeScriptReflectionHost(checker);
const dtsReader = new migrations.DtsMetadataReader(checker, reflector);
const evaluator = new migrations.PartialEvaluator(reflector, checker, null);
const resourceLoader = info.ngCompiler?.['resourceManager'] ?? null;
// Pre-analyze the program and get access to the template type checker.
// If we are processing a non-Angular target, there is no template info.
const { templateTypeChecker } = info.ngCompiler?.['ensureAnalyzed']() ?? {
templateTypeChecker: null,
};
const knownFields = {
// Note: We don't support cross-target migration of `Partial<T>` usages.
// This is an acceptable limitation for performance reasons.
shouldTrackClassReference: () => false,
attemptRetrieveDescriptorFromSymbol: (s) => {
const propDeclaration = getTargetPropertyDeclaration(s);
if (propDeclaration !== null) {
const classFieldID = getUniqueIdForProperty(info, propDeclaration);
if (classFieldID !== null) {
return {
node: propDeclaration,
key: classFieldID,
};
}
}
return null;
},
};
let isTestFile = false;
const outputMigrationVisitor = (node) => {
// detect output declarations
if (ts.isPropertyDeclaration(node)) {
const outputDecorator = getOutputDecorator(node, reflector);
if (outputDecorator !== null) {
if (isOutputDeclarationEligibleForMigration(node)) {
const outputDef = {
id: getUniqueIdForProperty(info, node),
aliasParam: outputDecorator.args?.at(0),
};
const outputFile = project_paths.projectFile(node.getSourceFile(), info);
if (this.config.shouldMigrate === undefined ||
this.config.shouldMigrate({
key: outputDef.id,
node: node,
}, outputFile)) {
const aliasParam = outputDef.aliasParam;
const aliasOptionValue = aliasParam ? evaluator.evaluate(aliasParam) : undefined;
if (aliasOptionValue == undefined || typeof aliasOptionValue === 'string') {
filesWithOutputDeclarations.add(node.getSourceFile());
addOutputReplacement(outputFieldReplacements, outputDef.id, outputFile, calculateDeclarationReplacement(info, node, aliasOptionValue?.toString()));
}
else {
problematicUsages[outputDef.id] = true;
problematicDeclarationCount++;
}
}
}
else {
problematicDeclarationCount++;
}
}
}
// detect .next usages that should be migrated to .emit
if (isPotentialNextCallUsage(node) && ts.isPropertyAccessExpression(node.expression)) {
const propertyDeclaration = isTargetOutputDeclaration(node.expression.expression, checker, reflector, dtsReader);
if (propertyDeclaration !== null) {
const id = getUniqueIdForProperty(info, propertyDeclaration);
const outputFile = project_paths.projectFile(node.getSourceFile(), info);
addOutputReplacement(outputFieldReplacements, id, outputFile, calculateNextFnReplacement(info, node.expression.name));
}
}
// detect .complete usages that should be removed
if (isPotentialCompleteCallUsage(node) && ts.isPropertyAccessExpression(node.expression)) {
const propertyDeclaration = isTargetOutputDeclaration(node.expression.expression, checker, reflector, dtsReader);
if (propertyDeclaration !== null) {
const id = getUniqueIdForProperty(info, propertyDeclaration);
const outputFile = project_paths.projectFile(node.getSourceFile(), info);
if (ts.isExpressionStatement(node.parent)) {
addOutputReplacement(outputFieldReplacements, id, outputFile, calculateCompleteCallReplacement(info, node.parent));
}
else {
problematicUsages[id] = true;
}
}
}
addCommentForEmptyEmit(node, info, checker, reflector, dtsReader, outputFieldReplacements);
// detect imports of test runners
if (isTestRunnerImport(node)) {
isTestFile = true;
}
// detect unsafe access of the output property
if (isPotentialPipeCallUsage(node) && ts.isPropertyAccessExpression(node.expression)) {
const propertyDeclaration = isTargetOutputDeclaration(node.expression.expression, checker, reflector, dtsReader);
if (propertyDeclaration !== null) {
const id = getUniqueIdForProperty(info, propertyDeclaration);
if (isTestFile) {
const outputFile = project_paths.projectFile(node.getSourceFile(), info);
addOutputReplacement(outputFieldReplacements, id, outputFile, ...calculatePipeCallReplacement(info, node));
}
else {
problematicUsages[id] = true;
}
}
}
ts.forEachChild(node, outputMigrationVisitor);
};
// calculate output migration replacements
for (const sf of sourceFiles) {
isTestFile = false;
ts.forEachChild(sf, outputMigrationVisitor);
}
// take care of the references in templates and host bindings
const referenceResult = { references: [] };
const { visitor: templateHostRefVisitor } = index.createFindAllSourceFileReferencesVisitor(info, checker, reflector, resourceLoader, evaluator, templateTypeChecker, knownFields, null, // TODO: capture known output names as an optimization
referenceResult);
// calculate template / host binding replacements
for (const sf of sourceFiles) {
ts.forEachChild(sf, templateHostRefVisitor);
}
for (const ref of referenceResult.references) {
// detect .next usages that should be migrated to .emit in template and host binding expressions
if (ref.kind === index.ReferenceKind.InTemplate) {
const callExpr = checkNonTsReferenceCallsField(ref, 'next');
// TODO: here and below for host bindings, we should ideally filter in the global meta stage
// (instead of using the `outputFieldReplacements` map)
// as technically, the call expression could refer to an output
// from a whole different compilation unit (e.g. tsconfig.json).
if (callExpr !== null && outputFieldReplacements[ref.target.key] !== undefined) {
addOutputReplacement(outputFieldReplacements, ref.target.key, ref.from.templateFile, calculateNextFnReplacementInTemplate(ref.from.templateFile, callExpr.nameSpan));
}
}
else if (ref.kind === index.ReferenceKind.InHostBinding) {
const callExpr = checkNonTsReferenceCallsField(ref, 'next');
if (callExpr !== null && outputFieldReplacements[ref.target.key] !== undefined) {
addOutputReplacement(outputFieldReplacements, ref.target.key, ref.from.file, calculateNextFnReplacementInHostBinding(ref.from.file, ref.from.hostPropertyNode.getStart() + 1, callExpr.nameSpan));
}
}
}
// calculate import replacements but do so only for files that have output declarations
const importReplacements = calculateImportReplacements(info, filesWithOutputDeclarations);
return project_paths.confirmAsSerializable({
problematicDeclarationCount,
outputFields: outputFieldReplacements,
importReplacements,
problematicUsages,
});
}
async combine(unitA, unitB) {
const outputFields = {};
const importReplacements = {};
const problematicUsages = {};
let problematicDeclarationCount = 0;
for (const unit of [unitA, unitB]) {
for (const declIdStr of Object.keys(unit.outputFields)) {
const declId = declIdStr;
// THINK: detect clash? Should we have an utility to merge data based on unique IDs?
outputFields[declId] = unit.outputFields[declId];
}
for (const fileIDStr of Object.keys(unit.importReplacements)) {
const fileID = fileIDStr;
importReplacements[fileID] = unit.importReplacements[fileID];
}
problematicDeclarationCount += unit.problematicDeclarationCount;
}
for (const unit of [unitA, unitB]) {
for (const declIdStr of Object.keys(unit.problematicUsages)) {
const declId = declIdStr;
problematicUsages[declId] = unit.problematicUsages[declId];
}
}
return project_paths.confirmAsSerializable({
problematicDeclarationCount,
outputFields,
importReplacements,
problematicUsages,
});
}
async globalMeta(combinedData) {
const globalMeta = {
importReplacements: combinedData.importReplacements,
outputFields: combinedData.outputFields,
problematicDeclarationCount: combinedData.problematicDeclarationCount,
problematicUsages: {},
};
for (const keyStr of Object.keys(combinedData.problematicUsages)) {
const key = keyStr;
// it might happen that a problematic usage is detected but we didn't see the declaration - skipping those
if (globalMeta.outputFields[key] !== undefined) {
globalMeta.problematicUsages[key] = true;
}
}
// Noop here as we don't have any form of special global metadata.
return project_paths.confirmAsSerializable(combinedData);
}
async stats(globalMetadata) {
const detectedOutputs = new Set(Object.keys(globalMetadata.outputFields)).size +
globalMetadata.problematicDeclarationCount;
const problematicOutputs = new Set(Object.keys(globalMetadata.problematicUsages)).size +
globalMetadata.problematicDeclarationCount;
const successRate = detectedOutputs > 0 ? (detectedOutputs - problematicOutputs) / detectedOutputs : 1;
return project_paths.confirmAsSerializable({
detectedOutputs,
problematicOutputs,
successRate,
});
}
async migrate(globalData) {
const migratedFiles = new Set();
const problematicFiles = new Set();
const replacements = [];
for (const declIdStr of Object.keys(globalData.outputFields)) {
const declId = declIdStr;
const outputField = globalData.outputFields[declId];
if (!globalData.problematicUsages[declId]) {
replacements.push(...outputField.replacements);
migratedFiles.add(outputField.file.id);
}
else {
problematicFiles.add(outputField.file.id);
}
}
for (const fileIDStr of Object.keys(globalData.importReplacements)) {
const fileID = fileIDStr;
if (migratedFiles.has(fileID)) {
const importReplacements = globalData.importReplacements[fileID];
if (problematicFiles.has(fileID)) {
replacements.push(...importReplacements.add);
}
else {
replacements.push(...importReplacements.addAndRemove);
}
}
}
return { replacements };
}
}
function addOutputReplacement(outputFieldReplacements, outputId, file, ...replacements) {
let existingReplacements = outputFieldReplacements[outputId];
if (existingReplacements === undefined) {
outputFieldReplacements[outputId] = existingReplacements = {
file: file,
replacements: [],
};
}
existingReplacements.replacements.push(...replacements);
}
function addCommentForEmptyEmit(node, info, checker, reflector, dtsReader, outputFieldReplacements) {
if (!isEmptyEmitCall(node))
return;
const propertyAccess = getPropertyAccess(node);
if (!propertyAccess)
return;
const symbol = checker.getSymbolAtLocation(propertyAccess.name);
if (!symbol || !symbol.declarations?.length)
return;
const propertyDeclaration = isTargetOutputDeclaration(propertyAccess, checker, reflector, dtsReader);
if (!propertyDeclaration)
return;
const eventEmitterType = getEventEmitterArgumentType(propertyDeclaration);
if (!eventEmitterType)
return;
const id = getUniqueIdForProperty(info, propertyDeclaration);
const file = project_paths.projectFile(node.getSourceFile(), info);
const formatter = getFormatterText(node);
const todoReplacement = new project_paths.TextUpdate({
toInsert: `${formatter.indent}// TODO: The 'emit' function requires a mandatory ${eventEmitterType} argument\n`,
end: formatter.lineStartPos,
position: formatter.lineStartPos,
});
addOutputReplacement(outputFieldReplacements, id, file, new project_paths.Replacement(file, todoReplacement));
}
function isEmptyEmitCall(node) {
return (ts.isCallExpression(node) &&
ts.isPropertyAccessExpression(node.expression) &&
node.expression.name.text === 'emit' &&
node.arguments.length === 0);
}
function getPropertyAccess(node) {
const propertyAccessExpression = node.expression.expression;
return ts.isPropertyAccessExpression(propertyAccessExpression) ? propertyAccessExpression : null;
}
function getEventEmitterArgumentType(propertyDeclaration) {
const initializer = propertyDeclaration.initializer;
if (!initializer || !ts.isNewExpression(initializer))
return null;
const isEventEmitter = ts.isIdentifier(initializer.expression) && initializer.expression.getText() === 'EventEmitter';
if (!isEventEmitter)
return null;
const [typeArg] = initializer.typeArguments ?? [];
return typeArg ? typeArg.getText() : null;
}
function getFormatterText(node) {
const sourceFile = node.getSourceFile();
const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
const lineStartPos = sourceFile.getPositionOfLineAndCharacter(line, 0);
const indent = sourceFile.text.slice(lineStartPos, node.getStart());
return { indent, lineStartPos };
}
function migrate(options) {
return async (tree, context) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: (fs) => new OutputMigration({
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}...`);
}
},
afterProgramCreation: (info, fs) => {
const analysisPath = fs.resolve(options.analysisDir);
// Support restricting the analysis to subfolders for larger projects.
if (analysisPath !== '/') {
info.sourceFiles = info.sourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
info.fullProgramSourceFiles = info.fullProgramSourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
}
},
beforeUnitAnalysis: (tsconfigPath) => {
context.logger.info(`Scanning for outputs: ${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: ({ detectedOutputs, problematicOutputs, successRate }) => {
const migratedOutputs = detectedOutputs - problematicOutputs;
const successRatePercent = (successRate * 100).toFixed(2);
context.logger.info('');
context.logger.info(`Successfully migrated to outputs as functions 🎉`);
context.logger.info(` -> Migrated ${migratedOutputs} out of ${detectedOutputs} detected outputs (${successRatePercent} %).`);
},
});
};
}
exports.migrate = migrate;
+132
View File
@@ -0,0 +1,132 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var compiler = require('@angular/compiler');
/**
* parses the template string into the Html AST
*/
function parseTemplate(template) {
let parsed;
try {
// Note: we use the HtmlParser here, instead of the `parseTemplate` function, because the
// latter returns an Ivy AST, not an HTML AST. The HTML AST has the advantage of preserving
// interpolated text as text nodes containing a mixture of interpolation tokens and text tokens,
// rather than turning them into `BoundText` nodes like the Ivy AST does. This allows us to
// easily get the text-only ranges without having to reconstruct the original text.
parsed = new compiler.HtmlParser().parse(template, '', {
// Allows for ICUs to be parsed.
tokenizeExpansionForms: true,
// Explicitly disable blocks so that their characters are treated as plain text.
tokenizeBlocks: true,
preserveLineEndings: true,
});
// Don't migrate invalid templates.
if (parsed.errors && parsed.errors.length > 0) {
const errors = parsed.errors.map((e) => ({ type: 'parse', error: e }));
return { tree: undefined, errors };
}
}
catch (e) {
return { tree: undefined, errors: [{ type: 'parse', error: e }] };
}
return { tree: parsed, errors: [] };
}
function pipeMatchRegExpFor(name) {
return new RegExp(`\\|\\s*${name}`);
}
const commonModulePipes = [
'date',
'async',
'currency',
'number',
'i18nPlural',
'i18nSelect',
'json',
'keyvalue',
'slice',
'lowercase',
'uppercase',
'titlecase',
'percent',
].map((name) => pipeMatchRegExpFor(name));
function allFormsOf(selector) {
return [selector, `*${selector}`, `[${selector}]`];
}
const commonModuleDirectives = new Set([
...allFormsOf('ngComponentOutlet'),
...allFormsOf('ngTemplateOutlet'),
...allFormsOf('ngClass'),
...allFormsOf('ngPlural'),
...allFormsOf('ngPluralCase'),
...allFormsOf('ngStyle'),
...allFormsOf('ngTemplateOutlet'),
...allFormsOf('ngComponentOutlet'),
'[NgForOf]',
'[NgForTrackBy]',
'[ngIfElse]',
'[ngIfThenElse]',
'*ngIf',
'*ngSwitch',
'*ngFor',
]);
/**
* determines if the CommonModule can be safely removed from imports
*/
function canRemoveCommonModule(template) {
const parsed = parseTemplate(template);
let removeCommonModule = false;
if (parsed.tree !== undefined) {
const visitor = new CommonCollector();
compiler.visitAll(visitor, parsed.tree.rootNodes);
removeCommonModule = visitor.count === 0;
}
return removeCommonModule;
}
/** Finds all non-control flow elements from common module. */
class CommonCollector extends compiler.RecursiveVisitor {
count = 0;
visitElement(el) {
if (el.attrs.length > 0) {
for (const attr of el.attrs) {
if (this.hasDirectives(attr.name) || this.hasPipes(attr.value)) {
this.count++;
}
}
}
super.visitElement(el, null);
}
visitBlock(ast) {
for (const blockParam of ast.parameters) {
if (this.hasPipes(blockParam.expression)) {
this.count++;
}
}
super.visitBlock(ast, null);
}
visitText(ast) {
if (this.hasPipes(ast.value)) {
this.count++;
}
}
visitLetDeclaration(decl) {
if (this.hasPipes(decl.value)) {
this.count++;
}
super.visitLetDeclaration(decl, null);
}
hasDirectives(input) {
return commonModuleDirectives.has(input);
}
hasPipes(input) {
return commonModulePipes.some((regexp) => regexp.test(input));
}
}
exports.canRemoveCommonModule = canRemoveCommonModule;
exports.parseTemplate = parseTemplate;
@@ -0,0 +1,586 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var compilerCli = require('@angular/compiler-cli');
var schematics = require('@angular-devkit/schematics');
var core = require('@angular-devkit/core');
var posixPath = require('node:path/posix');
var migrations = require('@angular/compiler-cli/private/migrations');
var ts = require('typescript');
var path = require('node:path');
var project_tsconfig_paths = require('./project_tsconfig_paths-DkkMibv-.cjs');
function _interopNamespaceDefault(e) {
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var posixPath__namespace = /*#__PURE__*/_interopNamespaceDefault(posixPath);
var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
/**
* Angular compiler file system implementation that leverages an
* CLI schematic virtual file tree.
*/
class DevkitMigrationFilesystem {
tree;
constructor(tree) {
this.tree = tree;
}
extname(path) {
return core.extname(path);
}
isRoot(path) {
return path === core.normalize('/');
}
isRooted(path) {
return this.normalize(path).startsWith('/');
}
dirname(file) {
return this.normalize(core.dirname(file));
}
join(basePath, ...paths) {
return this.normalize(core.join(basePath, ...paths));
}
relative(from, to) {
return this.normalize(core.relative(from, to));
}
basename(filePath, extension) {
return posixPath__namespace.basename(filePath, extension);
}
normalize(path) {
return core.normalize(path);
}
resolve(...paths) {
const normalizedPaths = paths.map((p) => core.normalize(p));
// In dev-kit, the NodeJS working directory should never be
// considered, so `/` is the last resort over `cwd`.
return this.normalize(posixPath__namespace.resolve(core.normalize('/'), ...normalizedPaths));
}
pwd() {
return '/';
}
isCaseSensitive() {
return true;
}
exists(path) {
return statPath(this.tree, path) !== null;
}
readFile(path) {
return this.tree.readText(path);
}
readFileBuffer(path) {
const buffer = this.tree.read(path);
if (buffer === null) {
throw new Error(`File does not exist: ${path}`);
}
return buffer;
}
readdir(path) {
const dir = this.tree.getDir(path);
return [
...dir.subdirs,
...dir.subfiles,
];
}
lstat(path) {
const stat = statPath(this.tree, path);
if (stat === null) {
throw new Error(`File does not exist for "lstat": ${path}`);
}
return stat;
}
stat(path) {
const stat = statPath(this.tree, path);
if (stat === null) {
throw new Error(`File does not exist for "stat": ${path}`);
}
return stat;
}
realpath(filePath) {
return filePath;
}
getDefaultLibLocation() {
return 'node_modules/typescript/lib';
}
ensureDir(path) {
// Migrations should compute replacements and not write directly.
throw new Error('DevkitFilesystem#ensureDir is not supported.');
}
writeFile(path, data) {
// Migrations should compute replacements and not write directly.
throw new Error('DevkitFilesystem#writeFile is not supported.');
}
removeFile(path) {
// Migrations should compute replacements and not write directly.
throw new Error('DevkitFilesystem#removeFile is not supported.');
}
copyFile(from, to) {
// Migrations should compute replacements and not write directly.
throw new Error('DevkitFilesystem#copyFile is not supported.');
}
moveFile(from, to) {
// Migrations should compute replacements and not write directly.
throw new Error('DevkitFilesystem#moveFile is not supported.');
}
removeDeep(path) {
// Migrations should compute replacements and not write directly.
throw new Error('DevkitFilesystem#removeDeep is not supported.');
}
chdir(_path) {
throw new Error('FileSystem#chdir is not supported.');
}
symlink() {
throw new Error('FileSystem#symlink is not supported.');
}
}
/** Stats the given path in the virtual tree. */
function statPath(tree, path) {
let fileInfo = null;
let dirInfo = null;
try {
fileInfo = tree.get(path);
}
catch (e) {
if (e.constructor.name === 'PathIsDirectoryException') {
dirInfo = tree.getDir(path);
}
else {
throw e;
}
}
if (fileInfo !== null || dirInfo !== null) {
return {
isDirectory: () => dirInfo !== null,
isFile: () => fileInfo !== null,
isSymbolicLink: () => false,
};
}
return null;
}
/**
* Groups the given replacements per project relative
* file path.
*
* This allows for simple execution of the replacements
* against a given file. E.g. via {@link applyTextUpdates}.
*/
function groupReplacementsByFile(replacements) {
const result = new Map();
for (const { projectFile, update } of replacements) {
if (!result.has(projectFile.rootRelativePath)) {
result.set(projectFile.rootRelativePath, []);
}
result.get(projectFile.rootRelativePath).push(update);
}
return result;
}
/**
* Synchronously combines unit data for the given migration.
*
* Note: This helper is useful for testing and execution of
* Tsurge migrations in non-batchable environments. In general,
* prefer parallel execution of combining via e.g. Beam combiners.
*/
async function synchronouslyCombineUnitData(migration, unitDatas) {
if (unitDatas.length === 0) {
return null;
}
if (unitDatas.length === 1) {
return unitDatas[0];
}
let combined = unitDatas[0];
for (let i = 1; i < unitDatas.length; i++) {
const other = unitDatas[i];
combined = await migration.combine(combined, other);
}
return combined;
}
/** Whether we are executing inside Google */
function isGoogle3() {
return process.env['GOOGLE3_TSURGE'] === '1';
}
/**
* By default, Tsurge will always create an Angular compiler program
* for projects analyzed and migrated. This works perfectly fine in
* third-party where Tsurge migrations run in Angular CLI projects.
*
* In first party, when running against full Google3, creating an Angular
* program for e.g. plain `ts_library` targets is overly expensive and
* can result in out of memory issues for large TS targets. In 1P we can
* reliably distinguish between TS and Angular targets via the `angularCompilerOptions`.
*/
function google3UsePlainTsProgramIfNoKnownAngularOption() {
return process.env['GOOGLE3_TSURGE'] === '1';
}
/** Options that are good defaults for Tsurge migrations. */
const defaultMigrationTsOptions = {
// Avoid checking libraries to speed up migrations.
skipLibCheck: true,
skipDefaultLibCheck: true,
noEmit: true,
// Does not apply to g3 and externally is enforced when the app is built by the compiler.
disableTypeScriptVersionCheck: true,
};
/**
* Creates an instance of a TypeScript program for the given project.
*/
function createPlainTsProgram(tsHost, tsconfig, optionOverrides) {
const program = ts.createProgram({
rootNames: tsconfig.rootNames,
options: {
...tsconfig.options,
...defaultMigrationTsOptions,
...optionOverrides,
},
});
return {
ngCompiler: null,
program,
userOptions: tsconfig.options,
__programAbsoluteRootFileNames: tsconfig.rootNames,
host: tsHost,
};
}
/**
* Parses the configuration of the given TypeScript project and creates
* an instance of the Angular compiler for the project.
*/
function createNgtscProgram(tsHost, tsconfig, optionOverrides) {
const ngtscProgram = new compilerCli.NgtscProgram(tsconfig.rootNames, {
...tsconfig.options,
...defaultMigrationTsOptions,
...optionOverrides,
}, tsHost);
// Expose an easy way to debug-print ng semantic diagnostics.
if (process.env['DEBUG_NG_SEMANTIC_DIAGNOSTICS'] === '1') {
console.error(ts.formatDiagnosticsWithColorAndContext(ngtscProgram.getNgSemanticDiagnostics(), tsHost));
}
return {
ngCompiler: ngtscProgram.compiler,
program: ngtscProgram.getTsProgram(),
userOptions: tsconfig.options,
__programAbsoluteRootFileNames: tsconfig.rootNames,
host: tsHost,
};
}
/** Code of the error raised by TypeScript when a tsconfig doesn't match any files. */
const NO_INPUTS_ERROR_CODE = 18003;
/** Parses the given tsconfig file, supporting Angular compiler options. */
function parseTsconfigOrDie(absoluteTsconfigPath, fs) {
const tsconfig = compilerCli.readConfiguration(absoluteTsconfigPath, {}, fs);
// Skip the "No inputs found..." error since we don't want to interrupt the migration if a
// tsconfig doesn't match a file. This will result in an empty `Program` which is still valid.
const errors = tsconfig.errors.filter((diag) => diag.code !== NO_INPUTS_ERROR_CODE);
if (errors.length) {
throw new Error(`Tsconfig could not be parsed or is invalid:\n\n` + `${errors.map((e) => e.messageText)}`);
}
return tsconfig;
}
// Note: Try to keep mostly in sync with
// //depot/google3/javascript/angular2/tools/ngc_wrapped/tsc_plugin.ts
// TODO: Consider moving this logic into the 1P launcher.
const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
function fileNameToModuleNameFactory(rootDirs, workspaceName) {
return (importedFilePath) => {
let relativePath = '';
for (const rootDir of rootDirs) {
const rel = path__namespace.posix.relative(rootDir, importedFilePath);
if (!rel.startsWith('.')) {
relativePath = rel;
break;
}
}
if (relativePath) {
return `${workspaceName}/${relativePath.replace(EXT, '')}`;
}
else {
return importedFilePath.replace(EXT, '');
}
};
}
/** Creates the base program info for the given tsconfig path. */
function createBaseProgramInfo(absoluteTsconfigPath, fs, optionOverrides = {}) {
// Make sure the FS becomes globally available. Some code paths
// of the Angular compiler, or tsconfig parsing aren't leveraging
// the specified file system.
compilerCli.setFileSystem(fs);
const tsconfig = parseTsconfigOrDie(absoluteTsconfigPath, fs);
const tsHost = new compilerCli.NgtscCompilerHost(fs, tsconfig.options);
// When enabled, use a plain TS program if we are sure it's not
// an Angular project based on the `tsconfig.json`.
if (google3UsePlainTsProgramIfNoKnownAngularOption() &&
tsconfig.options['_useHostForImportGeneration'] === undefined) {
return createPlainTsProgram(tsHost, tsconfig, optionOverrides);
}
// The Angular program may try to emit references during analysis or migration.
// To replicate the Google3 import emission here, ensure the unified module resolution
// can be enabled by the compiler.
if (isGoogle3() && tsconfig.options.rootDirs) {
tsHost.fileNameToModuleName = fileNameToModuleNameFactory(tsconfig.options.rootDirs,
/* workspaceName*/ 'google3');
}
return createNgtscProgram(tsHost, tsconfig, optionOverrides);
}
/**
* Creates the {@link ProgramInfo} from the given base information.
*
* This function purely exists to support custom programs that are
* intended to be injected into Tsurge migrations. e.g. for language
* service refactorings.
*/
function getProgramInfoFromBaseInfo(baseInfo) {
const fullProgramSourceFiles = [...baseInfo.program.getSourceFiles()];
const sourceFiles = fullProgramSourceFiles.filter((f) => !f.isDeclarationFile &&
// Note `isShim` will work for the initial program, but for TCB programs, the shims are no longer annotated.
!migrations.isShim(f) &&
!f.fileName.endsWith('.ngtypecheck.ts'));
// Sort it by length in reverse order (longest first). This speeds up lookups,
// since there's no need to keep going through the array once a match is found.
const sortedRootDirs = migrations.getRootDirs(baseInfo.host, baseInfo.userOptions).sort((a, b) => b.length - a.length);
// TODO: Consider also following TS's logic here, finding the common source root.
// See: Program#getCommonSourceDirectory.
const primaryRoot = compilerCli.absoluteFrom(baseInfo.userOptions.rootDir ?? sortedRootDirs.at(-1) ?? baseInfo.program.getCurrentDirectory());
return {
...baseInfo,
sourceFiles,
fullProgramSourceFiles,
sortedRootDirs,
projectRoot: primaryRoot,
};
}
/**
* @private
*
* Base class for the possible Tsurge migration variants.
*
* For example, this class exposes methods to conveniently create
* TypeScript programs, while also allowing migration authors to override.
*/
class TsurgeBaseMigration {
/**
* Creates the TypeScript program for a given compilation unit.
*
* By default:
* - In 3P: Ngtsc programs are being created.
* - In 1P: Ngtsc or TS programs are created based on the Blaze target.
*/
createProgram(tsconfigAbsPath, fs, optionsOverride) {
return getProgramInfoFromBaseInfo(createBaseProgramInfo(tsconfigAbsPath, fs, optionsOverride));
}
}
/**
* A simpler variant of a {@link TsurgeComplexMigration} that does not
* fan-out into multiple workers per compilation unit to compute
* the final migration replacements.
*
* This is faster and less resource intensive as workers and TS programs
* are only ever created once.
*
* This is commonly the case when migrations are refactored to eagerly
* compute replacements in the analyze stage, and then leverage the
* global unit data to filter replacements that turned out to be "invalid".
*/
class TsurgeFunnelMigration extends TsurgeBaseMigration {
}
/**
* Complex variant of a `Tsurge` migration.
*
* For example, every analyze worker may contribute to a list of TS
* references that are later combined. The migrate phase can then compute actual
* file updates for all individual compilation units, leveraging the global metadata
* to e.g. see if there are any references from other compilation units that may be
* problematic and prevent migration of a given file.
*/
class TsurgeComplexMigration extends TsurgeBaseMigration {
}
exports.MigrationStage = void 0;
(function (MigrationStage) {
/** The migration is analyzing an entrypoint */
MigrationStage[MigrationStage["Analysis"] = 0] = "Analysis";
/** The migration is about to migrate an entrypoint */
MigrationStage[MigrationStage["Migrate"] = 1] = "Migrate";
})(exports.MigrationStage || (exports.MigrationStage = {}));
/** Runs a Tsurge within an Angular Devkit context. */
async function runMigrationInDevkit(config) {
const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(config.tree);
if (!buildPaths.length && !testPaths.length) {
throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run the migration.');
}
const tsconfigPaths = [...buildPaths, ...testPaths];
const fs = new DevkitMigrationFilesystem(config.tree);
compilerCli.setFileSystem(fs);
const migration = config.getMigration(fs);
const unitResults = [];
const isFunnelMigration = migration instanceof TsurgeFunnelMigration;
const compilationUnitAssignments = new Map();
for (const tsconfigPath of tsconfigPaths) {
config.beforeProgramCreation?.(tsconfigPath, exports.MigrationStage.Analysis);
const info = migration.createProgram(tsconfigPath, fs);
modifyProgramInfoToEnsureNonOverlappingFiles(tsconfigPath, info, compilationUnitAssignments);
config.afterProgramCreation?.(info, fs, exports.MigrationStage.Analysis);
config.beforeUnitAnalysis?.(tsconfigPath);
unitResults.push(await migration.analyze(info));
}
config.afterAllAnalyzed?.();
const combined = await synchronouslyCombineUnitData(migration, unitResults);
if (combined === null) {
config.afterAnalysisFailure?.();
return;
}
const globalMeta = await migration.globalMeta(combined);
let replacements;
if (isFunnelMigration) {
replacements = (await migration.migrate(globalMeta)).replacements;
}
else {
replacements = [];
for (const tsconfigPath of tsconfigPaths) {
config.beforeProgramCreation?.(tsconfigPath, exports.MigrationStage.Migrate);
const info = migration.createProgram(tsconfigPath, fs);
modifyProgramInfoToEnsureNonOverlappingFiles(tsconfigPath, info, compilationUnitAssignments);
config.afterProgramCreation?.(info, fs, exports.MigrationStage.Migrate);
const result = await migration.migrate(globalMeta, info);
replacements.push(...result.replacements);
}
}
const replacementsPerFile = new Map();
const changesPerFile = groupReplacementsByFile(replacements);
for (const [file, changes] of changesPerFile) {
if (!replacementsPerFile.has(file)) {
replacementsPerFile.set(file, changes);
}
}
for (const [file, changes] of replacementsPerFile) {
const recorder = config.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);
}
config.tree.commitUpdate(recorder);
}
config.whenDone?.(await migration.stats(globalMeta));
}
/**
* Special logic for devkit migrations. In the Angular CLI, or in 3P precisely,
* projects can have tsconfigs with overlapping source files. i.e. two tsconfigs
* like e.g. build or test include the same `ts.SourceFile` (`.ts`). Migrations
* should never have 2+ compilation units with overlapping source files as this
* can result in duplicated replacements or analysis— hence we only ever assign a
* source file to a compilation unit *once*.
*
* Note that this is fine as we expect Tsurge migrations to work together as
* isolated compilation units— so it shouldn't matter if worst case a `.ts`
* file ends up in the e.g. test program.
*/
function modifyProgramInfoToEnsureNonOverlappingFiles(tsconfigPath, info, compilationUnitAssignments) {
const sourceFiles = [];
for (const sf of info.sourceFiles) {
const assignment = compilationUnitAssignments.get(sf.fileName);
// File is already assigned to a different compilation unit.
if (assignment !== undefined && assignment !== tsconfigPath) {
continue;
}
compilationUnitAssignments.set(sf.fileName, tsconfigPath);
sourceFiles.push(sf);
}
info.sourceFiles = sourceFiles;
}
/** A text replacement for the given file. */
class Replacement {
projectFile;
update;
constructor(projectFile, update) {
this.projectFile = projectFile;
this.update = update;
}
}
/** An isolated text update that may be applied to a file. */
class TextUpdate {
data;
constructor(data) {
this.data = data;
}
}
/** Confirms that the given data `T` is serializable. */
function confirmAsSerializable(data) {
return data;
}
/**
* Gets a project file instance for the given file.
*
* Use this helper for dealing with project paths throughout your
* migration. The return type is serializable.
*
* See {@link ProjectFile}.
*/
function projectFile(file, { sortedRootDirs, projectRoot }) {
const fs = compilerCli.getFileSystem();
const filePath = fs.resolve(typeof file === 'string' ? file : file.fileName);
// Sorted root directories are sorted longest to shortest. First match
// is the appropriate root directory for ID computation.
for (const rootDir of sortedRootDirs) {
if (!isWithinBasePath(fs, rootDir, filePath)) {
continue;
}
return {
id: fs.relative(rootDir, filePath),
rootRelativePath: fs.relative(projectRoot, filePath),
};
}
// E.g. project directory may be `src/`, but files may be looked up
// from `node_modules/`. This is fine, but in those cases, no root
// directory matches.
const rootRelativePath = fs.relative(projectRoot, filePath);
return {
id: rootRelativePath,
rootRelativePath: rootRelativePath,
};
}
/**
* Whether `path` is a descendant of the `base`?
* E.g. `a/b/c` is within `a/b` but not within `a/x`.
*/
function isWithinBasePath(fs, base, path) {
return compilerCli.isLocalRelativePath(fs.relative(base, path));
}
exports.Replacement = Replacement;
exports.TextUpdate = TextUpdate;
exports.TsurgeComplexMigration = TsurgeComplexMigration;
exports.TsurgeFunnelMigration = TsurgeFunnelMigration;
exports.confirmAsSerializable = confirmAsSerializable;
exports.projectFile = projectFile;
exports.runMigrationInDevkit = runMigrationInDevkit;
@@ -0,0 +1,90 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var core = require('@angular-devkit/core');
/**
* Gets all tsconfig paths from a CLI project by reading the workspace configuration
* and looking for common tsconfig locations.
*/
async function getProjectTsConfigPaths(tree) {
// Start with some tsconfig paths that are generally used within CLI projects. Note
// that we are not interested in IDE-specific tsconfig files (e.g. /tsconfig.json)
const buildPaths = new Set();
const testPaths = new Set();
const workspace = await getWorkspace(tree);
for (const [, project] of workspace.projects) {
for (const [name, target] of project.targets) {
if (name !== 'build' && name !== 'test') {
continue;
}
for (const [, options] of allTargetOptions(target)) {
const tsConfig = options['tsConfig'];
// Filter out tsconfig files that don't exist in the CLI project.
if (typeof tsConfig !== 'string' || !tree.exists(tsConfig)) {
continue;
}
if (name === 'build') {
buildPaths.add(core.normalize(tsConfig));
}
else {
testPaths.add(core.normalize(tsConfig));
}
}
}
}
return {
buildPaths: [...buildPaths],
testPaths: [...testPaths],
};
}
/** Get options for all configurations for the passed builder target. */
function* allTargetOptions(target) {
if (target.options) {
yield [undefined, target.options];
}
if (!target.configurations) {
return;
}
for (const [name, options] of Object.entries(target.configurations)) {
if (options) {
yield [name, options];
}
}
}
function createHost(tree) {
return {
async readFile(path) {
const data = tree.read(path);
if (!data) {
throw new Error('File not found.');
}
return core.virtualFs.fileBufferToString(data);
},
async writeFile(path, data) {
return tree.overwrite(path, data);
},
async isDirectory(path) {
// Approximate a directory check.
// We don't need to consider empty directories and hence this is a good enough approach.
// This is also per documentation, see:
// https://angular.dev/tools/cli/schematics-for-libraries#get-the-project-configuration
return !tree.exists(path) && tree.getDir(path).subfiles.length > 0;
},
async isFile(path) {
return tree.exists(path);
},
};
}
async function getWorkspace(tree) {
const host = createHost(tree);
const { workspace } = await core.workspaces.readWorkspace('/', host);
return workspace;
}
exports.getProjectTsConfigPaths = getProjectTsConfigPaths;
@@ -0,0 +1,27 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
/**
* Gets the text of the given property name. Returns null if the property
* name couldn't be determined statically.
*/
function getPropertyNameText(node) {
if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) {
return node.text;
}
return null;
}
/** Finds a property with a specific name in an object literal expression. */
function findLiteralProperty(literal, name) {
return literal.properties.find((prop) => prop.name && ts.isIdentifier(prop.name) && prop.name.text === name);
}
exports.findLiteralProperty = findLiteralProperty;
exports.getPropertyNameText = getPropertyNameText;
+438
View File
@@ -0,0 +1,438 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var schematics = require('@angular-devkit/schematics');
var fs = require('fs');
var path = require('path');
var compiler_host = require('./compiler_host-CY14HvaP.cjs');
var project_tsconfig_paths = require('./project_tsconfig_paths-DkkMibv-.cjs');
var ts = require('typescript');
var migrations = require('@angular/compiler-cli/private/migrations');
var property_name = require('./property_name-BCpALNpZ.cjs');
require('@angular-devkit/core');
/**
* Finds the class declaration that is being referred to by a node.
* @param reference Node referring to a class declaration.
* @param typeChecker
*/
function findClassDeclaration(reference, typeChecker) {
return (typeChecker
.getTypeAtLocation(reference)
.getSymbol()
?.declarations?.find(ts.isClassDeclaration) || null);
}
/**
* Checks whether a component is standalone.
* @param node Class being checked.
* @param reflector The reflection host to use.
*/
function isStandaloneComponent(node, reflector) {
const decorators = reflector.getDecoratorsOfDeclaration(node);
if (decorators === null) {
return false;
}
const decorator = migrations.findAngularDecorator(decorators, 'Component', false);
if (decorator === undefined || decorator.args === null || decorator.args.length !== 1) {
return false;
}
const arg = decorator.args[0];
if (ts.isObjectLiteralExpression(arg)) {
const property = property_name.findLiteralProperty(arg, 'standalone');
if (property) {
return property.initializer.getText() === 'true';
}
else {
return true; // standalone is true by default in v19
}
}
return false;
}
/**
* Checks whether a node is variable declaration of type Routes or Route[] and comes from @angular/router
* @param node Variable declaration being checked.
* @param typeChecker
*/
function isAngularRoutesArray(node, typeChecker) {
if (ts.isVariableDeclaration(node)) {
const type = typeChecker.getTypeAtLocation(node);
if (type && typeChecker.isArrayType(type)) {
// Route[] is an array type
const typeArguments = typeChecker.getTypeArguments(type);
const symbol = typeArguments[0]?.getSymbol();
return (symbol?.name === 'Route' &&
symbol?.declarations?.some((decl) => {
return decl.getSourceFile().fileName.includes('@angular/router');
}));
}
}
return false;
}
/**
* Checks whether a node is a call expression to a router module method.
* Examples:
* - RouterModule.forRoot(routes)
* - RouterModule.forChild(routes)
*/
function isRouterModuleCallExpression(node, typeChecker) {
if (ts.isPropertyAccessExpression(node.expression)) {
const propAccess = node.expression;
const moduleSymbol = typeChecker.getSymbolAtLocation(propAccess.expression);
return (moduleSymbol?.name === 'RouterModule' &&
(propAccess.name.text === 'forRoot' || propAccess.name.text === 'forChild'));
}
return false;
}
/**
* Checks whether a node is a call expression to a router method.
* Example: this.router.resetConfig(routes)
*/
function isRouterCallExpression(node, typeChecker) {
if (ts.isCallExpression(node) &&
ts.isPropertyAccessExpression(node.expression) &&
node.expression.name.text === 'resetConfig') {
const calleeExpression = node.expression.expression;
const symbol = typeChecker.getSymbolAtLocation(calleeExpression);
if (symbol) {
const type = typeChecker.getTypeOfSymbolAtLocation(symbol, calleeExpression);
// if type of router is Router, then it is a router call expression
return type.aliasSymbol?.escapedName === 'Router';
}
}
return false;
}
/**
* Checks whether a node is a call expression to router provide function.
* Example: provideRoutes(routes)
*/
function isRouterProviderCallExpression(node, typeChecker) {
if (ts.isIdentifier(node.expression)) {
const moduleSymbol = typeChecker.getSymbolAtLocation(node.expression);
return moduleSymbol && moduleSymbol.name === 'provideRoutes';
}
return false;
}
/**
* Checks whether a node is a call expression to provideRouter function.
* Example: provideRouter(routes)
*/
function isProvideRoutesCallExpression(node, typeChecker) {
if (ts.isIdentifier(node.expression)) {
const moduleSymbol = typeChecker.getSymbolAtLocation(node.expression);
return moduleSymbol && moduleSymbol.name === 'provideRouter';
}
return false;
}
/**
* Converts all application routes that are using standalone components to be lazy loaded.
* @param sourceFile File that should be migrated.
* @param program
*/
function migrateFileToLazyRoutes(sourceFile, program) {
const typeChecker = program.getTypeChecker();
const reflector = new migrations.TypeScriptReflectionHost(typeChecker);
const printer = ts.createPrinter();
const tracker = new compiler_host.ChangeTracker(printer);
const routeArraysToMigrate = findRoutesArrayToMigrate(sourceFile, typeChecker);
if (routeArraysToMigrate.length === 0) {
return { pendingChanges: [], skippedRoutes: [], migratedRoutes: [] };
}
const { skippedRoutes, migratedRoutes } = migrateRoutesArray(routeArraysToMigrate, typeChecker, reflector, tracker);
return {
pendingChanges: tracker.recordChanges().get(sourceFile) || [],
skippedRoutes,
migratedRoutes,
};
}
/** Finds route object that can be migrated */
function findRoutesArrayToMigrate(sourceFile, typeChecker) {
const routesArrays = [];
sourceFile.forEachChild(function walk(node) {
if (ts.isCallExpression(node)) {
if (isRouterModuleCallExpression(node, typeChecker) ||
isRouterProviderCallExpression(node, typeChecker) ||
isRouterCallExpression(node, typeChecker) ||
isProvideRoutesCallExpression(node, typeChecker)) {
const arg = node.arguments[0]; // ex: RouterModule.forRoot(routes) or provideRouter(routes)
const routeFileImports = sourceFile.statements.filter(ts.isImportDeclaration);
if (ts.isArrayLiteralExpression(arg) && arg.elements.length > 0) {
// ex: inline routes array: RouterModule.forRoot([{ path: 'test', component: TestComponent }])
routesArrays.push({
routeFilePath: sourceFile.fileName,
array: arg,
routeFileImports,
});
}
else if (ts.isIdentifier(arg)) {
// ex: reference to routes array: RouterModule.forRoot(routes)
// RouterModule.forRoot(routes), provideRouter(routes), provideRoutes(routes)
const symbol = typeChecker.getSymbolAtLocation(arg);
if (!symbol?.declarations)
return;
for (const declaration of symbol.declarations) {
if (ts.isVariableDeclaration(declaration)) {
const initializer = declaration.initializer;
if (initializer && ts.isArrayLiteralExpression(initializer)) {
// ex: const routes = [{ path: 'test', component: TestComponent }];
routesArrays.push({
routeFilePath: sourceFile.fileName,
array: initializer,
routeFileImports,
});
}
}
}
}
}
}
else if (ts.isVariableDeclaration(node)) {
if (isAngularRoutesArray(node, typeChecker)) {
const initializer = node.initializer;
if (initializer &&
ts.isArrayLiteralExpression(initializer) &&
initializer.elements.length > 0) {
// ex: const routes: Routes = [{ path: 'test', component: TestComponent }];
if (routesArrays.find((x) => x.array === initializer)) {
// already exists
return;
}
routesArrays.push({
routeFilePath: sourceFile.fileName,
array: initializer,
routeFileImports: sourceFile.statements.filter(ts.isImportDeclaration),
});
}
}
}
else if (ts.isExportAssignment(node)) {
// Handles `export default routes`, `export default [...]` and `export default [...] as Routes`
let expression = node.expression;
if (ts.isAsExpression(expression)) {
expression = expression.expression;
}
if (ts.isArrayLiteralExpression(expression)) {
routesArrays.push({
routeFilePath: sourceFile.fileName,
array: expression,
routeFileImports: sourceFile.statements.filter(ts.isImportDeclaration),
});
}
else if (ts.isIdentifier(expression)) {
manageRoutesExportedByDefault(routesArrays, typeChecker, expression, sourceFile);
}
}
else if (ts.isExportDeclaration(node)) {
// Handles cases like `export { routes as default }`
if (node.exportClause && ts.isNamedExports(node.exportClause)) {
for (const specifier of node.exportClause.elements) {
if (specifier.name.text === 'default') {
manageRoutesExportedByDefault(routesArrays, typeChecker, specifier.propertyName ?? specifier.name, sourceFile);
}
}
}
}
node.forEachChild(walk);
});
return routesArrays;
}
/** Migrate a routes object standalone components to be lazy loaded. */
function migrateRoutesArray(routesArray, typeChecker, reflector, tracker) {
const migratedRoutes = [];
const skippedRoutes = [];
const importsToRemove = [];
for (const route of routesArray) {
route.array.elements.forEach((element) => {
if (ts.isObjectLiteralExpression(element)) {
const { migratedRoutes: migrated, skippedRoutes: toBeSkipped, importsToRemove: toBeRemoved, } = migrateRoute(element, route, typeChecker, reflector, tracker);
migratedRoutes.push(...migrated);
skippedRoutes.push(...toBeSkipped);
importsToRemove.push(...toBeRemoved);
}
});
}
for (const importToRemove of importsToRemove) {
tracker.removeNode(importToRemove);
}
return { migratedRoutes, skippedRoutes };
}
/**
* Migrates a single route object and returns the results of the migration
* It recursively migrates the children routes if they exist
*/
function migrateRoute(element, route, typeChecker, reflector, tracker) {
const skippedRoutes = [];
const migratedRoutes = [];
const importsToRemove = [];
const component = property_name.findLiteralProperty(element, 'component');
// this can be empty string or a variable that is not a string, or not present at all
const routePath = property_name.findLiteralProperty(element, 'path')?.getText() ?? '';
const children = property_name.findLiteralProperty(element, 'children');
// recursively migrate children routes first if they exist
if (children && ts.isArrayLiteralExpression(children.initializer)) {
for (const childRoute of children.initializer.elements) {
if (ts.isObjectLiteralExpression(childRoute)) {
const { migratedRoutes: migrated, skippedRoutes: toBeSkipped, importsToRemove: toBeRemoved, } = migrateRoute(childRoute, route, typeChecker, reflector, tracker);
migratedRoutes.push(...migrated);
skippedRoutes.push(...toBeSkipped);
importsToRemove.push(...toBeRemoved);
}
}
}
const routeMigrationResults = { migratedRoutes, skippedRoutes, importsToRemove };
if (!component) {
return routeMigrationResults;
}
const componentDeclaration = findClassDeclaration(component, typeChecker);
if (!componentDeclaration) {
return routeMigrationResults;
}
// if component is not a standalone component, skip it
if (!isStandaloneComponent(componentDeclaration, reflector)) {
skippedRoutes.push({ path: routePath, file: route.routeFilePath });
return routeMigrationResults;
}
const componentClassName = componentDeclaration.name && ts.isIdentifier(componentDeclaration.name)
? componentDeclaration.name.text
: null;
if (!componentClassName) {
return routeMigrationResults;
}
// if component is in the same file as the routes array, skip it
if (componentDeclaration.getSourceFile().fileName === route.routeFilePath) {
return routeMigrationResults;
}
const componentImport = route.routeFileImports.find((importDecl) => importDecl.importClause?.getText().includes(componentClassName));
// remove single and double quotes from the import path
let componentImportPath = ts.isStringLiteral(componentImport?.moduleSpecifier)
? componentImport.moduleSpecifier.text
: null;
// if the import path is not a string literal, skip it
if (!componentImportPath) {
skippedRoutes.push({ path: routePath, file: route.routeFilePath });
return routeMigrationResults;
}
const isDefaultExport = componentDeclaration.modifiers?.some((x) => x.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
const loadComponent = createLoadComponentPropertyAssignment(componentImportPath, componentClassName, isDefaultExport);
tracker.replaceNode(component, loadComponent);
// Add the import statement for the standalone component
if (!importsToRemove.includes(componentImport)) {
importsToRemove.push(componentImport);
}
migratedRoutes.push({ path: routePath, file: route.routeFilePath });
// the component was migrated, so we return the results
return routeMigrationResults;
}
/**
* Generates the loadComponent property assignment for a given component.
*
* Example:
* loadComponent: () => import('./path').then(m => m.componentName)
* or
* loadComponent: () => import('./path') // when isDefaultExport is true
*/
function createLoadComponentPropertyAssignment(componentImportPath, componentDeclarationName, isDefaultExport) {
return ts.factory.createPropertyAssignment('loadComponent', ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), isDefaultExport
? createImportCallExpression(componentImportPath) // will generate import('./path) and will skip the then() call
: ts.factory.createCallExpression(
// will generate import('./path).then(m => m.componentName)
ts.factory.createPropertyAccessExpression(createImportCallExpression(componentImportPath), 'then'), undefined, [createImportThenCallExpression(componentDeclarationName)])));
}
const manageRoutesExportedByDefault = (routesArrays, typeChecker, expression, sourceFile) => {
const symbol = typeChecker.getSymbolAtLocation(expression);
if (!symbol?.declarations) {
return;
}
for (const declaration of symbol.declarations) {
if (ts.isVariableDeclaration(declaration) &&
declaration.initializer &&
ts.isArrayLiteralExpression(declaration.initializer)) {
routesArrays.push({
routeFilePath: sourceFile.fileName,
array: declaration.initializer,
routeFileImports: sourceFile.statements.filter(ts.isImportDeclaration),
});
}
}
};
// import('./path)
const createImportCallExpression = (componentImportPath) => ts.factory.createCallExpression(ts.factory.createIdentifier('import'), undefined, [
ts.factory.createStringLiteral(componentImportPath, true),
]);
// m => m.componentName
const createImportThenCallExpression = (componentDeclarationName) => ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'm', undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('m'), componentDeclarationName));
function migrate(options) {
return async (tree, context) => {
const { buildPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(tree);
const basePath = process.cwd();
// TS and Schematic use paths in POSIX format even on Windows. This is needed as otherwise
// string matching such as `sourceFile.fileName.startsWith(pathToMigrate)` might not work.
const pathToMigrate = compiler_host.normalizePath(path.join(basePath, options.path));
if (!buildPaths.length) {
throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run the route lazy loading migration.');
}
let migratedRoutes = [];
let skippedRoutes = [];
for (const tsconfigPath of buildPaths) {
const { migratedRoutes: migrated, skippedRoutes: skipped } = standaloneRoutesMigration(tree, tsconfigPath, basePath, pathToMigrate, options);
migratedRoutes.push(...migrated);
skippedRoutes.push(...skipped);
}
if (migratedRoutes.length === 0 && skippedRoutes.length === 0) {
throw new schematics.SchematicsException(`Could not find any files to migrate under the path ${pathToMigrate}.`);
}
context.logger.info('🎉 Automated migration step has finished! 🎉');
context.logger.info(`Number of updated routes: ${migratedRoutes.length}`);
context.logger.info(`Number of skipped routes: ${skippedRoutes.length}`);
if (skippedRoutes.length > 0) {
context.logger.info(`Note: this migration was unable to optimize the following routes, since they use components declared in NgModules:`);
for (const route of skippedRoutes) {
context.logger.info(`- \`${route.path}\` path at \`${route.file}\``);
}
context.logger.info(`Consider making those components standalone and run this migration again. More information about standalone migration can be found at https://angular.dev/reference/migrations/standalone`);
}
context.logger.info('IMPORTANT! Please verify manually that your application builds and behaves as expected.');
context.logger.info(`See https://angular.dev/reference/migrations/route-lazy-loading for more information.`);
};
}
function standaloneRoutesMigration(tree, tsconfigPath, basePath, pathToMigrate, schematicOptions) {
if (schematicOptions.path.startsWith('..')) {
throw new schematics.SchematicsException('Cannot run route lazy loading migration outside of the current project.');
}
if (fs.existsSync(pathToMigrate) && !fs.statSync(pathToMigrate).isDirectory()) {
throw new schematics.SchematicsException(`Migration path ${pathToMigrate} has to be a directory. Cannot run the route lazy loading migration.`);
}
const program = compiler_host.createMigrationProgram(tree, tsconfigPath, basePath);
const sourceFiles = program
.getSourceFiles()
.filter((sourceFile) => sourceFile.fileName.startsWith(pathToMigrate) &&
compiler_host.canMigrateFile(basePath, sourceFile, program));
const migratedRoutes = [];
const skippedRoutes = [];
if (sourceFiles.length === 0) {
return { migratedRoutes, skippedRoutes };
}
for (const sourceFile of sourceFiles) {
const { pendingChanges, skippedRoutes: skipped, migratedRoutes: migrated, } = migrateFileToLazyRoutes(sourceFile, program);
skippedRoutes.push(...skipped);
migratedRoutes.push(...migrated);
const update = tree.beginUpdate(path.relative(basePath, sourceFile.fileName));
pendingChanges.forEach((change) => {
if (change.removeLength != null) {
update.remove(change.start, change.removeLength);
}
update.insertRight(change.start, change.text);
});
tree.commitUpdate(update);
}
return { migratedRoutes, skippedRoutes };
}
exports.migrate = migrate;
@@ -0,0 +1,103 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
require('@angular/compiler-cli');
require('@angular/compiler-cli/private/migrations');
require('node:path');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
var imports = require('./imports-CVmcbVA9.cjs');
var symbol = require('./symbol-DZeHSR-V.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
/** Name of the method being replaced. */
const METHOD_NAME = 'getCurrentNavigation';
/** Migration that replaces `Router.getCurrentNavigation` usages with `Router.currentNavigation()`. */
class RouterCurrentNavigationMigration extends project_paths.TsurgeFunnelMigration {
async analyze(info) {
const locations = [];
for (const sourceFile of info.sourceFiles) {
const routerSpecifier = imports.getImportSpecifier(sourceFile, '@angular/router', 'Router');
if (routerSpecifier === null) {
continue;
}
const typeChecker = info.program.getTypeChecker();
sourceFile.forEachChild(function walk(node) {
if (ts.isPropertyAccessExpression(node) &&
node.name.text === METHOD_NAME &&
isRouterType(typeChecker, node.expression, routerSpecifier)) {
locations.push({ file: project_paths.projectFile(sourceFile, info), position: node.name.getStart() });
}
else {
node.forEachChild(walk);
}
});
}
return project_paths.confirmAsSerializable({ locations });
}
async migrate(globalData) {
const replacements = globalData.locations.map(({ file, position }) => {
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: position,
end: position + METHOD_NAME.length,
toInsert: 'currentNavigation',
}));
});
return project_paths.confirmAsSerializable({ replacements });
}
async combine(unitA, unitB) {
const seen = new Set();
const locations = [];
const combined = [...unitA.locations, ...unitB.locations];
for (const location of combined) {
const key = `${location.file.id}#${location.position}`;
if (!seen.has(key)) {
seen.add(key);
locations.push(location);
}
}
return project_paths.confirmAsSerializable({ locations });
}
async globalMeta(combinedData) {
return project_paths.confirmAsSerializable(combinedData);
}
async stats() {
return project_paths.confirmAsSerializable({});
}
}
/**
* Checks if the given symbol represents a Router type.
*/
function isRouterType(typeChecker, expression, routerSpecifier) {
const expressionType = typeChecker.getTypeAtLocation(expression);
const expressionSymbol = expressionType.getSymbol();
if (!expressionSymbol) {
return false;
}
const declarations = expressionSymbol.getDeclarations() ?? [];
for (const declaration of declarations) {
if (symbol.isReferenceToImport(typeChecker, declaration, routerSpecifier)) {
return true;
}
}
return declarations.some((decl) => decl === routerSpecifier);
}
function migrate() {
return async (tree) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: () => new RouterCurrentNavigationMigration(),
});
};
}
exports.migrate = migrate;
@@ -0,0 +1,103 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
require('@angular/compiler-cli');
require('@angular/compiler-cli/private/migrations');
require('node:path');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
var imports = require('./imports-CVmcbVA9.cjs');
var symbol = require('./symbol-DZeHSR-V.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
/** Name of the method being replaced. */
const METHOD_NAME = 'lastSuccessfulNavigation';
/** Migration that replaces `Router.lastSuccessfulNavigation` usages with `Router.lastSuccessfulNavigation()`. */
class RouterLastSuccessfulNavigationMigration extends project_paths.TsurgeFunnelMigration {
async analyze(info) {
const locations = [];
for (const sourceFile of info.sourceFiles) {
const routerSpecifier = imports.getImportSpecifier(sourceFile, '@angular/router', 'Router');
if (routerSpecifier === null) {
continue;
}
const typeChecker = info.program.getTypeChecker();
sourceFile.forEachChild(function walk(node) {
if (ts.isPropertyAccessExpression(node) &&
node.name.text === METHOD_NAME &&
isRouterType(typeChecker, node.expression, routerSpecifier)) {
locations.push({ file: project_paths.projectFile(sourceFile, info), position: node.name.getStart() });
}
else {
node.forEachChild(walk);
}
});
}
return project_paths.confirmAsSerializable({ locations });
}
async migrate(globalData) {
const replacements = globalData.locations.map(({ file, position }) => {
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: position,
end: position + METHOD_NAME.length,
toInsert: 'lastSuccessfulNavigation()',
}));
});
return project_paths.confirmAsSerializable({ replacements });
}
async combine(unitA, unitB) {
const seen = new Set();
const locations = [];
const combined = [...unitA.locations, ...unitB.locations];
for (const location of combined) {
const key = `${location.file.id}#${location.position}`;
if (!seen.has(key)) {
seen.add(key);
locations.push(location);
}
}
return project_paths.confirmAsSerializable({ locations });
}
async globalMeta(combinedData) {
return project_paths.confirmAsSerializable(combinedData);
}
async stats() {
return project_paths.confirmAsSerializable({});
}
}
/**
* Checks if the given symbol represents a Router type.
*/
function isRouterType(typeChecker, expression, routerSpecifier) {
const expressionType = typeChecker.getTypeAtLocation(expression);
const expressionSymbol = expressionType.getSymbol();
if (!expressionSymbol) {
return false;
}
const declarations = expressionSymbol.getDeclarations() ?? [];
for (const declaration of declarations) {
if (symbol.isReferenceToImport(typeChecker, declaration, routerSpecifier)) {
return true;
}
}
return declarations.some((decl) => decl === routerSpecifier);
}
function migrate() {
return async (tree) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: () => new RouterLastSuccessfulNavigationMigration(),
});
};
}
exports.migrate = migrate;
@@ -0,0 +1,502 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
require('@angular-devkit/core');
require('node:path/posix');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
require('@angular/compiler-cli');
var migrations = require('@angular/compiler-cli/private/migrations');
var ts = require('typescript');
require('node:path');
var apply_import_manager = require('./apply_import_manager-CxA_YYgB.cjs');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
const ROUTER_TESTING_MODULE = 'RouterTestingModule';
const SPY_LOCATION = 'SpyLocation';
const ROUTER_MODULE = 'RouterModule';
const PROVIDE_LOCATION_MOCKS = 'provideLocationMocks';
const ANGULAR_ROUTER_TESTING = '@angular/router/testing';
const ANGULAR_ROUTER = '@angular/router';
const ANGULAR_COMMON_TESTING = '@angular/common/testing';
const IMPORTS_PROPERTY = 'imports';
const PROVIDERS_PROPERTY = 'providers';
const WITH_ROUTES_STATIC_METHOD = 'withRoutes';
const TESTBED_IDENTIFIER = 'TestBed';
const CONFIGURE_TESTING_MODULE = 'configureTestingModule';
function hasImportFromModule(sourceFile, modulePath, ...symbolNames) {
const symbolSet = new Set(symbolNames);
let hasImport = false;
ts.forEachChild(sourceFile, (node) => {
if (ts.isImportDeclaration(node) &&
ts.isStringLiteral(node.moduleSpecifier) &&
node.moduleSpecifier.text === modulePath &&
node.importClause?.namedBindings &&
ts.isNamedImports(node.importClause.namedBindings)) {
for (const element of node.importClause.namedBindings.elements) {
if (symbolSet.has(element.name.text)) {
hasImport = true;
break;
}
}
}
});
return hasImport;
}
function detectSpyLocationUrlChangesUsage(sourceFile) {
const hasSpyLocationImport = hasImportFromModule(sourceFile, ANGULAR_COMMON_TESTING, SPY_LOCATION);
let usesUrlChangesFeature = false;
function walk(node) {
if (usesUrlChangesFeature) {
return;
}
if (ts.isPropertyAccessExpression(node) &&
ts.isIdentifier(node.name) &&
node.name.text === 'urlChanges') {
usesUrlChangesFeature = true;
return;
}
node.forEachChild(walk);
}
walk(sourceFile);
return hasSpyLocationImport && usesUrlChangesFeature;
}
function createArrayLiteralReplacement(file, arrayLiteral, newElements, sourceFile) {
const elementNodes = newElements.map((element) => {
if (typeof element === 'string') {
return parseStringToExpression(element);
}
return element;
});
const newArray = ts.factory.updateArrayLiteralExpression(arrayLiteral, elementNodes);
const printer = ts.createPrinter({
newLine: ts.NewLineKind.LineFeed,
});
const newText = printer.printNode(ts.EmitHint.Unspecified, newArray, sourceFile);
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: arrayLiteral.getStart(),
end: arrayLiteral.getEnd(),
toInsert: newText,
}));
}
function createImportRemovalReplacement(file, importDeclaration, namedBindings, symbolToRemove, sourceFile) {
const otherImports = namedBindings.elements.filter((el) => el.name.text !== symbolToRemove);
if (otherImports.length === 0) {
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: importDeclaration.getStart(),
end: importDeclaration.getEnd() + 1,
toInsert: '',
}));
}
else {
const newNamedBindings = ts.factory.updateNamedImports(namedBindings, otherImports);
const printer = ts.createPrinter();
const newText = printer.printNode(ts.EmitHint.Unspecified, newNamedBindings, sourceFile);
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: namedBindings.getStart(),
end: namedBindings.getEnd(),
toInsert: newText,
}));
}
}
function isEmptyArrayExpression(expression) {
return ts.isArrayLiteralExpression(expression) && expression.elements.length === 0;
}
function getRoutesArgumentForMigration(routesNode, optionsNode) {
if (!routesNode) {
return undefined;
}
if (!isEmptyArrayExpression(routesNode)) {
return routesNode;
}
return optionsNode ? routesNode : undefined;
}
function createRouterModuleExpression(routesArg, optionsArg) {
const routerModuleIdentifier = ts.factory.createIdentifier(ROUTER_MODULE);
if (routesArg) {
// Build args list and include options if present
const args = [routesArg];
if (optionsArg) {
args.push(optionsArg);
}
// Create RouterModule.forRoot(routes, options?) expression
return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(routerModuleIdentifier, ts.factory.createIdentifier('forRoot')), undefined, args);
}
return routerModuleIdentifier;
}
function createProviderCallExpression(functionName, argument) {
return ts.factory.createCallExpression(ts.factory.createIdentifier(functionName), undefined, []);
}
function createArrayLiteralFromExpressions(expressions) {
return ts.factory.createArrayLiteralExpression(Array.from(expressions), true);
}
function parseStringToExpression(text) {
const wrapped = `(${text})`;
const sourceFile = ts.createSourceFile('temp.ts', wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
if (sourceFile.statements.length === 1) {
const statement = sourceFile.statements[0];
if (ts.isExpressionStatement(statement) && ts.isParenthesizedExpression(statement.expression)) {
return statement.expression.expression;
}
}
return parseExpressionWithPatternRecognition(text);
}
function parseExpressionWithPatternRecognition(text) {
const callPattern = analyzeCallPattern(text);
if (callPattern) {
return ts.factory.createCallExpression(callPattern.expression, undefined, Array.from(callPattern.arguments));
}
const arrayPattern = analyzeArrayPattern(text);
if (arrayPattern) {
return ts.factory.createArrayLiteralExpression(Array.from(arrayPattern.elements), true);
}
const literalPattern = analyzeLiteralPattern(text);
if (literalPattern) {
return literalPattern.expression;
}
return ts.factory.createIdentifier(text);
}
function analyzeCallPattern(text) {
const testExpression = `(${text})`;
const sourceFile = ts.createSourceFile('temp.ts', testExpression, ts.ScriptTarget.Latest, true);
if (sourceFile.statements.length === 1) {
const statement = sourceFile.statements[0];
if (ts.isExpressionStatement(statement) &&
ts.isParenthesizedExpression(statement.expression) &&
ts.isCallExpression(statement.expression.expression)) {
const callExpr = statement.expression.expression;
return {
type: 'call',
expression: callExpr.expression,
arguments: callExpr.arguments,
};
}
}
return null;
}
function analyzeArrayPattern(text) {
const sourceFile = ts.createSourceFile('temp.ts', text, ts.ScriptTarget.Latest, true);
if (sourceFile.statements.length === 1) {
const statement = sourceFile.statements[0];
if (ts.isExpressionStatement(statement) && ts.isArrayLiteralExpression(statement.expression)) {
return {
type: 'array',
elements: statement.expression.elements,
};
}
}
return null;
}
function analyzeLiteralPattern(text) {
const sourceFile = ts.createSourceFile('temp.ts', text, ts.ScriptTarget.Latest, true);
if (sourceFile.statements.length === 1) {
const statement = sourceFile.statements[0];
if (ts.isExpressionStatement(statement)) {
const expr = statement.expression;
if (ts.isStringLiteral(expr) || ts.isNumericLiteral(expr) || ts.isLiteralExpression(expr)) {
return {
type: 'literal',
expression: expr,
};
}
}
}
return null;
}
function removeRouterTestingModuleImport(sourceFile, file, replacements) {
ts.forEachChild(sourceFile, (node) => {
if (ts.isImportDeclaration(node) &&
ts.isStringLiteral(node.moduleSpecifier) &&
node.moduleSpecifier.text === ANGULAR_ROUTER_TESTING &&
node.importClause?.namedBindings &&
ts.isNamedImports(node.importClause.namedBindings)) {
const namedBindings = node.importClause.namedBindings;
replacements.push(createImportRemovalReplacement(file, node, namedBindings, ROUTER_TESTING_MODULE, sourceFile));
}
});
}
function migrateToRouterModule(usage, file, routesNode, optionsNode, replacements) {
const neededImportsExpressions = new Set();
const neededProvidersExpressions = new Set();
const optionsExpression = optionsNode ? optionsNode : undefined;
const routesExpression = getRoutesArgumentForMigration(routesNode, optionsNode);
const routerModuleExpression = createRouterModuleExpression(routesExpression, optionsExpression);
neededImportsExpressions.add(routerModuleExpression);
if (usage.usesSpyLocationUrlChanges) {
const provideLocationMocksExpression = createProviderCallExpression(PROVIDE_LOCATION_MOCKS);
neededProvidersExpressions.add(provideLocationMocksExpression);
}
if (usage.importsProperty && ts.isArrayLiteralExpression(usage.importsProperty.initializer)) {
const importsArray = usage.importsProperty.initializer;
const otherImportExpressions = usage.importsArrayElements.filter((el) => el !== usage.routerTestingModuleElement);
const allImportExpressions = [
...otherImportExpressions,
...Array.from(neededImportsExpressions),
];
replacements.push(createArrayLiteralReplacement(file, importsArray, allImportExpressions, usage.sourceFile));
}
if (neededProvidersExpressions.size > 0) {
if (usage.providersProperty &&
ts.isArrayLiteralExpression(usage.providersProperty.initializer)) {
const existingProvidersArray = usage.providersProperty.initializer;
const allProviderExpressions = [
...existingProvidersArray.elements,
...Array.from(neededProvidersExpressions),
];
replacements.push(createArrayLiteralReplacement(file, existingProvidersArray, allProviderExpressions, usage.sourceFile));
}
else {
const providersArray = createArrayLiteralFromExpressions(neededProvidersExpressions);
const printer = ts.createPrinter();
const providersText = printer.printNode(ts.EmitHint.Unspecified, providersArray, usage.sourceFile);
const insertPosition = usage.importsProperty.getEnd();
replacements.push(new project_paths.Replacement(file, new project_paths.TextUpdate({
position: insertPosition,
end: insertPosition,
toInsert: `,\n ${PROVIDERS_PROPERTY}: ${providersText}`,
})));
}
}
}
function analyzeRouterTestingModuleUsage(usage) {
const neededProviders = new Set();
const neededImports = new Set();
let hasLocationMocks = false;
const optionsExpression = usage.optionsNode ? usage.optionsNode : undefined;
const routesExpression = getRoutesArgumentForMigration(usage.routesNode, usage.optionsNode);
// Add RouterModule to imports (preserve options when present)
const routerModuleExpression = createRouterModuleExpression(routesExpression, optionsExpression);
neededImports.add(routerModuleExpression);
// Add location mocks ONLY if:
// 1. SpyLocation is imported from @angular/common/testing, AND
// 2. urlChanges property is accessed in the test
// 3. provideLocationMocks() is not already present
if (usage.usesSpyLocationUrlChanges) {
const provideLocationMocksExpression = createProviderCallExpression(PROVIDE_LOCATION_MOCKS);
neededProviders.add(provideLocationMocksExpression);
hasLocationMocks = true;
}
return {
neededProviders,
neededImports,
canRemoveRouterTestingModule: true,
replacementCount: 1,
hasLocationMocks,
};
}
function findRouterTestingModuleUsages(sourceFile) {
const usages = [];
const hasRouterTestingModule = hasImportFromModule(sourceFile, ANGULAR_ROUTER_TESTING, ROUTER_TESTING_MODULE);
const usesSpyLocationUrlChanges = detectSpyLocationUrlChangesUsage(sourceFile);
if (!hasRouterTestingModule) {
return usages;
}
function walk(node) {
if (ts.isCallExpression(node) &&
ts.isPropertyAccessExpression(node.expression) &&
node.expression.name.text === CONFIGURE_TESTING_MODULE &&
ts.isIdentifier(node.expression.expression) &&
node.expression.expression.text === TESTBED_IDENTIFIER &&
node.arguments.length > 0 &&
ts.isObjectLiteralExpression(node.arguments[0])) {
const config = node.arguments[0];
let importsProperty = null;
let providersProperty = null;
for (const prop of config.properties) {
if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
if (prop.name.text === IMPORTS_PROPERTY) {
importsProperty = prop;
}
else if (prop.name.text === PROVIDERS_PROPERTY) {
providersProperty = prop;
}
}
}
if (!importsProperty || !ts.isArrayLiteralExpression(importsProperty.initializer)) {
node.forEachChild(walk);
return;
}
const importsArray = importsProperty.initializer;
let routerTestingModuleElement = null;
let routesNode = null;
let optionsNode = null;
for (const element of importsArray.elements) {
if (ts.isIdentifier(element) && element.text === ROUTER_TESTING_MODULE) {
routerTestingModuleElement = element;
break;
}
else if (ts.isCallExpression(element) &&
ts.isPropertyAccessExpression(element.expression) &&
ts.isIdentifier(element.expression.expression) &&
element.expression.expression.text === ROUTER_TESTING_MODULE &&
element.expression.name.text === WITH_ROUTES_STATIC_METHOD) {
routerTestingModuleElement = element;
if (element.arguments.length > 0) {
routesNode = element.arguments[0];
}
if (element.arguments.length > 1) {
optionsNode = element.arguments[1];
}
break;
}
}
if (routerTestingModuleElement) {
usages.push({
sourceFile,
configObject: config,
importsProperty,
providersProperty,
routerTestingModuleElement,
routesNode,
optionsNode,
importsArrayElements: Array.from(importsArray.elements),
usesSpyLocationUrlChanges,
});
}
}
node.forEachChild(walk);
}
walk(sourceFile);
return usages;
}
function processRouterTestingModuleUsage(usage, sourceFile, info, importManager, replacements) {
const file = project_paths.projectFile(sourceFile, info);
const routesNode = usage.routesNode;
const optionsNode = usage.optionsNode;
const analysis = analyzeRouterTestingModuleUsage(usage);
migrateToRouterModule(usage, file, routesNode, optionsNode, replacements);
importManager.addImport({
exportModuleSpecifier: ANGULAR_ROUTER,
exportSymbolName: ROUTER_MODULE,
requestedFile: sourceFile,
});
if (analysis.hasLocationMocks) {
importManager.addImport({
exportModuleSpecifier: ANGULAR_COMMON_TESTING,
exportSymbolName: PROVIDE_LOCATION_MOCKS,
requestedFile: sourceFile,
});
}
removeRouterTestingModuleImport(sourceFile, file, replacements);
}
/**
* Migration that converts RouterTestingModule usages to the recommended API:
* - Replace RouterTestingModule with RouterModule for all tests (respecting existing imports)
* - Adds provideLocationMocks only when needed and not conflicting
*/
class RouterTestingModuleMigration extends project_paths.TsurgeFunnelMigration {
config;
constructor(config = {}) {
super();
this.config = config;
}
async analyze(info) {
const replacements = [];
const migratedUsages = [];
const filesWithLocationMocks = new Map();
const importManager = new migrations.ImportManager({
shouldUseSingleQuotes: () => true,
});
for (const sourceFile of info.sourceFiles) {
const file = project_paths.projectFile(sourceFile, info);
if (this.config.shouldMigrate && !this.config.shouldMigrate(file)) {
continue;
}
const usages = findRouterTestingModuleUsages(sourceFile);
for (const usage of usages) {
processRouterTestingModuleUsage(usage, sourceFile, info, importManager, replacements);
migratedUsages.push(usage);
if (usage.usesSpyLocationUrlChanges) {
filesWithLocationMocks.set(sourceFile.fileName, true);
}
}
}
apply_import_manager.applyImportManagerChanges(importManager, replacements, info.sourceFiles, info);
return project_paths.confirmAsSerializable({
replacements,
migratedUsages,
filesWithLocationMocks,
});
}
async migrate(globalData) {
return {
replacements: globalData.replacements,
};
}
async combine(unitA, unitB) {
const combinedFilesWithLocationMocks = new Map(unitA.filesWithLocationMocks);
for (const [fileName, hasLocationMocks] of unitB.filesWithLocationMocks) {
combinedFilesWithLocationMocks.set(fileName, hasLocationMocks || combinedFilesWithLocationMocks.get(fileName) || false);
}
return project_paths.confirmAsSerializable({
replacements: [...unitA.replacements, ...unitB.replacements],
migratedUsages: [...unitA.migratedUsages, ...unitB.migratedUsages],
filesWithLocationMocks: combinedFilesWithLocationMocks,
});
}
async globalMeta(combinedData) {
return project_paths.confirmAsSerializable(combinedData);
}
async stats(globalMetadata) {
const stats = {
counters: {
replacements: globalMetadata.replacements.length,
migratedUsages: globalMetadata.migratedUsages.length,
filesWithLocationMocks: globalMetadata.filesWithLocationMocks.size,
totalFiles: new Set(globalMetadata.migratedUsages.map((usage) => usage.sourceFile.fileName))
.size,
},
};
return stats;
}
}
function migrate(options) {
return async (tree, context) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: (fs) => new RouterTestingModuleMigration({
shouldMigrate: (file) => {
return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
!/(^|\/)node_modules\//.test(file.rootRelativePath) &&
/\.spec\.ts$/.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 RouterTestingModule 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 RouterTestingModule to RouterModule 🎉`);
context.logger.info(` -> Migrated ${stats.counters.migratedUsages} RouterTestingModule usages in ${stats.counters.totalFiles} test files.`);
if (stats.counters.filesWithLocationMocks > 0) {
context.logger.info(` -> Added provideLocationMocks() to ${stats.counters.filesWithLocationMocks} files with SpyLocation.urlChanges usage.`);
}
},
});
};
}
exports.migrate = migrate;
@@ -0,0 +1,205 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
require('@angular/compiler-cli');
require('@angular/compiler-cli/private/migrations');
require('node:path');
var project_paths = require('./project_paths-D2V-Uh2L.cjs');
var ng_component_template = require('./ng_component_template-BOuKAnQd.cjs');
var compiler = require('@angular/compiler');
var parse_html = require('./parse_html-C8eKA9px.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('@angular-devkit/schematics');
require('./project_tsconfig_paths-DkkMibv-.cjs');
require('./ng_decorators-DYy6II6x.cjs');
require('./imports-CVmcbVA9.cjs');
require('./property_name-BCpALNpZ.cjs');
function migrateTemplateToSelfClosingTags(template) {
let parsed = parse_html.parseTemplate(template);
if (parsed.tree === undefined) {
return { migrated: template, changed: false, replacementCount: 0 };
}
const visitor = new AngularElementCollector();
compiler.visitAll(visitor, parsed.tree.rootNodes);
let newTemplate = template;
let changedOffset = 0;
let replacementCount = 0;
for (let element of visitor.elements) {
const { start, end, tagName } = element;
const currentLength = newTemplate.length;
const templatePart = newTemplate.slice(start + changedOffset, end + changedOffset);
const convertedTemplate = replaceWithSelfClosingTag(templatePart, tagName);
// if the template has changed, replace the original template with the new one
if (convertedTemplate.length !== templatePart.length) {
newTemplate = replaceTemplate(newTemplate, convertedTemplate, start, end, changedOffset);
changedOffset += newTemplate.length - currentLength;
replacementCount++;
}
}
return { migrated: newTemplate, changed: changedOffset !== 0, replacementCount };
}
function replaceWithSelfClosingTag(html, tagName) {
const pattern = new RegExp(`<\\s*${tagName}\\s*([^>]*?(?:"[^"]*"|'[^']*'|[^'">])*)\\s*>([\\s\\S]*?)<\\s*/\\s*${tagName}\\s*>`, 'gi');
return html.replace(pattern, (_, content) => `<${tagName}${content ? ` ${content}` : ''} />`);
}
/**
* Replace the value in the template with the new value based on the start and end position + offset
*/
function replaceTemplate(template, replaceValue, start, end, offset) {
return template.slice(0, start + offset) + replaceValue + template.slice(end + offset);
}
const ALL_HTML_TAGS = new compiler.DomElementSchemaRegistry().allKnownElementNames();
class AngularElementCollector extends compiler.RecursiveVisitor {
elements = [];
constructor() {
super();
}
visitElement(element) {
if (!element.isSelfClosing &&
!ALL_HTML_TAGS.includes(element.name) &&
this.elementHasNoContent(element)) {
this.elements.push({
tagName: element.name,
start: element.sourceSpan.start.offset,
end: element.sourceSpan.end.offset,
});
}
return super.visitElement(element, null);
}
elementHasNoContent(element) {
if (!element.children?.length) {
return true;
}
if (element.children.length === 1) {
const child = element.children[0];
return child instanceof compiler.Text && /^\s*$/.test(child.value);
}
return false;
}
}
class SelfClosingTagsMigration extends project_paths.TsurgeFunnelMigration {
config;
constructor(config = {}) {
super();
this.config = config;
}
async analyze(info) {
const { sourceFiles, program } = info;
const typeChecker = program.getTypeChecker();
const tagReplacements = [];
for (const sf of sourceFiles) {
ts.forEachChild(sf, (node) => {
// Skipping any non component declarations
if (!ts.isClassDeclaration(node)) {
return;
}
const file = project_paths.projectFile(node.getSourceFile(), info);
if (this.config.shouldMigrate && this.config.shouldMigrate(file) === false) {
return;
}
const templateVisitor = new ng_component_template.NgComponentTemplateVisitor(typeChecker);
templateVisitor.visitNode(node);
templateVisitor.resolvedTemplates.forEach((template) => {
const { migrated, changed, replacementCount } = migrateTemplateToSelfClosingTags(template.content);
if (!changed) {
return;
}
const fileToMigrate = template.inline
? file
: project_paths.projectFile(template.filePath, info);
const end = template.start + template.content.length;
const replacements = [
prepareTextReplacement(fileToMigrate, migrated, template.start, end),
];
const fileReplacements = tagReplacements.find((tagReplacement) => tagReplacement.file === file);
if (fileReplacements) {
fileReplacements.replacements.push(...replacements);
fileReplacements.replacementCount += replacementCount;
}
else {
tagReplacements.push({ file, replacements, replacementCount });
}
});
});
}
return project_paths.confirmAsSerializable({ tagReplacements });
}
async combine(unitA, unitB) {
return project_paths.confirmAsSerializable({
tagReplacements: [...unitA.tagReplacements, ...unitB.tagReplacements],
});
}
async globalMeta(combinedData) {
const globalMeta = {
tagReplacements: combinedData.tagReplacements,
};
return project_paths.confirmAsSerializable(globalMeta);
}
async stats(globalMetadata) {
const touchedFilesCount = globalMetadata.tagReplacements.length;
const replacementCount = globalMetadata.tagReplacements.reduce((acc, cur) => acc + cur.replacementCount, 0);
return project_paths.confirmAsSerializable({
touchedFilesCount,
replacementCount,
});
}
async migrate(globalData) {
return { replacements: globalData.tagReplacements.flatMap(({ replacements }) => replacements) };
}
}
function prepareTextReplacement(file, replacement, start, end) {
return new project_paths.Replacement(file, new project_paths.TextUpdate({
position: start,
end: end,
toInsert: replacement,
}));
}
function migrate(options) {
return async (tree, context) => {
await project_paths.runMigrationInDevkit({
tree,
getMigration: (fs) => new SelfClosingTagsMigration({
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 component tags: ${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: ({ touchedFilesCount, replacementCount }) => {
context.logger.info('');
context.logger.info(`Successfully migrated to self-closing tags 🎉`);
context.logger.info(` -> Migrated ${replacementCount} components to self-closing tags in ${touchedFilesCount} component files.`);
},
});
};
}
exports.migrate = migrate;
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+51
View File
@@ -0,0 +1,51 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var schematics = require('@angular-devkit/schematics');
var signalQueriesMigration = require('./signal-queries-migration.cjs');
var signalInputMigration = require('./signal-input-migration.cjs');
var outputMigration = require('./output-migration.cjs');
require('@angular/compiler-cli/private/migrations');
require('typescript');
require('@angular/compiler-cli');
require('node:path');
require('./project_paths-D2V-Uh2L.cjs');
require('@angular-devkit/core');
require('node:path/posix');
require('./project_tsconfig_paths-DkkMibv-.cjs');
require('./apply_import_manager-CxA_YYgB.cjs');
require('./migrate_ts_type_references-MWoZx-Cb.cjs');
require('assert');
require('./index-BtLcQH8g.cjs');
require('@angular/compiler');
require('./leading_space-BTPRV0wu.cjs');
function migrate(options) {
// The migrations are independent so we can run them in any order, but we sort them here
// alphabetically so we get a consistent execution order in case of issue reports.
const migrations = options.migrations.slice().sort();
const rules = [];
for (const migration of migrations) {
switch (migration) {
case "inputs" /* SupportedMigrations.inputs */:
rules.push(signalInputMigration.migrate(options));
break;
case "outputs" /* SupportedMigrations.outputs */:
rules.push(outputMigration.migrate(options));
break;
case "queries" /* SupportedMigrations.queries */:
rules.push(signalQueriesMigration.migrate(options));
break;
default:
throw new schematics.SchematicsException(`Unsupported migration "${migration}"`);
}
}
return schematics.chain(rules);
}
exports.migrate = migrate;
File diff suppressed because it is too large Load Diff
+26
View File
@@ -0,0 +1,26 @@
'use strict';
/**
* @license Angular v21.2.1
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
'use strict';
var ts = require('typescript');
/** Checks whether a node is referring to a specific import specifier. */
function isReferenceToImport(typeChecker, node, importSpecifier) {
// If this function is called on an identifier (should be most cases), we can quickly rule out
// non-matches by comparing the identifier's string and the local name of the import specifier
// which saves us some calls to the type checker.
if (importSpecifier === null ||
(ts.isIdentifier(node) && node.text !== importSpecifier.name.text)) {
return false;
}
const nodeSymbol = typeChecker.getTypeAtLocation(node).getSymbol();
const importSymbol = typeChecker.getTypeAtLocation(importSpecifier).getSymbol();
return (!!(nodeSymbol?.declarations?.[0] && importSymbol?.declarations?.[0]) &&
nodeSymbol.declarations[0] === importSymbol.declarations[0]);
}
exports.isReferenceToImport = isReferenceToImport;