@seniorsistemas/angular-components 19.9.15-develop-11ab86f5 → 19.9.15

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

@@ -1,661 +0,0 @@
-"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