@seniorsistemas/angular-components 19.9.15 → 19.10.0

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

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