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

package/schematics/component-migration/accordion/steps/template-migration.js

@@ -0,0 +1,554 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateAccordionTemplate = migrateAccordionTemplate;
+exports.countLegacyAccordionUsages = countLegacyAccordionUsages;
+const compiler_1 = require("@angular/compiler");
+const template_edits_1 = require("../../shared/template-edits");
+const template_result_1 = require("../../shared/template-result");
+const todo_comments_1 = require("../../shared/todo-comments");
+const constants_1 = require("../constants");
+const title_content_1 = require("./title-content");
+function hasAttributeOrInput(element, name) {
+    return !!(0, template_edits_1.findTextAttribute)(element, name) || !!(0, template_edits_1.findBoundAttribute)(element, name);
+}
+function isLegacyAccordionHost(element) {
+    return hasAttributeOrInput(element, 'ngbAccordion');
+}
+function isLegacyAccordionItem(element) {
+    return hasAttributeOrInput(element, 'ngbAccordionItem');
+}
+function getAccordionMatches(template) {
+    return (0, template_edits_1.findTemplateElementsWithAncestors)(template, (element) => isLegacyAccordionHost(element) || isLegacyAccordionItem(element));
+}
+function getNearestAccordionHost(match) {
+    return [...match.ancestors].reverse().find(isLegacyAccordionHost) ?? null;
+}
+function getSourceText(attribute) {
+    const content = attribute.sourceSpan.start.file.content;
+    return content.slice(attribute.sourceSpan.start.offset, attribute.sourceSpan.end.offset);
+}
+function getEventHandlerText(output) {
+    const content = output.sourceSpan.start.file.content;
+    return content.slice(output.handlerSpan.start.offset, output.handlerSpan.end.offset);
+}
+function renderEventSource(name, handler) {
+    return `(${name})="${handler}"`;
+}
+function combineEventHandlers(first, second) {
+    return [first, second]
+        .filter((output) => !!output)
+        .map(getEventHandlerText)
+        .join('; ');
+}
+function renameAttributeSource(source, oldName, newName) {
+    const index = source.indexOf(oldName);
+    return index === -1 ? source : `${source.slice(0, index)}${newName}${source.slice(index + oldName.length)}`;
+}
+function renderAttributes(attributes) {
+    return attributes
+        .sort((a, b) => a.start - b.start)
+        .map((attribute) => attribute.text)
+        .filter(Boolean)
+        .join(' ');
+}
+function getLineIndent(content, offset) {
+    const lineStart = content.lastIndexOf('\n', offset - 1) + 1;
+    const prefix = content.slice(lineStart, offset);
+    return /^\s*$/.test(prefix) ? prefix : '';
+}
+function editEndTagName(element, name) {
+    if (!element.endSourceSpan) {
+        return null;
+    }
+    return {
+        start: element.endSourceSpan.start.offset + 2,
+        end: element.endSourceSpan.start.offset + 2 + element.name.length,
+        text: name
+    };
+}
+function replaceStartTag(element, name, attributes) {
+    const renderedAttributes = renderAttributes(attributes);
+    return {
+        start: element.startSourceSpan.start.offset,
+        end: element.startSourceSpan.end.offset,
+        text: `<${name}${renderedAttributes ? ` ${renderedAttributes}` : ''}>`
+    };
+}
+function getDirectChildElements(element) {
+    return element.children.filter((child) => child instanceof compiler_1.TmplAstElement);
+}
+function findDirectChildElement(element, predicate) {
+    return getDirectChildElements(element).find(predicate);
+}
+function hasOnlyAttributes(element, names) {
+    return (element.attributes.every((attribute) => names.has(attribute.name)) &&
+        element.inputs.length === 0 &&
+        element.outputs.length === 0 &&
+        element.references.length === 0);
+}
+function getHeaderLevel(header) {
+    const headingMatch = /^h([1-6])$/.exec(header.name);
+    if (headingMatch) {
+        return Number(headingMatch[1]);
+    }
+    const ariaLevel = (0, template_edits_1.findTextAttribute)(header, 'aria-level')?.value;
+    return ariaLevel && /^[1-6]$/.test(ariaLevel) ? Number(ariaLevel) : null;
+}
+function getItemParts(item) {
+    const header = findDirectChildElement(item, (child) => hasAttributeOrInput(child, 'ngbAccordionHeader'));
+    const titleButton = header
+        ? findDirectChildElement(header, (child) => hasAttributeOrInput(child, 'ngbAccordionButton'))
+        : undefined;
+    const collapse = findDirectChildElement(item, (child) => hasAttributeOrInput(child, 'ngbAccordionCollapse'));
+    const body = (collapse && findDirectChildElement(collapse, (child) => hasAttributeOrInput(child, 'ngbAccordionBody'))) ??
+        findDirectChildElement(item, (child) => hasAttributeOrInput(child, 'ngbAccordionBody'));
+    return header && titleButton && body ? { header, titleButton, collapse, body } : null;
+}
+function hasNonI18nButtonAttributes(button) {
+    return (button.attributes.some((attribute) => attribute.name !== 'ngbAccordionButton' && !attribute.name.startsWith('i18n')) ||
+        button.inputs.length > 0 ||
+        button.outputs.length > 0 ||
+        button.references.length > 0);
+}
+function hasNonCanonicalStructure(parts) {
+    const allowedHeaderAttributes = new Set(['ngbAccordionHeader', 'aria-level']);
+    return (!hasOnlyAttributes(parts.header, allowedHeaderAttributes) ||
+        hasNonI18nButtonAttributes(parts.titleButton) ||
+        (!!parts.collapse && !hasOnlyAttributes(parts.collapse, new Set(['ngbAccordionCollapse']))) ||
+        !hasOnlyAttributes(parts.body, new Set(['ngbAccordionBody'])));
+}
+function hasOutput(element, name) {
+    return !!(0, template_edits_1.findBoundEvent)(element, name);
+}
+function hasPreEventConflict(element) {
+    return ((hasOutput(element, 'show') && hasOutput(element, 'shown')) ||
+        (hasOutput(element, 'hide') && hasOutput(element, 'hidden')));
+}
+function getLegacyReference(element, value) {
+    return element.references.find((reference) => reference.value === value);
+}
+function hasSelectablePattern(host) {
+    const classes = (0, template_edits_1.getStaticClassTokens)(host);
+    const hostSource = host.sourceSpan.start.file.content.slice(host.sourceSpan.start.offset, host.sourceSpan.end.offset);
+    return (classes.includes('df-accordion-radio') ||
+        (0, template_edits_1.findTextAttribute)(host, 'role')?.value === 'radiogroup' ||
+        /\btype\s*=\s*["']radio["']/.test(hostSource));
+}
+function hasCustomHostClass(host) {
+    return (0, template_edits_1.getStaticClassTokens)(host).some((className) => !constants_1.LEGACY_HOST_CLASSES.has(className));
+}
+function getHostTodos(host, itemParts) {
+    const todos = [
+        {
+            code: 'accordion.review',
+            message: 'This accordion was migrated automatically. Verify behavior and visual appearance.'
+        }
+    ];
+    if ((0, template_edits_1.hasDynamicClassBinding)(host)) {
+        todos.push({
+            code: 'accordion.dynamic-class',
+            message: 'Dynamic accordion classes were preserved. Verify they do not depend on legacy accordion markup.'
+        });
+    }
+    if (hasCustomHostClass(host)) {
+        todos.push({
+            code: 'accordion.custom-classes',
+            message: 'Custom accordion classes were preserved. Verify that they still target the new DOM structure.'
+        });
+    }
+    if (getLegacyReference(host, 'ngbAccordion')) {
+        todos.push({
+            code: 'accordion.programmatic-api',
+            marker: 'human',
+            message: 'Template reference export was removed. Verify programmatic calls because the new API returns promises.'
+        });
+    }
+    if (hasOutput(host, 'show') || hasOutput(host, 'hide')) {
+        todos.push({
+            code: 'accordion.pre-event',
+            marker: 'human',
+            message: 'Legacy show/hide pre-events were mapped to post-change outputs. Verify timing-sensitive behavior.'
+        });
+    }
+    if (hasPreEventConflict(host)) {
+        todos.push({
+            code: 'accordion.event-conflict',
+            marker: 'human',
+            message: 'Pre-event and post-event handlers were combined on the same output. Verify timing-sensitive behavior.'
+        });
+    }
+    if (itemParts.some((parts) => !parts)) {
+        todos.push({
+            code: 'accordion.non-canonical-structure',
+            marker: 'human',
+            message: 'Some accordion items do not use the canonical ngbAccordion header/body structure and were not migrated.'
+        });
+    }
+    return todos;
+}
+function getHardStopHostTodos(host, itemParts) {
+    const todos = [];
+    if (hasSelectablePattern(host)) {
+        todos.push({
+            code: 'accordion.selectable-pattern',
+            marker: 'human',
+            message: 'Selectable/radio accordion markup was not migrated. Convert it to df-accordion-selectable manually.'
+        });
+    }
+    if (itemParts.length === 0 || itemParts.some((parts) => !parts)) {
+        todos.push({
+            code: 'accordion.non-canonical-structure',
+            marker: 'human',
+            message: 'Accordion items do not use the canonical ngbAccordion header/body structure and were not migrated.'
+        });
+    }
+    if (itemParts.some((parts) => parts && hasNonCanonicalStructure(parts))) {
+        todos.push({
+            code: 'accordion.non-canonical-structure',
+            marker: 'human',
+            message: 'Accordion header/body attributes were not migrated. Convert this structure manually.'
+        });
+    }
+    return todos;
+}
+function getHostHeadingLevel(itemParts, todos) {
+    const levels = itemParts
+        .map(({ header }) => getHeaderLevel(header))
+        .filter((level) => level !== null);
+    const uniqueLevels = new Set(levels);
+    if (uniqueLevels.size === 1 && levels.length === itemParts.length) {
+        return levels[0];
+    }
+    todos.push({
+        code: 'accordion.heading-level',
+        marker: 'human',
+        message: 'itemHeadingLevel was set to 2 because legacy header levels were missing or inconsistent.'
+    });
+    return 2;
+}
+function getStaticClassAttributeText(attribute) {
+    const tokens = attribute.value.split(/\s+/).filter(Boolean);
+    const remainingTokens = tokens.filter((className) => !constants_1.LEGACY_HOST_CLASSES.has(className));
+    return remainingTokens.length > 0 ? `class="${remainingTokens.join(' ')}"` : '';
+}
+function getHostAttributes(host, headingLevel, itemResults) {
+    const attributes = [];
+    const classes = (0, template_edits_1.getStaticClassTokens)(host);
+    const showOutput = (0, template_edits_1.findBoundEvent)(host, 'show');
+    const shownOutput = (0, template_edits_1.findBoundEvent)(host, 'shown');
+    const hideOutput = (0, template_edits_1.findBoundEvent)(host, 'hide');
+    const hiddenOutput = (0, template_edits_1.findBoundEvent)(host, 'hidden');
+    const subtitleTypes = itemResults
+        .map(({ subtitleType }) => subtitleType)
+        .filter((subtitleType) => subtitleType !== null);
+    for (const reference of host.references) {
+        attributes.push({
+            start: reference.sourceSpan.start.offset,
+            text: reference.value === 'ngbAccordion' ? `#${reference.name}` : getSourceText(reference)
+        });
+    }
+    for (const attribute of host.attributes) {
+        if (attribute.name === 'ngbAccordion') {
+            continue;
+        }
+        if (attribute.name === 'class') {
+            attributes.push({
+                start: attribute.sourceSpan.start.offset,
+                text: getStaticClassAttributeText(attribute)
+            });
+            continue;
+        }
+        attributes.push({ start: attribute.sourceSpan.start.offset, text: getSourceText(attribute) });
+    }
+    for (const input of host.inputs) {
+        const source = getSourceText(input);
+        if (input.name === 'ngbAccordion') {
+            continue;
+        }
+        if (input.name === 'destroyOnHide') {
+            attributes.push({
+                start: input.sourceSpan.start.offset,
+                text: renameAttributeSource(source, 'destroyOnHide', 'itemDestroyOnHide')
+            });
+            continue;
+        }
+        if (input.name === 'animation') {
+            attributes.push({
+                start: input.sourceSpan.start.offset,
+                text: renameAttributeSource(source, 'animation', 'animated')
+            });
+            continue;
+        }
+        attributes.push({ start: input.sourceSpan.start.offset, text: source });
+    }
+    for (const output of host.outputs) {
+        const source = getSourceText(output);
+        if (output.name === 'show') {
+            attributes.push({
+                start: output.sourceSpan.start.offset,
+                text: renderEventSource('itemShown', combineEventHandlers(output, shownOutput))
+            });
+            continue;
+        }
+        if (output.name === 'shown') {
+            if (showOutput) {
+                continue;
+            }
+            attributes.push({
+                start: output.sourceSpan.start.offset,
+                text: renameAttributeSource(source, 'shown', 'itemShown')
+            });
+            continue;
+        }
+        if (output.name === 'hide') {
+            attributes.push({
+                start: output.sourceSpan.start.offset,
+                text: renderEventSource('itemHidden', combineEventHandlers(output, hiddenOutput))
+            });
+            continue;
+        }
+        if (output.name === 'hidden') {
+            if (hideOutput) {
+                continue;
+            }
+            attributes.push({
+                start: output.sourceSpan.start.offset,
+                text: renameAttributeSource(source, 'hidden', 'itemHidden')
+            });
+            continue;
+        }
+        attributes.push({ start: output.sourceSpan.start.offset, text: source });
+    }
+    attributes.push({ start: host.startSourceSpan.end.offset, text: `itemHeadingLevel="${headingLevel}"` });
+    if (classes.includes('df-accordion-sm')) {
+        attributes.push({ start: host.startSourceSpan.end.offset, text: 'size="sm"' });
+    }
+    if (classes.includes('df-accordion-lg')) {
+        attributes.push({ start: host.startSourceSpan.end.offset, text: 'size="lg"' });
+    }
+    if (classes.includes('df-accordion-withsep')) {
+        attributes.push({ start: host.startSourceSpan.end.offset, text: 'separator' });
+    }
+    if (classes.includes('df-accordion-reverse')) {
+        attributes.push({ start: host.startSourceSpan.end.offset, text: 'arrowPosition="start"' });
+    }
+    if (itemResults.some(({ hasNumber }) => hasNumber)) {
+        attributes.push({ start: host.startSourceSpan.end.offset, text: 'addon="number"' });
+    }
+    if (subtitleTypes.length > 0) {
+        attributes.push({
+            start: host.startSourceSpan.end.offset,
+            text: `subtitleType="${subtitleTypes.includes('block') ? 'block' : 'inline'}"`
+        });
+    }
+    return attributes;
+}
+function getExpression(attribute) {
+    return attribute.valueSpan?.toString() ?? '';
+}
+function getVisibleAttribute(input, todos) {
+    const expression = getExpression(input).trim();
+    if (expression === 'false') {
+        return 'visible="true"';
+    }
+    if (expression === 'true') {
+        return 'visible="false"';
+    }
+    todos.push({
+        code: 'accordion.dynamic-collapsed',
+        message: 'Dynamic collapsed state was inverted to visible. Verify the expression still matches the intended state.'
+    });
+    return `[visible]="!(${expression})"`;
+}
+function getStaticVisibleAttribute(attribute, todos) {
+    if (attribute.value === 'false') {
+        return 'visible="true"';
+    }
+    if (attribute.value === 'true') {
+        return 'visible="false"';
+    }
+    todos.push({
+        code: 'accordion.dynamic-collapsed',
+        marker: 'human',
+        message: 'Static collapsed value was not a boolean literal. Verify the migrated visible input manually.'
+    });
+    return renameAttributeSource(getSourceText(attribute), 'collapsed', 'visible');
+}
+function getItemAttributes(item, todos) {
+    const attributes = [];
+    for (const reference of item.references) {
+        if (reference.value === 'ngbAccordionItem') {
+            todos.push({
+                code: 'accordion.programmatic-api',
+                marker: 'human',
+                message: 'Item template reference export was removed. Verify programmatic calls because the new API returns promises.'
+            });
+            attributes.push({ start: reference.sourceSpan.start.offset, text: `#${reference.name}` });
+        }
+        else {
+            attributes.push({ start: reference.sourceSpan.start.offset, text: getSourceText(reference) });
+        }
+    }
+    for (const attribute of item.attributes) {
+        if (attribute.name === 'ngbAccordionItem') {
+            if (attribute.value) {
+                attributes.push({
+                    start: attribute.sourceSpan.start.offset,
+                    text: renameAttributeSource(getSourceText(attribute), 'ngbAccordionItem', 'id')
+                });
+            }
+            continue;
+        }
+        if (attribute.name === 'collapsed') {
+            attributes.push({ start: attribute.sourceSpan.start.offset, text: getStaticVisibleAttribute(attribute, todos) });
+            continue;
+        }
+        if (attribute.name === 'class') {
+            todos.push({
+                code: 'accordion.custom-classes',
+                message: 'Custom accordion item classes were preserved. Verify that they still target the new DOM structure.'
+            });
+        }
+        attributes.push({ start: attribute.sourceSpan.start.offset, text: getSourceText(attribute) });
+    }
+    for (const input of item.inputs) {
+        const source = getSourceText(input);
+        if (input.name === 'ngbAccordionItem') {
+            attributes.push({
+                start: input.sourceSpan.start.offset,
+                text: renameAttributeSource(source, 'ngbAccordionItem', 'id')
+            });
+            continue;
+        }
+        if (input.name === 'collapsed') {
+            attributes.push({ start: input.sourceSpan.start.offset, text: getVisibleAttribute(input, todos) });
+            continue;
+        }
+        attributes.push({ start: input.sourceSpan.start.offset, text: source });
+    }
+    for (const output of item.outputs) {
+        const source = getSourceText(output);
+        if (output.name === 'show') {
+            todos.push({
+                code: 'accordion.pre-event',
+                marker: 'human',
+                message: 'Legacy show pre-event was mapped to shown. Verify the behavior because the new output fires after expansion.'
+            });
+            attributes.push({ start: output.sourceSpan.start.offset, text: renameAttributeSource(source, 'show', 'shown') });
+            continue;
+        }
+        if (output.name === 'hide') {
+            todos.push({
+                code: 'accordion.pre-event',
+                marker: 'human',
+                message: 'Legacy hide pre-event was mapped to hidden. Verify the behavior because the new output fires after collapse.'
+            });
+            attributes.push({ start: output.sourceSpan.start.offset, text: renameAttributeSource(source, 'hide', 'hidden') });
+            continue;
+        }
+        attributes.push({ start: output.sourceSpan.start.offset, text: source });
+    }
+    return attributes;
+}
+function unwrapBodyTemplate(source) {
+    const trimmed = source.trim();
+    const match = /^<ng-template\s*>([\s\S]*)<\/ng-template>$/.exec(trimmed);
+    return match ? match[1] : source;
+}
+function indentContent(content, indentation) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => (line.trim() ? `${indentation}${line.trimEnd()}` : line))
+        .join('\n');
+}
+function renderTemplateBlock(attribute, content, itemIndent, extraAttributes = '') {
+    const trimmed = content.trim();
+    const attributes = `${attribute}${extraAttributes ? ` ${extraAttributes}` : ''}`;
+    if (!trimmed.includes('\n')) {
+        return `${itemIndent}  <ng-template ${attributes}>${trimmed}</ng-template>`;
+    }
+    return `${itemIndent}  <ng-template ${attributes}>\n${indentContent(trimmed, `${itemIndent}    `)}\n${itemIndent}  </ng-template>`;
+}
+function getTitleTemplateAttributes(button) {
+    return button.attributes
+        .filter((attribute) => attribute.name.startsWith('i18n'))
+        .map(getSourceText)
+        .join(' ');
+}
+function escapeAttributeValue(value) {
+    return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
+function renderAccordionItem(item, parts) {
+    const todos = [];
+    const content = item.sourceSpan.start.file.content;
+    const itemIndent = getLineIndent(content, item.sourceSpan.start.offset);
+    const itemAttributes = getItemAttributes(item, todos);
+    const title = (0, template_edits_1.getElementInnerSource)(parts.titleButton);
+    const migratedTitle = (0, title_content_1.migrateTitleContent)(title, parts.titleButton);
+    const body = unwrapBodyTemplate((0, template_edits_1.getElementInnerSource)(parts.body));
+    if (!migratedTitle.subtitle && migratedTitle.hasRemainingLegacySubtitle) {
+        todos.push({
+            code: 'accordion.subtitle',
+            marker: 'human',
+            message: 'Legacy .df-subtitle markup was preserved because the subtitle content is complex. Convert it to the item subtitle input manually.'
+        });
+    }
+    if (migratedTitle.number) {
+        itemAttributes.push({
+            start: item.startSourceSpan.end.offset,
+            text: `number="${escapeAttributeValue(migratedTitle.number)}"`
+        });
+    }
+    if (migratedTitle.subtitle) {
+        itemAttributes.push({
+            start: item.startSourceSpan.end.offset,
+            text: `subtitle="${escapeAttributeValue(migratedTitle.subtitle)}"`
+        });
+    }
+    const titleTemplate = renderTemplateBlock('dfAccordionItemTitle', migratedTitle.title, itemIndent, getTitleTemplateAttributes(parts.titleButton));
+    const bodyTemplate = renderTemplateBlock('dfAccordionItemBody', body, itemIndent);
+    const renderedItemAttributes = renderAttributes(itemAttributes);
+    return {
+        text: `<df-accordion-item${renderedItemAttributes ? ` ${renderedItemAttributes}` : ''}>\n${titleTemplate}\n${bodyTemplate}\n${itemIndent}</df-accordion-item>`,
+        todos,
+        hasNumber: !!migratedTitle.number,
+        subtitleType: migratedTitle.subtitleType
+    };
+}
+function migrateAccordionTemplate(template) {
+    const edits = [];
+    const standaloneImports = [];
+    const matches = getAccordionMatches(template);
+    const hostMatches = matches.filter(({ element }) => isLegacyAccordionHost(element));
+    const itemMatches = matches.filter(({ element }) => isLegacyAccordionItem(element));
+    for (const hostMatch of hostMatches) {
+        const hostItems = itemMatches.filter((itemMatch) => getNearestAccordionHost(itemMatch) === hostMatch.element);
+        const itemParts = hostItems.map(({ element }) => getItemParts(element));
+        const hardStopTodos = getHardStopHostTodos(hostMatch.element, itemParts);
+        if (hardStopTodos.length > 0) {
+            (0, todo_comments_1.editTemplateTodos)(hostMatch.element, hardStopTodos, edits);
+            continue;
+        }
+        const canonicalItemParts = itemParts;
+        const itemResults = hostItems.map(({ element }, index) => renderAccordionItem(element, canonicalItemParts[index]));
+        const hostTodos = getHostTodos(hostMatch.element, canonicalItemParts);
+        const headingLevel = getHostHeadingLevel(canonicalItemParts, hostTodos);
+        const hostAttributes = getHostAttributes(hostMatch.element, headingLevel, itemResults);
+        (0, todo_comments_1.editTemplateTodos)(hostMatch.element, hostTodos, edits);
+        edits.push(replaceStartTag(hostMatch.element, 'df-accordion', hostAttributes));
+        const endTagEdit = editEndTagName(hostMatch.element, 'df-accordion');
+        if (endTagEdit) {
+            edits.push(endTagEdit);
+        }
+        for (const [index, itemMatch] of hostItems.entries()) {
+            const result = itemResults[index];
+            (0, todo_comments_1.editTemplateTodos)(itemMatch.element, result.todos, edits);
+            edits.push((0, template_edits_1.replaceElement)(itemMatch.element, result.text));
+        }
+        standaloneImports.push(...constants_1.ACCORDION_IMPORTS);
+    }
+    return (0, template_result_1.createTemplateMigrationResult)(template, edits, standaloneImports);
+}
+function countLegacyAccordionUsages(template) {
+    return getAccordionMatches(template).filter(({ element }) => isLegacyAccordionHost(element)).length;
+}

package/schematics/component-migration/accordion/steps/title-content.d.ts

@@ -0,0 +1,9 @@
+import { TmplAstElement } from '@angular/compiler';
+export interface MigratedTitleContent {
+    title: string;
+    number: string | null;
+    subtitle: string | null;
+    subtitleType: 'inline' | 'block' | null;
+    hasRemainingLegacySubtitle: boolean;
+}
+export declare function migrateTitleContent(title: string, button: TmplAstElement): MigratedTitleContent;

package/schematics/component-migration/accordion/steps/title-content.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateTitleContent = migrateTitleContent;
+const compiler_1 = require("@angular/compiler");
+const SIMPLE_LEGACY_TITLE_CLASSES = new Set(['flex-grow-1', 'd-flex', 'align-items-center', 'mb-2']);
+function getDirectChildElements(element) {
+    return element.children.filter((child) => child instanceof compiler_1.TmplAstElement);
+}
+function hasStaticClass(element, className) {
+    return element.attributes.some((attribute) => attribute.name === 'class' && attribute.value.split(/\s+/).includes(className));
+}
+function hasDirectLegacySubtitle(button) {
+    return getDirectChildElements(button).some((element) => hasStaticClass(element, 'df-subtitle'));
+}
+function extractLegacyTitlePart(source, className) {
+    const pattern = new RegExp(`<(?<tag>[a-zA-Z][\\w:-]*)\\b(?<attributes>[^>]*)class=["'][^"']*\\b${className}\\b[^"']*["'][^>]*>(?<content>[\\s\\S]*?)<\\/\\k<tag>>`);
+    const match = pattern.exec(source);
+    const groups = match?.groups;
+    if (!match || !groups || /<[^>]+>/.test(groups['content'])) {
+        return null;
+    }
+    return {
+        content: groups['content'].trim(),
+        source: source.slice(0, match.index) + source.slice(match.index + match[0].length)
+    };
+}
+function simplifyLegacyTitleMarkup(title) {
+    const trimmed = title.trim();
+    if (!trimmed.includes('<')) {
+        return trimmed;
+    }
+    for (const match of trimmed.matchAll(/<(?<closing>\/?)(?<tag>[a-zA-Z][\w:-]*)(?<attributes>[^>]*)>/g)) {
+        const groups = match.groups;
+        if (!groups || groups['closing']) {
+            continue;
+        }
+        if (groups['tag'] !== 'div' && groups['tag'] !== 'span') {
+            return title;
+        }
+        const attributes = groups['attributes'].trim();
+        const classMatch = /^class=["']([^"']*)["']$/.exec(attributes);
+        if (attributes && !classMatch) {
+            return title;
+        }
+        const classes = classMatch?.[1].split(/\s+/).filter(Boolean) ?? [];
+        if (classes.some((className) => !SIMPLE_LEGACY_TITLE_CLASSES.has(className))) {
+            return title;
+        }
+    }
+    const text = trimmed
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return text || title;
+}
+function migrateTitleContent(title, button) {
+    let migratedTitle = title;
+    const numberMatch = extractLegacyTitlePart(migratedTitle, 'df-accordion-number');
+    const number = numberMatch?.content.replace(/\.$/, '').trim() || null;
+    if (numberMatch) {
+        migratedTitle = numberMatch.source;
+    }
+    const subtitleMatch = extractLegacyTitlePart(migratedTitle, 'df-subtitle');
+    const subtitle = subtitleMatch?.content || null;
+    if (subtitleMatch) {
+        migratedTitle = subtitleMatch.source;
+    }
+    return {
+        title: number || subtitle ? simplifyLegacyTitleMarkup(migratedTitle) : migratedTitle,
+        number,
+        subtitle,
+        subtitleType: subtitle ? (hasDirectLegacySubtitle(button) ? 'inline' : 'block') : null,
+        hasRemainingLegacySubtitle: /\bclass\s*=\s*["'][^"']*\bdf-subtitle\b/.test(migratedTitle)
+    };
+}