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;
|
||||
Reference in New Issue
Block a user