@seniorsistemas/angular-components 19.9.15 → 19.10.0

package/schematics/migrations/migrate-deprecated-apis/index.js

@@ -0,0 +1,660 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITEM_ID = void 0;
+exports.migrateTemplateText = migrateTemplateText;
+exports.migrateApisInContent = migrateApisInContent;
+exports.migrateDeprecatedApis = migrateDeprecatedApis;
+exports.migrate = migrate;
+const path = require("path");
+const ts = require("typescript");
+const ast_utils_1 = require("../../utils/ast-utils");
+const report_1 = require("../../utils/report");
+const scope_1 = require("../../utils/scope");
+const symbol_utils_1 = require("../../utils/symbol-utils");
+const template_utils_1 = require("../../utils/template-utils");
+const eol_1 = require("../../utils/eol");
+/**
+ * Migra APIs depreciadas que têm substituto direto (renomeios mecânicos), sempre restritas ao elemento
+ * ou símbolo correto, e avisa (`addManual`) onde a conversão é ambígua.
+ *
+ * Templates (HTML e `template:` inline): usa o scanner de tags de `template-utils` (nunca uma regex solta sobre o arquivo),
+ * então `(onCodeChange)` só muda em `<s-code-editor>`, `[scale]` só em `<input sBignumberInput|sNumberInput>`, etc.
+ *
+ * Decisões:
+ * - `sNumberInput`/`sBignumberInput`/`sLocalizedNumberInput` (e as respectivas `*Directive`/`*Module`) -> `sNumericMask`/
+ *   `NumericMaskDirective`. Os defaults das diretivas antigas diferem da `sNumericMask`, então são gravados de forma
+ *   explícita no template para preservar o comportamento: `[precision]="15"`, `[allowNegative]="true"`,
+ *   `[blockDecimalOverflow]="false"` e `[minDecimalPlaces]`/`[maxDecimalPlaces]` (a partir de `[scale]`, ou `0`).
+ *   Na `sLocalizedNumberInput`, `precision` (casas decimais) vira `maxDecimalPlaces` e sempre há aviso de revisão,
+ *   porque o valor do `FormControl` passa a ser `string` e o erro `invalidNumber` deixa de existir.
+ * - `NumberAlignmentOption.X`/`BignumberAlignmentOption.X` -> `'left'`/`'right'` (o enum não tem mais efeito).
+ * - `localizedCurrency` -> `localizedBignumber` (mesmos defaults: scale 2 e símbolo do locale; só a chave `currencySymbol`
+ *   vira `prefix`; `emptyAsZero: true` preserva a exibição de string vazia como 0); `localizedCurrencyImpure` ->
+ *   `localizedBignumberImpure` (preserva a detecção de mudança impura).
+ *   Argumento que não seja um objeto literal com chaves conhecidas -> aviso, sem reescrever.
+ * - `localizedNumber` usava `Intl.NumberFormat` (sem prefixo, até 3 casas); vira `localizedBignumber: { prefix: '', scale: N, emptyAsZero: true, nullAsZero: true }`
+ *   (N = literal ou 0; as duas opções preservam a exibição de vazio e null como 0) e SEMPRE gera um aviso de revisão, porque o arredondamento/separadores podem divergir.
+ * - Símbolos TS (pipes e `BreadcrumbModule`) só são trocados se todos os usos forem elementos de array (`imports`, etc.).
+ *   Se algum template ainda usa o pipe antigo (não migrável), o símbolo antigo é mantido ao lado do novo.
+ */
+exports.ITEM_ID = 'apis';
+const PREFIX = '@seniorsistemas/angular-components/';
+const LOCALE = `${PREFIX}locale`;
+const NUMBER_INPUT = `${PREFIX}number-input`;
+const BIGNUMBER_INPUT = `${PREFIX}bignumber-input`;
+const BREADCRUMB = `${PREFIX}breadcrumb`;
+const NUMERIC_MASK = `${PREFIX}numeric-mask`;
+const LOCALIZED_NUMBER_INPUT = `${PREFIX}localized-number-input`;
+const NUMERIC_INPUT_ATTRS = ['sBignumberInput', 'sNumberInput', 'sLocalizedNumberInput'];
+const CURRENCY_ALLOWED_KEYS = ['scale', 'currencySymbol', 'thousandsSeparator', 'decimalSeparator'];
+const SAFE_SCALE_EXPRESSION = /^\s*(?:\d+|[A-Za-z_$][\w$]*(?:\??\.[A-Za-z_$][\w$]*)*!?|'[^'"\\]*')\s*$/;
+// ---------------------------------------------------------------------------------------------------------------------
+// Templates
+// ---------------------------------------------------------------------------------------------------------------------
+function findAttr(tag, ...names) {
+    return tag.attrs.find((attr) => names.includes(attr.name));
+}
+function renameAttr(tag, from, to, edits, manual) {
+    const attr = findAttr(tag, from);
+    if (!attr)
+        return;
+    if (findAttr(tag, to)) {
+        manual.push({
+            index: attr.start,
+            message: `<${tag.name}> tem "${from}" e "${to}" ao mesmo tempo: remova "${from}" manualmente.`,
+        });
+        return;
+    }
+    edits.push({ start: attr.nameStart, end: attr.nameEnd, replacement: to });
+}
+function collectTagEdits(text, edits, manual) {
+    for (const tag of (0, template_utils_1.scanOpenTags)(text)) {
+        if (tag.name === 's-code-editor') {
+            renameAttr(tag, '(onCodeChange)', '(codeChange)', edits, manual);
+        }
+        else if (tag.name === 's-profile-picture-picker') {
+            // Não é um rename: `changedImage` sempre emite `string`, enquanto `imageChange` emite
+            // `string | ProfilePicturePickerData` conforme o tipo de `[image]`. O handler precisa ser revisto.
+            const changed = findAttr(tag, '(changedImage)');
+            if (changed) {
+                manual.push({
+                    index: changed.start,
+                    message: '"(changedImage)" está depreciado, mas "(imageChange)" não é equivalente: emite string | ProfilePicturePickerData (conforme [image]). Troque o output e ajuste o tipo do handler manualmente.',
+                });
+            }
+        }
+        else if (tag.name === 'input' && findAttr(tag, ...NUMERIC_INPUT_ATTRS)) {
+            collectNumericInputEdits(text, tag, edits, manual);
+        }
+    }
+}
+function collectNumericInputEdits(text, tag, edits, manual) {
+    const directives = NUMERIC_INPUT_ATTRS.map((name) => findAttr(tag, name)).filter((attr) => !!attr);
+    if (directives.length > 1 || findAttr(tag, 'sNumericMask')) {
+        manual.push({
+            index: directives[0].start,
+            message: 'O <input> tem mais de uma diretiva numérica (sNumericMask, sBignumberInput, sNumberInput, sLocalizedNumberInput): mantenha apenas "sNumericMask" e revise os inputs manualmente.',
+        });
+        return;
+    }
+    const directive = directives[0];
+    const localized = directive.name === 'sLocalizedNumberInput';
+    const has = (...names) => !!findAttr(tag, ...names);
+    // Inputs com os defaults da diretiva antiga, para que o comportamento não mude silenciosamente.
+    const explicit = [];
+    // Todas as variações (`[thousandsSeparator]` e `thousandsSeparator`): a segunda passada não vê mais a tag, pois
+    // ela já deixou de ter a diretiva antiga.
+    for (const thousands of tag.attrs.filter((attr) => ['[thousandsSeparator]', 'thousandsSeparator'].includes(attr.name))) {
+        const target = thousands.name.startsWith('[') ? '[thousandSeparator]' : 'thousandSeparator';
+        renameAttr(tag, thousands.name, target, edits, manual);
+    }
+    if (localized) {
+        // `precision` da sLocalizedNumberInput é o nº máximo de casas decimais (padrão 2).
+        const precision = findAttr(tag, '[precision]', 'precision');
+        if (precision) {
+            renameAttr(tag, precision.name, precision.name.startsWith('[') ? '[maxDecimalPlaces]' : 'maxDecimalPlaces', edits, manual);
+        }
+        else {
+            explicit.push('[maxDecimalPlaces]="2"');
+        }
+        if (!has('[allowNegative]', 'allowNegative'))
+            explicit.push('[allowNegative]="true"');
+        manual.push({
+            index: directive.start,
+            message: 'sLocalizedNumberInput foi trocada por sNumericMask: o valor do FormControl agora é uma string em formato internacional (ex.: "1234.56") e o erro "invalidNumber" deixou de existir. Revise validações e mensagens.',
+        });
+    }
+    else {
+        const alignTo = findAttr(tag, '[alignTo]', 'alignTo');
+        if (alignTo) {
+            edits.push((0, template_utils_1.buildRemoveAttrEdit)(text, alignTo));
+            manual.push({
+                index: alignTo.start,
+                message: `"${alignTo.name}" foi removido: não tem mais efeito (o alinhamento é sempre à direita).`,
+            });
+        }
+        const scale = findAttr(tag, '[scale]', 'scale');
+        if (scale) {
+            collectScaleEdit(tag, scale, edits, manual);
+        }
+        else if (!has('[minDecimalPlaces]', 'minDecimalPlaces', '[maxDecimalPlaces]', 'maxDecimalPlaces')) {
+            explicit.push('[minDecimalPlaces]="0"', '[maxDecimalPlaces]="0"');
+        }
+        if (!has('[precision]', 'precision'))
+            explicit.push('[precision]="15"');
+        if (!has('[allowNegative]', 'allowNegative'))
+            explicit.push('[allowNegative]="true"');
+        if (!has('[blockDecimalOverflow]', 'blockDecimalOverflow'))
+            explicit.push('[blockDecimalOverflow]="false"');
+    }
+    edits.push({
+        start: directive.nameStart,
+        end: directive.nameEnd,
+        replacement: ['sNumericMask', ...explicit].join(' '),
+    });
+}
+function collectScaleEdit(tag, scale, edits, manual) {
+    if (findAttr(tag, '[minDecimalPlaces]', 'minDecimalPlaces', '[maxDecimalPlaces]', 'maxDecimalPlaces')) {
+        manual.push({
+            index: scale.start,
+            message: `"${scale.name}" convive com minDecimalPlaces/maxDecimalPlaces: remova "${scale.name}" manualmente.`,
+        });
+        return;
+    }
+    const value = scale.value?.trim();
+    const bound = scale.name.startsWith('[');
+    const safe = value !== undefined && (bound ? SAFE_SCALE_EXPRESSION.test(value) : /^\d+$/.test(value));
+    if (!safe) {
+        manual.push({
+            index: scale.start,
+            message: `"${scale.name}" com expressão que não dá para duplicar com segurança: troque por [minDecimalPlaces] e [maxDecimalPlaces].`,
+        });
+        return;
+    }
+    const quote = bound ? (scale.quote ?? '"') : '"';
+    edits.push({
+        start: scale.start,
+        end: scale.end,
+        replacement: `[minDecimalPlaces]=${quote}${value}${quote} [maxDecimalPlaces]=${quote}${value}${quote}`,
+    });
+}
+// ---- pipes ----
+const PIPE_REGEX = /(?<!\|)\|(?!\|)\s*(localizedCurrencyImpure|localizedCurrency|localizedNumber)(?![\w$])/g;
+/** Fim (exclusivo) da expressão do argumento de um pipe que começa em `from`. */
+function findPipeArgEnd(text, from, inInterpolation) {
+    let depth = 0;
+    let str = null;
+    for (let i = from; i < text.length; i++) {
+        const c = text[i];
+        if (str) {
+            if (c === '\\')
+                i++;
+            else if (c === str)
+                str = null;
+            continue;
+        }
+        if (c === "'" || c === '`') {
+            str = c;
+        }
+        else if (c === '"') {
+            if (!inInterpolation)
+                return i;
+            str = c;
+        }
+        else if (c === '(' || c === '[' || c === '{') {
+            depth++;
+        }
+        else if (c === ')' || c === ']' || c === '}') {
+            if (depth === 0)
+                return i;
+            depth--;
+        }
+        else if (depth === 0 && (c === ',' || c === ';' || c === ':')) {
+            return i;
+        }
+        else if (depth === 0 && c === '|' && text[i + 1] !== '|' && text[i - 1] !== '|') {
+            return i;
+        }
+    }
+    return text.length;
+}
+function buildCurrencyOptionsEdits(arg) {
+    const source = ts.createSourceFile('_arg.ts', `(${arg})`, ts.ScriptTarget.Latest, true);
+    if (source.parseDiagnostics.length > 0)
+        return undefined;
+    const statement = source.statements[0];
+    if (source.statements.length !== 1 || !ts.isExpressionStatement(statement))
+        return undefined;
+    const expression = statement.expression;
+    if (!ts.isParenthesizedExpression(expression) || !ts.isObjectLiteralExpression(expression.expression)) {
+        return undefined;
+    }
+    const edits = [];
+    for (const prop of expression.expression.properties) {
+        if (ts.isShorthandPropertyAssignment(prop)) {
+            if (!CURRENCY_ALLOWED_KEYS.includes(prop.name.text))
+                return undefined;
+            if (prop.name.text === 'currencySymbol') {
+                edits.push({
+                    start: prop.getStart(source) - 1,
+                    end: prop.getEnd() - 1,
+                    replacement: 'prefix: currencySymbol',
+                });
+            }
+        }
+        else if (ts.isPropertyAssignment(prop) && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name))) {
+            if (!CURRENCY_ALLOWED_KEYS.includes(prop.name.text))
+                return undefined;
+            if (prop.name.text === 'currencySymbol') {
+                edits.push({
+                    start: prop.name.getStart(source) - 1,
+                    end: prop.name.getEnd() - 1,
+                    replacement: 'prefix',
+                });
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    return edits;
+}
+function collectPipeEdits(text, edits, manual, quotesSafe) {
+    PIPE_REGEX.lastIndex = 0;
+    let match;
+    while ((match = PIPE_REGEX.exec(text)) !== null) {
+        const pipe = match[1];
+        const nameEnd = match.index + match[0].length;
+        const nameStart = nameEnd - pipe.length;
+        const interpolationOpen = text.lastIndexOf('{{', match.index);
+        const inInterpolation = interpolationOpen > text.lastIndexOf('}}', match.index);
+        let cursor = nameEnd;
+        while (/\s/.test(text[cursor] ?? ''))
+            cursor++;
+        const hasArg = text[cursor] === ':';
+        let argStart = -1;
+        let argEnd = -1;
+        let arg = '';
+        if (hasArg) {
+            argStart = cursor + 1;
+            while (/\s/.test(text[argStart] ?? ''))
+                argStart++;
+            argEnd = findPipeArgEnd(text, argStart, inInterpolation);
+            while (argEnd > argStart && /\s/.test(text[argEnd - 1]))
+                argEnd--;
+            arg = text.slice(argStart, argEnd);
+            let after = argEnd;
+            while (/\s/.test(text[after] ?? ''))
+                after++;
+            if (text[after] === ':') {
+                manual.push({
+                    index: match.index,
+                    message: `Pipe "${pipe}" com mais de um argumento: migre manualmente para localizedBignumber.`,
+                });
+                continue;
+            }
+        }
+        if (pipe === 'localizedNumber') {
+            if (!quotesSafe) {
+                manual.push({
+                    index: match.index,
+                    message: 'Pipe "localizedNumber": migre manualmente para localizedBignumber: { prefix: \'\', scale: N }.',
+                });
+                continue;
+            }
+            let scale;
+            if (!hasArg)
+                scale = '0';
+            else if (/^\d+$/.test(arg))
+                scale = arg;
+            else {
+                manual.push({
+                    index: match.index,
+                    message: `Pipe "localizedNumber" com argumento "${arg}" não literal: use localizedBignumber: { prefix: '', scale: <casas> }.`,
+                });
+                continue;
+            }
+            edits.push({ start: nameStart, end: nameEnd, replacement: 'localizedBignumber' });
+            const options = `{ prefix: '', scale: ${scale}, emptyAsZero: true, nullAsZero: true }`;
+            if (hasArg)
+                edits.push({ start: argStart, end: argEnd, replacement: options });
+            else
+                edits.push({ start: nameEnd, end: nameEnd, replacement: `: ${options}` });
+            manual.push({
+                index: match.index,
+                message: 'Pipe "localizedNumber" trocado por "localizedBignumber" com scale fixo, emptyAsZero e nullAsZero (valores vazios e null continuam sendo exibidos como 0): revise, pois o antigo usava Intl.NumberFormat (até 3 casas decimais) e o novo usa os separadores do LocaleService.',
+            });
+            continue;
+        }
+        const target = pipe === 'localizedCurrencyImpure' ? 'localizedBignumberImpure' : 'localizedBignumber';
+        // `Number('')` é 0: o pipe antigo formatava string vazia como 0 (ex.: 0,00), e o novo devolve vazio.
+        const keepEmptyAsZero = 'emptyAsZero: true';
+        if (!hasArg) {
+            edits.push({ start: nameEnd, end: nameEnd, replacement: `: { ${keepEmptyAsZero} }` });
+        }
+        if (hasArg) {
+            const argEdits = buildCurrencyOptionsEdits(arg);
+            if (!argEdits) {
+                manual.push({
+                    index: match.index,
+                    message: `Pipe "${pipe}" com argumento "${arg}" que não é um objeto literal conhecido: migre manualmente para ${target} (a chave currencySymbol vira prefix).`,
+                });
+                continue;
+            }
+            for (const e of argEdits) {
+                edits.push({ start: argStart + e.start, end: argStart + e.end, replacement: e.replacement });
+            }
+            if (arg.startsWith('{')) {
+                const isEmptyObject = arg.slice(1, -1).trim() === '';
+                edits.push({
+                    start: argStart + 1,
+                    end: argStart + 1,
+                    replacement: isEmptyObject ? ` ${keepEmptyAsZero} ` : ` ${keepEmptyAsZero},`,
+                });
+            }
+        }
+        edits.push({ start: nameStart, end: nameEnd, replacement: target });
+    }
+}
+function dropOverlaps(edits) {
+    const sorted = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+    const result = [];
+    let lastEnd = -1;
+    for (const edit of sorted) {
+        if (edit.start < lastEnd)
+            continue;
+        result.push(edit);
+        lastEnd = Math.max(lastEnd, edit.end);
+    }
+    return result;
+}
+/** Migra um texto de template (HTML inteiro ou conteúdo de `template:` inline). */
+function migrateTemplateText(text, options = { quotesSafe: true }) {
+    let current = text;
+    const manual = [];
+    // Vários passes: um pipe dentro do argumento de outro só fica livre de sobreposição na rodada seguinte.
+    for (let pass = 0; pass < 5; pass++) {
+        const edits = [];
+        const passManual = [];
+        collectTagEdits(current, edits, passManual);
+        collectPipeEdits(current, edits, passManual, options.quotesSafe);
+        if (pass === 0)
+            manual.push(...passManual);
+        const safe = dropOverlaps(edits);
+        if (safe.length === 0)
+            break;
+        const next = (0, ast_utils_1.applyChanges)(current, safe);
+        if (next === current)
+            break;
+        current = next;
+    }
+    return { updated: current, manual };
+}
+const SYMBOL_SPECS = [
+    {
+        from: LOCALE,
+        old: 'LocalizedNumberPipe',
+        new: 'LocalizedBignumberPipe',
+        newFrom: LOCALE,
+        mode: 'array',
+        pipe: 'localizedNumber',
+    },
+    {
+        from: LOCALE,
+        old: 'LocalizedCurrencyPipe',
+        new: 'LocalizedBignumberPipe',
+        newFrom: LOCALE,
+        mode: 'array',
+        pipe: 'localizedCurrency',
+    },
+    {
+        from: LOCALE,
+        old: 'LocalizedCurrencyImpurePipe',
+        new: 'LocalizedBignumberImpurePipe',
+        newFrom: LOCALE,
+        mode: 'array',
+        pipe: 'localizedCurrencyImpure',
+    },
+    ...[
+        { from: NUMBER_INPUT, old: 'NumberInputDirective' },
+        { from: NUMBER_INPUT, old: 'NumberInputModule' },
+        { from: BIGNUMBER_INPUT, old: 'BignumberInputDirective' },
+        { from: BIGNUMBER_INPUT, old: 'BignumberInputModule' },
+        { from: LOCALIZED_NUMBER_INPUT, old: 'LocalizedNumberInputDirective' },
+        { from: LOCALIZED_NUMBER_INPUT, old: 'LocalizedNumberInputModule' },
+    ].map(({ from, old }) => ({
+        from,
+        old,
+        new: 'NumericMaskDirective',
+        newFrom: NUMERIC_MASK,
+        mode: 'rename',
+    })),
+    {
+        from: BREADCRUMB,
+        old: 'BreadcrumbModule',
+        new: 'DynamicBreadcrumbComponent',
+        newFrom: BREADCRUMB,
+        mode: 'array',
+    },
+];
+const ENUM_SPECS = [
+    { from: NUMBER_INPUT, name: 'NumberAlignmentOption' },
+    { from: BIGNUMBER_INPUT, name: 'BignumberAlignmentOption' },
+];
+function parse(file, content) {
+    return ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+}
+function pipeStillUsed(file, content, pipe, readTemplate) {
+    const regex = new RegExp(`\\|\\s*${pipe}(?![\\w$])`);
+    const sourceFile = parse(file, content);
+    for (const seg of (0, template_utils_1.findInlineTemplateSegments)(sourceFile)) {
+        if (regex.test(content.slice(seg.start, seg.end)))
+            return true;
+    }
+    if (!readTemplate)
+        return false;
+    for (const match of content.matchAll(/templateUrl\s*:\s*['"`]([^'"`]+)['"`]/g)) {
+        const html = readTemplate(file, match[1]);
+        if (html === undefined)
+            continue;
+        if (regex.test(migrateTemplateText(html).updated))
+            return true;
+    }
+    return false;
+}
+function migrateSymbols(file, content, readTemplate, manual) {
+    let current = content;
+    for (const spec of SYMBOL_SPECS) {
+        if (!current.includes(spec.old))
+            continue;
+        const sourceFile = parse(file, current);
+        const imported = (0, symbol_utils_1.findNamedImport)(sourceFile, spec.old, spec.from);
+        if (!imported)
+            continue;
+        const line = (0, report_1.lineOf)(current, imported.element.getStart(sourceFile));
+        if (imported.element.propertyName) {
+            manual.push({ line, message: `"${spec.old}" importado com alias: troque manualmente por "${spec.new}".` });
+            continue;
+        }
+        const references = (0, symbol_utils_1.findReferences)(sourceFile, spec.old);
+        if (spec.mode === 'array') {
+            const outside = references.find((ref) => !(0, symbol_utils_1.isArrayElement)(ref));
+            if (outside) {
+                manual.push({
+                    line: (0, report_1.lineOf)(current, outside.getStart(sourceFile)),
+                    message: `"${spec.old}" é usado fora de um array de imports/providers: troque manualmente por "${spec.new}" e revise os argumentos.`,
+                });
+                continue;
+            }
+        }
+        const keepOld = !!spec.pipe && pipeStillUsed(file, current, spec.pipe, readTemplate);
+        const changes = [];
+        changes.push(...(0, symbol_utils_1.buildReplaceInArraysChanges)(sourceFile, spec.old, spec.new, keepOld));
+        changes.push(...(0, symbol_utils_1.buildEnsureInModuleImportsChanges)(sourceFile, spec.old, spec.new));
+        if (spec.mode === 'rename') {
+            for (const ref of references.filter((r) => !(0, symbol_utils_1.isArrayElement)(r))) {
+                const replacement = ts.isShorthandPropertyAssignment(ref.parent)
+                    ? `${spec.old}: ${spec.new}`
+                    : spec.new;
+                changes.push({ start: ref.getStart(sourceFile), end: ref.getEnd(), replacement });
+            }
+        }
+        if (!keepOld)
+            changes.push(...(0, ast_utils_1.buildRemoveNamedImportsChanges)(sourceFile, [spec.old], spec.from).changes);
+        current = (0, ast_utils_1.applyChanges)(current, (0, symbol_utils_1.consumeRemovedLineBreaks)(current, changes));
+        if (references.length > 0)
+            current = (0, ast_utils_1.ensureNamedImport)(current, spec.new, spec.newFrom);
+    }
+    return current;
+}
+function migrateAlignmentEnums(file, content, manual) {
+    let current = content;
+    for (const spec of ENUM_SPECS) {
+        if (!current.includes(spec.name))
+            continue;
+        const sourceFile = parse(file, current);
+        const imported = (0, symbol_utils_1.findNamedImport)(sourceFile, spec.name, spec.from);
+        if (!imported || imported.element.propertyName)
+            continue;
+        const changes = [];
+        let unresolved = false;
+        for (const ref of (0, symbol_utils_1.findReferences)(sourceFile, spec.name)) {
+            const parent = ref.parent;
+            const member = ts.isPropertyAccessExpression(parent) && parent.expression === ref ? parent.name.text : undefined;
+            if (member === 'RIGHT' || member === 'LEFT') {
+                changes.push({
+                    start: parent.getStart(sourceFile),
+                    end: parent.getEnd(),
+                    replacement: member === 'RIGHT' ? "'right'" : "'left'",
+                });
+            }
+            else {
+                unresolved = true;
+                manual.push({
+                    line: (0, report_1.lineOf)(current, ref.getStart(sourceFile)),
+                    message: `"${spec.name}" usado fora de ${spec.name}.RIGHT/LEFT: troque por 'left' | 'right'.`,
+                });
+            }
+        }
+        if (!unresolved)
+            changes.push(...(0, ast_utils_1.buildRemoveNamedImportsChanges)(sourceFile, [spec.name], spec.from).changes);
+        current = (0, ast_utils_1.applyChanges)(current, (0, symbol_utils_1.consumeRemovedLineBreaks)(current, changes));
+    }
+    return current;
+}
+const RATING_NODE_KEYS = ['id', 'title', 'icon'];
+/** O arquivo importa algo do entrypoint do rating-scale ou usa `<s-rating-scale>` no template inline. */
+function usesRatingScale(sourceFile, content) {
+    if (content.includes('<s-rating-scale'))
+        return true;
+    return sourceFile.statements.some((statement) => ts.isImportDeclaration(statement) &&
+        ts.isStringLiteral(statement.moduleSpecifier) &&
+        statement.moduleSpecifier.text === `${PREFIX}rating-scale`);
+}
+function migrateRatingScaleNodes(file, content, manual) {
+    if (!content.includes('icon'))
+        return content;
+    const sourceFile = parse(file, content);
+    if (!usesRatingScale(sourceFile, content))
+        return content;
+    const changes = [];
+    const visit = (node) => {
+        if (ts.isObjectLiteralExpression(node)) {
+            const named = (name) => node.properties.find((p) => ts.isPropertyAssignment(p) &&
+                (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
+                p.name.text === name);
+            const icon = named('icon');
+            // Só objetos no formato de nó (id/title/icon): objetos com outras chaves (ex.: itens de menu) não são nós.
+            const isNodeShape = node.properties.every((p) => ts.isPropertyAssignment(p) &&
+                (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
+                RATING_NODE_KEYS.includes(p.name.text));
+            if (icon && isNodeShape && named('id') && !named('selectedIcon') && !named('unselectedIcon')) {
+                const init = icon.initializer;
+                const line = (0, report_1.lineOf)(content, icon.getStart(sourceFile));
+                if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
+                    const quote = init.getText(sourceFile)[0];
+                    if (/\s/.test(init.text)) {
+                        manual.push({
+                            line,
+                            message: `rating-scale: "icon" com glifo já informado ("${init.text}"): defina selectedIcon e unselectedIcon manualmente.`,
+                        });
+                    }
+                    else {
+                        changes.push({
+                            start: icon.getStart(sourceFile),
+                            end: icon.getEnd(),
+                            replacement: `selectedIcon: ${quote}fas ${init.text}${quote}, unselectedIcon: ${quote}far ${init.text}${quote}`,
+                        });
+                    }
+                }
+                else {
+                    manual.push({
+                        line,
+                        message: 'rating-scale: "icon" dinâmico: defina selectedIcon (fas ...) e unselectedIcon (far ...) manualmente.',
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return changes.length > 0 ? (0, ast_utils_1.applyChanges)(content, changes) : content;
+}
+function warnBignumberDirective(file, content, manual) {
+    if (!content.includes('BignumberInputDirective'))
+        return;
+    const sourceFile = parse(file, content);
+    const imported = (0, symbol_utils_1.findNamedImport)(sourceFile, 'BignumberInputDirective', BIGNUMBER_INPUT);
+    if (!imported)
+        return;
+    manual.push({
+        line: (0, report_1.lineOf)(content, imported.element.getStart(sourceFile)),
+        message: 'BignumberInputDirective (importada com alias) está depreciada em favor de sNumericMask (NumericMaskDirective): troque manualmente.',
+    });
+}
+/**
+ * Migra um arquivo. `.html` (template), `.ts` (template inline, símbolos, enums e nós do rating-scale).
+ * `readTemplate` resolve `templateUrl` para decidir se um pipe antigo ainda é usado.
+ */
+function migrateApisInContent(file, content, readTemplate) {
+    const manual = [];
+    if (file.endsWith('.html')) {
+        const result = (0, template_utils_1.transformTemplates)(file, content, migrateTemplateText);
+        return result;
+    }
+    if (!file.endsWith('.ts') || file.endsWith('.d.ts'))
+        return { updated: content, manual };
+    const templated = (0, template_utils_1.transformTemplates)(file, content, migrateTemplateText);
+    manual.push(...templated.manual);
+    let current = templated.updated;
+    current = migrateSymbols(file, current, readTemplate, manual);
+    current = migrateAlignmentEnums(file, current, manual);
+    current = migrateRatingScaleNodes(file, current, manual);
+    warnBignumberDirective(file, current, manual);
+    return { updated: current, manual };
+}
+function migrateDeprecatedApis(options, report) {
+    return (tree, context) => {
+        const readTemplate = (relativeTo, templateUrl) => {
+            const resolved = path.posix.join(path.posix.dirname(relativeTo), templateUrl);
+            return tree.exists(resolved) ? tree.readText(resolved) : undefined;
+        };
+        (0, scope_1.visitScopedFiles)(tree, options, context, (file) => {
+            if (!(file.endsWith('.html') || file.endsWith('.ts')) || file.endsWith('.d.ts'))
+                return;
+            const content = tree.readText(file);
+            const { updated, manual } = migrateApisInContent(file, content, readTemplate);
+            if (updated !== content) {
+                tree.overwrite(file, (0, eol_1.preserveLineEndings)(content, updated));
+                report.markChanged(exports.ITEM_ID, file);
+            }
+            for (const entry of manual) {
+                report.addManual(exports.ITEM_ID, { file, line: entry.line, message: entry.message }, context);
+            }
+        });
+    };
+}
+function migrate(options = {}) {
+    return migrateDeprecatedApis(options, new report_1.MigrationReport());
+}
+//# sourceMappingURL=index.js.map