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

package/schematics/component-migration/dropdown/steps/template-wrapper.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueReferenceName = getUniqueReferenceName;
+exports.getProgrammaticReferenceName = getProgrammaticReferenceName;
+exports.getDropdownReferenceName = getDropdownReferenceName;
+exports.getMovedWrapperAttributes = getMovedWrapperAttributes;
+exports.editWrapper = editWrapper;
+exports.getUnsupportedWrapperTodos = getUnsupportedWrapperTodos;
+const compiler_1 = require("@angular/compiler");
+const template_edits_1 = require("../../shared/template-edits");
+const static_placement_1 = require("../../shared/static-placement");
+const template_menu_1 = require("./template-menu");
+const template_helpers_1 = require("./template-helpers");
+const WRAPPER_UNSUPPORTED_POSITIONING_ATTRIBUTES = ['display', 'popperOptions'];
+const WRAPPER_MOVED_ATTRIBUTES = [
+    'placement',
+    'open',
+    'autoClose',
+    'dropdownClass',
+    'container',
+    ...WRAPPER_UNSUPPORTED_POSITIONING_ATTRIBUTES
+];
+function getUniqueReferenceName(context) {
+    let referenceName = 'dropdownMenu';
+    let index = 1;
+    while (context.usedReferenceNames.has(referenceName)) {
+        referenceName = `dropdownMenu${index++}`;
+    }
+    context.usedReferenceNames.add(referenceName);
+    return referenceName;
+}
+function getProgrammaticReferenceName(element) {
+    return element.references.find((reference) => reference.value === 'ngbDropdown')?.name ?? null;
+}
+function getDropdownReferenceName(element, context) {
+    return getProgrammaticReferenceName(element) ?? getUniqueReferenceName(context);
+}
+function getMovedWrapperAttributes(wrapper, menu) {
+    const attributes = [];
+    const placement = (0, template_helpers_1.getDropdownAttribute)(wrapper, 'placement');
+    const open = (0, template_helpers_1.getDropdownAttribute)(wrapper, 'open');
+    const openChange = (0, template_edits_1.findBoundEvent)(wrapper, 'openChange');
+    const container = (0, template_helpers_1.getDropdownAttribute)(wrapper, 'container');
+    const menuSize = (0, template_menu_1.getMenuSize)(menu);
+    const menuClassPlacement = (0, template_menu_1.getMenuClassPlacement)(menu);
+    if (open instanceof compiler_1.TmplAstBoundAttribute) {
+        attributes.push(`[opened]="${(0, template_helpers_1.getAttributeValue)(open)}"`);
+    }
+    else if (open) {
+        const value = (0, template_helpers_1.getAttributeValue)(open);
+        attributes.push(value ? `opened="${value}"` : 'opened');
+    }
+    if (openChange) {
+        attributes.push(`(openedChange)="${(0, template_helpers_1.getEventValue)(openChange)}"`);
+    }
+    if (placement instanceof compiler_1.TmplAstBoundAttribute) {
+        attributes.push(`[placement]="${(0, template_helpers_1.getAttributeValue)(placement)}"`);
+    }
+    else if (placement) {
+        const mappedPlacement = (0, static_placement_1.mapStaticPlacement)((0, template_helpers_1.getAttributeValue)(placement));
+        if (mappedPlacement) {
+            attributes.push(`placement="${mappedPlacement}"`);
+        }
+    }
+    else if (menuClassPlacement) {
+        attributes.push(`placement="${menuClassPlacement}"`);
+    }
+    if (menuSize) {
+        attributes.push(`size="${menuSize}"`);
+    }
+    if (container) {
+        attributes.push(container.sourceSpan.start.file.content.slice(container.sourceSpan.start.offset, container.sourceSpan.end.offset));
+    }
+    return attributes;
+}
+function editWrapper(wrapper, edits) {
+    const dropdown = (0, template_helpers_1.getDropdownAttribute)(wrapper, 'ngbDropdown');
+    const openChange = (0, template_edits_1.findBoundEvent)(wrapper, 'openChange');
+    if (dropdown) {
+        edits.push((0, template_helpers_1.removeAttribute)(dropdown));
+    }
+    for (const reference of wrapper.references) {
+        if (reference.value === 'ngbDropdown') {
+            edits.push((0, template_helpers_1.removeAttribute)(reference));
+        }
+    }
+    for (const name of WRAPPER_MOVED_ATTRIBUTES) {
+        const attribute = (0, template_helpers_1.getDropdownAttribute)(wrapper, name);
+        if (attribute) {
+            edits.push((0, template_helpers_1.removeAttribute)(attribute));
+        }
+    }
+    if (openChange) {
+        edits.push((0, template_helpers_1.removeAttribute)(openChange));
+    }
+}
+function getUnsupportedWrapperTodos(wrapper) {
+    return {
+        autoClose: !!(0, template_helpers_1.getDropdownAttribute)(wrapper, 'autoClose'),
+        customPositioning: !!(0, template_helpers_1.getDropdownAttribute)(wrapper, 'dropdownClass') ||
+            WRAPPER_UNSUPPORTED_POSITIONING_ATTRIBUTES.some((name) => !!(0, template_helpers_1.getDropdownAttribute)(wrapper, name)) ||
+            (0, template_helpers_1.getDropdownAttribute)(wrapper, 'placement') instanceof compiler_1.TmplAstBoundAttribute,
+        programmaticApi: !!getProgrammaticReferenceName(wrapper)
+    };
+}

package/schematics/component-migration/index.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from '@angular-devkit/schematics';
+import { ComponentMigrationSchema } from './shared/types';
+export default function componentMigration(options: ComponentMigrationSchema): Rule;

package/schematics/component-migration/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = componentMigration;
+const registry_1 = require("./registry");
+const migrate_project_1 = require("./shared/migrate-project");
+const scan_project_1 = require("./shared/scan-project");
+const project_tsconfig_paths_1 = require("./utils/project_tsconfig_paths");
+function componentMigration(options) {
+    return async (tree, context) => {
+        const projectNames = await (0, project_tsconfig_paths_1.resolveProjectNames)(tree, options.project, options.all);
+        const runContext = (0, migrate_project_1.createComponentMigrationRunContext)();
+        const usageCounts = new Map(registry_1.componentMigrations.map((migration) => [migration.id, 0]));
+        for (const projectName of projectNames) {
+            const results = await (0, scan_project_1.scanProjectForComponentMigrations)(tree, projectName, registry_1.componentMigrations, runContext);
+            for (const result of results) {
+                usageCounts.set(result.migration.id, (usageCounts.get(result.migration.id) ?? 0) + result.legacyUsages);
+            }
+        }
+        context.logger.info(projectNames.length === 1
+            ? `Design Factory component migration scan for project "${projectNames[0]}"`
+            : `Design Factory component migration scan for ${projectNames.length} projects`);
+        for (const migration of registry_1.componentMigrations) {
+            context.logger.info(`${migration.id}: ${usageCounts.get(migration.id) ?? 0} usages`);
+        }
+    };
+}

package/schematics/component-migration/next-steps/index.d.ts

@@ -0,0 +1,13 @@
+import { Rule, SchematicContext } from '@angular-devkit/schematics';
+export interface NextStepsSchema {
+    componentId: string;
+    analyzedSourceFiles: number;
+    analyzedComponents: number;
+    analyzedTemplates: number;
+    changedTemplates: number;
+    changes: number;
+}
+export declare function formatComponentMigrationNextSteps(options: NextStepsSchema): string;
+export declare function logComponentMigrationNextSteps(context: SchematicContext, options: NextStepsSchema): void;
+export declare function scheduleComponentMigrationNextSteps(context: SchematicContext, options: NextStepsSchema): void;
+export default function nextSteps(options: NextStepsSchema): Rule;

package/schematics/component-migration/next-steps/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatComponentMigrationNextSteps = formatComponentMigrationNextSteps;
+exports.logComponentMigrationNextSteps = logComponentMigrationNextSteps;
+exports.scheduleComponentMigrationNextSteps = scheduleComponentMigrationNextSteps;
+exports.default = nextSteps;
+const tasks_1 = require("@angular-devkit/schematics/tasks");
+function formatComponentMigrationNextSteps(options) {
+    return `
+======================================================================
+Design Factory migration next steps
+======================================================================
+Latest deterministic run (${options.componentId}): ${options.changedTemplates} templates changed, ${options.changes} edits.
+Analyzed ${options.analyzedSourceFiles} source files, ${options.analyzedComponents} components, ${options.analyzedTemplates} templates.
+AI handoff updated in .df-migration/. It includes every generated component guide.
+
+1. Review the git diff.
+2. Run more component migration schematics if you want to hand off several components to AI at once.
+3. Start the AI-assisted migration phase by asking your AI tool to execute .df-migration/prompt.md.
+======================================================================`;
+}
+function logComponentMigrationNextSteps(context, options) {
+    for (const line of formatComponentMigrationNextSteps(options).split('\n')) {
+        context.logger.warn(line);
+    }
+}
+function scheduleComponentMigrationNextSteps(context, options) {
+    context.addTask(new tasks_1.RunSchematicTask('component-migration-next-steps', options));
+}
+function nextSteps(options) {
+    return (_tree, context) => {
+        logComponentMigrationNextSteps(context, options);
+    };
+}

package/schematics/component-migration/registry.d.ts

@@ -0,0 +1 @@
+export declare const componentMigrations: import("./shared/types").ComponentMigrationDefinition[];

package/schematics/component-migration/registry.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentMigrations = void 0;
+const migration_1 = require("./accordion/migration");
+const migration_2 = require("./alert/migration");
+const migration_3 = require("./button/migration");
+const migration_4 = require("./dropdown/migration");
+const migration_5 = require("./tooltip/migration");
+exports.componentMigrations = [
+    migration_1.accordionMigration,
+    migration_2.alertMigration,
+    migration_3.buttonMigration,
+    migration_4.dropdownMigration,
+    migration_5.tooltipMigration
+];

package/schematics/component-migration/schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "SchematicsComponentMigration",
+  "title": "Component Migration Schema",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "Name of the Angular project to scan",
+      "$default": {
+        "$source": "projectName"
+      }
+    },
+    "all": {
+      "type": "boolean",
+      "description": "Scan every buildable Angular project",
+      "default": false
+    }
+  }
+}

package/schematics/component-migration/shared/ai-handoff.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@angular-devkit/schematics';
+export declare function writeAiMigrationHandoff(tree: Tree, componentId: string): void;

package/schematics/component-migration/shared/ai-handoff.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeAiMigrationHandoff = writeAiMigrationHandoff;
+const schematics_1 = require("@angular-devkit/schematics");
+const fs_1 = require("fs");
+const path_1 = require("path");
+function readHandoffSourceFile(path) {
+    try {
+        return (0, fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch {
+        throw new schematics_1.SchematicsException(`Could not find migration handoff file "${path}".`);
+    }
+}
+function writeTextFile(tree, path, content) {
+    if (tree.exists(path)) {
+        if (tree.read(path)?.toString('utf-8') === content) {
+            return;
+        }
+        tree.overwrite(path, content);
+        return;
+    }
+    tree.create(path, content);
+}
+function writeAiMigrationHandoff(tree, componentId) {
+    writeTextFile(tree, '.df-migration/prompt.md', readHandoffSourceFile((0, path_1.join)(__dirname, '..', 'ai', 'prompt.md')));
+    writeTextFile(tree, `.df-migration/${componentId}/guide.md`, readHandoffSourceFile((0, path_1.join)(__dirname, '..', componentId, 'guide.md')));
+}

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

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+export declare function findComponentMetadata(component: ts.ClassDeclaration): ts.ObjectLiteralExpression | null;
+export declare function findComponentImportsArray(component: ts.ClassDeclaration): ts.ArrayLiteralExpression | null;
+export declare function isExplicitlyNonStandaloneComponent(component: ts.ClassDeclaration): boolean;
+export declare function findNgModuleMetadata(moduleClass: ts.ClassDeclaration): ts.ObjectLiteralExpression | null;
+export declare function findNgModuleDeclarationsArray(moduleClass: ts.ClassDeclaration): ts.ArrayLiteralExpression | null;
+export declare function findNgModuleImportsArray(moduleClass: ts.ClassDeclaration): ts.ArrayLiteralExpression | null;
+export declare function findDecoratorImportsArrays(sourceFile: ts.SourceFile): ts.ArrayLiteralExpression[];
+export declare function getNgModuleClasses(sourceFile: ts.SourceFile): ts.ClassDeclaration[];
+export declare function resolveClassDeclaration(typeChecker: ts.TypeChecker, expression: ts.Expression): ts.ClassDeclaration | null;

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findComponentMetadata = findComponentMetadata;
+exports.findComponentImportsArray = findComponentImportsArray;
+exports.isExplicitlyNonStandaloneComponent = isExplicitlyNonStandaloneComponent;
+exports.findNgModuleMetadata = findNgModuleMetadata;
+exports.findNgModuleDeclarationsArray = findNgModuleDeclarationsArray;
+exports.findNgModuleImportsArray = findNgModuleImportsArray;
+exports.findDecoratorImportsArrays = findDecoratorImportsArrays;
+exports.getNgModuleClasses = getNgModuleClasses;
+exports.resolveClassDeclaration = resolveClassDeclaration;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
+function findComponentMetadata(component) {
+    for (const decorator of ts.getDecorators(component) ?? []) {
+        const expression = decorator.expression;
+        if (!ts.isCallExpression(expression) ||
+            !ts.isIdentifier(expression.expression) ||
+            expression.expression.text !== 'Component') {
+            continue;
+        }
+        const [metadata] = expression.arguments;
+        if (metadata && ts.isObjectLiteralExpression(metadata)) {
+            return metadata;
+        }
+    }
+    return null;
+}
+function findComponentImportsArray(component) {
+    const metadata = findComponentMetadata(component);
+    if (!metadata) {
+        return null;
+    }
+    for (const property of metadata.properties) {
+        if (ts.isPropertyAssignment(property) &&
+            property.name.getText(component.getSourceFile()) === 'imports' &&
+            ts.isArrayLiteralExpression(property.initializer)) {
+            return property.initializer;
+        }
+    }
+    return null;
+}
+function isExplicitlyNonStandaloneComponent(component) {
+    const metadata = findComponentMetadata(component);
+    if (!metadata) {
+        return false;
+    }
+    return metadata.properties.some((property) => ts.isPropertyAssignment(property) &&
+        property.name.getText(component.getSourceFile()) === 'standalone' &&
+        property.initializer.kind === ts.SyntaxKind.FalseKeyword);
+}
+function findNgModuleMetadata(moduleClass) {
+    for (const decorator of ts.getDecorators(moduleClass) ?? []) {
+        const expression = decorator.expression;
+        if (!ts.isCallExpression(expression) ||
+            !ts.isIdentifier(expression.expression) ||
+            expression.expression.text !== 'NgModule') {
+            continue;
+        }
+        const [metadata] = expression.arguments;
+        if (metadata && ts.isObjectLiteralExpression(metadata)) {
+            return metadata;
+        }
+    }
+    return null;
+}
+function findNgModuleArrayProperty(moduleClass, propertyName) {
+    const metadata = findNgModuleMetadata(moduleClass);
+    if (!metadata) {
+        return null;
+    }
+    for (const property of metadata.properties) {
+        if (ts.isPropertyAssignment(property) &&
+            property.name.getText(moduleClass.getSourceFile()) === propertyName &&
+            ts.isArrayLiteralExpression(property.initializer)) {
+            return property.initializer;
+        }
+    }
+    return null;
+}
+function findNgModuleDeclarationsArray(moduleClass) {
+    return findNgModuleArrayProperty(moduleClass, 'declarations');
+}
+function findNgModuleImportsArray(moduleClass) {
+    return findNgModuleArrayProperty(moduleClass, 'imports');
+}
+function findDecoratorImportsArrays(sourceFile) {
+    const arrays = [];
+    const visitNode = (node) => {
+        if (ts.isClassDeclaration(node)) {
+            for (const decorator of ts.getDecorators(node) ?? []) {
+                const expression = decorator.expression;
+                const metadata = ts.isCallExpression(expression) ? expression.arguments[0] : undefined;
+                if (!metadata || !ts.isObjectLiteralExpression(metadata)) {
+                    continue;
+                }
+                for (const property of metadata.properties) {
+                    if (ts.isPropertyAssignment(property) &&
+                        property.name.getText(sourceFile) === 'imports' &&
+                        ts.isArrayLiteralExpression(property.initializer)) {
+                        arrays.push(property.initializer);
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visitNode);
+    };
+    visitNode(sourceFile);
+    return arrays;
+}
+function getNgModuleClasses(sourceFile) {
+    return sourceFile.statements.filter((statement) => ts.isClassDeclaration(statement) && !!findNgModuleMetadata(statement));
+}
+function resolveClassDeclaration(typeChecker, expression) {
+    if (!ts.isIdentifier(expression)) {
+        return null;
+    }
+    const symbol = typeChecker.getSymbolAtLocation(expression);
+    if (!symbol) {
+        return null;
+    }
+    const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(symbol) : symbol;
+    const declaration = resolvedSymbol.valueDeclaration ?? resolvedSymbol.declarations?.[0];
+    return declaration && ts.isClassDeclaration(declaration) ? declaration : null;
+}

package/schematics/component-migration/shared/button-visual-classes.d.ts

@@ -0,0 +1,24 @@
+export type ButtonVisualVariant = 'primary' | 'neutral' | 'danger';
+export type ButtonVisualAppearance = 'solid' | 'outline' | 'text';
+export type ButtonVisualSize = 'sm' | 'lg';
+export type ButtonVisualDirective = 'dfButton' | 'dfIconButton';
+export interface StaticButtonVisual {
+    variant: ButtonVisualVariant;
+    appearance: ButtonVisualAppearance;
+    size: ButtonVisualSize | null;
+    mirror: boolean;
+    transparent: boolean;
+    iconOnly: boolean;
+    matchedClass: string;
+}
+export interface ButtonVisualAttributesOptions {
+    directive?: ButtonVisualDirective;
+    includeIconOnly?: boolean;
+}
+export declare const BUTTON_VISUAL_DIRECTIVE_IMPORTS: Record<ButtonVisualDirective, string>;
+export declare const BUTTON_DYNAMIC_VISUAL_CLASSES: Set<string>;
+export declare function hasIconOnlyButtonClasses(classes: string[]): boolean;
+export declare function getStaticButtonVisual(classes: string[]): StaticButtonVisual | null;
+export declare function getButtonVisualSize(classes: string[]): ButtonVisualSize | null;
+export declare function getButtonVisualAttributes(visual: StaticButtonVisual, options?: ButtonVisualAttributesOptions): string[];
+export declare function getRemovableButtonVisualClasses(visual: StaticButtonVisual): Set<string>;

package/schematics/component-migration/shared/button-visual-classes.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUTTON_DYNAMIC_VISUAL_CLASSES = exports.BUTTON_VISUAL_DIRECTIVE_IMPORTS = void 0;
+exports.hasIconOnlyButtonClasses = hasIconOnlyButtonClasses;
+exports.getStaticButtonVisual = getStaticButtonVisual;
+exports.getButtonVisualSize = getButtonVisualSize;
+exports.getButtonVisualAttributes = getButtonVisualAttributes;
+exports.getRemovableButtonVisualClasses = getRemovableButtonVisualClasses;
+exports.BUTTON_VISUAL_DIRECTIVE_IMPORTS = {
+    dfButton: 'DfButton',
+    dfIconButton: 'DfIconButton'
+};
+const BUTTON_VARIANTS = ['primary', 'neutral', 'danger'];
+exports.BUTTON_DYNAMIC_VISUAL_CLASSES = new Set([
+    'btn-primary',
+    'btn-outline-primary',
+    'btn-neutral',
+    'btn-outline-neutral',
+    'btn-danger',
+    'btn-outline-danger',
+    'btn-sm',
+    'btn-lg',
+    'df-btn-tertiary',
+    'df-btn-transparent',
+    'df-btn-icononly',
+    'df-btn-primary-mirror',
+    'df-btn-outline-primary-mirror',
+    'df-btn-neutral-mirror',
+    'df-btn-outline-neutral-mirror',
+    'df-btn-danger-mirror',
+    'df-btn-outline-danger-mirror'
+]);
+function hasIconOnlyButtonClasses(classes) {
+    return classes.includes('df-btn-icononly');
+}
+function getStaticButtonVisual(classes) {
+    for (const variant of BUTTON_VARIANTS) {
+        const solidClass = `btn-${variant}`;
+        if (classes.includes(solidClass)) {
+            return getStaticButtonVisualFromClass(classes, variant, 'solid', false, solidClass);
+        }
+        const outlineClass = `btn-outline-${variant}`;
+        if (classes.includes(outlineClass)) {
+            return getStaticButtonVisualFromClass(classes, variant, 'outline', false, outlineClass);
+        }
+        const mirrorSolidClass = `df-btn-${variant}-mirror`;
+        if (classes.includes(mirrorSolidClass)) {
+            return getStaticButtonVisualFromClass(classes, variant, 'solid', true, mirrorSolidClass);
+        }
+        const mirrorOutlineClass = `df-btn-outline-${variant}-mirror`;
+        if (classes.includes(mirrorOutlineClass)) {
+            return getStaticButtonVisualFromClass(classes, variant, 'outline', true, mirrorOutlineClass);
+        }
+    }
+    return null;
+}
+function getStaticButtonVisualFromClass(classes, variant, appearance, mirror, matchedClass) {
+    return {
+        variant,
+        appearance: classes.includes('df-btn-tertiary') ? 'text' : appearance,
+        size: getButtonVisualSize(classes),
+        mirror,
+        transparent: classes.includes('df-btn-transparent'),
+        iconOnly: hasIconOnlyButtonClasses(classes),
+        matchedClass
+    };
+}
+function getButtonVisualSize(classes) {
+    if (classes.includes('btn-sm') === classes.includes('btn-lg')) {
+        return null;
+    }
+    return classes.includes('btn-sm') ? 'sm' : 'lg';
+}
+function getButtonVisualAttributes(visual, options = {}) {
+    const attributes = [];
+    if (options.directive) {
+        attributes.push(options.directive);
+    }
+    if (visual.variant !== 'primary') {
+        attributes.push(`variant="${visual.variant}"`);
+    }
+    if (visual.appearance !== 'solid') {
+        attributes.push(`appearance="${visual.appearance}"`);
+    }
+    if (visual.size) {
+        attributes.push(`size="${visual.size}"`);
+    }
+    if (visual.mirror) {
+        attributes.push('mirror');
+    }
+    if (visual.transparent) {
+        attributes.push('transparent');
+    }
+    if (options.includeIconOnly && visual.iconOnly) {
+        attributes.push('iconOnly');
+    }
+    return attributes;
+}
+function getRemovableButtonVisualClasses(visual) {
+    const removableClasses = new Set([
+        'btn',
+        visual.matchedClass,
+        'df-btn-tertiary',
+        'df-btn-transparent',
+        'df-btn-icononly'
+    ]);
+    if (visual.size) {
+        removableClasses.add(`btn-${visual.size}`);
+    }
+    return removableClasses;
+}

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

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { ComponentMigrationSourceContext } from './types';
+export type ComponentTemplatePredicate = (templates: string[]) => boolean;
+export declare function sourceFileUsesComponentTemplate(context: ComponentMigrationSourceContext, predicate: ComponentTemplatePredicate): boolean;
+export declare function moduleDeclaresComponentTemplate(context: ComponentMigrationSourceContext, moduleClass: ts.ClassDeclaration, predicate: ComponentTemplatePredicate): boolean;
+export declare function sourceFileDeclaresComponentTemplate(context: ComponentMigrationSourceContext, predicate: ComponentTemplatePredicate): boolean;
+export declare function sourceFileNeedsComponentTemplate(context: ComponentMigrationSourceContext, predicate: ComponentTemplatePredicate): boolean;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceFileUsesComponentTemplate = sourceFileUsesComponentTemplate;
+exports.moduleDeclaresComponentTemplate = moduleDeclaresComponentTemplate;
+exports.sourceFileDeclaresComponentTemplate = sourceFileDeclaresComponentTemplate;
+exports.sourceFileNeedsComponentTemplate = sourceFileNeedsComponentTemplate;
+const angular_component_1 = require("./angular-component");
+function sourceFileUsesComponentTemplate(context, predicate) {
+    return [...context.templatesByComponent.values()].some(predicate);
+}
+function moduleDeclaresComponentTemplate(context, moduleClass, predicate) {
+    const declarations = (0, angular_component_1.findNgModuleDeclarationsArray)(moduleClass);
+    return (declarations?.elements.some((element) => {
+        const component = (0, angular_component_1.resolveClassDeclaration)(context.typeChecker, element);
+        const templates = component ? context.projectTemplatesByComponent.get(component) : undefined;
+        return !!templates && predicate(templates);
+    }) ?? false);
+}
+function sourceFileDeclaresComponentTemplate(context, predicate) {
+    return (0, angular_component_1.getNgModuleClasses)(context.sourceFile).some((moduleClass) => moduleDeclaresComponentTemplate(context, moduleClass, predicate));
+}
+function sourceFileNeedsComponentTemplate(context, predicate) {
+    return sourceFileUsesComponentTemplate(context, predicate) || sourceFileDeclaresComponentTemplate(context, predicate);
+}

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

@@ -0,0 +1,45 @@
+import * as ts from 'typescript';
+import { MigrationTodo } from './todo-comments';
+import { TemplateEdit } from './template-edits';
+import { ComponentMigrationSourceContext } from './types';
+export interface ComponentNamedImport {
+    importedName: string;
+    localName: string;
+    moduleName: string;
+}
+interface ReplacementResult {
+    scopeName: string;
+    importName: string;
+}
+export interface ComponentScopeImportOptions {
+    context: ComponentMigrationSourceContext;
+    newImport: {
+        moduleName: string;
+        symbolName: string;
+    };
+    componentNeedsNewImport: (templates: string[]) => boolean;
+    componentKeepsLegacyScope?: (templates: string[]) => boolean;
+    legacyImports: ComponentNamedImport[];
+    legacyScopeImportedNames?: Iterable<string>;
+    cleanupScopeImportedNames?: Iterable<string>;
+    getReplacement?: (legacyImport: ComponentNamedImport) => ReplacementResult;
+    indirectComponentImportsTodo?: MigrationTodo;
+    addTopLevelImport?: boolean;
+}
+export interface ComponentScopeImportEdits {
+    edits: TemplateEdit[];
+    newImports: Set<string>;
+}
+export interface StandaloneComponentImportOptions {
+    indirectComponentImportsTodo?: MigrationTodo;
+    legacyImports?: ComponentNamedImport[];
+    legacyScopeImportedNames?: Iterable<string>;
+    componentKeepsLegacyScope?: (templates: string[]) => boolean;
+}
+export declare function getComponentNamedImports(sourceFile: ts.SourceFile, moduleNames: Iterable<string>, importedNames?: Iterable<string>): ComponentNamedImport[];
+export declare function editComponentScopeImports(options: ComponentScopeImportOptions): ComponentScopeImportEdits;
+export declare function editStandaloneComponentImports(context: ComponentMigrationSourceContext, moduleName: string, optionsOrTodo?: MigrationTodo | StandaloneComponentImportOptions): TemplateEdit[];
+export declare function hasIdentifierReferenceOutsideImports(sourceFile: ts.SourceFile, symbolName: string): boolean;
+export declare function editRemovableLegacyImports(sourceFile: ts.SourceFile, moduleNames: Iterable<string>, legacyImports: ComponentNamedImport[], shouldRemove: (legacyImport: ComponentNamedImport) => boolean): TemplateEdit[];
+export declare function editLegacyImportTodos(sourceFile: ts.SourceFile, moduleNames: Iterable<string>, shouldAddTodo: (legacyImport: ComponentNamedImport) => boolean, todo: MigrationTodo): TemplateEdit[];
+export {};