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

package/schematics/component-migration/shared/legacy-config-todos.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editLegacyConfigTodos = editLegacyConfigTodos;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
+const imports_1 = require("../utils/typescript/imports");
+const todo_comments_1 = require("./todo-comments");
+const LEGACY_CONFIG_IMPORTS = new Set([
+    '@ng-bootstrap/ng-bootstrap',
+    '@ng-bootstrap/ng-bootstrap/accordion',
+    '@ng-bootstrap/ng-bootstrap/alert',
+    '@ng-bootstrap/ng-bootstrap/dropdown',
+    '@ng-bootstrap/ng-bootstrap/tooltip'
+]);
+const LEGACY_CONFIG_TODOS = {
+    NgbAccordionConfig: {
+        code: 'accordion.config',
+        marker: 'human',
+        message: 'Legacy NgbAccordionConfig is not supported anymore. Review this configuration and migrate supported defaults to provideDfAccordionConfig().'
+    },
+    NgbAlertConfig: {
+        code: 'alert.config',
+        marker: 'human',
+        message: 'Legacy NgbAlertConfig is not supported anymore. Review this configuration and migrate supported defaults to provideDfAlertConfig().'
+    },
+    NgbDropdownConfig: {
+        code: 'dropdown.config',
+        marker: 'human',
+        message: 'Legacy NgbDropdownConfig is not supported anymore. DfDropdown has no provideDfDropdownConfig() equivalent yet; review this configuration manually.'
+    },
+    NgbTooltipConfig: {
+        code: 'tooltip.config',
+        marker: 'human',
+        message: 'Legacy NgbTooltipConfig is not supported anymore. Review this configuration and migrate supported defaults to provideDfTooltipConfig().'
+    }
+};
+function getImportedConfigNames(statement) {
+    if (!ts.isStringLiteral(statement.moduleSpecifier) || !LEGACY_CONFIG_IMPORTS.has(statement.moduleSpecifier.text)) {
+        return [];
+    }
+    const namedBindings = statement.importClause?.namedBindings;
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+        return [];
+    }
+    return namedBindings.elements
+        .map((element) => element.propertyName?.text ?? element.name.text)
+        .filter((symbolName) => LEGACY_CONFIG_TODOS[symbolName]);
+}
+function isLegacyConfigIdentifier(node, context) {
+    const importData = (0, imports_1.getImportOfIdentifier)(node, context.typeChecker);
+    if (!importData || !LEGACY_CONFIG_IMPORTS.has(importData.moduleName) || !LEGACY_CONFIG_TODOS[importData.symbolName]) {
+        return null;
+    }
+    return importData.symbolName;
+}
+function editLegacyConfigTodos(context, configNames) {
+    const edits = [];
+    const requestedConfigNames = new Set(configNames);
+    const reportedConfigNames = new Set();
+    function addTodo(configName, node) {
+        if (!requestedConfigNames.has(configName) || reportedConfigNames.has(configName)) {
+            return;
+        }
+        const edit = (0, todo_comments_1.editSourceTodo)(context.sourceFile, node, LEGACY_CONFIG_TODOS[configName]);
+        if (edit) {
+            edits.push(edit);
+        }
+        reportedConfigNames.add(configName);
+    }
+    for (const statement of context.sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            for (const configName of getImportedConfigNames(statement)) {
+                addTodo(configName, statement);
+            }
+        }
+    }
+    function visit(node) {
+        if (ts.isIdentifier(node)) {
+            const configName = isLegacyConfigIdentifier(node, context);
+            if (configName) {
+                addTodo(configName, node);
+            }
+        }
+        if (reportedConfigNames.size < requestedConfigNames.size) {
+            ts.forEachChild(node, visit);
+        }
+    }
+    visit(context.sourceFile);
+    return edits;
+}

package/schematics/component-migration/shared/migrate-project.d.ts

@@ -0,0 +1,12 @@
+import { Tree } from '@angular-devkit/schematics';
+import { ComponentMigrationDefinition, ComponentMigrationRunContext } from './types';
+export interface ComponentMigrationResult {
+    analyzedSourceFiles: number;
+    analyzedComponents: number;
+    analyzedTemplates: number;
+    changedTemplates: number;
+    changes: number;
+    changedFiles: string[];
+}
+export declare function createComponentMigrationRunContext(): ComponentMigrationRunContext;
+export declare function migrateProjectComponentTemplates(tree: Tree, projectName: string, migration: ComponentMigrationDefinition, runContext?: ComponentMigrationRunContext): Promise<ComponentMigrationResult>;

package/schematics/component-migration/shared/migrate-project.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComponentMigrationRunContext = createComponentMigrationRunContext;
+exports.migrateProjectComponentTemplates = migrateProjectComponentTemplates;
+const compiler_host_1 = require("../utils/typescript/compiler_host");
+const project_templates_1 = require("./project-templates");
+function addFileEdit(fileEdits, filePath, edit) {
+    const edits = fileEdits.get(filePath) ?? [];
+    edits.push(edit);
+    fileEdits.set(filePath, edits);
+}
+function addStandaloneImportRequirements(standaloneImportsByComponent, component, requirements) {
+    const componentRequirements = standaloneImportsByComponent.get(component) ?? [];
+    for (const requirement of requirements) {
+        if (!componentRequirements.some((existing) => existing.moduleName === requirement.moduleName && existing.symbolName === requirement.symbolName)) {
+            componentRequirements.push(requirement);
+        }
+    }
+    standaloneImportsByComponent.set(component, componentRequirements);
+}
+function applyFileEdits(tree, fileEdits) {
+    for (const [filePath, edits] of fileEdits) {
+        const recorder = tree.beginUpdate(filePath);
+        for (const edit of edits.sort((a, b) => b.start - a.start || b.end - a.end)) {
+            recorder.remove(edit.start, edit.end - edit.start);
+            recorder.insertRight(edit.start, edit.text);
+        }
+        tree.commitUpdate(recorder);
+    }
+}
+function createComponentMigrationRunContext() {
+    return {
+        processedSourceFiles: new Set(),
+        processedTemplateFiles: new Set(),
+        migratedExternalTemplates: new Map(),
+        changedFiles: new Set()
+    };
+}
+async function migrateProjectComponentTemplates(tree, projectName, migration, runContext = createComponentMigrationRunContext()) {
+    const { basePath, program, typeChecker, sourceTemplates } = await (0, project_templates_1.collectProjectTemplates)(tree, projectName);
+    const templatesBySourceFile = new Map();
+    const standaloneImportsBySourceFile = new Map();
+    const projectTemplatesByComponent = new Map();
+    const projectStandaloneImportsByComponent = new Map();
+    const fileEdits = new Map();
+    const editableSourceFilePaths = new Set();
+    const analyzedComponents = new Set();
+    const analyzedTemplates = new Set();
+    let analyzedSourceFiles = 0;
+    let changedTemplates = 0;
+    let changes = 0;
+    for (const { sourceFile, templates: collectedTemplates } of sourceTemplates) {
+        const sourceFilePath = (0, project_templates_1.getWorkspaceRelativePath)(sourceFile.fileName);
+        const sourceFileWasProcessed = runContext.processedSourceFiles.has(sourceFilePath);
+        if (!sourceFileWasProcessed) {
+            runContext.processedSourceFiles.add(sourceFilePath);
+            editableSourceFilePaths.add(sourceFilePath);
+            analyzedSourceFiles++;
+        }
+        const templatesByComponent = new Map();
+        const standaloneImportsByComponent = new Map();
+        templatesBySourceFile.set(sourceFile, templatesByComponent);
+        standaloneImportsBySourceFile.set(sourceFile, standaloneImportsByComponent);
+        for (const template of collectedTemplates) {
+            if (!sourceFileWasProcessed) {
+                analyzedTemplates.add(template.inline ? `${sourceFile.fileName}:${template.start}` : template.absFilePath);
+            }
+            if (!sourceFileWasProcessed && template.container) {
+                analyzedComponents.add(template.container);
+            }
+            const templateKey = template.inline ? `${sourceFilePath}:${template.start}` : template.filePath;
+            const templateWasProcessed = runContext.processedTemplateFiles.has(templateKey);
+            let migrationResult = template.inline ? undefined : runContext.migratedExternalTemplates.get(template.filePath);
+            if (!migrationResult) {
+                migrationResult = migration.migrateTemplate?.(template.content) ?? { content: template.content, changes: 0 };
+                if (!template.inline) {
+                    runContext.migratedExternalTemplates.set(template.filePath, migrationResult);
+                }
+            }
+            if (!templateWasProcessed) {
+                runContext.processedTemplateFiles.add(templateKey);
+            }
+            if (!templateWasProcessed && migrationResult.content !== template.content) {
+                addFileEdit(fileEdits, template.filePath, {
+                    start: template.start,
+                    end: template.start + template.content.length,
+                    text: migrationResult.content
+                });
+                changedTemplates++;
+                changes += migrationResult.changes;
+            }
+            if (template.container) {
+                const templates = templatesByComponent.get(template.container) ?? [];
+                templates.push(migrationResult.content);
+                templatesByComponent.set(template.container, templates);
+                projectTemplatesByComponent.set(template.container, templates);
+                addStandaloneImportRequirements(standaloneImportsByComponent, template.container, migrationResult.standaloneImports ?? []);
+                addStandaloneImportRequirements(projectStandaloneImportsByComponent, template.container, migrationResult.standaloneImports ?? []);
+            }
+        }
+    }
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!(0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program)) {
+            continue;
+        }
+        const sourceFilePath = (0, project_templates_1.getWorkspaceRelativePath)(sourceFile.fileName);
+        if (!runContext.processedSourceFiles.has(sourceFilePath)) {
+            runContext.processedSourceFiles.add(sourceFilePath);
+            analyzedSourceFiles++;
+        }
+        const projectSourceEdits = migration.migrateProjectSourceFile?.({
+            sourceFile,
+            typeChecker,
+            templatesByComponent: templatesBySourceFile.get(sourceFile) ?? new Map(),
+            projectTemplatesByComponent,
+            standaloneImportsByComponent: standaloneImportsBySourceFile.get(sourceFile) ?? new Map(),
+            projectStandaloneImportsByComponent
+        }) ?? [];
+        for (const edit of projectSourceEdits) {
+            addFileEdit(fileEdits, sourceFilePath, edit);
+        }
+        changes += projectSourceEdits.length;
+        if (!editableSourceFilePaths.has(sourceFilePath)) {
+            continue;
+        }
+        const sourceEdits = migration.migrateSourceFile?.({
+            sourceFile,
+            typeChecker,
+            templatesByComponent: templatesBySourceFile.get(sourceFile) ?? new Map(),
+            projectTemplatesByComponent,
+            standaloneImportsByComponent: standaloneImportsBySourceFile.get(sourceFile) ?? new Map(),
+            projectStandaloneImportsByComponent
+        }) ?? [];
+        for (const edit of sourceEdits) {
+            addFileEdit(fileEdits, sourceFilePath, edit);
+        }
+        changes += sourceEdits.length;
+    }
+    for (const filePath of fileEdits.keys()) {
+        runContext.changedFiles.add(filePath);
+    }
+    applyFileEdits(tree, fileEdits);
+    return {
+        analyzedSourceFiles,
+        analyzedComponents: analyzedComponents.size,
+        analyzedTemplates: analyzedTemplates.size,
+        changedTemplates,
+        changes,
+        changedFiles: [...fileEdits.keys()]
+    };
+}

package/schematics/component-migration/shared/project-templates.d.ts

@@ -0,0 +1,15 @@
+import { Tree } from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+import { ResolvedResource } from '../utils/component-resource-collector';
+export interface ProjectSourceTemplates {
+    sourceFile: ts.SourceFile;
+    templates: ResolvedResource[];
+}
+export interface ProjectTemplateCollection {
+    basePath: string;
+    program: ts.Program;
+    typeChecker: ts.TypeChecker;
+    sourceTemplates: ProjectSourceTemplates[];
+}
+export declare function getWorkspaceRelativePath(fileName: string): string;
+export declare function collectProjectTemplates(tree: Tree, projectName: string): Promise<ProjectTemplateCollection>;

package/schematics/component-migration/shared/project-templates.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkspaceRelativePath = getWorkspaceRelativePath;
+exports.collectProjectTemplates = collectProjectTemplates;
+const tslib_1 = require("tslib");
+const schematics_1 = require("@angular-devkit/schematics");
+const core_1 = require("@angular-devkit/core");
+const path_1 = require("path");
+const ts = tslib_1.__importStar(require("typescript"));
+const component_resource_collector_1 = require("../utils/component-resource-collector");
+const project_tsconfig_paths_1 = require("../utils/project_tsconfig_paths");
+const compiler_host_1 = require("../utils/typescript/compiler_host");
+function getWorkspaceRelativePath(fileName) {
+    const absFilePath = (0, core_1.normalize)(path_1.posix.resolve('/', (0, core_1.normalize)(fileName)));
+    return path_1.posix.relative((0, core_1.normalize)(process.cwd()), absFilePath);
+}
+function collectTemplates(tree, sourceFile, typeChecker) {
+    const resourceCollector = new component_resource_collector_1.ComponentResourceCollector(typeChecker, tree);
+    const visitNode = (node) => {
+        ts.forEachChild(node, visitNode);
+        resourceCollector.visitNode(node);
+    };
+    visitNode(sourceFile);
+    return resourceCollector.resolvedTemplates;
+}
+async function collectProjectTemplates(tree, projectName) {
+    const { buildPaths } = await (0, project_tsconfig_paths_1.getProjectTsConfigPaths)(tree, projectName);
+    const tsconfigPath = buildPaths[0];
+    if (!tsconfigPath) {
+        throw new schematics_1.SchematicsException(`Could not find a build tsconfig for project "${projectName}".`);
+    }
+    const basePath = process.cwd();
+    const program = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
+    const typeChecker = program.getTypeChecker();
+    const sourceTemplates = program
+        .getSourceFiles()
+        .filter((sourceFile) => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program))
+        .map((sourceFile) => ({
+        sourceFile,
+        templates: collectTemplates(tree, sourceFile, typeChecker)
+    }));
+    return { basePath, program, typeChecker, sourceTemplates };
+}

package/schematics/component-migration/shared/scan-project.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@angular-devkit/schematics';
+import { ComponentMigrationDefinition, ComponentMigrationRunContext, ComponentMigrationScanResult } from './types';
+export declare function scanProjectForComponentMigrations(tree: Tree, projectName: string, migrations: ComponentMigrationDefinition[], runContext?: Pick<ComponentMigrationRunContext, 'processedSourceFiles'>): Promise<ComponentMigrationScanResult[]>;

package/schematics/component-migration/shared/scan-project.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanProjectForComponentMigrations = scanProjectForComponentMigrations;
+const project_templates_1 = require("./project-templates");
+async function scanProjectForComponentMigrations(tree, projectName, migrations, runContext) {
+    const { sourceTemplates } = await (0, project_templates_1.collectProjectTemplates)(tree, projectName);
+    const usageCounts = new Map(migrations.map((migration) => [migration.id, 0]));
+    for (const { sourceFile, templates } of sourceTemplates) {
+        const sourceFilePath = (0, project_templates_1.getWorkspaceRelativePath)(sourceFile.fileName);
+        if (runContext?.processedSourceFiles.has(sourceFilePath)) {
+            continue;
+        }
+        runContext?.processedSourceFiles.add(sourceFilePath);
+        for (const template of templates) {
+            for (const migration of migrations) {
+                usageCounts.set(migration.id, (usageCounts.get(migration.id) ?? 0) + migration.countLegacyTemplateUsages(template.content));
+            }
+        }
+    }
+    return migrations.map((migration) => ({
+        migration,
+        legacyUsages: usageCounts.get(migration.id) ?? 0
+    }));
+}

package/schematics/component-migration/shared/static-placement.d.ts

@@ -0,0 +1 @@
+export declare function mapStaticPlacement(value: string): string | null;

package/schematics/component-migration/shared/static-placement.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapStaticPlacement = mapStaticPlacement;
+const STATIC_PLACEMENT_MAP = new Map([
+    ['top', 'top'],
+    ['bottom', 'bottom'],
+    ['left', 'start'],
+    ['right', 'end'],
+    ['start', 'start'],
+    ['end', 'end'],
+    ['auto', 'auto'],
+    ['vertical', 'vertical'],
+    ['horizontal', 'horizontal'],
+    ['top-start', 'top-start'],
+    ['top-left', 'top-start'],
+    ['top-end', 'top-end'],
+    ['top-right', 'top-end'],
+    ['bottom-start', 'bottom-start'],
+    ['bottom-left', 'bottom-start'],
+    ['bottom-end', 'bottom-end'],
+    ['bottom-right', 'bottom-end'],
+    ['left-start', 'start-start'],
+    ['left-top', 'start-start'],
+    ['start-start', 'start-start'],
+    ['start-top', 'start-start'],
+    ['left-end', 'start-end'],
+    ['left-bottom', 'start-end'],
+    ['start-end', 'start-end'],
+    ['start-bottom', 'start-end'],
+    ['right-start', 'end-start'],
+    ['right-top', 'end-start'],
+    ['end-start', 'end-start'],
+    ['end-top', 'end-start'],
+    ['right-end', 'end-end'],
+    ['right-bottom', 'end-end'],
+    ['end-end', 'end-end'],
+    ['end-bottom', 'end-end']
+]);
+function mapStaticPlacement(value) {
+    const placements = value
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((placement) => STATIC_PLACEMENT_MAP.get(placement) ?? placement);
+    return placements.length > 0 ? placements.join(' ') : null;
+}

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

@@ -0,0 +1,28 @@
+import { TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstElement, TmplAstNode, TmplAstTextAttribute } from '@angular/compiler';
+export interface TemplateEdit {
+    start: number;
+    end: number;
+    text: string;
+}
+export interface TemplateElementMatch {
+    element: TmplAstElement;
+    ancestors: TmplAstElement[];
+}
+export type ClassAttribute = TmplAstTextAttribute | TmplAstBoundAttribute;
+export declare function applyTemplateEdits(template: string, edits: TemplateEdit[]): string;
+export declare function replaceElement(element: TmplAstElement, text: string): TemplateEdit;
+export declare function getElementInnerSource(element: TmplAstElement): string;
+export declare function visitTemplateNodes(nodes: TmplAstNode[], visitor: (node: TmplAstNode, ancestors: TmplAstElement[]) => void, ancestors?: TmplAstElement[]): void;
+export declare function findTemplateElements(template: string, predicate: (element: TmplAstElement) => boolean): TmplAstElement[];
+export declare function findTemplateElementsWithAncestors(template: string, predicate: (element: TmplAstElement) => boolean): TemplateElementMatch[];
+export declare function findTextAttribute(element: TmplAstElement, name: string): TmplAstTextAttribute | undefined;
+export declare function findBoundAttribute(element: TmplAstElement, name: string): TmplAstBoundAttribute | undefined;
+export declare function isInterpolatedClassAttribute(attribute: TmplAstBoundAttribute): boolean;
+export declare function findStaticOrInterpolatedClassAttribute(element: TmplAstElement): ClassAttribute | undefined;
+export declare function findBoundEvent(element: TmplAstElement, name: string): TmplAstBoundEvent | undefined;
+export declare function getStartTagInsertOffset(element: TmplAstElement): number;
+export declare function getStartTagAttributesOffset(element: TmplAstElement): number;
+export declare function removeTextAttribute(attribute: ClassAttribute): TemplateEdit;
+export declare function getStaticClassTokens(element: TmplAstElement): string[];
+export declare function getStaticOrInterpolatedClassTokens(element: TmplAstElement): string[];
+export declare function hasDynamicClassBinding(element: TmplAstElement): boolean;

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

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTemplateEdits = applyTemplateEdits;
+exports.replaceElement = replaceElement;
+exports.getElementInnerSource = getElementInnerSource;
+exports.visitTemplateNodes = visitTemplateNodes;
+exports.findTemplateElements = findTemplateElements;
+exports.findTemplateElementsWithAncestors = findTemplateElementsWithAncestors;
+exports.findTextAttribute = findTextAttribute;
+exports.findBoundAttribute = findBoundAttribute;
+exports.isInterpolatedClassAttribute = isInterpolatedClassAttribute;
+exports.findStaticOrInterpolatedClassAttribute = findStaticOrInterpolatedClassAttribute;
+exports.findBoundEvent = findBoundEvent;
+exports.getStartTagInsertOffset = getStartTagInsertOffset;
+exports.getStartTagAttributesOffset = getStartTagAttributesOffset;
+exports.removeTextAttribute = removeTextAttribute;
+exports.getStaticClassTokens = getStaticClassTokens;
+exports.getStaticOrInterpolatedClassTokens = getStaticOrInterpolatedClassTokens;
+exports.hasDynamicClassBinding = hasDynamicClassBinding;
+const compiler_1 = require("@angular/compiler");
+function applyTemplateEdits(template, edits) {
+    if (edits.length === 0) {
+        return template;
+    }
+    const content = edits
+        .sort((a, b) => b.start - a.start || b.end - a.end)
+        .reduce((content, edit) => content.slice(0, edit.start) + edit.text + content.slice(edit.end), template);
+    return removeWhitespaceOnlyLines(content);
+}
+function replaceElement(element, text) {
+    return {
+        start: element.sourceSpan.start.offset,
+        end: element.sourceSpan.end.offset,
+        text
+    };
+}
+function getElementInnerSource(element) {
+    const content = element.sourceSpan.start.file.content;
+    const start = element.startSourceSpan.end.offset;
+    const end = element.endSourceSpan?.start.offset ?? element.sourceSpan.end.offset;
+    return content.slice(start, end);
+}
+function removeWhitespaceOnlyLines(content) {
+    return content.replace(/^[ \t]+(?:\r?\n)/gm, '');
+}
+function visitTemplateNodes(nodes, visitor, ancestors = []) {
+    for (const node of nodes) {
+        visitor(node, ancestors);
+        const childAncestors = node instanceof compiler_1.TmplAstElement ? [...ancestors, node] : ancestors;
+        const nodeWithChildren = node;
+        if (nodeWithChildren.children) {
+            visitTemplateNodes(nodeWithChildren.children, visitor, childAncestors);
+        }
+        const nodeWithBranches = node;
+        for (const branch of nodeWithBranches.branches ?? []) {
+            visitTemplateNodes(branch.children, visitor, childAncestors);
+        }
+        const nodeWithCases = node;
+        for (const switchCase of nodeWithCases.cases ?? []) {
+            visitTemplateNodes(switchCase.children, visitor, childAncestors);
+        }
+        const nodeWithGroups = node;
+        for (const group of nodeWithGroups.groups ?? []) {
+            visitTemplateNodes(group.children, visitor, childAncestors);
+        }
+        const nodeWithEmpty = node;
+        if (nodeWithEmpty.empty) {
+            visitTemplateNodes(nodeWithEmpty.empty.children, visitor, childAncestors);
+        }
+        const nodeWithDeferredBlocks = node;
+        for (const deferredBlock of [
+            nodeWithDeferredBlocks.placeholder,
+            nodeWithDeferredBlocks.loading,
+            nodeWithDeferredBlocks.error
+        ]) {
+            if (deferredBlock) {
+                visitTemplateNodes(deferredBlock.children, visitor, childAncestors);
+            }
+        }
+    }
+}
+function findTemplateElements(template, predicate) {
+    const parsedTemplate = (0, compiler_1.parseTemplate)(template, 'component-template.html', {
+        preserveWhitespaces: true,
+        preserveLineEndings: true
+    });
+    const elements = [];
+    visitTemplateNodes(parsedTemplate.nodes, (node) => {
+        if (node instanceof compiler_1.TmplAstElement && predicate(node)) {
+            elements.push(node);
+        }
+    });
+    return elements;
+}
+function findTemplateElementsWithAncestors(template, predicate) {
+    const parsedTemplate = (0, compiler_1.parseTemplate)(template, 'component-template.html', {
+        preserveWhitespaces: true,
+        preserveLineEndings: true
+    });
+    const elements = [];
+    visitTemplateNodes(parsedTemplate.nodes, (node, ancestors) => {
+        if (node instanceof compiler_1.TmplAstElement && predicate(node)) {
+            elements.push({ element: node, ancestors });
+        }
+    });
+    return elements;
+}
+function findTextAttribute(element, name) {
+    return element.attributes.find((attribute) => attribute.name === name);
+}
+function findBoundAttribute(element, name) {
+    return element.inputs.find((attribute) => attribute.name === name);
+}
+function isInterpolatedClassAttribute(attribute) {
+    const value = attribute.value;
+    return attribute.name === 'class' && value.ast instanceof compiler_1.Interpolation;
+}
+function findStaticOrInterpolatedClassAttribute(element) {
+    return findTextAttribute(element, 'class') ?? element.inputs.find(isInterpolatedClassAttribute);
+}
+function findBoundEvent(element, name) {
+    return element.outputs.find((output) => output.name === name);
+}
+function getStartTagInsertOffset(element) {
+    const content = element.startSourceSpan.start.file.content;
+    const tagEndOffset = element.startSourceSpan.end.offset;
+    return content[tagEndOffset - 2] === '/' ? tagEndOffset - 2 : tagEndOffset - 1;
+}
+function getStartTagAttributesOffset(element) {
+    return element.startSourceSpan.start.offset + element.name.length + 1;
+}
+function removeTextAttribute(attribute) {
+    const content = attribute.sourceSpan.start.file.content;
+    const start = attribute.sourceSpan.start.offset;
+    return {
+        start: /\s/.test(content[start - 1] ?? '') ? start - 1 : start,
+        end: attribute.sourceSpan.end.offset,
+        text: ''
+    };
+}
+function getStaticClassTokens(element) {
+    return findTextAttribute(element, 'class')?.value.split(/\s+/).filter(Boolean) ?? [];
+}
+function getStaticOrInterpolatedClassTokens(element) {
+    const classAttribute = findStaticOrInterpolatedClassAttribute(element);
+    const fallbackValue = typeof classAttribute?.value === 'string' ? classAttribute.value : '';
+    const value = classAttribute?.valueSpan?.toString() ?? fallbackValue;
+    return value.split(/\s+/).filter(Boolean);
+}
+function hasDynamicClassBinding(element) {
+    return (!!findTextAttribute(element, 'ngClass') ||
+        element.inputs.some((input) => input.name === 'class' || input.name === 'ngClass' || input.type === compiler_1.BindingType.Class));
+}

package/schematics/component-migration/shared/template-result.d.ts

@@ -0,0 +1,3 @@
+import { ComponentMigrationTemplateResult, StandaloneImportRequirement } from './types';
+import { TemplateEdit } from './template-edits';
+export declare function createTemplateMigrationResult(template: string, edits: TemplateEdit[], standaloneImports?: StandaloneImportRequirement[]): ComponentMigrationTemplateResult;

package/schematics/component-migration/shared/template-result.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTemplateMigrationResult = createTemplateMigrationResult;
+const template_edits_1 = require("./template-edits");
+function createTemplateMigrationResult(template, edits, standaloneImports) {
+    return {
+        content: (0, template_edits_1.applyTemplateEdits)(template, edits),
+        changes: edits.length,
+        standaloneImports
+    };
+}

package/schematics/component-migration/shared/testing.d.ts

@@ -0,0 +1,13 @@
+import { TempScopedNodeJsSyncHost } from '@angular-devkit/core/node/testing';
+import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
+export interface ComponentMigrationTestContext {
+    host: TempScopedNodeJsSyncHost;
+    tree: UnitTestTree;
+    tmpDirPath: string;
+    previousWorkingDir: string;
+    logs: string[];
+}
+export declare function setupComponentMigrationTest(runner: SchematicTestRunner, testCaseRoot: string): ComponentMigrationTestContext;
+export declare function cleanupComponentMigrationTest(context: ComponentMigrationTestContext): void;
+export declare function expectTestCaseOutputFile(tree: UnitTestTree, testCaseRoot: string, filePath: string): void;
+export declare function expectSchematicIdempotent(runner: SchematicTestRunner, schematicName: string, context: ComponentMigrationTestContext): Promise<void>;