@openrewrite/recipes-nodejs 0.51.0-20260922-170911 → 0.51.1

package/src/migrate/source-map-support/enable-source-maps-at-launch.ts

@@ -0,0 +1,289 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, ScanningRecipe, Tree, TreeVisitor} from "@openrewrite/rewrite";
+import {J} from "@openrewrite/rewrite/java";
+import {JavaScriptVisitor, JS, maybeUnbind} from "@openrewrite/rewrite/javascript";
+import {getMemberKeyName, isLiteral, isMember, isObject, Json, JsonVisitor} from "@openrewrite/rewrite/json";
+import {PlainText} from "@openrewrite/rewrite/text";
+import {dirOf, isPackageJson} from "../package-json-support";
+import {addSourceMapsFlag, launchesNode, REGISTER_MODULES, shebangWithSourceMapsFlag} from "./register-flag";
+import {isSourceMapSupport, SourceMapSupportVisitor, sourcePathOf, stringLiteral} from "./source-map-support-support";
+
+interface Accumulator {
+    /** Files holding an `install()` or `register` entry point the in-place rewrite declines. */
+    declined: string[];
+    /** `bin` targets each `package.json` declares, as repo-relative paths. */
+    binTargets: string[];
+    /** Files whose shebang can carry Node's flags. */
+    rewritableShebangs: string[];
+    /** Packages with a script that runs Node directly, which can take the flag. */
+    launchableScripts: string[];
+    /** Every `package.json` directory, so a source can be attributed to its package. */
+    packageDirs: string[];
+}
+
+/** The nearest enclosing directory that is a package, for a repo-relative path. */
+function packageOf(path: string, packageDirs: string[]): string | undefined {
+    const candidates = packageDirs.filter(dir => dir === '' || path.startsWith(dir + '/'));
+    return candidates.sort((a, b) => b.length - a.length)[0];
+}
+
+function joinPath(dir: string, rest: string): string {
+    const normalized = rest.replace(/^\.\//, '');
+    return dir === '' ? normalized : `${dir}/${normalized}`;
+}
+
+export class EnableSourceMapsAtLaunch extends ScanningRecipe<Accumulator> {
+    readonly name = "org.openrewrite.node.migrate.source-map-support.enable-source-maps-at-launch";
+    readonly displayName = "Enable native source maps at launch and drop `source-map-support`";
+    readonly description = "Where `source-map-support` is installed too late for `process.setSourceMapsEnabled(true)` " +
+        "to stand in for it — in an ES module, every `import` is evaluated before any statement runs, so the call " +
+        "would only map what loads after it — this puts `--enable-source-maps` on whatever launches the process " +
+        "instead, which Node applies before the first module loads. The flag goes into the package's `bin` shebang " +
+        "(as `#!/usr/bin/env -S node --enable-source-maps`) and into any `package.json` script that runs `node` or " +
+        "`mocha` directly. The `install()` call and `register` import are then redundant and are removed, rather " +
+        "than replaced by a call that would map less. A package with no launcher this recipe can reach is left " +
+        "alone and reported by `FindSourceMapSupportManualMigrations`.";
+    readonly tags = ["source-map-support"];
+
+    initialValue(_ctx: ExecutionContext): Accumulator {
+        return {declined: [], binTargets: [], rewritableShebangs: [], launchableScripts: [], packageDirs: []};
+    }
+
+    async scanner(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>> {
+        const js = new class extends SourceMapSupportVisitor<ExecutionContext> {
+            protected override async visitShebang(shebang: JS.Shebang, p: ExecutionContext): Promise<J | undefined> {
+                if (shebangWithSourceMapsFlag(shebang.text)) acc.rewritableShebangs.push(sourcePathOf(this.cursor));
+                return super.visitShebang(shebang, p);
+            }
+
+            protected override async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                if (!jsImport.importClause && REGISTER_MODULES.has(stringLiteral(jsImport.moduleSpecifier?.element) ?? '')) {
+                    this.recordIfDeclined();
+                }
+                return super.visitImportDeclaration(jsImport, p);
+            }
+
+            protected override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                if (this.isInstall(method) || isRegisterRequire(method)) this.recordIfDeclined();
+                return super.visitMethodInvocation(method, p);
+            }
+
+            /** Only a site the in-place rewrite turns down is this recipe's business. */
+            private recordIfDeclined(): void {
+                if (this.mapsEverythingLoaded()) return;
+                const path = sourcePathOf(this.cursor);
+                if (!acc.declined.includes(path)) acc.declined.push(path);
+            }
+        };
+
+        const json = new class extends JsonVisitor<ExecutionContext> {
+            protected override async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                if (!isPackageJson(doc.sourcePath) || !isObject(doc.value)) return doc;
+                const dir = dirOf(doc.sourcePath);
+                if (!acc.packageDirs.includes(dir)) acc.packageDirs.push(dir);
+                const root = doc.value as Json.Object;
+                for (const padded of root.members) {
+                    if (!isMember(padded.element)) continue;
+                    const member = padded.element as Json.Member;
+                    const key = getMemberKeyName(member) ?? '';
+                    if (key === 'bin') {
+                        for (const target of binTargetsOf(member.value)) acc.binTargets.push(joinPath(dir, target));
+                    } else if (key === 'scripts' && isObject(member.value)) {
+                        const launchable = (member.value as Json.Object).members.some(entry => {
+                            if (!isMember(entry.element)) return false;
+                            const value = (entry.element as Json.Member).value;
+                            return isLiteral(value) && typeof value.value === 'string' && launchesNode(value.value);
+                        });
+                        if (launchable && !acc.launchableScripts.includes(dir)) acc.launchableScripts.push(dir);
+                    }
+                }
+                return doc;
+            }
+        };
+
+        return new class extends TreeVisitor<Tree, ExecutionContext> {
+            protected override async accept(tree: Tree, p: ExecutionContext): Promise<Tree | undefined> {
+                if (tree.kind === JS.Kind.CompilationUnit) return js.visit(tree, p);
+                if (tree.kind === Json.Kind.Document) return json.visit(tree, p);
+                if (tree.kind === PlainText.Kind.PlainText) {
+                    const text = tree as PlainText;
+                    const first = text.text.split('\n', 1)[0];
+                    if (shebangWithSourceMapsFlag(first)) acc.rewritableShebangs.push(text.sourcePath);
+                }
+                return tree;
+            }
+        };
+    }
+
+    async editorWithData(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>> {
+        const packageOfPath = (path: string) => enclosingPackage(path, acc.packageDirs);
+
+        // A package can take the flag if a script runs Node, or if a shebang this recipe can rewrite
+        // belongs to it — either the declining file's own or one its `bin` points at.
+        const shebangsFor = (dir: string) => acc.rewritableShebangs.filter(path =>
+            packageOfPath(path) === dir &&
+            (acc.declined.includes(path) || acc.binTargets.includes(path)));
+
+        const declinedPackages = new Set(acc.declined.map(packageOfPath));
+        const flagged = new Set([...declinedPackages].filter(dir =>
+            acc.launchableScripts.includes(dir) || shebangsFor(dir).length > 0));
+
+        const removeSites = new Set(acc.declined.filter(path => flagged.has(packageOfPath(path))));
+        const shebangsToFlag = new Set([...flagged].flatMap(shebangsFor));
+        // A shebang already puts the flag on the process this package launches, so its scripts —
+        // which may run unrelated tools — are left as they are.
+        const scriptPackages = new Set([...flagged].filter(dir => shebangsFor(dir).length === 0));
+
+        const js = new class extends JavaScriptVisitor<ExecutionContext> {
+            protected override async visitJsCompilationUnit(cu: JS.CompilationUnit, p: ExecutionContext): Promise<J | undefined> {
+                const flagShebang = shebangsToFlag.has(cu.sourcePath);
+                const removeHere = removeSites.has(cu.sourcePath);
+                if (!flagShebang && !removeHere) return cu;
+
+                let statements = cu.statements;
+                if (flagShebang) {
+                    statements = statements.map(padded => {
+                        if (padded.element.kind !== JS.Kind.Shebang) return padded;
+                        const flagged = shebangWithSourceMapsFlag((padded.element as JS.Shebang).text);
+                        return flagged ? {...padded, element: {...padded.element, text: flagged} as JS.Shebang} : padded;
+                    });
+                }
+                if (removeHere) {
+                    statements = withoutStatements(statements, s => isRedundantEntryPoint(s));
+                }
+                const result = statements === cu.statements ? cu : {...cu, statements} as JS.CompilationUnit;
+                const visited = await super.visitJsCompilationUnit(result, p) as JS.CompilationUnit;
+                if (removeHere) {
+                    // The launch flag covers the whole process, so nothing needs the module any more.
+                    maybeUnbind(this, {module: 'source-map-support'});
+                    maybeUnbind(this, {module: 'source-map-support', member: 'install'});
+                }
+                return visited;
+            }
+        };
+
+        const json = new class extends JsonVisitor<ExecutionContext> {
+            protected override async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                if (!isPackageJson(doc.sourcePath) || !isObject(doc.value)) return doc;
+                if (!scriptPackages.has(dirOf(doc.sourcePath))) return doc;
+                const root = doc.value as Json.Object;
+                let changed = false;
+                const members = root.members.map(padded => {
+                    if (!isMember(padded.element)) return padded;
+                    const member = padded.element as Json.Member;
+                    if (getMemberKeyName(member) !== 'scripts' || !isObject(member.value)) return padded;
+                    const scripts = member.value as Json.Object;
+                    let sectionChanged = false;
+                    const entries = scripts.members.map(entry => {
+                        if (!isMember(entry.element)) return entry;
+                        const script = entry.element as Json.Member;
+                        const value = script.value;
+                        if (!isLiteral(value) || typeof value.value !== 'string') return entry;
+                        const updated = addSourceMapsFlag(value.value);
+                        if (updated === value.value) return entry;
+                        sectionChanged = true;
+                        return {
+                            ...entry,
+                            element: {...script, value: {...value, value: updated, source: JSON.stringify(updated)}} as Json.Member
+                        };
+                    });
+                    if (!sectionChanged) return padded;
+                    changed = true;
+                    return {...padded, element: {...member, value: {...scripts, members: entries}} as Json.Member};
+                });
+                return changed ? {...doc, value: {...root, members}} as Json.Document : doc;
+            }
+        };
+
+        return new class extends TreeVisitor<Tree, ExecutionContext> {
+            protected override async accept(tree: Tree, p: ExecutionContext): Promise<Tree | undefined> {
+                if (tree.kind === JS.Kind.CompilationUnit) return js.visit(tree, p);
+                if (tree.kind === Json.Kind.Document) return json.visit(tree, p);
+                if (tree.kind === PlainText.Kind.PlainText) {
+                    const text = tree as PlainText;
+                    if (!shebangsToFlag.has(text.sourcePath)) return tree;
+                    const lines = text.text.split('\n');
+                    const flagged = shebangWithSourceMapsFlag(lines[0]);
+                    if (!flagged) return tree;
+                    return {...text, text: [flagged, ...lines.slice(1)].join('\n')} as PlainText;
+                }
+                return tree;
+            }
+        };
+    }
+}
+
+/**
+ * Drops the statements `remove` selects, handing the first of a removed run its successor's place
+ * in the layout, so the blank line that separated it from what came before isn't left behind. Only
+ * the whitespace moves: a comment sits in the prefix of the statement it documents, so taking the
+ * successor's prefix wholesale would delete the comment that belongs to it.
+ */
+function withoutStatements(statements: J.RightPadded<any>[], remove: (s: J) => boolean): J.RightPadded<any>[] {
+    const kept: J.RightPadded<any>[] = [];
+    let pendingWhitespace: string | undefined;
+    for (const padded of statements) {
+        if (remove(padded.element)) {
+            pendingWhitespace ??= (padded.element.prefix as J.Space).whitespace;
+            continue;
+        }
+        kept.push(pendingWhitespace === undefined ? padded : {
+            ...padded,
+            element: {...padded.element, prefix: {...padded.element.prefix, whitespace: pendingWhitespace}}
+        });
+        pendingWhitespace = undefined;
+    }
+    return kept;
+}
+
+/** The innermost package a repo-relative path belongs to, of those the scan saw. */
+function enclosingPackage(path: string, packageDirs: string[]): string {
+    return packageOf(path, packageDirs) ?? '';
+}
+
+/** `require('source-map-support/register')`, which loads the module for its side effect alone. */
+function isRegisterRequire(m: J.MethodInvocation): boolean {
+    return !m.select && m.name.simpleName === 'require' &&
+        REGISTER_MODULES.has(stringLiteral(m.arguments.elements[0]?.element) ?? '');
+}
+
+/** Whether a top-level statement exists only to install source-map-support. */
+function isRedundantEntryPoint(statement: J): boolean {
+    if (statement.kind === JS.Kind.Import) {
+        const imp = statement as JS.Import;
+        return !imp.importClause && isSourceMapSupport(stringLiteral(imp.moduleSpecifier?.element));
+    }
+    const expression = statement.kind === JS.Kind.ExpressionStatement
+        ? (statement as JS.ExpressionStatement).expression
+        : statement;
+    const call = expression?.kind === JS.Kind.Await ? (expression as JS.Await).expression : expression;
+    if (call?.kind !== J.Kind.MethodInvocation) return false;
+    const m = call as J.MethodInvocation;
+    if (isRegisterRequire(m)) return true;
+    if (m.name.simpleName !== 'install') return false;
+    const select = m.select?.element;
+    return select?.kind === J.Kind.MethodInvocation
+        ? isSourceMapSupport(requiredModuleOf(select as J.MethodInvocation))
+        : select !== undefined;
+}
+
+function requiredModuleOf(m: J.MethodInvocation): string | undefined {
+    return !m.select && m.name.simpleName === 'require'
+        ? stringLiteral(m.arguments.elements[0]?.element)
+        : undefined;
+}
+
+function binTargetsOf(value: Json.Value): string[] {
+    if (isLiteral(value)) return typeof value.value === 'string' ? [value.value] : [];
+    if (!isObject(value)) return [];
+    return (value as Json.Object).members.flatMap(padded => {
+        if (!isMember(padded.element)) return [];
+        const entry = (padded.element as Json.Member).value;
+        return isLiteral(entry) && typeof entry.value === 'string' ? [entry.value] : [];
+    });
+}

package/src/migrate/source-map-support/migrate-source-map-support-to-native.ts

@@ -14,17 +14,22 @@ export class MigrateSourceMapSupportToNative extends Recipe {
     readonly displayName = "Migrate `source-map-support` to Node.js native source maps";
     readonly description = "Replaces the `source-map-support` package with Node.js's built-in source map support. " +
         "Where Node is launched from `package.json` scripts or mocha/ava configuration, `source-map-support/register` becomes " +
-        "the `--enable-source-maps` flag; in code, `install()` and `register` imports become `process.setSourceMapsEnabled(true)`. " +
+        "the `--enable-source-maps` flag; in code, `install()` and `register` imports become " +
+        "`process.setSourceMapsEnabled(true)` where that maps everything the module loads. Where it would not " +
+        "— in an ES module every `import` is evaluated before any statement runs — the flag goes on the " +
+        "launcher instead, in the package's `bin` shebang or a `node` script, and the entry point is removed " +
+        "as redundant. " +
         "Uses with no native equivalent (custom `retrieveSourceMap`, browser bundles, webpack banners) are left in place, and " +
-        "the dependency is removed from each `package.json` that no longer needs it. Everything left in place is " +
-        "recorded in the `SourceMapSupportManualMigrationSteps` data table with a suggested replacement.";
+        "the dependency is removed from each `package.json` that declares it, with the lock file updated to match. " +
+        "Everything left in place is recorded in the `SourceMapSupportManualMigrationSteps` data table with a " +
+        "suggested replacement, and has to be migrated before building, since the dependency is removed regardless.";
     readonly tags = ["source-map-support"];
 
     async recipeList(): Promise<Recipe[]> {
         return [
             ...sourceMapSupportRewriteRecipes(),
             new FindSourceMapSupportManualMigrations(),
-            new RemoveUnusedSourceMapSupportDependency({accountForMigration: true}),
+            new RemoveUnusedSourceMapSupportDependency(),
         ];
     }
 }

package/src/migrate/source-map-support/register-flag.ts

@@ -30,6 +30,54 @@ function commandOf(segment: string): string | undefined {
     return undefined;
 }
 
+/** A `#!/usr/bin/env node` line, which `env -S` lets carry Node's own flags. */
+const SHEBANG = /^#!(\s*\S*\/env\s+)(-S\s+)?node(?=\s|$)(.*)$/;
+
+const ENABLE_FLAG = '--enable-source-maps';
+
+export function hasSourceMapsFlag(text: string): boolean {
+    return new RegExp(`(^|\\s)${ENABLE_FLAG}(\\s|$)`).test(text);
+}
+
+/**
+ * Whether any part of a shell command launches this package's own code under Node. An inline
+ * `node -e` program and a `node_modules/...` entry point are Node processes too, but neither loads
+ * the module whose entry point is being removed, so neither is a launcher worth flagging.
+ */
+export function launchesNode(script: string): boolean {
+    return script.split(/(\s*(?:&&|\|\||;|\|)\s*)/).some((part, i) => {
+        if (i % 2 === 1 || !NODE_FLAG_COMMANDS.has(commandOf(part) ?? '')) return false;
+        if (/(^|\s)(?:-e|--eval|-p|--print)(?=\s|$)/.test(part)) return false;
+        return !/(^|\s)node_modules\//.test(part);
+    });
+}
+
+/**
+ * Adds `--enable-source-maps` to each part of a shell command that runs Node or mocha, so the flag
+ * is in place before any module loads. Parts running anything else are left alone, since a flag
+ * they don't recognize would fail them.
+ */
+export function addSourceMapsFlag(script: string): string {
+    const parts = script.split(/(\s*(?:&&|\|\||;|\|)\s*)/);
+    return parts.map((part, i) => {
+        if (i % 2 === 1 || !NODE_FLAG_COMMANDS.has(commandOf(part) ?? '') || hasSourceMapsFlag(part)) return part;
+        // Straight after the command, where Node's own flags have to sit: anything later is the script's.
+        return part.replace(/(^|\s)((?:\S*[\\/])?(?:node|mocha|_mocha))(?=\s|$)/, `$1$2 ${ENABLE_FLAG}`);
+    }).join('');
+}
+
+/**
+ * The shebang with `--enable-source-maps` added, or undefined where the line isn't a plain
+ * `env node` shebang. `env -S` is what allows an argument at all; without it the kernel hands
+ * `node --enable-source-maps` to `env` as a single program name.
+ */
+export function shebangWithSourceMapsFlag(line: string): string | undefined {
+    const match = SHEBANG.exec(line);
+    if (!match || hasSourceMapsFlag(line)) return undefined;
+    const [, env, dashS, rest] = match;
+    return `#!${env}${dashS ?? '-S '}node ${ENABLE_FLAG}${rest}`;
+}
+
 /**
  * Replaces `-r source-map-support/register` with `--enable-source-maps` in each part of a shell
  * command that runs Node or mocha. Parts that run anything else are left alone, since a flag they

package/src/migrate/source-map-support/remove-unused-source-map-support-dependency.ts

@@ -4,23 +4,14 @@
  * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
  */
 
-import {Recipe} from "@openrewrite/rewrite";
-import {RemoveUnusedDependency} from "../remove-unused-dependency";
-import {sourceMapSupportRewriteRecipes} from "./source-map-support-rewrites";
+import {RemoveDependencies} from "../remove-dependencies";
 
-export class RemoveUnusedSourceMapSupportDependency extends RemoveUnusedDependency {
+export class RemoveUnusedSourceMapSupportDependency extends RemoveDependencies {
     readonly name = "org.openrewrite.node.migrate.source-map-support.remove-unused-source-map-support-dependency";
-    readonly displayName = "Remove unused `source-map-support` dependency";
-    readonly description = "Removes `source-map-support` and `@types/source-map-support` from each `package.json` whose " +
-        "package no longer references it from a JavaScript or TypeScript source, a `package.json` script or tool " +
-        "configuration, or a `.mocharc`/`mocha.opts` file. A webpack banner that injects `require(\"source-map-support\")` " +
-        "into a bundle counts as a use. Lock files are not regenerated; run the package manager's install afterwards.";
+    readonly displayName = "Remove the `source-map-support` dependency";
+    readonly description = "Removes `source-map-support` and `@types/source-map-support` from each `package.json` " +
+        "that declares them, and updates the lock file to match.";
     readonly tags = ["source-map-support"];
 
-    protected readonly module = 'source-map-support';
     protected readonly packages = ['source-map-support', '@types/source-map-support'];
-
-    protected migrationRecipes(): Recipe[] {
-        return sourceMapSupportRewriteRecipes();
-    }
 }

package/src/migrate/source-map-support/source-map-support-rewrites.ts

@@ -5,6 +5,7 @@
  */
 
 import {Recipe} from "@openrewrite/rewrite";
+import {EnableSourceMapsAtLaunch} from "./enable-source-maps-at-launch";
 import {ReplaceSourceMapSupportInstall} from "./replace-source-map-support-install";
 import {ReplaceSourceMapSupportRegisterInPackageJson} from "./replace-source-map-support-register-in-package-json";
 import {ReplaceSourceMapSupportRegisterInMochaConfig} from "./replace-source-map-support-register-in-mocha-config";
@@ -15,5 +16,7 @@ export function sourceMapSupportRewriteRecipes(): Recipe[] {
         new ReplaceSourceMapSupportRegisterInPackageJson(),
         new ReplaceSourceMapSupportRegisterInMochaConfig(),
         new ReplaceSourceMapSupportInstall(),
+        // Last of the rewrites: it takes the entry points the in-place rewrite turned down.
+        new EnableSourceMapsAtLaunch(),
     ];
 }

package/src/migrate/upgrade-node-22.ts

@@ -4,6 +4,7 @@
  * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
  */
 import {Recipe} from "@openrewrite/rewrite";
+import {prepareJavaRecipe} from "@openrewrite/rewrite/rpc";
 import {RemovePromisifyOnPromise} from "./promisify-on-promise";
 import {ReplaceIsWebAssemblyCompiledModule} from "./util-types-wasm";
 import {ReplaceCryptoConstructors} from "./crypto-constructors";
@@ -48,6 +49,7 @@ export class UpgradeNode22 extends Recipe {
         return [
             new IncreaseNodeEngineVersion({version: "22"}),
             new IncreaseNodeEngineVersionInGithubActions({version: "22"}),
+            await prepareJavaRecipe("org.openrewrite.nodejs.migrate.UpgradeNodeVersion", {version: "22"}),
             ...node22EolDeprecations,
             ...node22RuntimeDeprecations,
             ...olderDeprecations,

package/src/migrate/upgrade-node-24.ts

@@ -4,6 +4,7 @@
  * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
  */
 import {Recipe} from "@openrewrite/rewrite";
+import {prepareJavaRecipe} from "@openrewrite/rewrite/rpc";
 import {ReplaceUtilLog} from "./util-log";
 import {ReplaceZlibBytesRead} from "./zlib-bytes-read";
 import {ReplaceCryptoFips} from "./crypto-fips";
@@ -43,6 +44,7 @@ export class UpgradeNode24 extends Recipe {
         return [
             new IncreaseNodeEngineVersion({version: "24"}),
             new IncreaseNodeEngineVersionInGithubActions({version: "24"}),
+            await prepareJavaRecipe("org.openrewrite.nodejs.migrate.UpgradeNodeVersion", {version: "24"}),
             new UpgradeNode22(),
             ...node24EolDeprecations,
             ...node24RuntimeDeprecations,

package/dist/migrate/remove-unused-dependency.d.ts

@@ -1,43 +0,0 @@
-import { DataTable, ExecutionContext, Recipe, ScanningRecipe, TreeVisitor } from "@openrewrite/rewrite";
-import { Json } from "@openrewrite/rewrite/json";
-interface Accumulator {
-    referencingFiles: string[];
-    parsedFiles: string[];
-    replacementFiles: string[];
-}
-export declare class DependencyKept {
-    sourcePath: string;
-    recipe: string;
-    package: string;
-    reason: string;
-    evidence: string;
-}
-export declare function dependenciesKept(): DataTable<DependencyKept>;
-export declare const KEPT_REASONS: {
-    projen: (module: string) => string;
-    referenced: (module: string) => string;
-    unparsed: string;
-};
-export declare function dirOf(path: string): string;
-export declare function isPackageJson(path: string): boolean;
-export declare function anyBeneath(dir: string, files: string[]): boolean;
-export declare function removeMembers(obj: Json.Object, keys: Set<string>): Json.Object;
-export declare abstract class RemoveUnusedDependency extends ScanningRecipe<Accumulator> {
-    protected abstract readonly module: string;
-    protected abstract readonly packages: string[];
-    protected abstract migrationRecipes(): Recipe[];
-    protected replacementModules(): string[];
-    private readonly kept;
-    protected mockFile(): RegExp;
-    private readonly precedingRecipes;
-    accountForMigration?: boolean;
-    constructor(options?: {
-        precedingRecipes?: Recipe[];
-        accountForMigration?: boolean;
-    });
-    initialValue(_ctx: ExecutionContext): Accumulator;
-    scanner(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>>;
-    editorWithData(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>>;
-}
-export {};
-//# sourceMappingURL=remove-unused-dependency.d.ts.map

package/dist/migrate/remove-unused-dependency.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"remove-unused-dependency.d.ts","sourceRoot":"","sources":["../../src/migrate/remove-unused-dependency.ts"],"names":[],"mappings":"AAMA,OAAO,EAAS,SAAS,EAAgB,gBAAgB,EAAoB,MAAM,EAAE,cAAc,EAAkC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAC9K,OAAO,EAAuC,IAAI,EAAkC,MAAM,2BAA2B,CAAC;AAkBtH,UAAU,WAAW;IACjB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,qBAAa,cAAc;IAEvB,UAAU,EAAG,MAAM,CAAC;IAGpB,MAAM,EAAG,MAAM,CAAC;IAGhB,OAAO,EAAG,MAAM,CAAC;IAGjB,MAAM,EAAG,MAAM,CAAC;IAGhB,QAAQ,EAAG,MAAM,CAAC;CACrB;AAED,wBAAgB,gBAAgB,IAAI,SAAS,CAAC,cAAc,CAAC,CAO5D;AAED,eAAO,MAAM,YAAY;qBACJ,MAAM;yBAIF,MAAM;;CAK9B,CAAC;AAEF,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG1C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAEhE;AAkBD,wBAAgB,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAU9E;AAkCD,8BAAsB,sBAAuB,SAAQ,cAAc,CAAC,WAAW,CAAC;IAE5E,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAG3C,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAG/C,SAAS,CAAC,QAAQ,CAAC,gBAAgB,IAAI,MAAM,EAAE;IAO/C,SAAS,CAAC,kBAAkB,IAAI,MAAM,EAAE;IAIxC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAG3C,SAAS,CAAC,QAAQ,IAAI,MAAM;IAQ5B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAW;IAQ5C,mBAAmB,CAAC,EAAE,OAAO,CAAC;gBAElB,OAAO,CAAC,EAAE;QAAE,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;KAAE;IAKpF,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,WAAW;IAI3C,OAAO,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;IAwCtE,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;CA0CtF"}