@seniorsistemas/angular-components 19.9.15 → 19.10.0-develop-ef29acb7

package/schematics/migrations/migrate-deprecated-dynamic-form/index.js

@@ -0,0 +1,661 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITEM_ID = void 0;
+exports.migrateFieldTypesInContent = migrateFieldTypesInContent;
+exports.migrateFieldsBindingsInContent = migrateFieldsBindingsInContent;
+exports.migrateDeprecatedDynamicForm = migrateDeprecatedDynamicForm;
+exports.migrate = migrate;
+const ts = require("typescript");
+const ast_utils_1 = require("../../utils/ast-utils");
+const symbol_utils_1 = require("../../utils/symbol-utils");
+const report_1 = require("../../utils/report");
+const scope_1 = require("../../utils/scope");
+const eol_1 = require("../../utils/eol");
+exports.ITEM_ID = 'dynamic-form';
+const PKG = '@seniorsistemas/angular-components';
+const DYNAMIC_FORM = `${PKG}/dynamic-form`;
+const CALENDAR_TYPES = new Set(['date', 'dateTime', 'localDateTime', 'time']);
+const MEMO_METHOD = 'dynamicTypeToConfigs';
+const MEMO_CACHE = 'dynamicTypeToConfigsCache';
+const MAX_PASSES = 25;
+// ─── Utilitários de AST ───────────────────────────────────────────────────────
+function parse(content) {
+    return ts.createSourceFile('_dynamic-form.ts', content, ts.ScriptTarget.Latest, true);
+}
+function elementName(el) {
+    const name = el.name;
+    if (!name)
+        return undefined;
+    return ts.isIdentifier(name) || ts.isStringLiteralLike(name) ? name.text : undefined;
+}
+function findElement(o, name) {
+    return o.properties.find((p) => elementName(p) === name);
+}
+function literalType(o, sf) {
+    const el = findElement(o, 'type');
+    if (!el || !ts.isPropertyAssignment(el) || !ts.isStringLiteralLike(el.initializer))
+        return undefined;
+    return {
+        el,
+        value: el.initializer.text,
+        quote: el.initializer.getText(sf)[0] === '"' ? '"' : "'",
+        key: el.name.getText(sf),
+    };
+}
+function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((m) => m.kind === kind);
+}
+function decoratorNames(node) {
+    if (!ts.canHaveDecorators(node))
+        return [];
+    return (ts.getDecorators(node) ?? []).map((d) => {
+        const expr = ts.isCallExpression(d.expression) ? d.expression.expression : d.expression;
+        return ts.isIdentifier(expr) ? expr.text : '';
+    });
+}
+function lineIndent(content, pos) {
+    const lineStart = content.lastIndexOf('\n', pos - 1) + 1;
+    return /^[ \t]*/.exec(content.slice(lineStart, pos))?.[0] ?? '';
+}
+/** Indentação da linha quando o nó é o primeiro item dela, senão `undefined`. */
+function ownLineIndent(content, pos) {
+    const lineStart = content.lastIndexOf('\n', pos - 1) + 1;
+    const prefix = content.slice(lineStart, pos);
+    return /^[ \t]*$/.test(prefix) ? prefix : undefined;
+}
+function removeUnusedImport(content, name) {
+    const sf = parse(content);
+    let uses = 0;
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node) && node.text === name)
+            uses++;
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    if (uses > 0)
+        return content;
+    const { changes } = (0, ast_utils_1.buildRemoveNamedImportsChanges)(sf, [name], PKG);
+    return changes.length > 0 ? (0, ast_utils_1.applyChanges)(content, (0, symbol_utils_1.consumeRemovedLineBreaks)(content, changes)) : content;
+}
+function rebuildObject(content, sf, o, edit) {
+    const props = [...o.properties];
+    const removed = new Set(edit.remove ?? []);
+    const multiline = content.slice(o.getStart(sf), o.getEnd()).includes('\n');
+    let indent = lineIndent(content, o.getStart(sf)) + '    ';
+    for (const p of [...props].reverse()) {
+        const own = ownLineIndent(content, p.getStart(sf));
+        if (own !== undefined) {
+            indent = own;
+            break;
+        }
+    }
+    const parts = [];
+    for (const p of props) {
+        if (removed.has(p))
+            continue;
+        const text = edit.replace?.get(p) ?? content.slice(p.getStart(sf), p.getEnd());
+        const lead = content.slice(p.getFullStart(), p.getStart(sf)).trim();
+        const hasComment = lead.startsWith('//') || lead.startsWith('/*');
+        parts.push(hasComment ? `${lead}\n${indent}${text}` : text);
+    }
+    parts.push(...(edit.append ?? []));
+    if (props.length === 0 || parts.length === 0) {
+        return {
+            start: o.getStart(sf),
+            end: o.getEnd(),
+            replacement: parts.length === 0 ? '{}' : `{ ${parts.join(', ')} }`,
+        };
+    }
+    return {
+        start: props[0].getStart(sf),
+        end: props[props.length - 1].getEnd(),
+        replacement: parts.join(multiline ? `,\n${indent}` : ', '),
+    };
+}
+function applyObjectPass(content, handler, manual) {
+    let current = content;
+    for (let i = 0; i < MAX_PASSES; i++) {
+        const sf = parse(current);
+        const changes = [];
+        const imports = [];
+        const ctx = { sf, content: current };
+        const visit = (node) => {
+            if (ts.isObjectLiteralExpression(node)) {
+                const edit = handler(node, ctx);
+                if (edit) {
+                    changes.push(rebuildObject(current, sf, node, edit), ...(edit.outer ?? []));
+                    imports.push(...(edit.imports ?? []));
+                    const line = (0, report_1.lineOf)(current, node.getStart(sf));
+                    for (const message of edit.manual ?? [])
+                        manual.push({ line, message, target: 'code' });
+                    return;
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sf);
+        if (changes.length === 0)
+            break;
+        current = (0, ast_utils_1.applyChanges)(current, changes);
+        for (const { name, from } of imports)
+            current = (0, ast_utils_1.ensureNamedImport)(current, name, from);
+    }
+    return current;
+}
+// ─── integer -> number, textAreaIA, calendário, priority, appendTo ────────────
+const integerHandler = (o, ctx) => {
+    const t = literalType(o, ctx.sf);
+    if (!t || t.value !== 'integer')
+        return undefined;
+    const edit = {
+        replace: new Map([[t.el, `${t.key}: ${t.quote}number${t.quote}`]]),
+        append: [],
+    };
+    if (!findElement(o, 'scale'))
+        edit.append.push('scale: 0');
+    for (const flag of ['allowNegative', 'autoClear']) {
+        const el = findElement(o, flag);
+        if (!el) {
+            edit.append.push(`${flag}: false`);
+        }
+        else if (ts.isPropertyAssignment(el)) {
+            edit.replace.set(el, `${el.name.getText(ctx.sf)}: false`);
+        }
+    }
+    return edit;
+};
+const textAreaIaHandler = (o, ctx) => {
+    const t = literalType(o, ctx.sf);
+    if (!t || t.value !== 'textAreaIA')
+        return undefined;
+    return { replace: new Map([[t.el, `${t.key}: ${t.quote}contentGenerator${t.quote}`]]) };
+};
+function localeOptionsLiteral(init) {
+    if (ts.isObjectLiteralExpression(init))
+        return init;
+    if ((ts.isNewExpression(init) || ts.isCallExpression(init)) && init.arguments?.length) {
+        const [arg] = init.arguments;
+        if (ts.isObjectLiteralExpression(arg))
+            return arg;
+    }
+    return undefined;
+}
+const calendarLocaleHandler = (o, ctx) => {
+    const el = findElement(o, 'calendarLocaleOptions');
+    if (!el || !ts.isPropertyAssignment(el))
+        return undefined;
+    const literal = localeOptionsLiteral(el.initializer);
+    if (!literal)
+        return undefined;
+    const edit = { remove: [el], append: [] };
+    for (const name of ['dateFormat', 'hourFormat']) {
+        const inner = findElement(literal, name);
+        if (inner && !findElement(o, name)) {
+            edit.append.push(ctx.content.slice(inner.getStart(ctx.sf), inner.getEnd()));
+        }
+    }
+    return edit;
+};
+const priorityHandler = (o, ctx) => {
+    const parent = o.parent;
+    if (!ts.isPropertyAssignment(parent))
+        return undefined;
+    const parentName = elementName(parent);
+    if (parentName !== 'leftAddon' && parentName !== 'rightAddon')
+        return undefined;
+    const el = findElement(o, 'priority');
+    return el ? { remove: [el] } : undefined;
+};
+const appendToHandler = (o, ctx) => {
+    const t = literalType(o, ctx.sf);
+    if (!t || !CALENDAR_TYPES.has(t.value))
+        return undefined;
+    const el = findElement(o, 'appendTo');
+    return el ? { remove: [el] } : undefined;
+};
+/** `numberLocaleOptions` não tem mais efeito; `legacyNumber` fica de fora (não é migrado). */
+const numberLocaleOptionsHandler = (o, ctx) => {
+    const t = literalType(o, ctx.sf);
+    if (!t || t.value === 'legacyNumber')
+        return undefined;
+    const el = findElement(o, 'numberLocaleOptions');
+    return el ? { remove: [el] } : undefined;
+};
+// ─── Tipos CurrencyFieldConfig / NumberFieldConfig -> BignumberFieldConfig ────
+function renameConfigTypes(content) {
+    // CurrencyFieldConfig não é renomeada: 'money' é um tipo estável, não migrado.
+    // NumberFieldConfig continua válido para legacyNumber: só troca quando o arquivo não o usa.
+    const names = [];
+    if (!content.includes('legacyNumber'))
+        names.push('NumberFieldConfig');
+    const sf = parse(content);
+    const { changes, removedNames } = (0, ast_utils_1.buildRemoveNamedImportsChanges)(sf, names, DYNAMIC_FORM);
+    if (removedNames.length === 0)
+        return content;
+    const renamed = new Set(removedNames);
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node) && renamed.has(node.text)) {
+            const parent = node.parent;
+            const isTypePosition = (ts.isTypeReferenceNode(parent) && parent.typeName === node) ||
+                (ts.isExpressionWithTypeArguments(parent) && parent.expression === node);
+            if (isTypePosition) {
+                changes.push({ start: node.getStart(sf), end: node.getEnd(), replacement: 'BignumberFieldConfig' });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return (0, ast_utils_1.ensureNamedImport)((0, ast_utils_1.applyChanges)(content, changes), 'BignumberFieldConfig', DYNAMIC_FORM);
+}
+// ─── Migração de tipos/propriedades de um arquivo .ts ─────────────────────────
+const TRIGGERS = [
+    'integer',
+    'textAreaIA',
+    'calendarLocaleOptions',
+    'priority',
+    'appendTo',
+    'numberLocaleOptions',
+    'NumberFieldConfig',
+];
+function dedupeManual(entries) {
+    const seen = new Set();
+    return entries.filter((e) => {
+        const key = `${e.line}:${e.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** Parte pura dos tipos de campo e propriedades depreciadas (sem `[fields]` -> `[configs]`). */
+function migrateFieldTypesInContent(content) {
+    if (!content.includes(PKG) || !TRIGGERS.some((t) => content.includes(t))) {
+        return { updated: content, manual: [] };
+    }
+    const manual = [];
+    let updated = content;
+    updated = applyObjectPass(updated, integerHandler, manual);
+    updated = applyObjectPass(updated, textAreaIaHandler, manual);
+    const afterCalendar = applyObjectPass(updated, calendarLocaleHandler, manual);
+    if (afterCalendar !== updated) {
+        updated = removeUnusedImport(afterCalendar, 'CalendarLocaleOptions');
+    }
+    const afterPriority = applyObjectPass(updated, priorityHandler, manual);
+    if (afterPriority !== updated) {
+        updated = removeUnusedImport(afterPriority, 'ButtonPriority');
+    }
+    updated = applyObjectPass(updated, appendToHandler, manual);
+    const afterNumberLocale = applyObjectPass(updated, numberLocaleOptionsHandler, manual);
+    if (afterNumberLocale !== updated) {
+        updated = removeUnusedImport(afterNumberLocale, 'NumberLocaleOptions');
+    }
+    updated = renameConfigTypes(updated);
+    // calendarLocaleOptions que não são literais não podem ser convertidos automaticamente.
+    if (updated.includes('calendarLocaleOptions')) {
+        const sf = parse(updated);
+        const visit = (node) => {
+            if (ts.isPropertyAssignment(node) && elementName(node) === 'calendarLocaleOptions') {
+                manual.push({
+                    line: (0, report_1.lineOf)(updated, node.getStart(sf)),
+                    message: '"calendarLocaleOptions" não é um objeto literal: mova "dateFormat"/"hourFormat" para o campo e remova a propriedade manualmente.',
+                    target: 'code',
+                });
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sf);
+    }
+    return { updated, manual: dedupeManual(manual) };
+}
+// ─── [fields] -> [configs] ────────────────────────────────────────────────────
+const MEMO_MEMBERS = (indent) => [
+    `private readonly ${MEMO_CACHE} = new WeakMap<DynamicType[], DynamicStructure[]>();`,
+    '',
+    `${indent}protected ${MEMO_METHOD}(fields: DynamicType[] | null | undefined): DynamicStructure[] {`,
+    `${indent}    if (!fields) return [];`,
+    `${indent}    let configs = this.${MEMO_CACHE}.get(fields);`,
+    `${indent}    if (!configs) {`,
+    `${indent}        configs = dynamicTypeToDynamicStructure(fields);`,
+    `${indent}        this.${MEMO_CACHE}.set(fields, configs);`,
+    `${indent}    }`,
+    `${indent}    return configs;`,
+    `${indent}}`,
+].join('\n');
+function findComponentClass(sf, requireInlineTemplate) {
+    for (const node of sf.statements) {
+        if (!ts.isClassDeclaration(node))
+            continue;
+        for (const d of ts.getDecorators(node) ?? []) {
+            if (!ts.isCallExpression(d.expression))
+                continue;
+            if (d.expression.expression.getText(sf) !== 'Component')
+                continue;
+            if (!requireInlineTemplate)
+                return node;
+            if (inlineTemplateNode(d.expression))
+                return node;
+        }
+    }
+    return undefined;
+}
+function inlineTemplateNode(call) {
+    const [arg] = call.arguments;
+    if (!arg || !ts.isObjectLiteralExpression(arg))
+        return undefined;
+    const el = findElement(arg, 'template');
+    if (el && ts.isPropertyAssignment(el) && ts.isStringLiteralLike(el.initializer))
+        return el.initializer;
+    return undefined;
+}
+function inlineTemplate(sf) {
+    for (const node of sf.statements) {
+        if (!ts.isClassDeclaration(node))
+            continue;
+        for (const d of ts.getDecorators(node) ?? []) {
+            if (!ts.isCallExpression(d.expression) || d.expression.expression.getText(sf) !== 'Component')
+                continue;
+            const tpl = inlineTemplateNode(d.expression);
+            if (tpl) {
+                const start = tpl.getStart(sf) + 1;
+                const end = tpl.getEnd() - 1;
+                return { start, end, text: sf.text.slice(start, end) };
+            }
+        }
+    }
+    return undefined;
+}
+function analyzeExpression(expr) {
+    const sf = ts.createSourceFile('_expr.ts', `(${expr});`, ts.ScriptTarget.Latest, true);
+    const stmt = sf.statements[0];
+    if (!stmt || !ts.isExpressionStatement(stmt))
+        return { kind: 'other' };
+    let node = stmt.expression;
+    while (ts.isParenthesizedExpression(node))
+        node = node.expression;
+    if (ts.isIdentifier(node))
+        return { kind: 'prop', name: node.text };
+    if (ts.isPropertyAccessExpression(node) && node.expression.kind === ts.SyntaxKind.ThisKeyword) {
+        return { kind: 'prop', name: node.name.text };
+    }
+    return { kind: 'other' };
+}
+function countIdentifierInTemplate(tpl, name) {
+    const escaped = name.replace(/[$]/g, '\\$');
+    // O nome do atributo ([fields]/[configs]) não conta como uso da propriedade.
+    const withoutAttrNames = tpl.replace(/\[(?:fields|configs)\]=/g, '');
+    return (withoutAttrNames.match(new RegExp(`(?<![\\w$.])${escaped}(?![\\w$])`, 'g')) ?? []).length;
+}
+function reindent(text, extra) {
+    return text
+        .split('\n')
+        .map((line, i) => (i === 0 || line.trim() === '' ? line : extra + line))
+        .join('\n');
+}
+/**
+ * Migra `[fields]` para `[configs]` em um componente. `html` é o template externo; sem ele usa o `template:` inline.
+ * Retorna o `.ts` (e o template, quando externo) reescritos e as pendências manuais.
+ */
+function migrateFieldsBindingsInContent(tsContent, html) {
+    const manual = [];
+    const unchanged = { ts: tsContent, html, manual };
+    const sf = parse(tsContent);
+    const inline = html === undefined ? inlineTemplate(sf) : undefined;
+    const tpl = html ?? inline?.text;
+    if (tpl === undefined || !tpl.includes('s-dynamic-form'))
+        return unchanged;
+    const bindingRe = /\[fields\]="([^"]*)"|\[configs\]="([A-Za-z_$][\w$]*)Configs"|\[configs\]="dynamicTypeToConfigs\(/g;
+    const tagRe = /<s-dynamic-form\b[^>]*>/g;
+    if (!tpl.match(tagRe)?.some((tag) => /\[fields\]=|\[configs\]=/.test(tag)))
+        return unchanged;
+    const cls = findComponentClass(sf, html === undefined);
+    if (!cls) {
+        if (/\[fields\]="/.test(tpl)) {
+            manual.push({
+                line: 1,
+                message: 'Classe do componente não encontrada: troque "[fields]" por "[configs]" manualmente (DynamicStructure[]).',
+                target: 'template',
+            });
+        }
+        return { ts: tsContent, html, manual };
+    }
+    const changes = [];
+    const wrapped = new Set();
+    let memoEnsured = false;
+    let needsMemoImports = false;
+    let needsStructureImport = false;
+    const indent = cls.members[0] ? lineIndent(tsContent, cls.members[0].getStart(sf)) : '    ';
+    const ensureMemo = () => {
+        needsMemoImports = true;
+        if (memoEnsured)
+            return false;
+        memoEnsured = true;
+        const existing = cls.members.find((m) => ts.isMethodDeclaration(m) && ts.isIdentifier(m.name) && m.name.text === MEMO_METHOD);
+        if (existing) {
+            if (cls.getText(sf).includes(MEMO_CACHE))
+                return false;
+            changes.push({
+                start: existing.getStart(sf),
+                end: existing.getEnd(),
+                replacement: MEMO_MEMBERS(indent),
+            });
+            return true;
+        }
+        const insertAt = cls.getEnd() - 1;
+        changes.push({
+            start: insertAt,
+            end: insertAt,
+            replacement: `\n${indent}${MEMO_MEMBERS(indent)}\n`,
+        });
+        return true;
+    };
+    /**
+     * Escolhe entre as duas estratégias de migração de `[fields]`/getter `*Configs` para `[configs]`:
+     *
+     * - **Reescrever na origem** (preferida): converte o próprio array para `DynamicStructure[]`
+     *   (`[{ type: 'row', fields: [...] }]`), remove o getter e liga `[configs]` direto na propriedade. Só é seguro
+     *   quando a propriedade é um array **literal**, não é `static`/`declare`/`@Input()`, **não é referenciada em
+     *   nenhum outro ponto da classe** (`this.x`) e aparece uma única vez no template: aí ninguém mais depende do
+     *   formato `DynamicType[]`.
+     * - **Memoizar** (fallback, `false` aqui): mantém o array como está e passa a converter via `dynamicTypeToConfigs`,
+     *   que memoiza por referência do array (`WeakMap`). Gera aviso manual: quem mutar o array no lugar
+     *   (`push`/`splice`) precisa reatribuí-lo para o formulário atualizar.
+     */
+    const tryWrapAtOrigin = (name, getter) => {
+        const member = cls.members.find((m) => ts.isPropertyDeclaration(m) && ts.isIdentifier(m.name) && m.name.text === name);
+        if (!member || !member.initializer || !ts.isArrayLiteralExpression(member.initializer))
+            return false;
+        if (hasModifier(member, ts.SyntaxKind.StaticKeyword) || hasModifier(member, ts.SyntaxKind.DeclareKeyword)) {
+            return false;
+        }
+        if (decoratorNames(member).includes('Input'))
+            return false;
+        let references = 0;
+        const visit = (node) => {
+            if (node === member || node === getter)
+                return;
+            if (ts.isPropertyAccessExpression(node) &&
+                node.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                node.name.text === name) {
+                references++;
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(cls);
+        if (references > 0)
+            return false;
+        if (wrapped.has(name))
+            return true;
+        wrapped.add(name);
+        needsStructureImport = true;
+        const arr = member.initializer;
+        const original = arr.getText(sf);
+        const base = lineIndent(tsContent, member.getStart(sf));
+        const step = '    ';
+        const replacement = original.includes('\n')
+            ? `[\n${base}${step}{\n${base}${step}${step}type: 'row',\n${base}${step}${step}fields: ${reindent(original, step + step)},\n${base}${step}},\n${base}]`
+            : `[{ type: 'row', fields: ${original} }]`;
+        changes.push({ start: arr.getStart(sf), end: arr.getEnd(), replacement });
+        if (member.type) {
+            changes.push({ start: member.type.getStart(sf), end: member.type.getEnd(), replacement: 'DynamicStructure[]' });
+        }
+        else {
+            const anchor = member.questionToken ?? member.exclamationToken ?? member.name;
+            changes.push({ start: anchor.getEnd(), end: anchor.getEnd(), replacement: ': DynamicStructure[]' });
+        }
+        if (getter) {
+            changes.push({ start: getter.getFullStart(), end: getter.getEnd(), replacement: '' });
+        }
+        return true;
+    };
+    const newTpl = tpl.replace(tagRe, (tag, tagOffset) => tag.replace(bindingRe, (match, fieldsExpr, getterProp, offset) => {
+        const line = (0, report_1.lineOf)(tpl, tagOffset + (offset ?? 0));
+        if (fieldsExpr !== undefined) {
+            const info = analyzeExpression(fieldsExpr);
+            if (info.kind === 'prop' && countIdentifierInTemplate(tpl, info.name) === 1) {
+                if (tryWrapAtOrigin(info.name, undefined))
+                    return `[configs]="${info.name}"`;
+            }
+            ensureMemo();
+            manual.push({
+                line,
+                target: 'template',
+                message: `"[fields]" migrado para "[configs]" via "${MEMO_METHOD}(...)", que memoiza por referência do array: se "${fieldsExpr}" for mutado no lugar (push/splice), reatribua o array para atualizar o formulário.`,
+            });
+            return `[configs]="${MEMO_METHOD}(${fieldsExpr})"`;
+        }
+        if (getterProp !== undefined) {
+            const getterName = `${getterProp}Configs`;
+            const getter = cls.members.find((m) => ts.isGetAccessorDeclaration(m) && ts.isIdentifier(m.name) && m.name.text === getterName);
+            const body = getter?.body?.getText(sf) ?? '';
+            const source = /^\{\s*return\s+dynamicTypeToDynamicStructure\(\s*this\.([\w$]+)\s*\)\s*;?\s*\}$/.exec(body);
+            if (!getter || !source)
+                return match;
+            const prop = source[1];
+            if (countIdentifierInTemplate(tpl, getterName) === 1 && countIdentifierInTemplate(tpl, prop) === 0) {
+                if (tryWrapAtOrigin(prop, getter))
+                    return `[configs]="${prop}"`;
+            }
+            ensureMemo();
+            changes.push({
+                start: getter.body.getStart(sf),
+                end: getter.body.getEnd(),
+                replacement: `{\n${indent}${indent}return this.${MEMO_METHOD}(this.${prop});\n${indent}}`,
+            });
+            manual.push({
+                line: (0, report_1.lineOf)(tsContent, getter.getStart(sf)),
+                target: 'code',
+                message: `O getter "${getterName}" agora memoiza o resultado por referência de "${prop}": se o array for mutado no lugar (push/splice), reatribua-o para atualizar o formulário.`,
+            });
+            return match;
+        }
+        // [configs]="dynamicTypeToConfigs(expr)" gerado pelo v19: só garante a memoização do método.
+        if (ensureMemo()) {
+            manual.push({
+                line,
+                target: 'template',
+                message: `O método "${MEMO_METHOD}" agora memoiza por referência do array: se ele for mutado no lugar (push/splice), reatribua o array para atualizar o formulário.`,
+            });
+        }
+        return match;
+    }));
+    if (changes.length === 0 && newTpl === tpl)
+        return { ts: tsContent, html, manual: [] };
+    if (inline && newTpl !== tpl) {
+        changes.push({ start: inline.start, end: inline.end, replacement: newTpl });
+    }
+    let updatedTs = changes.length > 0 ? (0, ast_utils_1.applyChanges)(tsContent, changes) : tsContent;
+    if (needsMemoImports) {
+        for (const name of ['DynamicType', 'DynamicStructure', 'dynamicTypeToDynamicStructure']) {
+            updatedTs = (0, ast_utils_1.ensureNamedImport)(updatedTs, name, DYNAMIC_FORM);
+        }
+    }
+    else if (needsStructureImport) {
+        updatedTs = (0, ast_utils_1.ensureNamedImport)(updatedTs, 'DynamicStructure', DYNAMIC_FORM);
+    }
+    if (wrapped.size > 0) {
+        // O getter `*Configs` (que chamava `dynamicTypeToDynamicStructure`) e o tipo do array saem da classe:
+        // limpa o que deixou de ser referenciado.
+        for (const name of ['DynamicType', 'ExpandedDynamicType', 'dynamicTypeToDynamicStructure']) {
+            updatedTs = removeUnusedImport(updatedTs, name);
+        }
+    }
+    return { ts: updatedTs, html: html === undefined ? undefined : newTpl, manual };
+}
+// ─── Rule ─────────────────────────────────────────────────────────────────────
+function migrateDeprecatedDynamicForm(options, report) {
+    return (tree, context) => {
+        const tsFiles = [];
+        const htmlFiles = [];
+        (0, scope_1.visitScopedFiles)(tree, options, context, (path) => {
+            if (path.includes('/dist/') || path.endsWith('.d.ts'))
+                return;
+            if (path.endsWith('.ts'))
+                tsFiles.push(path);
+            else if (path.endsWith('.html'))
+                htmlFiles.push(path);
+        });
+        const changed = new Set();
+        const write = (path, content, updated) => {
+            if (updated === content)
+                return;
+            tree.overwrite(path, (0, eol_1.preserveLineEndings)(content, updated));
+            changed.add(path);
+        };
+        // 1) Tipos de campo e propriedades depreciadas.
+        for (const path of tsFiles) {
+            const content = tree.readText(path);
+            const result = migrateFieldTypesInContent(content);
+            write(path, content, result.updated);
+            for (const m of result.manual) {
+                report.addManual(exports.ITEM_ID, { file: path, line: m.line, message: m.message }, context);
+            }
+        }
+        // 2) [fields] -> [configs] em templates inline.
+        for (const path of tsFiles) {
+            const content = tree.readText(path);
+            if (!content.includes('s-dynamic-form'))
+                continue;
+            const result = migrateFieldsBindingsInContent(content);
+            write(path, content, result.ts);
+            for (const m of result.manual) {
+                report.addManual(exports.ITEM_ID, { file: path, line: m.line, message: m.message }, context);
+            }
+        }
+        // 3) [fields] -> [configs] em templates externos (pareados com o .ts de mesmo nome).
+        for (const htmlPath of htmlFiles) {
+            const html = tree.readText(htmlPath);
+            if (!html.includes('s-dynamic-form'))
+                continue;
+            if (!html.includes('[fields]') && !html.includes('[configs]'))
+                continue;
+            const tsPath = htmlPath.replace(/\.html$/, '.ts');
+            if (!tree.exists(tsPath)) {
+                if (html.includes('[fields]')) {
+                    report.addManual(exports.ITEM_ID, {
+                        file: htmlPath,
+                        message: `Não foi possível encontrar ${tsPath.replace(/^\//, '')}: troque "[fields]" por "[configs]" manualmente (DynamicStructure[]).`,
+                    }, context);
+                }
+                continue;
+            }
+            const tsContent = tree.readText(tsPath);
+            const result = migrateFieldsBindingsInContent(tsContent, html);
+            write(tsPath, tsContent, result.ts);
+            if (result.html !== undefined)
+                write(htmlPath, html, result.html);
+            for (const m of result.manual) {
+                report.addManual(exports.ITEM_ID, { file: m.target === 'template' ? htmlPath : tsPath, line: m.line, message: m.message }, context);
+            }
+        }
+        for (const path of changed)
+            report.markChanged(exports.ITEM_ID, path);
+    };
+}
+function migrate(options = {}) {
+    return migrateDeprecatedDynamicForm(options, new report_1.MigrationReport());
+}
+//# sourceMappingURL=index.js.map