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

package/schematics/migrations/migrate-modules-to-standalone/index.js

@@ -1,632 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MODULES_MAP = exports.ITEM_ID = void 0;
-exports.isUsedInTemplates = isUsedInTemplates;
-exports.migrateModulesInContent = migrateModulesInContent;
-exports.migrateModulesToStandalone = migrateModulesToStandalone;
-exports.migrate = migrate;
-const path = require("path");
-const ts = require("typescript");
-const ast_utils_1 = require("../../utils/ast-utils");
-const html_utils_1 = require("../../utils/html-utils");
-const report_1 = require("../../utils/report");
-const scope_1 = require("../../utils/scope");
-const modulesMapJson = require("./modules-map.json");
-const eol_1 = require("../../utils/eol");
-const tsconfig_paths_1 = require("../../utils/tsconfig-paths");
-exports.ITEM_ID = 'modules';
-const PACKAGE = '@seniorsistemas/angular-components';
-/** Tabela gerada por `scripts/generate-modules-map.js` (não editar à mão). */
-exports.MODULES_MAP = modulesMapJson;
-// ---------------------------------------------------------------------------------------------------
-// Análise de template
-// ---------------------------------------------------------------------------------------------------
-/** `true` quando o template usa o selector/atributo/pipe descrito em `usedBy` (sem `usedBy`, considera usado). */
-function isUsedInTemplates(usedBy, templates) {
-    if (!usedBy)
-        return true;
-    const text = templates.join('\n');
-    const tests = [
-        ...(usedBy.selector ?? []).map((s) => new RegExp(`<${(0, html_utils_1.escapeRegex)(s)}(?![\\w-])`)),
-        ...(usedBy.attribute ?? []).map((a) => new RegExp(`(?<![\\w-])${(0, html_utils_1.escapeRegex)(a)}(?![\\w-])`)),
-        ...(usedBy.pipe ?? []).map((p) => new RegExp(`\\|\\s*${(0, html_utils_1.escapeRegex)(p)}(?!\\w)`)),
-    ];
-    if (tests.length === 0)
-        return true;
-    return tests.some((re) => re.test(text));
-}
-function propertyOf(obj, name) {
-    return obj.properties.find((p) => ts.isPropertyAssignment(p) && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === name);
-}
-function decoratorName(decorator) {
-    const expr = decorator.expression;
-    return ts.isCallExpression(expr) && ts.isIdentifier(expr.expression) ? expr.expression.text : undefined;
-}
-function resolveSibling(fromFile, relative) {
-    return path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), relative));
-}
-/** Templates (texto) de uma classe `@Component`, `[]` para diretivas/pipes, ou `undefined` se não resolvível. */
-function templatesOfClass(filePath, cls, readFile) {
-    const decorators = ts.getDecorators(cls) ?? [];
-    const component = decorators.find((d) => decoratorName(d) === 'Component');
-    if (!component)
-        return decorators.some((d) => ['Directive', 'Pipe'].includes(decoratorName(d) ?? '')) ? [] : undefined;
-    const arg = component.expression.arguments[0];
-    if (!arg || !ts.isObjectLiteralExpression(arg))
-        return undefined;
-    const inline = propertyOf(arg, 'template');
-    if (inline)
-        return [inline.initializer.getText()];
-    const url = propertyOf(arg, 'templateUrl');
-    if (url && ts.isStringLiteralLike(url.initializer)) {
-        const content = readFile(resolveSibling(filePath, url.initializer.text));
-        return content === undefined ? undefined : [content];
-    }
-    return undefined;
-}
-function findClass(sourceFile, name) {
-    return sourceFile.statements.find((s) => ts.isClassDeclaration(s) && s.name?.text === name);
-}
-/** Resolve os templates de uma classe declarada no mesmo arquivo ou importada por caminho relativo ou alias do tsconfig. */
-function templatesOfDeclaration(filePath, sourceFile, className, readFile, resolveAlias) {
-    const local = findClass(sourceFile, className);
-    if (local)
-        return templatesOfClass(filePath, local, readFile);
-    for (const node of sourceFile.statements) {
-        if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier))
-            continue;
-        const bindings = node.importClause?.namedBindings;
-        if (!bindings || !ts.isNamedImports(bindings))
-            continue;
-        const element = bindings.elements.find((el) => el.name.text === className);
-        if (!element)
-            continue;
-        const specifier = node.moduleSpecifier.text;
-        const bases = specifier.startsWith('.') ? [resolveSibling(filePath, specifier)] : resolveAlias(specifier);
-        for (const base of bases) {
-            for (const candidate of [`${base}.ts`, `${base}/index.ts`]) {
-                const content = readFile(candidate);
-                if (content === undefined)
-                    continue;
-                const imported = ts.createSourceFile(candidate, content, ts.ScriptTarget.Latest, true);
-                const cls = findClass(imported, (element.propertyName ?? element.name).text);
-                return cls ? templatesOfClass(candidate, cls, readFile) : undefined;
-            }
-        }
-        return undefined;
-    }
-    return undefined;
-}
-function resolveScope(filePath, sourceFile, context, readFile, resolveAlias) {
-    const obj = context.object;
-    if (!obj)
-        return { kind: 'none' };
-    if (context.owner === 'component') {
-        const inline = propertyOf(obj, 'template');
-        if (inline)
-            return { kind: 'resolved', templates: [inline.initializer.getText()] };
-        const url = propertyOf(obj, 'templateUrl');
-        if (url && ts.isStringLiteralLike(url.initializer)) {
-            const content = readFile(resolveSibling(filePath, url.initializer.text));
-            return content === undefined
-                ? { kind: 'unresolved', reason: `template "${url.initializer.text}" não encontrado` }
-                : { kind: 'resolved', templates: [content] };
-        }
-        return { kind: 'none' };
-    }
-    const declarations = propertyOf(obj, 'declarations');
-    if (!declarations || !ts.isArrayLiteralExpression(declarations.initializer))
-        return { kind: 'none' };
-    const elements = declarations.initializer.elements;
-    if (elements.length === 0)
-        return { kind: 'none' };
-    const templates = [];
-    for (const el of elements) {
-        const resolved = ts.isIdentifier(el) ? templatesOfDeclaration(filePath, sourceFile, el.text, readFile, resolveAlias) : undefined;
-        if (!resolved) {
-            return {
-                kind: 'unresolved',
-                reason: `não foi possível ler o template de "${el.getText()}" (declarations)`,
-            };
-        }
-        templates.push(...resolved);
-    }
-    return { kind: 'resolved', templates };
-}
-// ---------------------------------------------------------------------------------------------------
-// Escolha dos símbolos
-// ---------------------------------------------------------------------------------------------------
-function selectSymbols(entry, context, scope, providerOnly) {
-    const all = [...entry.standalone, ...entry.transitive];
-    if (context.kind === 'exports' || context.kind === 'free')
-        return all;
-    if (scope.kind === 'resolved') {
-        const standalone = entry.standalone.length <= 1
-            ? entry.standalone
-            : entry.standalone.filter((s) => !s.usedBy || isUsedInTemplates(s.usedBy, scope.templates));
-        const transitive = entry.transitive.filter((t) => isUsedInTemplates(t.usedBy, scope.templates));
-        return [...standalone, ...transitive];
-    }
-    // `X.forRoot()` sem template para analisar é só configuração: não precisa dos standalones.
-    if (providerOnly && scope.kind === 'none')
-        return [];
-    return all;
-}
-// ---------------------------------------------------------------------------------------------------
-// Utilitários de edição
-// ---------------------------------------------------------------------------------------------------
-function lineIndent(content, pos) {
-    const lineStart = content.lastIndexOf('\n', pos - 1) + 1;
-    return /^[ \t]*/.exec(content.slice(lineStart, pos))?.[0] ?? '';
-}
-/**
- * Comentários entre o último elemento e o `]` (ex.: marcadores de gerador de código como
- * `/*{CA:MODULE_IMPORTS:START}*\/`): não pertencem a nenhum elemento e se perderiam ao reconstruir o array.
- */
-function trailingComments(content, arr) {
-    const last = arr.elements[arr.elements.length - 1];
-    if (!last)
-        return [];
-    const tail = content.slice(last.getEnd(), arr.getEnd() - 1).replace(/^\s*,/, '');
-    return tail
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-}
-function renderArray(content, arr, items) {
-    const kept = trailingComments(content, arr);
-    if (items.length === 0 && kept.length === 0)
-        return '[]';
-    const original = content.slice(arr.getStart(), arr.getEnd());
-    if (!original.includes('\n'))
-        return `[${items.join(', ')}]`;
-    const eol = content.includes('\r\n') ? '\r\n' : '\n';
-    const closeIndent = lineIndent(content, arr.getEnd() - 1);
-    const first = arr.elements[0];
-    const itemIndent = first ? lineIndent(content, first.getStart()) : `${closeIndent}    `;
-    const trailing = arr.elements.hasTrailingComma || arr.elements.length === 0 ? ',' : '';
-    const lines = [];
-    if (items.length > 0)
-        lines.push(`${items.map((i) => `${itemIndent}${i}`).join(`,${eol}`)}${trailing}`);
-    lines.push(...kept.map((c) => `${itemIndent}${c}`));
-    return `[${eol}${lines.join(eol)}${eol}${closeIndent}]`;
-}
-function insertPropertyChange(content, obj, text) {
-    if (obj.properties.length === 0) {
-        return { start: obj.getStart(), end: obj.getEnd(), replacement: `{ ${text} }` };
-    }
-    const last = obj.properties[obj.properties.length - 1];
-    const tail = content.slice(last.getEnd(), obj.getEnd() - 1);
-    const commaIndex = tail.indexOf(',');
-    const hasTrailingComma = commaIndex !== -1;
-    const insertAt = hasTrailingComma ? last.getEnd() + commaIndex + 1 : last.getEnd();
-    if (!content.slice(obj.getStart(), obj.getEnd()).includes('\n')) {
-        return { start: insertAt, end: insertAt, replacement: `${hasTrailingComma ? ' ' : ', '}${text}` };
-    }
-    const eol = content.includes('\r\n') ? '\r\n' : '\n';
-    const indent = lineIndent(content, last.getStart());
-    return {
-        start: insertAt,
-        end: insertAt,
-        replacement: hasTrailingComma ? `${eol}${indent}${text},` : `,${eol}${indent}${text}`,
-    };
-}
-function normalizeText(text) {
-    return text.replace(/\s+/g, '');
-}
-function unwrap(expr) {
-    let current = expr;
-    while (ts.isNonNullExpression(current) ||
-        ts.isParenthesizedExpression(current) ||
-        ts.isAsExpression(current) ||
-        ts.isTypeAssertionExpression(current)) {
-        current = current.expression;
-    }
-    return current;
-}
-function importSpecifier(entrypoint) {
-    return entrypoint.startsWith('@') ? entrypoint : `${PACKAGE}/${entrypoint}`;
-}
-/**
- * Remove nomes de um `import { ... } from '<specifier>'` (comparação exata do caminho). Apaga a declaração
- * inteira quando não sobra nada.
- */
-function removeNamedImports(content, specifier, names) {
-    const sourceFile = ts.createSourceFile('_imports.ts', content, ts.ScriptTarget.Latest, true);
-    const changes = [];
-    for (const node of sourceFile.statements) {
-        if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier))
-            continue;
-        if (node.moduleSpecifier.text !== specifier)
-            continue;
-        const bindings = node.importClause?.namedBindings;
-        if (!bindings || !ts.isNamedImports(bindings))
-            continue;
-        const kept = bindings.elements.filter((el) => !names.has(el.name.text));
-        if (kept.length === bindings.elements.length)
-            continue;
-        if (kept.length === 0 && !node.importClause?.name) {
-            const trailing = /^[ \t]*\r?\n/.exec(content.slice(node.getEnd()));
-            changes.push({ start: node.getStart(), end: node.getEnd() + (trailing ? trailing[0].length : 0), replacement: '' });
-            continue;
-        }
-        const multiline = content.slice(bindings.getStart(), bindings.getEnd()).includes('\n');
-        const eol = content.includes('\r\n') ? '\r\n' : '\n';
-        const rendered = multiline
-            ? `{${eol}${kept.map((el) => `    ${el.getText()}`).join(`,${eol}`)},${eol}}`
-            : `{ ${kept.map((el) => el.getText()).join(', ')} }`;
-        changes.push({ start: bindings.getStart(), end: bindings.getEnd(), replacement: rendered });
-    }
-    return changes.length > 0 ? (0, ast_utils_1.applyChanges)(content, changes) : content;
-}
-// ---------------------------------------------------------------------------------------------------
-// Migração de um arquivo
-// ---------------------------------------------------------------------------------------------------
-function buildRefs(sourceFile, map) {
-    const byKey = new Map(map.modules.map((m) => [`${m.entrypoint}:${m.module}`, m]));
-    const refs = new Map();
-    for (const node of sourceFile.statements) {
-        if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier))
-            continue;
-        const specifier = node.moduleSpecifier.text;
-        if (!specifier.startsWith(`${PACKAGE}/`))
-            continue;
-        const entrypoint = specifier.slice(PACKAGE.length + 1);
-        const bindings = node.importClause?.namedBindings;
-        if (!bindings || !ts.isNamedImports(bindings))
-            continue;
-        for (const el of bindings.elements) {
-            const found = byKey.get(`${entrypoint}:${(el.propertyName ?? el.name).text}`);
-            if (found)
-                refs.set(el.name.text, { entry: found, specifier });
-        }
-    }
-    return refs;
-}
-function contextOf(arr) {
-    const prop = arr.parent;
-    if (!prop || !ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
-        return { kind: 'free', owner: 'none' };
-    const obj = prop.parent;
-    if (!obj || !ts.isObjectLiteralExpression(obj))
-        return { kind: 'free', owner: 'none' };
-    let owner = 'none';
-    const parent = obj.parent;
-    if (parent && ts.isCallExpression(parent) && parent.arguments[0] === obj) {
-        const callee = parent.expression;
-        const calleeName = ts.isIdentifier(callee)
-            ? callee.text
-            : ts.isPropertyAccessExpression(callee)
-                ? callee.name.text
-                : '';
-        if (calleeName === 'configureTestingModule' || calleeName === 'moduleMetadata')
-            owner = 'module';
-        if (calleeName === 'Component')
-            owner = 'component';
-        if (calleeName === 'NgModule')
-            owner = 'module';
-    }
-    if (owner === 'none')
-        return { kind: 'free', owner, object: obj };
-    if (prop.name.text === 'imports') {
-        return { kind: owner === 'component' ? 'component-imports' : 'module-imports', object: obj, owner };
-    }
-    if (prop.name.text === 'exports')
-        return { kind: 'exports', object: obj, owner };
-    return { kind: 'free', object: obj, owner };
-}
-function migrateModulesInContent(filePath, content, readFile = () => undefined, map = exports.MODULES_MAP, resolveAlias = () => []) {
-    if (!content.includes(`${PACKAGE}/`))
-        return { updated: content, manual: [] };
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-    const refs = buildRefs(sourceFile, map);
-    if (refs.size === 0)
-        return { updated: content, manual: [] };
-    const manual = [];
-    const addManual = (node, message) => {
-        manual.push({ line: (0, report_1.lineOf)(content, node.getStart(sourceFile)), message });
-    };
-    const handled = new Set();
-    const needed = new Map();
-    const plans = new Map();
-    const newProps = new Map();
-    const keep = new Set();
-    const scopes = new Map();
-    const warnedScope = new Set();
-    const planOf = (arr) => {
-        let plan = plans.get(arr);
-        if (!plan) {
-            plan = { replace: new Map(), append: [] };
-            plans.set(arr, plan);
-        }
-        return plan;
-    };
-    const need = (symbol) => {
-        needed.set(`${symbol.entrypoint}:${symbol.symbol}`, symbol);
-    };
-    const scopeFor = (context) => {
-        if (!context.object)
-            return { kind: 'none' };
-        let scope = scopes.get(context.object);
-        if (!scope) {
-            scope = resolveScope(filePath, sourceFile, context, readFile, resolveAlias);
-            scopes.set(context.object, scope);
-        }
-        return scope;
-    };
-    const symbolsFor = (node, ref, context, providerOnly) => {
-        const scope = scopeFor(context);
-        const symbols = selectSymbols(ref.entry, context, scope, providerOnly);
-        if (scope.kind === 'unresolved' &&
-            (ref.entry.transitive.length > 0 || ref.entry.standalone.length > 1) &&
-            !providerOnly) {
-            const key = `${ref.entry.module}:${node.getStart(sourceFile)}`;
-            if (!warnedScope.has(key)) {
-                warnedScope.add(key);
-                addManual(node, `${ref.entry.module}: ${scope.reason}; foram adicionados todos os standalones que o módulo reexportava (${symbols
-                    .map((s) => s.symbol)
-                    .join(', ')}). Remova os que não forem usados.`);
-            }
-        }
-        if (ref.entry.manual)
-            addManual(node, `${ref.entry.module}: ${ref.entry.manual}`);
-        symbols.forEach(need);
-        return symbols.map((s) => s.symbol);
-    };
-    /** `X.forRoot(...)` / `X.forChild(...)` onde `X` é um módulo mapeado. */
-    const asModuleCall = (expr) => {
-        const inner = unwrap(expr);
-        if (!ts.isCallExpression(inner) || !ts.isPropertyAccessExpression(inner.expression))
-            return undefined;
-        const target = inner.expression.expression;
-        const form = inner.expression.name.text;
-        if (!ts.isIdentifier(target) || (form !== 'forRoot' && form !== 'forChild'))
-            return undefined;
-        const ref = refs.get(target.text);
-        return ref ? { ref, form, call: inner, identifier: target } : undefined;
-    };
-    const providerText = (call) => {
-        const rule = call.ref.entry.forRoot;
-        const args = rule.args ? call.call.arguments.map((a) => a.getText(sourceFile)).join(', ') : '';
-        return `${rule.replacement}(${args})`;
-    };
-    const markHandled = (node) => {
-        const visit = (n) => {
-            handled.add(n);
-            ts.forEachChild(n, visit);
-        };
-        visit(node);
-    };
-    /**
-     * Acrescenta `text` ao array `propName` do objeto (criando a propriedade se não existir).
-     * Retorna `false` quando a propriedade existe mas não é um array literal (não editável com segurança).
-     */
-    const registerInProp = (obj, propName, text) => {
-        if (!obj)
-            return false;
-        const prop = propertyOf(obj, propName);
-        if (prop) {
-            if (!ts.isArrayLiteralExpression(prop.initializer))
-                return false;
-            const plan = planOf(prop.initializer);
-            if (!plan.append.some((a) => normalizeText(a) === normalizeText(text)))
-                plan.append.push(text);
-            return true;
-        }
-        const byProp = newProps.get(obj) ?? new Map();
-        const list = byProp.get(propName) ?? [];
-        if (!list.some((a) => normalizeText(a) === normalizeText(text)))
-            list.push(text);
-        byProp.set(propName, list);
-        newProps.set(obj, byProp);
-        return true;
-    };
-    /**
-     * Standalone em `exports` de um `NgModule` também precisa estar no `imports` do mesmo módulo
-     * (o compilador rejeita standalone só exportado), então acrescenta os símbolos lá.
-     */
-    const registerExported = (context, names) => {
-        if (context.kind !== 'exports' || context.owner !== 'module')
-            return;
-        for (const name of names)
-            registerInProp(context.object, 'imports', name);
-    };
-    const processArray = (arr) => {
-        const context = contextOf(arr);
-        for (const el of arr.elements) {
-            // 1. Módulo simples: `XModule`
-            if (ts.isIdentifier(el) && refs.has(el.text)) {
-                const names = symbolsFor(el, refs.get(el.text), context, false);
-                planOf(arr).replace.set(el, names);
-                handled.add(el);
-                registerExported(context, names);
-                continue;
-            }
-            // 2. `X.forRoot(...)` / `X.forChild()` como elemento do array
-            const moduleCall = ts.isCallExpression(unwrap(el)) ? asModuleCall(el) : undefined;
-            if (moduleCall) {
-                const { ref, form } = moduleCall;
-                if (form === 'forChild' && ref.entry.forChild === 'remove') {
-                    const names = symbolsFor(el, ref, context, false);
-                    planOf(arr).replace.set(el, names);
-                    registerExported(context, names);
-                    markHandled(el);
-                }
-                else if (form === 'forRoot' && ref.entry.forRoot && context.kind === 'module-imports') {
-                    const text = providerText(moduleCall);
-                    if (registerInProp(context.object, 'providers', text)) {
-                        need({ symbol: ref.entry.forRoot.replacement, entrypoint: ref.entry.forRoot.entrypoint });
-                        planOf(arr).replace.set(el, symbolsFor(el, ref, context, true));
-                        markHandled(el);
-                    }
-                    else {
-                        addManual(el, `${ref.entry.module}.forRoot(): "providers" não é um array literal; ` +
-                            `mova manualmente para ${ref.entry.forRoot.replacement}().`);
-                        markHandled(el);
-                        keep.add(moduleCall.identifier.text);
-                    }
-                }
-                else if (form === 'forRoot' && ref.entry.forRoot) {
-                    addManual(el, `${ref.entry.module}.forRoot() em um contexto não reconhecido (ex.: imports de componente standalone): ` +
-                        `registre ${ref.entry.forRoot.replacement}() nos providers.`);
-                    markHandled(el);
-                    keep.add(moduleCall.identifier.text);
-                }
-                else {
-                    addManual(el, `${ref.entry.module}.${form}() não tem tratamento automático: migre manualmente.`);
-                    markHandled(el);
-                    keep.add(moduleCall.identifier.text);
-                }
-                continue;
-            }
-            // 3. `...X.forRoot().providers!`
-            if (ts.isSpreadElement(el)) {
-                const inner = unwrap(el.expression);
-                if (ts.isPropertyAccessExpression(inner) && inner.name.text === 'providers') {
-                    const call = asModuleCall(inner.expression);
-                    if (call && call.form === 'forRoot' && call.ref.entry.forRoot) {
-                        need({ symbol: call.ref.entry.forRoot.replacement, entrypoint: call.ref.entry.forRoot.entrypoint });
-                        planOf(arr).replace.set(el, [providerText(call)]);
-                        markHandled(el);
-                    }
-                }
-                continue;
-            }
-            // 4. `importProvidersFrom(X.forRoot(), outro)`
-            if (ts.isCallExpression(el) &&
-                ts.isIdentifier(el.expression) &&
-                el.expression.text === 'importProvidersFrom') {
-                const remaining = [];
-                const providers = [];
-                let changed = false;
-                for (const arg of el.arguments) {
-                    if (ts.isIdentifier(arg) && refs.has(arg.text)) {
-                        handled.add(arg);
-                        changed = true;
-                        continue;
-                    }
-                    const call = asModuleCall(arg);
-                    if (call && call.form === 'forChild' && call.ref.entry.forChild === 'remove') {
-                        markHandled(arg);
-                        changed = true;
-                        continue;
-                    }
-                    if (call && call.form === 'forRoot' && call.ref.entry.forRoot) {
-                        need({ symbol: call.ref.entry.forRoot.replacement, entrypoint: call.ref.entry.forRoot.entrypoint });
-                        providers.push(providerText(call));
-                        markHandled(arg);
-                        changed = true;
-                        continue;
-                    }
-                    remaining.push(arg.getText(sourceFile));
-                }
-                if (changed) {
-                    const texts = [...providers];
-                    if (remaining.length > 0)
-                        texts.push(`importProvidersFrom(${remaining.join(', ')})`);
-                    planOf(arr).replace.set(el, texts);
-                }
-            }
-        }
-    };
-    const visitArrays = (node) => {
-        if (ts.isArrayLiteralExpression(node))
-            processArray(node);
-        ts.forEachChild(node, visitArrays);
-    };
-    visitArrays(sourceFile);
-    // Referências a módulos que ficaram fora dos arrays tratados: mantém o import e avisa.
-    const visitRefs = (node) => {
-        if (ts.isIdentifier(node) && refs.has(node.text) && !handled.has(node)) {
-            const parent = node.parent;
-            const inImport = parent && (ts.isImportSpecifier(parent) || ts.isImportClause(parent));
-            if (!inImport) {
-                keep.add(node.text);
-                addManual(node, `"${node.text}" é usado fora de um array de imports/providers: migre manualmente.`);
-            }
-        }
-        ts.forEachChild(node, visitRefs);
-    };
-    visitRefs(sourceFile);
-    if (plans.size === 0 && newProps.size === 0) {
-        return { updated: content, manual };
-    }
-    const changes = [];
-    const hasComments = (arr) => /\/\/|\/\*/.test(content.slice(arr.getStart(), arr.getEnd()));
-    for (const [arr, plan] of plans) {
-        const commented = hasComments(arr);
-        const existing = new Set();
-        for (const el of arr.elements) {
-            if (!plan.replace.has(el))
-                existing.add(normalizeText(el.getText(sourceFile)));
-        }
-        const items = [];
-        for (const el of arr.elements) {
-            const replacement = plan.replace.get(el);
-            if (replacement === undefined) {
-                items.push(commented ? el.getFullText(sourceFile).trim() : el.getText(sourceFile));
-                continue;
-            }
-            for (const text of replacement) {
-                const key = normalizeText(text);
-                if (existing.has(key))
-                    continue;
-                existing.add(key);
-                items.push(text);
-            }
-        }
-        for (const text of plan.append) {
-            const key = normalizeText(text);
-            if (!existing.has(key)) {
-                existing.add(key);
-                items.push(text);
-            }
-        }
-        changes.push({ start: arr.getStart(sourceFile), end: arr.getEnd(), replacement: renderArray(content, arr, items) });
-    }
-    for (const [obj, byProp] of newProps) {
-        const text = [...byProp].map(([name, texts]) => `${name}: [${texts.join(', ')}]`).join(', ');
-        changes.push(insertPropertyChange(content, obj, text));
-    }
-    let updated = (0, ast_utils_1.applyChanges)(content, changes);
-    for (const symbol of needed.values()) {
-        updated = (0, ast_utils_1.ensureNamedImport)(updated, symbol.symbol, importSpecifier(symbol.entrypoint));
-    }
-    const removeBySpecifier = new Map();
-    for (const [local, ref] of refs) {
-        if (keep.has(local))
-            continue;
-        const names = removeBySpecifier.get(ref.specifier) ?? new Set();
-        names.add(local);
-        removeBySpecifier.set(ref.specifier, names);
-    }
-    for (const [specifier, names] of removeBySpecifier) {
-        updated = removeNamedImports(updated, specifier, names);
-    }
-    return { updated, manual };
-}
-function migrateModulesToStandalone(options, report) {
-    return (tree, context) => {
-        const readFile = (filePath) => (tree.exists(filePath) ? tree.readText(filePath) : undefined);
-        const resolveAlias = (0, tsconfig_paths_1.createAliasResolver)(tree);
-        (0, scope_1.visitScopedFiles)(tree, options, context, (filePath) => {
-            if (!filePath.endsWith('.ts') || filePath.endsWith('.d.ts'))
-                return;
-            const content = tree.readText(filePath);
-            if (!content.includes(`${PACKAGE}/`))
-                return;
-            const { updated, manual } = migrateModulesInContent(filePath, content, readFile, exports.MODULES_MAP, resolveAlias);
-            if (updated !== content) {
-                tree.overwrite(filePath, (0, eol_1.preserveLineEndings)(content, updated));
-                report.markChanged(exports.ITEM_ID, filePath);
-            }
-            for (const entry of manual) {
-                report.addManual(exports.ITEM_ID, { file: filePath, line: entry.line, message: entry.message }, context);
-            }
-        });
-    };
-}
-function migrate(options = {}) {
-    return migrateModulesToStandalone(options, new report_1.MigrationReport());
-}
-//# sourceMappingURL=index.js.map