@design-factory/angular 21.1.0 → 22.0.0-next.0

package/schematics/component-migration/shared/component-imports.js

@@ -0,0 +1,380 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentNamedImports = getComponentNamedImports;
+exports.editComponentScopeImports = editComponentScopeImports;
+exports.editStandaloneComponentImports = editStandaloneComponentImports;
+exports.hasIdentifierReferenceOutsideImports = hasIdentifierReferenceOutsideImports;
+exports.editRemovableLegacyImports = editRemovableLegacyImports;
+exports.editLegacyImportTodos = editLegacyImportTodos;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
+const angular_component_1 = require("./angular-component");
+const component_context_1 = require("./component-context");
+const import_edits_1 = require("./import-edits");
+const todo_comments_1 = require("./todo-comments");
+function toSet(values) {
+    return new Set(values ?? []);
+}
+function getNamedBindings(statement) {
+    const namedBindings = statement.importClause?.namedBindings;
+    return namedBindings && ts.isNamedImports(namedBindings) ? namedBindings : null;
+}
+function getComponentNamedImports(sourceFile, moduleNames, importedNames) {
+    const modules = toSet(moduleNames);
+    const names = importedNames ? toSet(importedNames) : null;
+    const imports = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            !modules.has(statement.moduleSpecifier.text)) {
+            continue;
+        }
+        for (const element of getNamedBindings(statement)?.elements ?? []) {
+            const importedName = element.propertyName?.text ?? element.name.text;
+            if (!names || names.has(importedName)) {
+                imports.push({
+                    importedName,
+                    localName: element.name.text,
+                    moduleName: statement.moduleSpecifier.text
+                });
+            }
+        }
+    }
+    return imports;
+}
+function findComponentImportsProperty(sourceFile, component) {
+    const metadata = (0, angular_component_1.findComponentMetadata)(component);
+    if (!metadata) {
+        return null;
+    }
+    for (const property of metadata.properties) {
+        if (ts.isPropertyAssignment(property) && property.name.getText(sourceFile) === 'imports') {
+            return property;
+        }
+    }
+    return null;
+}
+function componentHasImportsProperty(sourceFile, component) {
+    return !!findComponentImportsProperty(sourceFile, component);
+}
+function editNewComponentImportsProperty(component, _sourceFile, symbolName) {
+    const metadata = (0, angular_component_1.findComponentMetadata)(component);
+    const lastProperty = metadata?.properties[metadata.properties.length - 1];
+    if (!lastProperty) {
+        return [];
+    }
+    return [{ start: lastProperty.getEnd(), end: lastProperty.getEnd(), text: `,\n  imports: [${symbolName}]` }];
+}
+function editNewNgModuleImportsProperty(moduleClass, _sourceFile, symbolName) {
+    const metadata = (0, angular_component_1.findNgModuleMetadata)(moduleClass);
+    const lastProperty = metadata?.properties[metadata.properties.length - 1];
+    if (!lastProperty) {
+        return [];
+    }
+    return [{ start: lastProperty.getEnd(), end: lastProperty.getEnd(), text: `,\n  imports: [${symbolName}]` }];
+}
+function isDeclaredInSourceNgModule(context, component) {
+    return (0, angular_component_1.getNgModuleClasses)(context.sourceFile).some((moduleClass) => {
+        const declarations = (0, angular_component_1.findNgModuleDeclarationsArray)(moduleClass);
+        return declarations?.elements.some((element) => (0, angular_component_1.resolveClassDeclaration)(context.typeChecker, element) === component);
+    });
+}
+function getDuplicateIdentifierElements(importsArray) {
+    const seenIdentifiers = new Set();
+    const duplicateElements = [];
+    for (const element of importsArray.elements) {
+        if (!ts.isIdentifier(element)) {
+            continue;
+        }
+        if (seenIdentifiers.has(element.text)) {
+            duplicateElements.push(element);
+        }
+        else {
+            seenIdentifiers.add(element.text);
+        }
+    }
+    return duplicateElements;
+}
+function renderArrayElements(sourceFile, importsArray, elements) {
+    const content = sourceFile.text.slice(importsArray.getStart(sourceFile) + 1, importsArray.getEnd() - 1);
+    if (!content.includes('\n')) {
+        return elements.join(', ');
+    }
+    const elementIndent = content.match(/\n(\s*)\S/)?.[1] ?? '  ';
+    const closingIndent = content.match(/\n(\s*)$/)?.[1] ?? '';
+    return elements.length > 0 ? `\n${elementIndent}${elements.join(`,\n${elementIndent}`)}\n${closingIndent}` : '';
+}
+function editArrayIdentifierImportsWithCleanup(sourceFile, importsArray, symbolNames, removableElements) {
+    if (removableElements.length === 0) {
+        return (0, import_edits_1.editArrayIdentifierImports)(sourceFile, importsArray, symbolNames);
+    }
+    const removableIndexes = new Set(removableElements.map((element) => importsArray.elements.indexOf(element)));
+    const existingElements = importsArray.elements
+        .filter((_element, index) => !removableIndexes.has(index))
+        .map((element) => element.getText(sourceFile));
+    const existingIdentifiers = new Set(importsArray.elements.flatMap((element, index) => !removableIndexes.has(index) && ts.isIdentifier(element) ? [element.text] : []));
+    const missingSymbols = symbolNames.filter((symbolName) => !existingIdentifiers.has(symbolName));
+    return [
+        {
+            start: importsArray.getStart(sourceFile) + 1,
+            end: importsArray.getEnd() - 1,
+            text: renderArrayElements(sourceFile, importsArray, [...existingElements, ...missingSymbols])
+        }
+    ];
+}
+function uniqueElements(elements) {
+    return elements.filter((element, index) => elements.indexOf(element) === index);
+}
+function getLegacyScopeElements(importsArray, legacyImports, importedNames) {
+    const legacyLocalNames = new Set(legacyImports
+        .filter((legacyImport) => importedNames.has(legacyImport.importedName))
+        .map(({ localName }) => localName));
+    return importsArray.elements.filter((element) => ts.isIdentifier(element) && legacyLocalNames.has(element.text));
+}
+function editScopeImportsArray(sourceFile, importsArray, options, needsNewImport, keepsLegacyScope, newImports) {
+    const legacyScopeImportedNames = toSet(options.legacyScopeImportedNames);
+    const cleanupScopeImportedNames = toSet(options.cleanupScopeImportedNames);
+    const identifiers = importsArray.elements.filter(ts.isIdentifier);
+    const hasNewSymbol = identifiers.some((element) => element.text === options.newImport.symbolName);
+    const legacyElements = keepsLegacyScope
+        ? []
+        : getLegacyScopeElements(importsArray, options.legacyImports, legacyScopeImportedNames);
+    const cleanupElements = getLegacyScopeElements(importsArray, options.legacyImports, cleanupScopeImportedNames);
+    const duplicateElements = getDuplicateIdentifierElements(importsArray);
+    const removableElements = uniqueElements([...legacyElements, ...cleanupElements, ...duplicateElements]);
+    if (!needsNewImport) {
+        return (0, import_edits_1.editListElements)(importsArray, removableElements, sourceFile);
+    }
+    if (hasNewSymbol) {
+        return (0, import_edits_1.editListElements)(importsArray, removableElements, sourceFile);
+    }
+    const replaceableElement = legacyElements[0];
+    if (replaceableElement) {
+        const legacyImport = options.legacyImports.find((candidate) => candidate.localName === replaceableElement.text);
+        const replacement = legacyImport
+            ? (options.getReplacement?.(legacyImport) ?? {
+                scopeName: options.newImport.symbolName,
+                importName: options.newImport.symbolName
+            })
+            : { scopeName: options.newImport.symbolName, importName: options.newImport.symbolName };
+        const [first, ...rest] = removableElements;
+        newImports.add(replacement.importName);
+        return [
+            { start: first.getStart(sourceFile), end: first.getEnd(), text: replacement.scopeName },
+            ...(0, import_edits_1.editListElements)(importsArray, rest, sourceFile)
+        ];
+    }
+    newImports.add(options.newImport.symbolName);
+    return [
+        ...(0, import_edits_1.editListElements)(importsArray, removableElements, sourceFile),
+        ...(0, import_edits_1.editArrayIdentifierImports)(sourceFile, importsArray, [options.newImport.symbolName])
+    ];
+}
+function editComponentScopeImports(options) {
+    const { context } = options;
+    const edits = [];
+    const newImports = new Set();
+    for (const [component, templates] of context.templatesByComponent) {
+        const needsNewImport = options.componentNeedsNewImport(templates);
+        const keepsLegacyScope = options.componentKeepsLegacyScope?.(templates) ?? false;
+        if ((!needsNewImport && !options.cleanupScopeImportedNames) || (0, angular_component_1.isExplicitlyNonStandaloneComponent)(component)) {
+            continue;
+        }
+        const importsArray = (0, angular_component_1.findComponentImportsArray)(component);
+        if (importsArray) {
+            edits.push(...editScopeImportsArray(context.sourceFile, importsArray, options, needsNewImport, keepsLegacyScope, newImports));
+        }
+        else if (needsNewImport &&
+            !componentHasImportsProperty(context.sourceFile, component) &&
+            !isDeclaredInSourceNgModule(context, component)) {
+            edits.push(...editNewComponentImportsProperty(component, context.sourceFile, options.newImport.symbolName));
+            newImports.add(options.newImport.symbolName);
+        }
+        else if (needsNewImport && options.indirectComponentImportsTodo) {
+            const importsProperty = findComponentImportsProperty(context.sourceFile, component);
+            if (importsProperty && !ts.isArrayLiteralExpression(importsProperty.initializer)) {
+                const edit = (0, todo_comments_1.editSourceTodo)(context.sourceFile, importsProperty, options.indirectComponentImportsTodo);
+                if (edit) {
+                    edits.push(edit);
+                }
+            }
+        }
+    }
+    for (const moduleClass of (0, angular_component_1.getNgModuleClasses)(context.sourceFile)) {
+        const needsNewImport = (0, component_context_1.moduleDeclaresComponentTemplate)(context, moduleClass, options.componentNeedsNewImport);
+        const keepsLegacyScope = options.componentKeepsLegacyScope
+            ? (0, component_context_1.moduleDeclaresComponentTemplate)(context, moduleClass, options.componentKeepsLegacyScope)
+            : false;
+        if (!needsNewImport && !options.cleanupScopeImportedNames) {
+            continue;
+        }
+        const importsArray = (0, angular_component_1.findNgModuleImportsArray)(moduleClass);
+        if (importsArray) {
+            edits.push(...editScopeImportsArray(context.sourceFile, importsArray, options, needsNewImport, keepsLegacyScope, newImports));
+        }
+        else if (needsNewImport) {
+            edits.push(...editNewNgModuleImportsProperty(moduleClass, context.sourceFile, options.newImport.symbolName));
+            newImports.add(options.newImport.symbolName);
+        }
+    }
+    if (newImports.size > 0 && options.addTopLevelImport !== false) {
+        edits.push(...(0, import_edits_1.addNamedImports)(context.sourceFile, options.newImport.moduleName, [...newImports]));
+    }
+    return { edits, newImports };
+}
+function getSortedSymbolNames(requirements) {
+    return [...new Set(requirements.map((requirement) => requirement.symbolName))].sort();
+}
+function editComponentStandaloneImports(context, component, symbolNames, templates, options) {
+    if ((0, angular_component_1.isExplicitlyNonStandaloneComponent)(component)) {
+        return { edits: [], addsScopeImport: false };
+    }
+    const importsArray = (0, angular_component_1.findComponentImportsArray)(component);
+    if (importsArray) {
+        const keepsLegacyScope = options.componentKeepsLegacyScope?.(templates) ?? false;
+        const removableElements = keepsLegacyScope
+            ? []
+            : getLegacyScopeElements(importsArray, options.legacyImports ?? [], toSet(options.legacyScopeImportedNames));
+        return {
+            edits: editArrayIdentifierImportsWithCleanup(context.sourceFile, importsArray, symbolNames, removableElements),
+            addsScopeImport: true
+        };
+    }
+    if (componentHasImportsProperty(context.sourceFile, component)) {
+        const indirectComponentImportsTodo = options.indirectComponentImportsTodo;
+        if (!indirectComponentImportsTodo) {
+            return { edits: [], addsScopeImport: false };
+        }
+        const importsProperty = findComponentImportsProperty(context.sourceFile, component);
+        const edit = importsProperty && !ts.isArrayLiteralExpression(importsProperty.initializer)
+            ? (0, todo_comments_1.editSourceTodo)(context.sourceFile, importsProperty, indirectComponentImportsTodo)
+            : null;
+        return { edits: edit ? [edit] : [], addsScopeImport: false };
+    }
+    if (isDeclaredInSourceNgModule(context, component)) {
+        return { edits: [], addsScopeImport: false };
+    }
+    return {
+        edits: editNewComponentImportsProperty(component, context.sourceFile, symbolNames.join(', ')),
+        addsScopeImport: true
+    };
+}
+function editNgModuleStandaloneImports(context, moduleClass, symbolNames, options) {
+    const importsArray = (0, angular_component_1.findNgModuleImportsArray)(moduleClass);
+    if (importsArray) {
+        const keepsLegacyScope = options.componentKeepsLegacyScope
+            ? (0, component_context_1.moduleDeclaresComponentTemplate)(context, moduleClass, options.componentKeepsLegacyScope)
+            : false;
+        const removableElements = keepsLegacyScope
+            ? []
+            : getLegacyScopeElements(importsArray, options.legacyImports ?? [], toSet(options.legacyScopeImportedNames));
+        return {
+            edits: editArrayIdentifierImportsWithCleanup(context.sourceFile, importsArray, symbolNames, removableElements),
+            addsScopeImport: true
+        };
+    }
+    return {
+        edits: editNewNgModuleImportsProperty(moduleClass, context.sourceFile, symbolNames.join(', ')),
+        addsScopeImport: true
+    };
+}
+function editStandaloneComponentImports(context, moduleName, optionsOrTodo) {
+    const edits = [];
+    const fileRequirements = [];
+    const options = optionsOrTodo && 'code' in optionsOrTodo ? { indirectComponentImportsTodo: optionsOrTodo } : (optionsOrTodo ?? {});
+    for (const [component, requirements] of context.standaloneImportsByComponent) {
+        const moduleRequirements = requirements.filter((requirement) => requirement.moduleName === moduleName);
+        if (moduleRequirements.length === 0) {
+            continue;
+        }
+        const componentImportEdits = editComponentStandaloneImports(context, component, getSortedSymbolNames(moduleRequirements), context.templatesByComponent.get(component) ?? [], options);
+        if (componentImportEdits.edits.length > 0) {
+            if (componentImportEdits.addsScopeImport) {
+                fileRequirements.push(...moduleRequirements);
+            }
+            edits.push(...componentImportEdits.edits);
+        }
+    }
+    for (const moduleClass of (0, angular_component_1.getNgModuleClasses)(context.sourceFile)) {
+        const declarationsArray = (0, angular_component_1.findNgModuleDeclarationsArray)(moduleClass);
+        if (!declarationsArray) {
+            continue;
+        }
+        const moduleRequirements = declarationsArray.elements
+            .flatMap((element) => {
+            const component = (0, angular_component_1.resolveClassDeclaration)(context.typeChecker, element);
+            return component ? (context.projectStandaloneImportsByComponent.get(component) ?? []) : [];
+        })
+            .filter((requirement) => requirement.moduleName === moduleName);
+        if (moduleRequirements.length === 0) {
+            continue;
+        }
+        const moduleImportEdits = editNgModuleStandaloneImports(context, moduleClass, getSortedSymbolNames(moduleRequirements), options);
+        if (moduleImportEdits.edits.length > 0) {
+            if (moduleImportEdits.addsScopeImport) {
+                fileRequirements.push(...moduleRequirements);
+            }
+            edits.push(...moduleImportEdits.edits);
+        }
+    }
+    if (fileRequirements.length > 0) {
+        edits.push(...(0, import_edits_1.addNamedImports)(context.sourceFile, moduleName, getSortedSymbolNames(fileRequirements)));
+    }
+    return edits;
+}
+function getSkippedRanges(sourceFile) {
+    const importDeclarationRanges = sourceFile.statements.flatMap((statement) => ts.isImportDeclaration(statement) ? [{ start: statement.getFullStart(), end: statement.getEnd() }] : []);
+    const decoratorImportsArrayRanges = (0, angular_component_1.findDecoratorImportsArrays)(sourceFile).map((importsArray) => ({
+        start: importsArray.getStart(sourceFile),
+        end: importsArray.getEnd()
+    }));
+    return [...importDeclarationRanges, ...decoratorImportsArrayRanges];
+}
+function hasIdentifierReferenceOutsideImports(sourceFile, symbolName) {
+    const skippedRanges = getSkippedRanges(sourceFile);
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, sourceFile.text);
+    let token = scanner.scan();
+    while (token !== ts.SyntaxKind.EndOfFileToken) {
+        const start = scanner.getTokenStart();
+        const end = scanner.getTokenEnd();
+        if (token === ts.SyntaxKind.Identifier &&
+            scanner.getTokenText() === symbolName &&
+            !skippedRanges.some((range) => start >= range.start && end <= range.end)) {
+            return true;
+        }
+        token = scanner.scan();
+    }
+    return false;
+}
+function editRemovableLegacyImports(sourceFile, moduleNames, legacyImports, shouldRemove) {
+    const removableImports = legacyImports
+        .filter((legacyImport) => shouldRemove(legacyImport))
+        .filter((legacyImport) => !hasIdentifierReferenceOutsideImports(sourceFile, legacyImport.localName))
+        .map((legacyImport) => legacyImport.importedName);
+    return (0, import_edits_1.removeNamedImports)(sourceFile, moduleNames, removableImports);
+}
+function editLegacyImportTodos(sourceFile, moduleNames, shouldAddTodo, todo) {
+    const modules = toSet(moduleNames);
+    const edits = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            !modules.has(statement.moduleSpecifier.text)) {
+            continue;
+        }
+        const moduleName = statement.moduleSpecifier.text;
+        const imports = getNamedBindings(statement)?.elements.map((element) => ({
+            importedName: element.propertyName?.text ?? element.name.text,
+            localName: element.name.text,
+            moduleName
+        }));
+        if (!imports?.some(shouldAddTodo)) {
+            continue;
+        }
+        const edit = (0, todo_comments_1.editSourceTodo)(sourceFile, statement, todo);
+        if (edit) {
+            edits.push(edit);
+        }
+    }
+    return edits;
+}

package/schematics/component-migration/shared/create-component-schematic.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from '@angular-devkit/schematics';
+import { ComponentMigrationDefinition, ComponentMigrationSchema } from './types';
+export declare function createComponentMigrationSchematic(migration: ComponentMigrationDefinition): (options: ComponentMigrationSchema) => Rule;

package/schematics/component-migration/shared/create-component-schematic.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComponentMigrationSchematic = createComponentMigrationSchematic;
+const project_tsconfig_paths_1 = require("../utils/project_tsconfig_paths");
+const ai_handoff_1 = require("./ai-handoff");
+const migrate_project_1 = require("./migrate-project");
+const next_steps_1 = require("../next-steps");
+const scan_project_1 = require("./scan-project");
+function emptyMigrationResult() {
+    return {
+        analyzedSourceFiles: 0,
+        analyzedComponents: 0,
+        analyzedTemplates: 0,
+        changedTemplates: 0,
+        changes: 0,
+        changedFiles: []
+    };
+}
+function mergeMigrationResults(target, source) {
+    target.analyzedSourceFiles += source.analyzedSourceFiles;
+    target.analyzedComponents += source.analyzedComponents;
+    target.analyzedTemplates += source.analyzedTemplates;
+    target.changedTemplates += source.changedTemplates;
+    target.changes += source.changes;
+    target.changedFiles.push(...source.changedFiles);
+}
+function createComponentMigrationSchematic(migration) {
+    return (options) => async (tree, context) => {
+        const projectNames = await (0, project_tsconfig_paths_1.resolveProjectNames)(tree, options.project, options.all);
+        const runContext = (0, migrate_project_1.createComponentMigrationRunContext)();
+        if (options.scan) {
+            const usageCounts = new Map([[migration.id, 0]]);
+            for (const projectName of projectNames) {
+                const [result] = await (0, scan_project_1.scanProjectForComponentMigrations)(tree, projectName, [migration], runContext);
+                usageCounts.set(migration.id, (usageCounts.get(migration.id) ?? 0) + result.legacyUsages);
+            }
+            const result = { migration, legacyUsages: usageCounts.get(migration.id) ?? 0 };
+            context.logger.info(`${result.migration.id}: ${result.legacyUsages} usages`);
+            return;
+        }
+        const migrationResult = emptyMigrationResult();
+        for (const projectName of projectNames) {
+            mergeMigrationResults(migrationResult, await (0, migrate_project_1.migrateProjectComponentTemplates)(tree, projectName, migration, runContext));
+        }
+        (0, ai_handoff_1.writeAiMigrationHandoff)(tree, migration.id);
+        (0, next_steps_1.scheduleComponentMigrationNextSteps)(context, {
+            componentId: migration.id,
+            analyzedSourceFiles: migrationResult.analyzedSourceFiles,
+            analyzedComponents: migrationResult.analyzedComponents,
+            analyzedTemplates: migrationResult.analyzedTemplates,
+            changedTemplates: migrationResult.changedTemplates,
+            changes: migrationResult.changes
+        });
+    };
+}

package/schematics/component-migration/shared/import-edits.d.ts

@@ -0,0 +1,11 @@
+import * as ts from 'typescript';
+import { TemplateEdit } from './template-edits';
+type NodeList<T extends ts.Node> = {
+    elements: ts.NodeArray<T>;
+};
+export declare function editListElements<T extends ts.Node>(list: NodeList<T>, elementsToRemove: T[], sourceFile: ts.SourceFile): TemplateEdit[];
+export declare function editListElement<T extends ts.Node>(list: NodeList<T>, element: T, sourceFile: ts.SourceFile): TemplateEdit;
+export declare function editArrayIdentifierImports(sourceFile: ts.SourceFile, importsArray: ts.ArrayLiteralExpression, symbolNames: string[]): TemplateEdit[];
+export declare function addNamedImports(sourceFile: ts.SourceFile, moduleName: string, importNames: string[]): TemplateEdit[];
+export declare function removeNamedImports(sourceFile: ts.SourceFile, moduleNames: string | Iterable<string>, importedNames: Iterable<string>): TemplateEdit[];
+export {};

package/schematics/component-migration/shared/import-edits.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editListElements = editListElements;
+exports.editListElement = editListElement;
+exports.editArrayIdentifierImports = editArrayIdentifierImports;
+exports.addNamedImports = addNamedImports;
+exports.removeNamedImports = removeNamedImports;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
+function toModuleNames(moduleNames) {
+    return typeof moduleNames === 'string' ? new Set([moduleNames]) : new Set(moduleNames);
+}
+function editListElements(list, elementsToRemove, sourceFile) {
+    if (elementsToRemove.length === 0) {
+        return [];
+    }
+    const removeIndexes = new Set(elementsToRemove.map((element) => list.elements.indexOf(element)));
+    const edits = [];
+    let index = 0;
+    while (index < list.elements.length) {
+        if (!removeIndexes.has(index)) {
+            index++;
+            continue;
+        }
+        const firstIndex = index;
+        while (index + 1 < list.elements.length && removeIndexes.has(index + 1)) {
+            index++;
+        }
+        const lastIndex = index;
+        const previous = list.elements[firstIndex - 1];
+        const next = list.elements[lastIndex + 1];
+        if (next) {
+            edits.push({
+                start: list.elements[firstIndex].getStart(sourceFile),
+                end: next.getStart(sourceFile),
+                text: ''
+            });
+        }
+        else if (previous) {
+            edits.push({
+                start: previous.getEnd(),
+                end: list.elements[lastIndex].getEnd(),
+                text: ''
+            });
+        }
+        else {
+            edits.push({
+                start: list.elements[firstIndex].getStart(sourceFile),
+                end: list.elements[lastIndex].getEnd(),
+                text: ''
+            });
+        }
+        index++;
+    }
+    return edits;
+}
+function editListElement(list, element, sourceFile) {
+    return editListElements(list, [element], sourceFile)[0];
+}
+function editArrayIdentifierImports(sourceFile, importsArray, symbolNames) {
+    const existingSymbols = new Set(importsArray.elements.flatMap((element) => (ts.isIdentifier(element) ? [element.text] : [])));
+    const missingSymbols = symbolNames.filter((symbolName) => !existingSymbols.has(symbolName));
+    if (missingSymbols.length === 0) {
+        return [];
+    }
+    const insertOffset = importsArray.elements.length > 0
+        ? importsArray.elements[importsArray.elements.length - 1].getEnd()
+        : importsArray.getStart(sourceFile) + 1;
+    return [
+        {
+            start: insertOffset,
+            end: insertOffset,
+            text: `${importsArray.elements.length > 0 ? ', ' : ''}${missingSymbols.join(', ')}`
+        }
+    ];
+}
+function getNamedBindings(statement) {
+    const namedBindings = statement.importClause?.namedBindings;
+    return namedBindings && ts.isNamedImports(namedBindings) ? namedBindings : null;
+}
+function getNamedImportText(sourceFile, element) {
+    return element.getText(sourceFile);
+}
+function addNamedImports(sourceFile, moduleName, importNames) {
+    const uniqueImportNames = [...new Set(importNames)].sort();
+    if (uniqueImportNames.length === 0) {
+        return [];
+    }
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== moduleName) {
+            continue;
+        }
+        const namedBindings = getNamedBindings(statement);
+        if (namedBindings) {
+            const existing = new Set(namedBindings.elements.map((element) => getNamedImportText(sourceFile, element)));
+            const missing = uniqueImportNames.filter((importName) => !existing.has(importName));
+            if (missing.length === 0) {
+                return [];
+            }
+            const insertOffset = namedBindings.elements.length > 0
+                ? namedBindings.elements[namedBindings.elements.length - 1].getEnd()
+                : namedBindings.getStart(sourceFile) + 1;
+            return [
+                {
+                    start: insertOffset,
+                    end: insertOffset,
+                    text: namedBindings.elements.length > 0 ? `, ${missing.join(', ')}` : ` ${missing.join(', ')} `
+                }
+            ];
+        }
+        if (statement.importClause?.name) {
+            const insertOffset = statement.importClause.name.getEnd();
+            return [{ start: insertOffset, end: insertOffset, text: `, { ${uniqueImportNames.join(', ')} }` }];
+        }
+    }
+    const firstStatement = sourceFile.statements[0];
+    return [
+        {
+            start: firstStatement?.getStart(sourceFile) ?? 0,
+            end: firstStatement?.getStart(sourceFile) ?? 0,
+            text: `import { ${uniqueImportNames.join(', ')} } from '${moduleName}';\n`
+        }
+    ];
+}
+function removeNamedImports(sourceFile, moduleNames, importedNames) {
+    const modules = toModuleNames(moduleNames);
+    const names = new Set(importedNames);
+    const edits = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            !modules.has(statement.moduleSpecifier.text)) {
+            continue;
+        }
+        const namedBindings = getNamedBindings(statement);
+        if (!namedBindings) {
+            continue;
+        }
+        const remaining = namedBindings.elements.filter((element) => {
+            const importedName = element.propertyName?.text ?? element.name.text;
+            return !names.has(importedName);
+        });
+        if (remaining.length === namedBindings.elements.length) {
+            continue;
+        }
+        edits.push(remaining.length === 0 && !statement.importClause?.name
+            ? { start: statement.getFullStart(), end: statement.getEnd(), text: '' }
+            : {
+                start: namedBindings.getStart(sourceFile),
+                end: namedBindings.getEnd(),
+                text: `{ ${remaining.map((element) => element.getText(sourceFile)).join(', ')} }`
+            });
+    }
+    return edits;
+}

package/schematics/component-migration/shared/legacy-config-todos.d.ts

@@ -0,0 +1,3 @@
+import { TemplateEdit } from './template-edits';
+import { ComponentMigrationSourceContext } from './types';
+export declare function editLegacyConfigTodos(context: ComponentMigrationSourceContext, configNames: Iterable<string>): TemplateEdit[];