knip 6.32.3 → 6.34.0

package/dist/DependencyDeputy.d.ts

@@ -22,9 +22,8 @@ export declare class DependencyDeputy {
     installedBinaries: Map<string, InstalledBinaries>;
     hasTypesIncluded: Map<string, Set<string>>;
     constructor({ isProduction, isStrict, isReportDependencies }: MainOptions);
-    addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }: {
+    addWorkspace({ name, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }: {
         name: string;
-        cwd: string;
         dir: string;
         manifestPath: string;
         manifestStr: string;

package/dist/DependencyDeputy.js

@@ -26,7 +26,7 @@ export class DependencyDeputy {
         this.installedBinaries = new Map();
         this.hasTypesIncluded = new Map();
     }
-    addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }) {
+    addWorkspace({ name, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }) {
         const dependencies = Object.keys(manifest.dependencies ?? {});
         const peerDependencies = Object.keys(manifest.peerDependencies ?? {});
         const optionalDependencies = Object.keys(manifest.optionalDependencies ?? {});
@@ -45,7 +45,6 @@ export class DependencyDeputy {
             const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
                 packageNames,
                 dir,
-                cwd,
             });
             this.setHostDependencies(name, hostDependencies);
             this.installedBinaries.set(name, installedBinaries);

package/dist/ProjectPrincipal.d.ts

@@ -1,6 +1,6 @@
 import type { ParseResult } from 'oxc-parser';
 import { CacheConsultant } from './CacheConsultant.ts';
-import type { AsyncCompilers, SyncCompilers } from './compilers/types.ts';
+import type { AsyncCompilers, Compilers, SyncCompilers } from './compilers/types.ts';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext, PluginVisitorObject } from './types/config.ts';
 import type { FileNode, ModuleGraph } from './types/module-graph.ts';
 import type { Paths } from './types/project.ts';
@@ -19,6 +19,8 @@ export declare class ProjectPrincipal {
     private _localRefsVisitor;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
+    private scopedSyncCompilers;
+    private scopedAsyncCompilers;
     private paths;
     private rootDirs;
     private tsConfigFile;
@@ -26,14 +28,15 @@ export declare class ProjectPrincipal {
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
     private findWorkspacePackageTarget;
+    private findWorkspaceNameByFilePath;
     fileManager: SourceFileManager;
     private resolveModule;
     resolveGlobPattern: ResolveGlobPattern;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
     private onPathAdded;
-    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspacePackageTarget?: WorkspacePackageTargetHandler);
-    addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
+    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspacePackageTarget: WorkspacePackageTargetHandler | undefined, findWorkspaceNameByFilePath: (filePath: string) => string | undefined);
+    addCompilers(workspaceName: string, compilers: Compilers): void;
     addPaths(paths: Paths, basePath: string, scope: string): void;
     addRootDirs(rootDirs: string[] | undefined, scope: string): void;
     init(): void;

package/dist/ProjectPrincipal.js

@@ -21,6 +21,7 @@ export class ProjectPrincipal {
         sourceText: '',
         addScript: () => { },
         addImport: () => { },
+        markImportExpressionHandled: () => { },
         addImportGlob: () => { },
         markExportRegistered: () => { },
     };
@@ -29,6 +30,8 @@ export class ProjectPrincipal {
     _localRefsVisitor;
     syncCompilers = new Map();
     asyncCompilers = new Map();
+    scopedSyncCompilers = new Map();
+    scopedAsyncCompilers = new Map();
     paths = new Map();
     rootDirs = new Map();
     tsConfigFile;
@@ -36,16 +39,18 @@ export class ProjectPrincipal {
     cache;
     toSourceFilePath;
     findWorkspacePackageTarget;
+    findWorkspaceNameByFilePath;
     fileManager;
     resolveModule = () => undefined;
     resolveGlobPattern = pattern => [pattern];
     resolvedFiles = new Set();
     deletedFiles = new Set();
     onPathAdded;
-    constructor(options, toSourceFilePath, findWorkspacePackageTarget) {
+    constructor(options, toSourceFilePath, findWorkspacePackageTarget, findWorkspaceNameByFilePath) {
         this.cache = new CacheConsultant('root', options);
         this.toSourceFilePath = toSourceFilePath;
         this.findWorkspacePackageTarget = findWorkspacePackageTarget;
+        this.findWorkspaceNameByFilePath = findWorkspaceNameByFilePath;
         this.tsConfigFile = options.tsConfigFile ? toAbsolute(options.tsConfigFile, options.cwd) : undefined;
         this.pluginVisitorObjects.push(createBunShellVisitor(this.pluginCtx));
         this.fileManager = new SourceFileManager({
@@ -53,16 +58,34 @@ export class ProjectPrincipal {
         });
         this.walkAndAnalyze = timerify(this.walkAndAnalyze.bind(this), 'walkAndAnalyze');
     }
-    addCompilers(compilers) {
+    addCompilers(workspaceName, compilers) {
         for (const [ext, compiler] of compilers[0]) {
-            if (!this.syncCompilers.has(ext)) {
-                this.syncCompilers.set(ext, compiler);
+            const workspaceCompilers = this.scopedSyncCompilers.get(ext);
+            if (workspaceCompilers) {
+                workspaceCompilers.set(workspaceName, compiler);
+            }
+            else {
+                const workspaceCompilers = new Map([[workspaceName, compiler]]);
+                this.scopedSyncCompilers.set(ext, workspaceCompilers);
+                this.syncCompilers.set(ext, (source, filePath) => {
+                    const owner = this.findWorkspaceNameByFilePath(filePath);
+                    return ((owner ? workspaceCompilers.get(owner) : undefined) ?? compiler)(source, filePath);
+                });
                 this.extensions.add(ext);
             }
         }
         for (const [ext, compiler] of compilers[1]) {
-            if (!this.asyncCompilers.has(ext)) {
-                this.asyncCompilers.set(ext, compiler);
+            const workspaceCompilers = this.scopedAsyncCompilers.get(ext);
+            if (workspaceCompilers) {
+                workspaceCompilers.set(workspaceName, compiler);
+            }
+            else {
+                const workspaceCompilers = new Map([[workspaceName, compiler]]);
+                this.scopedAsyncCompilers.set(ext, workspaceCompilers);
+                this.asyncCompilers.set(ext, (source, filePath) => {
+                    const owner = this.findWorkspaceNameByFilePath(filePath);
+                    return ((owner ? workspaceCompilers.get(owner) : undefined) ?? compiler)(source, filePath);
+                });
                 this.extensions.add(ext);
             }
         }

package/dist/cli.js

@@ -51,7 +51,7 @@ const main = async () => {
             isShowProgress: options.isShowProgress,
             isTreatConfigHintsAsErrors: options.isTreatConfigHintsAsErrors,
             isTreatTagHintsAsErrors: options.isTreatTagHintsAsErrors,
-            maxShowIssues: args['max-show-issues'] ? Number(args['max-show-issues']) : undefined,
+            maxShowIssues: options.maxShowIssues,
             options: args['reporter-options'] ?? '',
             preprocessorOptions: args['preprocessor-options'] ?? '',
             selectedWorkspaces,
@@ -75,7 +75,7 @@ const main = async () => {
             perfObserver.reset();
         }
         if (!args['no-exit-code'] &&
-            (totalErrorCount > Number(args['max-issues'] ?? 0) ||
+            (totalErrorCount > options.maxIssues ||
                 (!options.isDisableConfigHints && options.isTreatConfigHintsAsErrors && configurationHints.length > 0) ||
                 (!options.isDisableTagHints && options.isTreatTagHintsAsErrors && tagHints.size > 0))) {
             process.exitCode = 1;

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { KnipConfig } from './types.ts';
+export declare const defineConfig: (config: KnipConfig) => KnipConfig;

package/dist/config.js

@@ -0,0 +1 @@
+export const defineConfig = (config) => config;

package/dist/graph/analyze.js

@@ -106,7 +106,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                     exportedItem.members.length > 0 &&
                                     exportedItem.type !== 'enum';
                                 if ((isEnumMembers || isNsMembers) && exportedItem.members.length > 0) {
-                                    if (importsForExport.enumerated?.has(identifier))
+                                    if (explorer.isEnumerated(filePath, identifier))
                                         continue;
                                     if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
                                         continue;
@@ -191,7 +191,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                         }
                     }
                 }
-                if (file.imports?.external) {
+                if (file.imports.external) {
                     for (const extImport of file.imports.external) {
                         const packageName = getPackageNameFromModuleSpecifier(extImport.specifier);
                         const isHandled = packageName &&
@@ -200,7 +200,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 isTypeOnly: extImport.isTypeOnly,
                                 isResolved: extImport.filePath !== undefined,
                             });
-                        if (!isHandled)
+                        if (!isHandled && !(extImport.jsDocTags?.size && shouldIgnoreTags(extImport.jsDocTags)))
                             collector.addIssue({
                                 type: 'unlisted',
                                 filePath,
@@ -214,7 +214,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             });
                     }
                 }
-                if (file.imports?.unresolved) {
+                if (file.imports.unresolved) {
                     for (const unresolvedImport of file.imports.unresolved) {
                         const { specifier, pos, line, col } = unresolvedImport;
                         collector.addIssue({

package/dist/graph/build.js

@@ -41,7 +41,6 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             continue;
         deputy.addWorkspace({
             name,
-            cwd: options.cwd,
             dir,
             manifestPath,
             manifestStr,
@@ -91,7 +90,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             compilers[0].set(ext, compiler);
         };
         await worker.registerCompilers(registerCompiler);
-        principal.addCompilers(compilers);
+        principal.addCompilers(name, compilers);
         const extensions = getCompilerExtensions(compilers);
         const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
         const config = chief.getConfigForWorkspace(name, extensions);

package/dist/graph-explorer/explorer.d.ts

@@ -5,6 +5,7 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
         treatStarAtEntryAsReferenced?: boolean;
     }) => readonly [false, string | undefined];
     hasStrictlyNsReferences: (filePath: string, identifier: string) => [boolean, (string | undefined)?];
+    isEnumerated: (filePath: string, identifier: string) => boolean;
     buildExportsTree: (options: {
         filePath?: string;
         identifier?: string;

package/dist/graph-explorer/explorer.js

@@ -6,12 +6,14 @@ import { getContention } from './operations/get-contention.js';
 import { getDependencyUsage } from './operations/get-dependency-usage.js';
 import { getUsage } from './operations/get-usage.js';
 import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references.js';
+import { isEnumerated } from './operations/is-enumerated.js';
 import { isReferenced } from './operations/is-referenced.js';
 import { resolveDefinition } from './operations/resolve-definition.js';
 export const createGraphExplorer = (graph, entryPaths) => {
     return {
         isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
         hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, filePath, graph.get(filePath)?.importedBy, identifier),
+        isEnumerated: (filePath, identifier) => isEnumerated(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
         getDependencyUsage: (pattern) => getDependencyUsage(graph, pattern),
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),

package/dist/graph-explorer/operations/is-enumerated.d.ts

@@ -0,0 +1,2 @@
+import type { ImportMaps, ModuleGraph } from '../../types/module-graph.ts';
+export declare const isEnumerated: (graph: ModuleGraph, filePath: string, importsForExport: ImportMaps | undefined, identifier: string) => boolean;

package/dist/graph-explorer/operations/is-enumerated.js

@@ -0,0 +1,33 @@
+import { getAliasReExportMap, getPassThroughReExportSources, getStarReExportSources } from '../visitors.js';
+export const isEnumerated = (graph, filePath, importsForExport, identifier) => {
+    const seen = new Set();
+    const walkDown = (path, importMaps, id) => {
+        if (!importMaps || seen.has(path))
+            return false;
+        seen.add(path);
+        if (importMaps.enumerated?.has(id))
+            return true;
+        const follow = (sources, nextId) => {
+            for (const source of sources) {
+                if (walkDown(source, graph.get(source)?.importedBy, nextId))
+                    return true;
+            }
+            return false;
+        };
+        const directSources = getPassThroughReExportSources(importMaps, id);
+        if (directSources && follow(directSources, id))
+            return true;
+        const starSources = getStarReExportSources(importMaps);
+        if (starSources && follow(starSources, id))
+            return true;
+        const aliasMap = getAliasReExportMap(importMaps, id);
+        if (aliasMap) {
+            for (const [alias, sources] of aliasMap) {
+                if (follow(sources, alias))
+                    return true;
+            }
+        }
+        return false;
+    };
+    return walkDown(filePath, importsForExport, identifier);
+};

package/dist/manifest/helpers.d.ts

@@ -1,9 +1,8 @@
-import type { Scripts } from '../types/package-json.ts';
+import type { PackageJson, Scripts } from '../types/package-json.ts';
 type LoadPackageManifestOptions = {
     dir: string;
     packageName: string;
-    cwd: string;
 };
-export declare const loadPackageManifest: ({ dir, packageName, cwd }: LoadPackageManifestOptions) => any;
+export declare const loadPackageManifest: ({ dir, packageName }: LoadPackageManifestOptions) => PackageJson | undefined;
 export declare const getFilteredScripts: (scripts: Scripts) => Scripts[];
 export {};

package/dist/manifest/helpers.js

@@ -1,49 +1,13 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from '../util/path.js';
+import { resolvePackageManifestPath } from '../util/resolve.js';
 import { _require } from '../util/require.js';
-const monorepoRootCache = new Map();
-const findMonorepoRootAbove = (startDir) => {
-    if (monorepoRootCache.has(startDir))
-        return monorepoRootCache.get(startDir);
-    let current = dirname(startDir);
-    let result;
-    while (current !== dirname(current)) {
-        if (existsSync(join(current, 'pnpm-workspace.yaml'))) {
-            result = current;
-            break;
-        }
-        try {
-            const pkg = JSON.parse(readFileSync(join(current, 'package.json'), 'utf8'));
-            if (pkg.workspaces) {
-                result = current;
-                break;
-            }
-        }
-        catch { }
-        current = dirname(current);
-    }
-    monorepoRootCache.set(startDir, result);
-    return result;
-};
-export const loadPackageManifest = ({ dir, packageName, cwd }) => {
+export const loadPackageManifest = ({ dir, packageName }) => {
+    const manifestPath = resolvePackageManifestPath(packageName, dir);
+    if (!manifestPath)
+        return;
     try {
-        return _require(join(dir, 'node_modules', packageName, 'package.json'));
+        return _require(manifestPath);
     }
     catch { }
-    if (dir !== cwd) {
-        try {
-            return _require(join(cwd, 'node_modules', packageName, 'package.json'));
-        }
-        catch { }
-        return;
-    }
-    const root = findMonorepoRootAbove(cwd);
-    if (root) {
-        try {
-            return _require(join(root, 'node_modules', packageName, 'package.json'));
-        }
-        catch { }
-    }
 };
 export const getFilteredScripts = (scripts) => {
     if (!scripts)

package/dist/manifest/index.d.ts

@@ -2,9 +2,8 @@ import type { HostDependencies, InstalledBinaries } from '../types/workspace.ts'
 type Options = {
     packageNames: string[];
     dir: string;
-    cwd: string;
 };
-declare const getMetaDataFromPackageJson: ({ cwd, dir, packageNames }: Options) => {
+declare const getMetaDataFromPackageJson: ({ dir, packageNames }: Options) => {
     hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
     hasTypesIncluded: Set<string>;

package/dist/manifest/index.js

@@ -1,7 +1,7 @@
 import { isDefinitelyTyped } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { loadPackageManifest } from './helpers.js';
-const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
+const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
     const hostDependencies = new Map();
     const installedBinaries = new Map();
     const hasTypesIncluded = new Set();
@@ -13,7 +13,7 @@ const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
             installedBinaries.set(key, new Set([value]));
     };
     for (const packageName of packageNames) {
-        const manifest = loadPackageManifest({ cwd, dir, packageName });
+        const manifest = loadPackageManifest({ dir, packageName });
         if (manifest) {
             const defaultBinaryName = packageName.replace(/^@[^/]+\//, '');
             const binaries = typeof manifest.bin === 'string' ? [defaultBinaryName] : Object.keys(manifest.bin ?? {});

package/dist/plugins/dotenv/index.js

@@ -1,14 +1,7 @@
 import { argsFrom } from '../../binaries/util.js';
 const title = 'dotenv';
 const args = {
-    fromArgs: (parsed, args) => {
-        if (parsed._[0])
-            return argsFrom(args, parsed._[0]);
-        if (!parsed['--'] || parsed['--'].length === 0)
-            return [];
-        const script = parsed['--'].map(arg => (arg.includes(' ') ? `"${arg}"` : arg)).join(' ');
-        return [script];
-    },
+    fromArgs: (parsed, args) => (parsed._[0] ? argsFrom(args, parsed._[0]) : (parsed['--'] ?? [])),
 };
 const plugin = {
     title,

package/dist/plugins/eslint/helpers.d.ts

@@ -1,6 +1,7 @@
 import type { PluginOptions } from '../../types/config.ts';
 import { type ConfigInput, type Input } from '../../util/input.ts';
-import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated } from './types.ts';
+import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated, Settings } from './types.ts';
 export declare const isFlatConfig: (fileName: string) => boolean;
 export declare const getInputs: (config: ESLintConfigDeprecated | OverrideConfigDeprecated | ESLintConfig, options: PluginOptions) => (Input | ConfigInput)[];
+export declare const getInputsFromSettings: (settings?: Settings) => Input[];
 export declare const resolveFormatters: (formatters: string | string[]) => Set<Input>;

package/dist/plugins/eslint/helpers.js

@@ -80,6 +80,7 @@ const getDependenciesFromSettings = (settings = {}) => {
         }
     });
 };
+export const getInputsFromSettings = (settings) => compact(getDependenciesFromSettings(settings)).map(id => toDeferResolve(id, { optional: true }));
 const builtinFormatters = new Set(['html', 'json-with-metadata', 'json', 'stylish']);
 export const resolveFormatters = (formatters) => {
     const inputs = new Set();

package/dist/plugins/eslint/resolveFromAST.d.ts

@@ -1,3 +1,4 @@
 import type { Program } from 'oxc-parser';
 import { type Input } from '../../util/input.ts';
+export declare const getInputsFromSettingsAST: (program: Program) => Input[];
 export declare const getInputsFromFlatConfigAST: (program: Program) => Input[];

package/dist/plugins/eslint/resolveFromAST.js

@@ -3,7 +3,7 @@ import { toDeferResolve } from '../../util/input.js';
 import { findProperty, getPropertyKey } from '../../typescript/ast-helpers.js';
 import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isInternal } from '../../util/path.js';
-export const getInputsFromFlatConfigAST = (program) => {
+export const getInputsFromSettingsAST = (program) => {
     const inputs = [];
     const addResolver = (key, resolver) => {
         if (!resolver || resolver === 'node' || isInternal(resolver))
@@ -35,6 +35,9 @@ export const getInputsFromFlatConfigAST = (program) => {
         },
     });
     visitor.visit(program);
-    inputs.push(toDeferResolve('eslint-import-resolver-typescript', { optional: true }));
     return inputs;
 };
+export const getInputsFromFlatConfigAST = (program) => [
+    ...getInputsFromSettingsAST(program),
+    toDeferResolve('eslint-import-resolver-typescript', { optional: true }),
+];

package/dist/plugins/eslint/types.d.ts

@@ -6,7 +6,7 @@ type ParserOptions = {
         presets: string[];
     };
 };
-type Settings = Record<string, Record<string, unknown> | string>;
+export type Settings = Record<string, Record<string, unknown> | string>;
 type Rules = Record<string, string | number>;
 type BaseConfig = {
     extends?: string | string[];

package/dist/plugins/moonrepo/index.js

@@ -1,4 +1,5 @@
 import { hasDependency } from '../../util/plugin.js';
+import { toShellCommand } from '../../util/scripts.js';
 const title = 'moonrepo';
 const enablers = ['@moonrepo/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -6,12 +7,11 @@ const isRootOnly = true;
 const config = ['moon.yml', '.moon/tasks.yml', '.moon/tasks/*.yml'];
 const resolveConfig = async (config, options) => {
     const tasks = config.tasks ? Object.values(config.tasks) : [];
+    const expand = (value) => value.replace('$workspaceRoot', options.rootCwd).replace('$projectRoot', options.cwd);
     const inputs = tasks
         .map(task => task.command)
         .filter(command => command)
-        .map(command => (Array.isArray(command) ? command.join(' ') : command))
-        .map(command => command.replace('$workspaceRoot', options.rootCwd))
-        .map(command => command.replace('$projectRoot', options.cwd))
+        .map(command => (Array.isArray(command) ? toShellCommand(command.map(expand)) : expand(command)))
         .flatMap(command => options.getInputsFromScripts(command));
     return [...inputs];
 };

package/dist/plugins/node/index.js

@@ -1,5 +1,6 @@
 import { toEntry, toProductionEntry } from '../../util/input.js';
 import { getScriptCommands } from '../../util/scripts.js';
+import { createFsPromisesGlobVisitor } from './visitors/fsPromisesGlob.js';
 const title = 'Node.js';
 const isEnabled = () => true;
 const patterns = [
@@ -21,6 +22,9 @@ const hasNodeTest = (scripts) => {
     return result;
 };
 const entry = ['server.js'];
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createFsPromisesGlobVisitor(ctx));
+};
 const resolve = options => {
     const entries = entry.map(id => toProductionEntry(id));
     if (hasNodeTest(options.manifest.scripts) || hasNodeTest(options.rootManifest?.scripts)) {
@@ -53,5 +57,6 @@ const plugin = {
     entry,
     resolve,
     args,
+    registerVisitors,
 };
 export default plugin;

package/dist/plugins/node/visitors/fsPromisesGlob.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../../types/config.ts';
+export declare function createFsPromisesGlobVisitor(ctx: PluginVisitorContext): PluginVisitorObject;

package/dist/plugins/node/visitors/fsPromisesGlob.js

@@ -0,0 +1,89 @@
+import { findProperty, getPropertyKey } from '../../../typescript/ast-helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+const FS_PROMISES = new Set(['node:fs/promises', 'fs/promises']);
+export function createFsPromisesGlobVisitor(ctx) {
+    const globNames = new Set();
+    const namespaceNames = new Set();
+    return {
+        Program() {
+            globNames.clear();
+            namespaceNames.clear();
+        },
+        ImportDeclaration(node) {
+            if (!FS_PROMISES.has(node.source.value))
+                return;
+            for (const specifier of node.specifiers ?? []) {
+                if (specifier.type === 'ImportNamespaceSpecifier') {
+                    namespaceNames.add(specifier.local.name);
+                }
+                else if (specifier.type === 'ImportSpecifier' &&
+                    specifier.imported.type === 'Identifier' &&
+                    specifier.imported.name === 'glob') {
+                    globNames.add(specifier.local.name);
+                }
+            }
+        },
+        VariableDeclarator(node) {
+            if (node.init?.type !== 'CallExpression' ||
+                node.init.callee.type !== 'Identifier' ||
+                node.init.callee.name !== 'require' ||
+                !isStringLiteral(node.init.arguments[0]) ||
+                !FS_PROMISES.has(getStringValue(node.init.arguments[0])))
+                return;
+            if (node.id.type === 'Identifier') {
+                namespaceNames.add(node.id.name);
+            }
+            else if (node.id.type === 'ObjectPattern') {
+                for (const property of node.id.properties) {
+                    if (property.type === 'Property' &&
+                        getPropertyKey(property) === 'glob' &&
+                        property.value.type === 'Identifier') {
+                        globNames.add(property.value.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            let isGlobCall = node.callee.type === 'Identifier' && globNames.has(node.callee.name);
+            if (!isGlobCall &&
+                node.callee.type === 'MemberExpression' &&
+                !node.callee.computed &&
+                node.callee.object.type === 'Identifier' &&
+                namespaceNames.has(node.callee.object.name) &&
+                node.callee.property.type === 'Identifier' &&
+                node.callee.property.name === 'glob') {
+                isGlobCall = true;
+            }
+            if (!isGlobCall)
+                return;
+            const arg = node.arguments[0];
+            if (!arg)
+                return;
+            let patterns;
+            if (isStringLiteral(arg)) {
+                patterns = [getStringValue(arg)];
+            }
+            else if (arg.type === 'ArrayExpression') {
+                patterns = [];
+                for (const element of arg.elements) {
+                    if (!element || !isStringLiteral(element))
+                        return;
+                    patterns.push(getStringValue(element));
+                }
+            }
+            if (!patterns?.length || patterns.some(pattern => pattern.startsWith('!')))
+                return;
+            const options = node.arguments[1];
+            if (options && options.type !== 'ObjectExpression')
+                return;
+            if (options &&
+                (options.properties.length > 1 ||
+                    options.properties.some(property => property.type !== 'Property' || property.computed || getPropertyKey(property) !== 'cwd')))
+                return;
+            const cwdNode = findProperty(options, 'cwd');
+            if (cwdNode && !isStringLiteral(cwdNode))
+                return;
+            ctx.addImportGlob(patterns, { cwd: cwdNode ? getStringValue(cwdNode) : '.' });
+        },
+    };
+}