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

package/schematics/component-migration/tooltip/steps/template-attributes.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasTooltipI18nAttribute = hasTooltipI18nAttribute;
+exports.editTooltipElement = editTooltipElement;
+const compiler_1 = require("@angular/compiler");
+const template_edits_1 = require("../../shared/template-edits");
+const static_placement_1 = require("../../shared/static-placement");
+const template_todos_1 = require("./template-todos");
+function getAttributeKeySpan(attribute) {
+    return attribute.keySpan ?? attribute.sourceSpan;
+}
+function renameAttribute(attribute, name, edits) {
+    const keySpan = getAttributeKeySpan(attribute);
+    edits.push({
+        start: keySpan.start.offset,
+        end: keySpan.end.offset,
+        text: name
+    });
+}
+function removeAttribute(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 setAttributeValue(attribute, value, edits) {
+    const valueSpan = attribute.valueSpan;
+    if (!valueSpan) {
+        return;
+    }
+    edits.push({
+        start: valueSpan.start.offset,
+        end: valueSpan.end.offset,
+        text: value
+    });
+}
+function getAttributeValue(attribute) {
+    if (!attribute) {
+        return null;
+    }
+    return attribute.valueSpan?.toString().trim() ?? (typeof attribute.value === 'string' ? attribute.value.trim() : '');
+}
+function isBoundAttribute(attribute) {
+    return attribute instanceof compiler_1.TmplAstBoundAttribute;
+}
+function isTextAttribute(attribute) {
+    return attribute instanceof compiler_1.TmplAstTextAttribute;
+}
+function getTooltipContentAttribute(element) {
+    return (0, template_edits_1.findTextAttribute)(element, 'ngbTooltip') ?? (0, template_edits_1.findBoundAttribute)(element, 'ngbTooltip');
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function renameStartTagAttribute(element, name, newName, edits) {
+    const content = element.sourceSpan.start.file.content;
+    const start = element.sourceSpan.start.offset;
+    const end = element.startSourceSpan?.end.offset ?? content.indexOf('>', start) + 1;
+    const startTag = content.slice(start, end);
+    const match = new RegExp(`(^|[\\s<])(${escapeRegExp(name)})(?=\\s|=|>|/)`).exec(startTag);
+    if (!match) {
+        return;
+    }
+    const attributeStart = start + match.index + match[1].length;
+    edits.push({
+        start: attributeStart,
+        end: attributeStart + name.length,
+        text: newName
+    });
+}
+function getStartTagAttributeSpan(element, name) {
+    const content = element.sourceSpan.start.file.content;
+    const start = element.sourceSpan.start.offset;
+    const end = element.startSourceSpan?.end.offset ?? content.indexOf('>', start) + 1;
+    const startTag = content.slice(start, end);
+    const match = new RegExp(`\\s+${escapeRegExp(name)}(?:\\s*=\\s*(?:"[^"]*"|'[^']*'|[^\\s>]+))?`).exec(startTag);
+    if (!match) {
+        return null;
+    }
+    return {
+        start: start + match.index,
+        end: start + match.index + match[0].length
+    };
+}
+function hasStartTagAttribute(element, name) {
+    return !!getStartTagAttributeSpan(element, name);
+}
+function removeStartTagAttribute(element, name, edits) {
+    const span = getStartTagAttributeSpan(element, name);
+    if (span) {
+        edits.push({ ...span, text: '' });
+    }
+}
+function editTooltipI18nAttribute(element, edits) {
+    renameStartTagAttribute(element, 'i18n-ngbTooltip', 'i18n-dfTooltip', edits);
+}
+function hasTooltipI18nAttribute(element) {
+    return hasStartTagAttribute(element, 'i18n-ngbTooltip');
+}
+function isStringLiteralExpression(value) {
+    return /^(['"`])[\s\S]*\1$/.test(value);
+}
+function isTemplateReferenceContent(attribute, context) {
+    if (!isBoundAttribute(attribute)) {
+        return false;
+    }
+    const value = getAttributeValue(attribute);
+    return !!value && context.templateReferenceNames.has(value);
+}
+function getStaticTooltipClassSize(attribute) {
+    if (!attribute || !isTextAttribute(attribute)) {
+        return null;
+    }
+    const classNames = attribute.value.split(/\s+/).filter(Boolean);
+    if (classNames.length !== 1) {
+        return null;
+    }
+    if (classNames[0] === 'tooltip-inner-sm') {
+        return 'sm';
+    }
+    if (classNames[0] === 'tooltip-inner-lg') {
+        return 'lg';
+    }
+    return null;
+}
+function hasUnsupportedBoundTooltipClass(attribute) {
+    return !!attribute && isBoundAttribute(attribute);
+}
+function hasUnsupportedStaticTooltipClass(attribute) {
+    return !!attribute && isTextAttribute(attribute) && !getStaticTooltipClassSize(attribute);
+}
+function getStaticTriggers(attribute) {
+    return attribute && isTextAttribute(attribute) ? attribute.value.trim() : null;
+}
+function isManualTrigger(attribute) {
+    if (!attribute) {
+        return false;
+    }
+    const triggers = getStaticTriggers(attribute);
+    return !!triggers && triggers.includes('manual');
+}
+function hasCustomTriggers(attribute) {
+    return !!attribute && getStaticTriggers(attribute) !== 'hover focus';
+}
+function editPlacement(element, edits, todos) {
+    const placement = (0, template_edits_1.findTextAttribute)(element, 'placement') ?? (0, template_edits_1.findBoundAttribute)(element, 'placement');
+    if (!placement) {
+        return;
+    }
+    if (isTextAttribute(placement)) {
+        const mappedPlacement = (0, static_placement_1.mapStaticPlacement)(placement.value);
+        if (mappedPlacement) {
+            renameAttribute(placement, 'dfTooltipPlacement', edits);
+            setAttributeValue(placement, mappedPlacement, edits);
+        }
+        else {
+            edits.push(removeAttribute(placement));
+        }
+        return;
+    }
+    renameAttribute(placement, 'dfTooltipPlacement', edits);
+    todos.dynamicPlacement = true;
+}
+function editDisableTooltip(element, edits) {
+    const disabled = (0, template_edits_1.findTextAttribute)(element, 'disableTooltip') ?? (0, template_edits_1.findBoundAttribute)(element, 'disableTooltip');
+    if (disabled) {
+        renameAttribute(disabled, 'dfTooltipDisabled', edits);
+    }
+}
+function editTooltipClass(element, edits, todos, contentMigrated) {
+    const tooltipClass = (0, template_todos_1.getTooltipClassAttribute)(element);
+    const size = getStaticTooltipClassSize(tooltipClass);
+    if (size && contentMigrated) {
+        edits.push(removeAttribute(tooltipClass));
+        edits.push({
+            start: (0, template_edits_1.getStartTagInsertOffset)(element),
+            end: (0, template_edits_1.getStartTagInsertOffset)(element),
+            text: ` dfTooltipSize="${size}"`
+        });
+        return;
+    }
+    if (hasUnsupportedBoundTooltipClass(tooltipClass)) {
+        todos.customClass = true;
+        edits.push(removeAttribute(tooltipClass));
+    }
+    else if (hasUnsupportedStaticTooltipClass(tooltipClass)) {
+        todos.customClass = true;
+        edits.push(removeAttribute(tooltipClass));
+    }
+}
+function editTooltipTruncate(element, edits, todos) {
+    const truncate = (0, template_todos_1.getTooltipTruncateAttribute)(element);
+    if (!truncate) {
+        return;
+    }
+    todos.truncate = true;
+    edits.push(removeAttribute(truncate));
+}
+function canMigrateTooltipContent(contentAttribute, element, context, todos) {
+    const tooltipReference = (0, template_todos_1.getTooltipReference)(element);
+    if (isTemplateReferenceContent(contentAttribute, context)) {
+        todos.templateContent = true;
+        return false;
+    }
+    if (tooltipReference) {
+        todos.templateReference = true;
+        return false;
+    }
+    return true;
+}
+function editTriggers(element, edits, todos, contentMigrated) {
+    const triggers = (0, template_todos_1.getTriggersAttribute)(element);
+    if (!triggers) {
+        return;
+    }
+    if (isManualTrigger(triggers)) {
+        todos.manualTrigger = true;
+    }
+    else if (hasCustomTriggers(triggers)) {
+        todos.customTriggers = true;
+    }
+    if (contentMigrated) {
+        edits.push(removeAttribute(triggers));
+    }
+}
+function editAutoClose(element, edits, todos, contentMigrated) {
+    const autoClose = (0, template_todos_1.getAutoCloseAttribute)(element);
+    if (!autoClose) {
+        return;
+    }
+    todos.autoClose = true;
+    if (contentMigrated) {
+        edits.push(removeAttribute(autoClose));
+    }
+}
+function editTooltipElement(element, context, edits) {
+    const todos = {};
+    const contentAttribute = getTooltipContentAttribute(element);
+    if (!contentAttribute) {
+        if (hasTooltipI18nAttribute(element)) {
+            removeStartTagAttribute(element, 'i18n-ngbTooltip', edits);
+            todos.orphanI18n = true;
+        }
+        return { migrated: false, todos };
+    }
+    const contentMigrated = canMigrateTooltipContent(contentAttribute, element, context, todos);
+    if (contentMigrated) {
+        renameAttribute(contentAttribute, 'dfTooltip', edits);
+        editTooltipI18nAttribute(element, edits);
+        if (isBoundAttribute(contentAttribute) && !(getAttributeValue(contentAttribute) ?? '').includes('{{')) {
+            todos.dynamicContent = !isStringLiteralExpression(getAttributeValue(contentAttribute) ?? '');
+        }
+    }
+    if (contentMigrated) {
+        editPlacement(element, edits, todos);
+        editDisableTooltip(element, edits);
+    }
+    editTooltipClass(element, edits, todos, contentMigrated);
+    editTooltipTruncate(element, edits, todos);
+    editTriggers(element, edits, todos, contentMigrated);
+    editAutoClose(element, edits, todos, contentMigrated);
+    return { migrated: contentMigrated, todos };
+}

package/schematics/component-migration/tooltip/steps/template-todos.d.ts

@@ -0,0 +1,24 @@
+import { TmplAstBoundAttribute, TmplAstElement, TmplAstReference, TmplAstTextAttribute } from '@angular/compiler';
+import { MigrationTodo } from '../../shared/todo-comments';
+import { TemplateEdit } from '../../shared/template-edits';
+export interface TooltipTemplateTodoContext {
+    migrated?: boolean;
+    dynamicContent?: boolean;
+    templateContent?: boolean;
+    customClass?: boolean;
+    customTriggers?: boolean;
+    manualTrigger?: boolean;
+    autoClose?: boolean;
+    truncate?: boolean;
+    templateReference?: boolean;
+    dynamicPlacement?: boolean;
+    orphanI18n?: boolean;
+}
+export type TooltipAttribute = TmplAstTextAttribute | TmplAstBoundAttribute;
+export declare const TOOLTIP_REVIEW_TODO: MigrationTodo;
+export declare function getTooltipReference(element: TmplAstElement): TmplAstReference | undefined;
+export declare function getTooltipTruncateAttribute(element: TmplAstElement): TooltipAttribute | undefined;
+export declare function getTooltipClassAttribute(element: TmplAstElement): TooltipAttribute | undefined;
+export declare function getTriggersAttribute(element: TmplAstElement): TooltipAttribute | undefined;
+export declare function getAutoCloseAttribute(element: TmplAstElement): TooltipAttribute | undefined;
+export declare function editTooltipTemplateTodos(element: TmplAstElement, edits: TemplateEdit[], context: TooltipTemplateTodoContext): void;

package/schematics/component-migration/tooltip/steps/template-todos.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOLTIP_REVIEW_TODO = void 0;
+exports.getTooltipReference = getTooltipReference;
+exports.getTooltipTruncateAttribute = getTooltipTruncateAttribute;
+exports.getTooltipClassAttribute = getTooltipClassAttribute;
+exports.getTriggersAttribute = getTriggersAttribute;
+exports.getAutoCloseAttribute = getAutoCloseAttribute;
+exports.editTooltipTemplateTodos = editTooltipTemplateTodos;
+const todo_comments_1 = require("../../shared/todo-comments");
+const template_edits_1 = require("../../shared/template-edits");
+exports.TOOLTIP_REVIEW_TODO = {
+    code: 'tooltip.review',
+    message: 'This tooltip was migrated automatically. Verify behavior and visual appearance.'
+};
+const TOOLTIP_DYNAMIC_CONTENT_TODO = {
+    code: 'tooltip.dynamic-content',
+    message: 'Dynamic tooltip content was migrated without rewriting the expression. Verify it returns plain text.'
+};
+const TOOLTIP_TEMPLATE_CONTENT_TODO = {
+    code: 'tooltip.template-content',
+    marker: 'human',
+    message: 'Template-based tooltip content was not migrated. Convert it to plain tooltip text or a popover manually.'
+};
+const TOOLTIP_CUSTOM_CLASS_TODO = {
+    code: 'tooltip.custom-class',
+    marker: 'human',
+    message: 'The legacy tooltipClass attribute is not supported by the new tooltip API. Verify the visual intent manually.'
+};
+const TOOLTIP_CUSTOM_TRIGGERS_TODO = {
+    code: 'tooltip.custom-triggers',
+    marker: 'human',
+    message: 'Custom tooltip triggers are not supported by the new tooltip API. Verify the interaction manually.'
+};
+const TOOLTIP_MANUAL_TRIGGER_TODO = {
+    code: 'tooltip.manual-trigger',
+    marker: 'human',
+    message: 'Manual tooltip trigger control was not migrated. Replace the interaction manually if still needed.'
+};
+const TOOLTIP_AUTO_CLOSE_TODO = {
+    code: 'tooltip.auto-close',
+    marker: 'human',
+    message: 'Tooltip autoClose behavior was not migrated. Verify the old click behavior manually.'
+};
+const TOOLTIP_TRUNCATE_TODO = {
+    code: 'tooltip.truncate',
+    marker: 'human',
+    message: 'dfTooltipTruncate depends on the legacy tooltip and was not migrated automatically.'
+};
+const TOOLTIP_TEMPLATE_REFERENCE_TODO = {
+    code: 'tooltip.template-reference',
+    marker: 'human',
+    message: 'Template references to ngbTooltip were not migrated because the new tooltip has no equivalent export.'
+};
+const TOOLTIP_DYNAMIC_PLACEMENT_TODO = {
+    code: 'tooltip.dynamic-placement',
+    message: 'Dynamic tooltip placement was migrated. Verify it only returns supported dfTooltipPlacement values.'
+};
+const TOOLTIP_ORPHAN_I18N_TODO = {
+    code: 'tooltip.orphan-i18n',
+    marker: 'human',
+    message: 'Legacy tooltip i18n marker had no tooltip binding on this element. Verify whether a tooltip was intended.'
+};
+function getTooltipReference(element) {
+    return element.references.find((reference) => reference.value === 'ngbTooltip');
+}
+function getTooltipTruncateAttribute(element) {
+    return (0, template_edits_1.findTextAttribute)(element, 'dfTooltipTruncate') ?? (0, template_edits_1.findBoundAttribute)(element, 'dfTooltipTruncate');
+}
+function getTooltipClassAttribute(element) {
+    return (0, template_edits_1.findTextAttribute)(element, 'tooltipClass') ?? (0, template_edits_1.findBoundAttribute)(element, 'tooltipClass');
+}
+function getTriggersAttribute(element) {
+    return (0, template_edits_1.findTextAttribute)(element, 'triggers') ?? (0, template_edits_1.findBoundAttribute)(element, 'triggers');
+}
+function getAutoCloseAttribute(element) {
+    return (0, template_edits_1.findTextAttribute)(element, 'autoClose') ?? (0, template_edits_1.findBoundAttribute)(element, 'autoClose');
+}
+function editTooltipTemplateTodos(element, edits, context) {
+    const todos = [];
+    if (context.migrated && !context.dynamicContent) {
+        todos.push(exports.TOOLTIP_REVIEW_TODO);
+    }
+    if (context.dynamicContent) {
+        todos.push(TOOLTIP_DYNAMIC_CONTENT_TODO);
+    }
+    if (context.templateContent) {
+        todos.push(TOOLTIP_TEMPLATE_CONTENT_TODO);
+    }
+    if (context.customClass) {
+        todos.push(TOOLTIP_CUSTOM_CLASS_TODO);
+    }
+    if (context.customTriggers) {
+        todos.push(TOOLTIP_CUSTOM_TRIGGERS_TODO);
+    }
+    if (context.manualTrigger) {
+        todos.push(TOOLTIP_MANUAL_TRIGGER_TODO);
+    }
+    if (context.autoClose) {
+        todos.push(TOOLTIP_AUTO_CLOSE_TODO);
+    }
+    if (context.truncate) {
+        todos.push(TOOLTIP_TRUNCATE_TODO);
+    }
+    if (context.templateReference) {
+        todos.push(TOOLTIP_TEMPLATE_REFERENCE_TODO);
+    }
+    if (context.dynamicPlacement) {
+        todos.push(TOOLTIP_DYNAMIC_PLACEMENT_TODO);
+    }
+    if (context.orphanI18n) {
+        todos.push(TOOLTIP_ORPHAN_I18N_TODO);
+    }
+    (0, todo_comments_1.editTemplateTodos)(element, todos, edits);
+}

package/schematics/component-migration/tooltip/steps/tooltip-imports.d.ts

@@ -0,0 +1,3 @@
+import { TemplateEdit } from '../../shared/template-edits';
+import { ComponentMigrationSourceContext } from '../../shared/types';
+export declare function editTooltipImports(context: ComponentMigrationSourceContext): TemplateEdit[];

package/schematics/component-migration/tooltip/steps/tooltip-imports.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editTooltipImports = editTooltipImports;
+const component_imports_1 = require("../../shared/component-imports");
+const component_context_1 = require("../../shared/component-context");
+const NEW_TOOLTIP_IMPORT = '@design-factory/angular/tooltip';
+const DF_TOOLTIP = 'DfTooltip';
+const LEGACY_NG_BOOTSTRAP_IMPORTS = new Set(['@ng-bootstrap/ng-bootstrap/tooltip', '@ng-bootstrap/ng-bootstrap']);
+const LEGACY_DESIGN_FACTORY_IMPORTS = new Set([
+    '@design-factory/design-factory',
+    '@design-factory/design-factory/tooltip'
+]);
+const LEGACY_TOOLTIP_IMPORTS = new Set([...LEGACY_NG_BOOTSTRAP_IMPORTS, ...LEGACY_DESIGN_FACTORY_IMPORTS]);
+const LEGACY_DIRECTIVE_SCOPE_SYMBOLS = new Set(['NgbTooltip']);
+const LEGACY_MODULE_SCOPE_SYMBOLS = new Set(['NgbTooltipModule', 'DfTooltipModule']);
+const LEGACY_SCOPE_SYMBOLS = new Set([...LEGACY_DIRECTIVE_SCOPE_SYMBOLS, ...LEGACY_MODULE_SCOPE_SYMBOLS]);
+const LEGACY_TRUNCATE_SCOPE_SYMBOLS = new Set(['DfTooltipTruncateDirective']);
+const LEGACY_IMPORT_SYMBOLS = new Set([...LEGACY_SCOPE_SYMBOLS, 'DfTooltipTruncateDirective', 'NgbTooltipConfig']);
+function componentUsesDfTooltip(templates) {
+    return templates.some((template) => /(?:\[)?dfTooltip(?:\]|=|\s|>)/.test(template));
+}
+function componentUsesLegacyTooltip(templates) {
+    return templates.some((template) => /(^|[\s<])(?:\[)?ngbTooltip(?:\]|=|\s|>)/.test(template.replace(/<!--[\s\S]*?-->/g, '')));
+}
+function sourceFileNeedsDfTooltip(context) {
+    return (0, component_context_1.sourceFileNeedsComponentTemplate)(context, componentUsesDfTooltip);
+}
+function getLegacyTooltipImports(sourceFile) {
+    return (0, component_imports_1.getComponentNamedImports)(sourceFile, LEGACY_TOOLTIP_IMPORTS, LEGACY_IMPORT_SYMBOLS);
+}
+function editUnusedLegacyImportDeclarations(context, legacyImports) {
+    const sourceNeedsLegacyTooltip = (0, component_context_1.sourceFileNeedsComponentTemplate)(context, componentUsesLegacyTooltip);
+    return (0, component_imports_1.editRemovableLegacyImports)(context.sourceFile, LEGACY_TOOLTIP_IMPORTS, legacyImports, (legacyImport) => {
+        if (LEGACY_MODULE_SCOPE_SYMBOLS.has(legacyImport.importedName)) {
+            return false;
+        }
+        if (sourceNeedsLegacyTooltip && LEGACY_DIRECTIVE_SCOPE_SYMBOLS.has(legacyImport.importedName)) {
+            return false;
+        }
+        return true;
+    });
+}
+function editRemainingLegacyImportTodos(context) {
+    const sourceNeedsLegacyTooltip = (0, component_context_1.sourceFileNeedsComponentTemplate)(context, componentUsesLegacyTooltip);
+    return (0, component_imports_1.editLegacyImportTodos)(context.sourceFile, LEGACY_TOOLTIP_IMPORTS, (legacyImport) => LEGACY_MODULE_SCOPE_SYMBOLS.has(legacyImport.importedName) ||
+        (sourceNeedsLegacyTooltip && LEGACY_DIRECTIVE_SCOPE_SYMBOLS.has(legacyImport.importedName)), {
+        code: 'tooltip.legacy-import',
+        message: 'Legacy tooltip import remains for second-pass verification. Remove it after confirming no legacy tooltip APIs need it.'
+    });
+}
+function hasLegacyTruncateImport(legacyImports) {
+    return legacyImports.some((legacyImport) => legacyImport.importedName === 'DfTooltipTruncateDirective');
+}
+function editTooltipImports(context) {
+    const edits = [];
+    const legacyImports = getLegacyTooltipImports(context.sourceFile);
+    if (sourceFileNeedsDfTooltip(context) || hasLegacyTruncateImport(legacyImports)) {
+        const scopeEdits = (0, component_imports_1.editComponentScopeImports)({
+            context,
+            newImport: { moduleName: NEW_TOOLTIP_IMPORT, symbolName: DF_TOOLTIP },
+            componentNeedsNewImport: componentUsesDfTooltip,
+            componentKeepsLegacyScope: componentUsesLegacyTooltip,
+            legacyImports,
+            legacyScopeImportedNames: LEGACY_DIRECTIVE_SCOPE_SYMBOLS,
+            cleanupScopeImportedNames: LEGACY_TRUNCATE_SCOPE_SYMBOLS,
+            indirectComponentImportsTodo: {
+                code: 'tooltip.indirect-component-imports',
+                message: 'Component imports use an indirect value. Add DfTooltip to that imports value after verifying its shape.'
+            }
+        });
+        edits.push(...scopeEdits.edits);
+    }
+    if (legacyImports.length === 0) {
+        return edits;
+    }
+    edits.push(...editUnusedLegacyImportDeclarations(context, legacyImports));
+    edits.push(...editRemainingLegacyImportTodos(context));
+    return edits;
+}

package/schematics/component-migration/utils/component-resource-collector.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { Tree } from '@angular-devkit/schematics';
+export interface ResolvedResource {
+    /** Class declaration that contains this resource. */
+    container: ts.ClassDeclaration | null;
+    /** File content of the given template. */
+    content: string;
+    /** Start offset of the resource content (e.g. in the inline source file) */
+    start: number;
+    /** Whether the given resource is inline or not. */
+    inline: boolean;
+    /** Path to the file that contains this resource. */
+    filePath: string;
+    /** Absolute path to the file that contains this resource. */
+    absFilePath: string;
+}
+/**
+ * Collector that can be used to find Angular templates referenced within TypeScript source files.
+ */
+export declare class ComponentResourceCollector {
+    typeChecker: ts.TypeChecker;
+    private tree;
+    resolvedTemplates: ResolvedResource[];
+    constructor(typeChecker: ts.TypeChecker, tree: Tree);
+    visitNode(node: ts.Node): void;
+    private _visitClassDeclaration;
+}

package/schematics/component-migration/utils/component-resource-collector.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentResourceCollector = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const core_1 = require("@angular-devkit/core");
+const ts = tslib_1.__importStar(require("typescript"));
+const decorators_1 = require("./typescript/decorators");
+const functions_1 = require("./typescript/functions");
+const property_name_1 = require("./typescript/property-name");
+/**
+ * Collector that can be used to find Angular templates referenced within TypeScript source files.
+ */
+class ComponentResourceCollector {
+    constructor(typeChecker, tree) {
+        this.typeChecker = typeChecker;
+        this.tree = tree;
+        this.resolvedTemplates = [];
+    }
+    visitNode(node) {
+        if (node.kind === ts.SyntaxKind.ClassDeclaration) {
+            this._visitClassDeclaration(node);
+        }
+    }
+    _visitClassDeclaration(node) {
+        const decorators = ts.getDecorators(node);
+        if (!decorators || !decorators.length) {
+            return;
+        }
+        const ngDecorators = (0, decorators_1.getAngularDecorators)(this.typeChecker, decorators);
+        const componentDecorator = ngDecorators.find((dec) => dec.name === 'Component');
+        // In case no "@Component" decorator could be found on the current class, skip.
+        if (!componentDecorator) {
+            return;
+        }
+        const decoratorCall = componentDecorator.node.expression;
+        // In case the component decorator call is not valid, skip this class declaration.
+        if (decoratorCall.arguments.length !== 1) {
+            return;
+        }
+        const componentMetadata = (0, functions_1.unwrapExpression)(decoratorCall.arguments[0]);
+        // Ensure that the component metadata is an object literal expression.
+        if (!ts.isObjectLiteralExpression(componentMetadata)) {
+            return;
+        }
+        const sourceFile = node.getSourceFile();
+        const absFilePath = (0, core_1.normalize)(path_1.posix.resolve('/', (0, core_1.normalize)(sourceFile.fileName)));
+        const filePath = path_1.posix.relative((0, core_1.normalize)(process.cwd()), absFilePath);
+        const sourceFileDirPath = (0, path_1.dirname)(sourceFile.fileName);
+        // Walk through all component metadata properties and determine the referenced
+        // HTML templates (either external or inline)
+        componentMetadata.properties.forEach((property) => {
+            if (!ts.isPropertyAssignment(property)) {
+                return;
+            }
+            const propertyName = (0, property_name_1.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.
+                const templateStartIdx = property.initializer.getStart() + 1;
+                this.resolvedTemplates.push({
+                    filePath,
+                    absFilePath,
+                    container: node,
+                    content: property.initializer.getText().slice(1, -1),
+                    inline: true,
+                    start: templateStartIdx
+                });
+            }
+            if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {
+                const templateUrl = property.initializer.text;
+                const absTemplatePath = (0, core_1.normalize)(path_1.posix.resolve('/', (0, core_1.normalize)(sourceFileDirPath), (0, core_1.normalize)(templateUrl)));
+                const templatePath = path_1.posix.relative((0, core_1.normalize)(process.cwd()), absTemplatePath);
+                // In case the template does not exist in the file system, skip this
+                // external template.
+                if (!this.tree.exists(templatePath)) {
+                    return;
+                }
+                const fileContent = stripBom(this.tree.readText(templatePath) || '');
+                if (fileContent) {
+                    this.resolvedTemplates.push({
+                        filePath: templatePath,
+                        absFilePath: absTemplatePath,
+                        container: node,
+                        content: fileContent,
+                        inline: false,
+                        start: 0
+                    });
+                }
+            }
+        });
+    }
+}
+exports.ComponentResourceCollector = ComponentResourceCollector;
+/** Strips the BOM from a string. */
+function stripBom(content) {
+    return content.replace(/\uFEFF/g, '');
+}

package/schematics/component-migration/utils/project_tsconfig_paths.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Tree } from '@angular-devkit/schematics';
+/**
+ * Gets all tsconfig paths from a CLI project by reading the workspace configuration
+ * and looking for common tsconfig locations.
+ */
+export declare function getProjectTsConfigPaths(tree: Tree, projectName?: string): Promise<{
+    buildPaths: string[];
+    testPaths: string[];
+}>;
+export declare function getBuildableProjectNames(tree: Tree): Promise<string[]>;
+export declare function resolveProjectNames(tree: Tree, projectName?: string, all?: boolean): Promise<string[]>;