Primeiro commit do projeto Angular
This commit is contained in:
Generated
Vendored
+117
@@ -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;
|
||||
+84
@@ -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;
|
||||
+66
@@ -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;
|
||||
+644
@@ -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;
|
||||
+321
@@ -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;
|
||||
+387
@@ -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;
|
||||
+318
@@ -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;
|
||||
+1930
File diff suppressed because it is too large
Load Diff
+110
@@ -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
@@ -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;
|
||||
+1364
File diff suppressed because it is too large
Load Diff
+30
@@ -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;
|
||||
Generated
Vendored
+1971
File diff suppressed because it is too large
Load Diff
+185
@@ -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;
|
||||
+39
@@ -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;
|
||||
+542
@@ -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;
|
||||
+487
@@ -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
@@ -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
@@ -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
@@ -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;
|
||||
+586
@@ -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;
|
||||
Generated
Vendored
+90
@@ -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;
|
||||
+27
@@ -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
@@ -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;
|
||||
+103
@@ -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;
|
||||
Generated
Vendored
+103
@@ -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;
|
||||
Generated
Vendored
+502
@@ -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;
|
||||
+205
@@ -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;
|
||||
+1573
File diff suppressed because it is too large
Load Diff
+1173
File diff suppressed because it is too large
Load Diff
+51
@@ -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;
|
||||
+2105
File diff suppressed because it is too large
Load Diff
+26
@@ -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;
|
||||
+85
@@ -0,0 +1,85 @@
|
||||
{
|
||||
"schematics": {
|
||||
"standalone-migration": {
|
||||
"description": "Converts the entire application or a part of it to standalone",
|
||||
"factory": "./bundles/standalone-migration.cjs#migrate",
|
||||
"schema": "./ng-generate/standalone-migration/schema.json",
|
||||
"aliases": ["standalone"]
|
||||
},
|
||||
"inject-migration": {
|
||||
"description": "Converts usages of constructor-based injection to the inject() function",
|
||||
"factory": "./bundles/inject-migration.cjs#migrate",
|
||||
"schema": "./ng-generate/inject-migration/schema.json",
|
||||
"aliases": ["inject"]
|
||||
},
|
||||
"route-lazy-loading-migration": {
|
||||
"description": "Updates route definitions to use lazy-loading of components instead of eagerly referencing them",
|
||||
"factory": "./bundles/route-lazy-loading.cjs#migrate",
|
||||
"schema": "./ng-generate/route-lazy-loading/schema.json",
|
||||
"aliases": ["route-lazy-loading"]
|
||||
},
|
||||
"signal-input-migration": {
|
||||
"description": "Updates `@Input` declarations to signal inputs, while also migrating all relevant references.",
|
||||
"factory": "./bundles/signal-input-migration.cjs#migrate",
|
||||
"schema": "./ng-generate/signal-input-migration/schema.json",
|
||||
"aliases": ["signal-inputs", "signal-input"]
|
||||
},
|
||||
"signal-queries-migration": {
|
||||
"description": "Updates query declarations to signal queries, while also migrating all relevant references.",
|
||||
"factory": "./bundles/signal-queries-migration.cjs#migrate",
|
||||
"schema": "./ng-generate/signal-queries-migration/schema.json",
|
||||
"aliases": ["signal-queries", "signal-query", "signal-query-migration"]
|
||||
},
|
||||
"output-migration": {
|
||||
"description": "Updates @output declarations to the functional equivalent, while also migrating all relevant references.",
|
||||
"factory": "./bundles/output-migration.cjs#migrate",
|
||||
"schema": "./ng-generate/output-migration/schema.json",
|
||||
"aliases": ["outputs"]
|
||||
},
|
||||
"signals": {
|
||||
"description": "Combines all signals-related migrations into a single migration",
|
||||
"factory": "./bundles/signals.cjs#migrate",
|
||||
"schema": "./ng-generate/signals/schema.json"
|
||||
},
|
||||
"cleanup-unused-imports": {
|
||||
"description": "Removes unused imports from standalone components.",
|
||||
"factory": "./bundles/cleanup-unused-imports.cjs#migrate",
|
||||
"schema": "./ng-generate/cleanup-unused-imports/schema.json"
|
||||
},
|
||||
"self-closing-tags-migration": {
|
||||
"description": "Updates the components templates to use self-closing tags where possible",
|
||||
"factory": "./bundles/self-closing-tags-migration.cjs#migrate",
|
||||
"schema": "./ng-generate/self-closing-tags-migration/schema.json",
|
||||
"aliases": ["self-closing-tag"]
|
||||
},
|
||||
"common-to-standalone-migration": {
|
||||
"description": "Replaces CommonModule with individual imports from @angular/common",
|
||||
"factory": "./bundles/common-to-standalone-migration.cjs#migrate",
|
||||
"schema": "./migrations/common-to-standalone-migration/schema.json",
|
||||
"aliases": ["common-to-standalone"]
|
||||
},
|
||||
"control-flow-migration": {
|
||||
"description": "Converts the entire application to block control flow syntax",
|
||||
"factory": "./bundles/control-flow-migration.cjs#migrate",
|
||||
"schema": "./migrations/control-flow-migration/schema.json",
|
||||
"aliases": ["control-flow"]
|
||||
},
|
||||
"ngclass-to-class-migration": {
|
||||
"description": "Updates usages of `ngClass` directives to the `class` bindings where possible",
|
||||
"factory": "./bundles/ngclass-to-class-migration.cjs#migrate",
|
||||
"schema": "./migrations/ngclass-to-class-migration/schema.json",
|
||||
"aliases": ["ngclass-to-class"]
|
||||
},
|
||||
"ngstyle-to-style-migration": {
|
||||
"description": "Updates usages of `ngStyle` directives to the `style` bindings where possible",
|
||||
"factory": "./bundles/ngstyle-to-style-migration.cjs#migrate",
|
||||
"schema": "./migrations/ngstyle-to-style-migration/schema.json",
|
||||
"aliases": ["ngstyle-to-style"]
|
||||
},
|
||||
"router-testing-module-migration": {
|
||||
"description": "Replaces deprecated RouterTestingModule with provideRouter() as recommended in the deprecation note",
|
||||
"factory": "./bundles/router-testing-module-migration.cjs#migrate",
|
||||
"schema": "./migrations/router-testing-module-migration/schema.json"
|
||||
}
|
||||
}
|
||||
}
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
{
|
||||
"schematics": {
|
||||
"control-flow-migration": {
|
||||
"version": "21.0.0",
|
||||
"description": "Converts the entire application to block control flow syntax",
|
||||
"factory": "./bundles/control-flow-migration.cjs#migrate"
|
||||
},
|
||||
"router-current-navigation": {
|
||||
"version": "21.0.0",
|
||||
"description": "Replaces usages of the deprecated Router.getCurrentNavigation method with the Router.currentNavigation signal",
|
||||
"factory": "./bundles/router-current-navigation.cjs#migrate",
|
||||
"optional": true
|
||||
},
|
||||
"router-last-successful-navigation": {
|
||||
"version": "21.0.0",
|
||||
"description": "Ensures that the Router.lastSuccessfulNavigation signal is now invoked",
|
||||
"factory": "./bundles/router-last-successful-navigation.cjs#migrate"
|
||||
},
|
||||
"application-config-core": {
|
||||
"version": "21.0.0",
|
||||
"description": "Moves imports of `ApplicationConfig` from `@angular/platform-browser` to `@angular/core`",
|
||||
"factory": "./bundles/application-config-core.cjs#migrate"
|
||||
},
|
||||
"add-bootstrap-context-to-server-main": {
|
||||
"version": "21.0.0",
|
||||
"description": "Adds `BootstrapContext` to `bootstrapApplication` calls in `main.server.ts` to support server rendering.",
|
||||
"factory": "./bundles/add-bootstrap-context-to-server-main.cjs#migrate"
|
||||
},
|
||||
"bootstrap-options-migration": {
|
||||
"version": "21.0.0",
|
||||
"description": "Migrates deprecated bootstrap options to providers.",
|
||||
"factory": "./bundles/bootstrap-options-migration.cjs#migrate"
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+14
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularCommonToStandaloneMigration",
|
||||
"title": "Angular Common to Standalone Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory where all components and modules should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+20
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularControlFlowMigration",
|
||||
"title": "Angular Control Flow Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path relative to the project root which should be migrated",
|
||||
"x-prompt": "Which path in your project should be migrated?",
|
||||
"default": "./"
|
||||
},
|
||||
"format": {
|
||||
"type": "boolean",
|
||||
"description": "Enables reformatting of your templates",
|
||||
"x-prompt": "Should the migration reformat your templates?",
|
||||
"default": "true"
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+20
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularNgclassToClassMigration",
|
||||
"title": "Angular ngClass to class Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory where all templates should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
},
|
||||
"migrateSpaceSeparatedKey": {
|
||||
"type": "boolean",
|
||||
"description": "Enables the migration of object literals with space-separated keys",
|
||||
"x-prompt": "Should the migration also migrate space-separated keys?",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+20
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularNgStyleToStyleMigration",
|
||||
"title": "Angular ngStyle to style Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory where all templates should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
},
|
||||
"bestEffortMode": {
|
||||
"type": "boolean",
|
||||
"description": "Enables the migration of object references",
|
||||
"x-prompt": "Should the migration also migrate object references?",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+14
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularRouterTestingToProvideRouterMigration",
|
||||
"title": "Angular RouterTestingModule to provideRouter Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory where all tests should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularCleanupUnusedImportsMigration",
|
||||
"title": "Angular Cleanup Unused Imports Schema",
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularInjectMigration",
|
||||
"title": "Angular Inject Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path relative to the project root which should be migrated",
|
||||
"x-prompt": "Which path in your project should be migrated?",
|
||||
"default": "./"
|
||||
},
|
||||
"migrateAbstractClasses": {
|
||||
"type": "boolean",
|
||||
"description": "Whether abstract classes should be migrated",
|
||||
"x-prompt": "Do you want to migrate abstract classes? Abstract classes are not migrated by default, because their parameters aren't guaranteed to be injectable",
|
||||
"default": false
|
||||
},
|
||||
"backwardsCompatibleConstructors": {
|
||||
"type": "boolean",
|
||||
"description": "Whether to clean up constructors or keep their signatures backwards compatible",
|
||||
"x-prompt": "Do you want to clean up all constructors or keep them backwards compatible? Enabling this option will include an additional signature of `constructor(...args: unknown[]);` that will avoid errors for sub-classes, but will increase the amount of generated code by the migration",
|
||||
"default": false
|
||||
},
|
||||
"nonNullableOptional": {
|
||||
"type": "boolean",
|
||||
"description": "Whether to cast the optional inject sites to be non-nullable",
|
||||
"x-prompt": "Do you want optional inject calls to be non-nullable? Enable this option if you want the return type to be identical to @Optional(), at the expense of worse type safety",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
}
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularOutputMigration",
|
||||
"title": "Angular Output migration",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory where all outputs should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
},
|
||||
"analysisDir": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory that should be analyzed. References to migrated outputs are migrated based on this folder. Useful for larger projects if the analysis takes too long and the analysis scope can be narrowed.",
|
||||
"default": "./"
|
||||
}
|
||||
}
|
||||
}
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularStandaloneRoutesMigration",
|
||||
"title": "Angular Standalone Routes Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path relative to the project root which should be migrated",
|
||||
"x-prompt": "Which path in your project should be migrated?",
|
||||
"default": "./"
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+14
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularSelfClosingTagMigration",
|
||||
"title": "Angular Self Closing Tag Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory where all templates should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+30
@@ -0,0 +1,30 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularSignalInputMigration",
|
||||
"title": "Angular Signal Input migration",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory where all inputs should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
},
|
||||
"analysisDir": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory that should be analyzed. References to migrated inputs are migrated based on this folder. Useful for larger projects if the analysis takes too long and the analysis scope can be narrowed.",
|
||||
"default": "./"
|
||||
},
|
||||
"bestEffortMode": {
|
||||
"type": "boolean",
|
||||
"description": "Whether to eagerly migrate as much as possible, ignoring problematic patterns that would otherwise prevent migration.",
|
||||
"x-prompt": "Do you want to migrate as much as possible, even if it may break your build?",
|
||||
"default": false
|
||||
},
|
||||
"insertTodos": {
|
||||
"type": "boolean",
|
||||
"description": "Whether the migration should add TODOs for inputs that could not be migrated",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+30
@@ -0,0 +1,30 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularSignalQueriesMigration",
|
||||
"title": "Angular Signal Queries migration",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory where all queries should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
},
|
||||
"analysisDir": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory that should be analyzed. References to migrated queries are migrated based on this folder. Useful for larger projects if the analysis takes too long and the analysis scope can be narrowed.",
|
||||
"default": "./"
|
||||
},
|
||||
"bestEffortMode": {
|
||||
"type": "boolean",
|
||||
"description": "Whether to eagerly migrate as much as possible, ignoring problematic patterns that would otherwise prevent migration.",
|
||||
"x-prompt": "Do you want to migrate as much as possible, even if it may break your build?",
|
||||
"default": false
|
||||
},
|
||||
"insertTodos": {
|
||||
"type": "boolean",
|
||||
"description": "Whether the migration should add TODOs for queries that could not be migrated",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
}
|
||||
+66
@@ -0,0 +1,66 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularSignalMigration",
|
||||
"title": "Angular Signals migration",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"migrations": {
|
||||
"type": "array",
|
||||
"default": [
|
||||
"inputs",
|
||||
"outputs",
|
||||
"queries"
|
||||
],
|
||||
"items": {
|
||||
"type": "string",
|
||||
"enum": [
|
||||
"inputs",
|
||||
"outputs",
|
||||
"queries"
|
||||
]
|
||||
},
|
||||
"description": "Signals-related migrations that should be run",
|
||||
"x-prompt": {
|
||||
"message": "Which migrations do you want to run?",
|
||||
"type": "list",
|
||||
"multiselect": true,
|
||||
"items": [
|
||||
{
|
||||
"value": "inputs",
|
||||
"label": "Convert `@Input` to the signal-based `input`"
|
||||
},
|
||||
{
|
||||
"value": "outputs",
|
||||
"label": "Convert `@Output` to the new `output` function"
|
||||
},
|
||||
{
|
||||
"value": "queries",
|
||||
"label": "Convert `@ViewChild`/`@ViewChildren` and `@ContentChild`/`@ContentChildren` to the signal-based `viewChild`/`viewChildren` and `contentChild`/`contentChildren`"
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory that should be migrated.",
|
||||
"x-prompt": "Which directory do you want to migrate?",
|
||||
"default": "./"
|
||||
},
|
||||
"analysisDir": {
|
||||
"type": "string",
|
||||
"description": "Path to the directory that should be analyzed. Useful for larger projects if the analysis takes too long and the analysis scope can be narrowed.",
|
||||
"default": "./"
|
||||
},
|
||||
"bestEffortMode": {
|
||||
"type": "boolean",
|
||||
"description": "Whether to eagerly migrate as much as possible, ignoring problematic patterns that would otherwise prevent migration.",
|
||||
"x-prompt": "Do you want to migrate as much as possible, even if it may break your build?",
|
||||
"default": false
|
||||
},
|
||||
"insertTodos": {
|
||||
"type": "boolean",
|
||||
"description": "Whether the migration should add TODOs for code that could not be migrated",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+38
@@ -0,0 +1,38 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema",
|
||||
"$id": "AngularStandaloneMigration",
|
||||
"title": "Angular Standalone Migration Schema",
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"mode": {
|
||||
"description": "Operation that should be performed by the migrator",
|
||||
"type": "string",
|
||||
"enum": ["convert-to-standalone", "prune-ng-modules", "standalone-bootstrap"],
|
||||
"default": "convert-to-standalone",
|
||||
"x-prompt": {
|
||||
"message": "Choose the type of migration:",
|
||||
"type": "list",
|
||||
"items": [
|
||||
{
|
||||
"value": "convert-to-standalone",
|
||||
"label": "Convert all components, directives and pipes to standalone"
|
||||
},
|
||||
{
|
||||
"value": "prune-ng-modules",
|
||||
"label": "Remove unnecessary NgModule classes"
|
||||
},
|
||||
{
|
||||
"value": "standalone-bootstrap",
|
||||
"label": "Bootstrap the application using standalone APIs"
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Path relative to the project root which should be migrated",
|
||||
"x-prompt": "Which path in your project should be migrated?",
|
||||
"default": "./"
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user