knip 5.62.0 → 5.63.1

package/dist/ProjectPrincipal.d.ts

@@ -1,11 +1,12 @@
 import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
-import type { GetImportsAndExportsOptions } from './types/config.js';
+import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile } from './types/config.js';
 import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
 import type { Paths, PrincipalOptions } from './types/project.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
+import type { MainOptions } from './util/create-options.js';
 import type { ToSourceFilePath } from './util/to-source-path.js';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
@@ -30,7 +31,8 @@ export declare class ProjectPrincipal {
         languageServiceHost: ts.LanguageServiceHost;
     };
     findReferences?: ts.LanguageService['findReferences'];
-    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, isProduction, }: PrincipalOptions);
+    getImplementationAtPosition?: ts.LanguageService['getImplementationAtPosition'];
+    constructor(options: MainOptions, { compilerOptions, compilers, pkgName, toSourceFilePath }: PrincipalOptions);
     init(): void;
     addPaths(paths: Paths, basePath: string): void;
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
@@ -50,7 +52,7 @@ export declare class ProjectPrincipal {
     getUsedResolvedFiles(): string[];
     private getProgramSourceFiles;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>): FileNode;
+    analyzeSourceFile(filePath: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile): FileNode;
     invalidateFile(filePath: string): void;
     findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
     hasExternalReferences(filePath: string, exportedItem: Export): boolean;

package/dist/ProjectPrincipal.js

@@ -42,8 +42,8 @@ export class ProjectPrincipal {
     toSourceFilePath;
     backend;
     findReferences;
-    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, isProduction, }) {
-        this.cwd = cwd;
+    getImplementationAtPosition;
+    constructor(options, { compilerOptions, compilers, pkgName, toSourceFilePath }) {
         this.compilerOptions = {
             ...compilerOptions,
             ...baseCompilerOptions,
@@ -54,12 +54,13 @@ export class ProjectPrincipal {
         this.extensions = new Set([...DEFAULT_EXTENSIONS, ...getCompilerExtensions(compilers)]);
         this.syncCompilers = syncCompilers;
         this.asyncCompilers = asyncCompilers;
-        this.isSkipLibs = isSkipLibs;
-        this.isWatch = isWatch;
-        this.cache = new CacheConsultant({ name: pkgName || ANONYMOUS, isEnabled: isCache, cacheLocation, isProduction });
+        this.cwd = options.cwd;
+        this.isSkipLibs = options.isSkipLibs;
+        this.isWatch = options.isWatch;
+        this.cache = new CacheConsultant(pkgName || ANONYMOUS, options);
         this.toSourceFilePath = toSourceFilePath;
         this.backend = {
-            fileManager: new SourceFileManager({ compilers, isSkipLibs }),
+            fileManager: new SourceFileManager({ compilers, isSkipLibs: options.isSkipLibs }),
         };
     }
     init() {
@@ -155,7 +156,7 @@ export class ProjectPrincipal {
         const sourceFiles = this.getProgramSourceFiles();
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
-    analyzeSourceFile(filePath, options) {
+    analyzeSourceFile(filePath, options, ignoreExportsUsedInFile) {
         const fd = this.cache.getFileDescriptor(filePath);
         if (!fd.changed && fd.meta?.data)
             return fd.meta.data;
@@ -167,21 +168,25 @@ export class ProjectPrincipal {
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
         const resolve = (specifier) => this.backend.resolveModuleNames([specifier], sourceFile.fileName)[0];
-        return _getImportsAndExports(sourceFile, resolve, typeChecker, { ...options, skipExports });
+        return _getImportsAndExports(sourceFile, resolve, typeChecker, options, ignoreExportsUsedInFile, skipExports);
     }
     invalidateFile(filePath) {
         this.backend.fileManager.snapshotCache.delete(filePath);
         this.backend.fileManager.sourceFileCache.delete(filePath);
     }
     findUnusedMembers(filePath, members) {
-        if (!this.findReferences) {
+        if (!this.findReferences || !this.getImplementationAtPosition) {
             const languageService = ts.createLanguageService(this.backend.languageServiceHost, ts.createDocumentRegistry());
             this.findReferences = timerify(languageService.findReferences);
+            this.getImplementationAtPosition = timerify(languageService.getImplementationAtPosition);
         }
         return members.filter(member => {
             if (member.jsDocTags.has(PUBLIC_TAG))
                 return false;
-            const referencedSymbols = this.findReferences?.(filePath, member.pos) ?? [];
+            const implementations = this.getImplementationAtPosition?.(filePath, member.pos)?.filter(impl => impl.fileName !== filePath || impl.textSpan.start !== member.pos) ?? [];
+            const referencedSymbols = this.findReferences?.(filePath, member.pos)?.filter(sym => !implementations.some(impl => impl.fileName === sym.definition.fileName &&
+                impl.textSpan.start === sym.definition.textSpan.start &&
+                impl.textSpan.length === sym.definition.textSpan.length)) ?? [];
             const refs = referencedSymbols.flatMap(refs => refs.references).filter(ref => !ref.isDefinition);
             return refs.length === 0;
         });
@@ -189,9 +194,10 @@ export class ProjectPrincipal {
     hasExternalReferences(filePath, exportedItem) {
         if (exportedItem.jsDocTags.has(PUBLIC_TAG))
             return false;
-        if (!this.findReferences) {
+        if (!this.findReferences || !this.getImplementationAtPosition) {
             const languageService = ts.createLanguageService(this.backend.languageServiceHost, ts.createDocumentRegistry());
             this.findReferences = timerify(languageService.findReferences);
+            this.getImplementationAtPosition = timerify(languageService.getImplementationAtPosition);
         }
         const referencedSymbols = this.findReferences(filePath, exportedItem.pos);
         if (!referencedSymbols?.length)

package/dist/WorkspaceWorker.d.ts

@@ -5,11 +5,11 @@ import type { Configuration, GetReferencedInternalFilePath, GetSourceFile, Works
 import type { ConfigurationHints } from './types/issues.js';
 import type { PackageJson } from './types/package-json.js';
 import type { DependencySet } from './types/workspace.js';
+import type { MainOptions } from './util/create-options.js';
 import { type Input } from './util/input.js';
 type WorkspaceManagerOptions = {
     name: string;
     dir: string;
-    cwd: string;
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
@@ -20,11 +20,8 @@ type WorkspaceManagerOptions = {
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
     enabledPluginsInAncestors: string[];
-    isProduction: boolean;
-    isStrict: boolean;
-    isCache: boolean;
-    cacheLocation: string;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
+    options: MainOptions;
 };
 type CacheItem = {
     resolveConfig?: Input[];
@@ -34,24 +31,22 @@ type CacheItem = {
 export declare class WorkspaceWorker {
     name: string;
     dir: string;
-    cwd: string;
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
     getReferencedInternalFilePath: GetReferencedInternalFilePath;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     getSourceFile: GetSourceFile;
-    isProduction: boolean;
-    isStrict: boolean;
     rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
+    options: MainOptions;
     enabledPluginsMap: Record<PluginName, boolean>;
     enabledPlugins: PluginName[];
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, isCache, cacheLocation, configFilesMap, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -19,32 +19,27 @@ const initEnabledPluginsMap = () => Object.keys(Plugins).reduce((enabled, plugin
 export class WorkspaceWorker {
     name;
     dir;
-    cwd;
     config;
     manifest;
     dependencies;
     getReferencedInternalFilePath;
     findWorkspaceByFilePath;
     getSourceFile;
-    isProduction;
-    isStrict;
     rootIgnore;
     negatedWorkspacePatterns = [];
     ignoredWorkspacePatterns = [];
+    options;
     enabledPluginsMap = initEnabledPluginsMap();
     enabledPlugins = [];
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, isCache, cacheLocation, configFilesMap, }) {
+    constructor({ name, dir, config, manifest, dependencies, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }) {
         this.name = name;
         this.dir = dir;
-        this.cwd = cwd;
         this.config = config;
         this.manifest = manifest;
         this.dependencies = dependencies;
-        this.isProduction = isProduction;
-        this.isStrict = isStrict;
         this.rootIgnore = rootIgnore;
         this.negatedWorkspacePatterns = negatedWorkspacePatterns;
         this.ignoredWorkspacePatterns = ignoredWorkspacePatterns;
@@ -53,7 +48,8 @@ export class WorkspaceWorker {
         this.getReferencedInternalFilePath = getReferencedInternalFilePath;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
         this.getSourceFile = getSourceFile;
-        this.cache = new CacheConsultant({ name: `plugins-${name}`, isEnabled: isCache, cacheLocation, isProduction });
+        this.options = options;
+        this.cache = new CacheConsultant(`plugins-${name}`, options);
         this.getConfigurationHints = timerify(this.getConfigurationHints.bind(this), 'worker.getConfigurationHints');
     }
     async init() {
@@ -64,7 +60,7 @@ export class WorkspaceWorker {
         for (const [pluginName, plugin] of PluginEntries) {
             if (this.config[pluginName] === false)
                 continue;
-            if (this.cwd !== this.dir && plugin.isRootOnly)
+            if (this.options.cwd !== this.dir && plugin.isRootOnly)
                 continue;
             if (this.config[pluginName]) {
                 this.enabledPluginsMap[pluginName] = true;
@@ -169,10 +165,10 @@ export class WorkspaceWorker {
     async runPlugins() {
         const wsName = this.name;
         const cwd = this.dir;
-        const rootCwd = this.cwd;
+        const rootCwd = this.options.cwd;
         const manifest = this.manifest;
         const containingFilePath = join(cwd, 'package.json');
-        const isProduction = this.isProduction;
+        const isProduction = this.options.isProduction;
         const knownBinsOnly = false;
         const manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
         const baseOptions = { manifestScriptNames, cwd, rootCwd, containingFilePath, knownBinsOnly };
@@ -344,7 +340,7 @@ export class WorkspaceWorker {
                 } while (remainingPlugins.size > 0 && configFiles.size > 0);
             }
         }
-        debugLogArray(wsName, 'Plugin dependencies', () => compact(inputs.map(toDebugString)));
+        debugLogArray(wsName, 'Plugin dependencies', () => compact(inputs.map(input => toDebugString(input, rootCwd))));
         return inputs;
     }
     getConfigurationHints(type, patterns, filePaths, includedPaths) {

package/dist/binaries/bash-parser.js

@@ -88,7 +88,7 @@ export const getDependenciesFromScript = (script, options) => {
         return parsed?.commands ? getDependenciesFromNodes(parsed.commands) : [];
     }
     catch (error) {
-        const msg = `Warning: failed to parse and ignoring script in ${relative(options.containingFilePath)} (${truncate(script, 30)})`;
+        const msg = `Warning: failed to parse and ignoring script in ${relative(options.cwd, options.containingFilePath)} (${truncate(script, 30)})`;
         debugLogObject('*', msg, error);
         return [];
     }

package/dist/binaries/fallback.js

@@ -4,11 +4,13 @@ import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
 const spawningBinaries = ['cross-env', 'retry-cli'];
 const endOfCommandBinaries = ['dotenvx'];
 const positionals = new Set(['babel-node', 'esbuild', 'execa', 'jiti', 'oxnode', 'vite-node', 'zx']);
+const positionalBinaries = new Set(['concurrently']);
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args, { boolean: ['quiet', 'verbose'], '--': endOfCommandBinaries.includes(binary) });
-    const bin = binary.startsWith('.') ? toEntry(binary) : toBinary(binary);
+    const bin = binary.startsWith('.') ? toEntry(binary) : /[*:]/.test(binary) ? undefined : toBinary(binary);
     const shiftedArgs = spawningBinaries.includes(binary) ? fromArgs(args) : [];
     const pos = positionals.has(binary) ? [toDeferResolve(parsed._[0])] : [];
     const newCommand = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
-    return compact([bin, ...shiftedArgs, ...pos, ...newCommand]);
+    const commands = positionalBinaries.has(binary) ? parsed._.flatMap(cmd => fromArgs([cmd])) : [];
+    return compact([bin, ...shiftedArgs, ...pos, ...newCommand, ...commands]);
 };

package/dist/binaries/package-manager/pnpm.js

@@ -3,9 +3,12 @@ import { toBinary } from '../../util/input.js';
 import { resolveDlx } from './pnpx.js';
 const commands = [
     'add',
+    'approve-builds',
     'audit',
     'bin',
     'cache',
+    'cat-file',
+    'cat-index',
     'config',
     'dedupe',
     'deploy',
@@ -13,7 +16,9 @@ const commands = [
     'doctor',
     'env',
     'fetch',
+    'find-hash',
     'i',
+    'ignored-builds',
     'import',
     'init',
     'install-test',
@@ -25,7 +30,6 @@ const commands = [
     'ln',
     'ls',
     'outdated',
-    'outdated',
     'pack',
     'patch-commit',
     'patch-remove',
@@ -39,6 +43,7 @@ const commands = [
     'rm',
     'root',
     'run',
+    'self-update',
     'server',
     'setup',
     'start',

package/dist/cli.js

@@ -1,102 +1,85 @@
 import { main } from './index.js';
 import { perfObserver } from './util/Performance.js';
-import parsedArgValues, { helpText } from './util/cli-arguments.js';
+import { helpText } from './util/cli-arguments.js';
+import parseArgs from './util/cli-arguments.js';
+import { createOptions } from './util/create-options.js';
 import { getKnownError, isConfigurationError, isDisplayReason, isKnownError } from './util/errors.js';
 import { logError, logWarning } from './util/log.js';
-import { cwd, join, toPosix } from './util/path.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
 import { prettyMilliseconds } from './util/string.js';
-import { splitTags } from './util/tag.js';
-import { isTrace } from './util/trace.js';
 import { version } from './version.js';
-const defaultCacheLocation = join(cwd, 'node_modules', '.cache', 'knip');
-const { 'allow-remove-files': isRemoveFiles = false, cache: isCache = false, 'cache-location': cacheLocation = defaultCacheLocation, debug: isDebug = false, dependencies: isDependenciesShorthand = false, exclude: excludedIssueTypes = [], 'experimental-tags': experimentalTags = [], exports: isExportsShorthand = false, files: isFilesShorthand = false, fix: isFix = false, format: isFormat = false, 'fix-type': fixTypes = [], help: isHelp, include: includedIssueTypes = [], 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, 'max-issues': maxIssues = '0', 'memory-realtime': memoryRealtime = false, 'no-config-hints': isNoConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace || memoryRealtime, preprocessor = [], 'preprocessor-options': preprocessorOptions = '', production: isProduction = false, reporter = ['symbols'], 'reporter-options': reporterOptions = '', strict: isStrict = false, tags = [], 'treat-config-hints-as-errors': treatConfigHintsAsErrors = false, tsConfig, version: isVersion, watch: isWatch = false, workspace: rawWorkspaceArg, } = parsedArgValues;
-if (isHelp) {
-    console.log(helpText);
-    process.exit(0);
+let parsedCLIArgs = {};
+try {
+    parsedCLIArgs = parseArgs();
 }
-if (isVersion) {
-    console.log(version);
-    process.exit(0);
+catch (error) {
+    if (error instanceof Error) {
+        console.error(error.message);
+        console.log(`\n${helpText}`);
+        process.exit(1);
+    }
+    throw error;
 }
-const isShowProgress = isNoProgress === false && process.stdout.isTTY && typeof process.stdout.cursorTo === 'function';
-const workspace = rawWorkspaceArg ? toPosix(rawWorkspaceArg).replace(/^\.\//, '').replace(/\/$/, '') : undefined;
 const run = async () => {
     try {
-        const { report, issues, counters, rules, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaces, } = await main({
-            cacheLocation,
-            cwd,
-            excludedIssueTypes,
-            fixTypes: fixTypes.flatMap(type => type.split(',')),
-            gitignore: !isNoGitIgnore,
-            includedIssueTypes,
-            isCache,
-            isDebug,
-            isDependenciesShorthand,
-            isExportsShorthand,
-            isFilesShorthand,
-            isFix: isFix || fixTypes.length > 0,
-            isFormat,
-            isIncludeEntryExports,
-            isIncludeLibs,
-            isIsolateWorkspaces,
-            isProduction: isStrict || isProduction,
-            isRemoveFiles,
-            isShowProgress,
-            isStrict,
-            isWatch,
-            tags: tags.length > 0 ? splitTags(tags) : splitTags(experimentalTags),
-            tsConfigFile: tsConfig,
-            workspace,
-        });
-        const isDisableConfigHints = isNoConfigHints || isProduction || Boolean(workspace);
-        if (isWatch || isTrace)
+        const options = await createOptions({ parsedCLIArgs });
+        if (parsedCLIArgs.help) {
+            console.log(helpText);
+            process.exit(0);
+        }
+        if (parsedCLIArgs.version) {
+            console.log(version);
+            process.exit(0);
+        }
+        const { issues, counters, tagHints, configurationHints, includedWorkspaceDirs } = await main(options);
+        if (options.isWatch || options.isTrace)
             return;
         const initialData = {
-            report,
+            report: options.includedIssueTypes,
             issues,
             counters,
             tagHints,
             configurationHints,
-            isDisableConfigHints,
-            isTreatConfigHintsAsErrors,
-            cwd,
-            isProduction,
-            isShowProgress,
-            options: reporterOptions,
-            preprocessorOptions,
-            includedWorkspaces,
+            includedWorkspaceDirs,
+            cwd: options.cwd,
+            configFilePath: options.configFilePath,
+            isDisableConfigHints: options.isDisableConfigHints,
+            isProduction: options.isProduction,
+            isShowProgress: options.isShowProgress,
+            isTreatConfigHintsAsErrors: options.isTreatConfigHintsAsErrors,
+            options: parsedCLIArgs['reporter-options'] ?? '',
+            preprocessorOptions: parsedCLIArgs['preprocessor-options'] ?? '',
         };
-        const finalData = await runPreprocessors(preprocessor, initialData);
-        await runReporters(reporter, finalData);
+        const finalData = await runPreprocessors(parsedCLIArgs.preprocessor ?? [], initialData);
+        await runReporters(parsedCLIArgs.reporter ?? ['symbols'], finalData);
         const totalErrorCount = Object.keys(finalData.report)
-            .filter(reportGroup => finalData.report[reportGroup] && rules[reportGroup] === 'error')
+            .filter(reportGroup => finalData.report[reportGroup] && options.rules[reportGroup] === 'error')
             .reduce((errorCount, reportGroup) => errorCount + finalData.counters[reportGroup], 0);
         if (perfObserver.isEnabled)
             await perfObserver.finalize();
         if (perfObserver.isTimerifyFunctions)
             console.log(`\n${perfObserver.getTimerifiedFunctionsTable()}`);
-        if (perfObserver.isMemoryUsageEnabled && !memoryRealtime)
+        if (perfObserver.isMemoryUsageEnabled && !parsedCLIArgs['memory-realtime'])
             console.log(`\n${perfObserver.getMemoryUsageTable()}`);
         if (perfObserver.isEnabled) {
             const duration = perfObserver.getCurrentDurationInMs();
             console.log('\nTotal running time:', prettyMilliseconds(duration));
             perfObserver.reset();
         }
-        if (experimentalTags.length > 0) {
+        if (parsedCLIArgs['experimental-tags'] && parsedCLIArgs['experimental-tags'].length > 0) {
             logWarning('DEPRECATION WARNING', '--experimental-tags is deprecated, please start using --tags instead');
         }
-        if (isIsolateWorkspaces && report.classMembers) {
+        if (options.isIsolateWorkspaces && options.includedIssueTypes.classMembers) {
             logWarning('WARNING', 'Class members are not tracked when using the --isolate-workspaces flag');
         }
-        if ((!noExitCode && totalErrorCount > Number(maxIssues)) ||
-            ((treatConfigHintsAsErrors || isTreatConfigHintsAsErrors) && configurationHints.size > 0)) {
+        if ((!parsedCLIArgs['no-exit-code'] && totalErrorCount > Number(parsedCLIArgs['max-issues'] ?? 0)) ||
+            (options.isTreatConfigHintsAsErrors && configurationHints.size > 0)) {
             process.exit(1);
         }
     }
     catch (error) {
         process.exitCode = 2;
-        if (!isDebug && error instanceof Error && isKnownError(error)) {
+        if (!parsedCLIArgs.debug && error instanceof Error && isKnownError(error)) {
             const knownError = getKnownError(error);
             logError('ERROR', knownError.message);
             if (isDisplayReason(knownError))

package/dist/compilers/index.d.ts

@@ -4,9 +4,6 @@ import type { AsyncCompilerFn, AsyncCompilers, RawSyncCompilers, SyncCompilerFn,
 export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     syncCompilers: Record<string, SyncCompilerFn>;
     asyncCompilers: Record<string, AsyncCompilerFn>;
-    exclude?: ("dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
-    tags?: string[] | undefined;
-    include?: ("dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
     node?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -264,6 +261,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'node-modules-inspector'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     nodemon?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -319,6 +321,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    pnpm?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     postcss?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -379,6 +386,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    rslib?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     rspack?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -554,8 +566,9 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    exclude?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
     $schema?: string | undefined;
-    rules?: Partial<Record<"dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers", "error" | "warn" | "off">> | undefined;
+    rules?: Partial<Record<"files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers", "error" | "warn" | "off">> | undefined;
     paths?: Record<string, string[]> | undefined;
     ignore?: string | string[] | undefined;
     ignoreBinaries?: (string | RegExp)[] | undefined;
@@ -566,7 +579,9 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
     compilers?: Record<string, true | ((args_0: string, args_1: string, ...args: unknown[]) => string) | ((args_0: string, args_1: string, ...args: unknown[]) => Promise<string>)> | undefined;
+    tags?: string[] | undefined;
     treatConfigHintsAsErrors?: boolean | undefined;
+    include?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
     workspaces?: Record<string, {
         node?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -825,6 +840,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'node-modules-inspector'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         nodemon?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -880,6 +900,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        pnpm?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         postcss?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -940,6 +965,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        rslib?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         rspack?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/graph/analyze.d.ts

@@ -4,9 +4,8 @@ import type { DependencyDeputy } from '../DependencyDeputy.js';
 import type { IssueCollector } from '../IssueCollector.js';
 import type { IssueFixer } from '../IssueFixer.js';
 import type { PrincipalFactory } from '../PrincipalFactory.js';
-import type { Tags } from '../types/cli.js';
-import type { Report } from '../types/issues.js';
 import type { ModuleGraph } from '../types/module-graph.js';
+import type { MainOptions } from '../util/create-options.js';
 interface AnalyzeOptions {
     analyzedFiles: Set<string>;
     chief: ConfigurationChief;
@@ -16,13 +15,9 @@ interface AnalyzeOptions {
     factory: PrincipalFactory;
     fixer: IssueFixer;
     graph: ModuleGraph;
-    isFix: boolean;
-    isIncludeLibs: boolean;
-    isProduction: boolean;
-    report: Report;
     streamer: ConsoleStreamer;
-    tags: Tags;
     unreferencedFiles: Set<string>;
+    options: MainOptions;
 }
-export declare const analyze: (options: AnalyzeOptions) => Promise<() => Promise<void>>;
+export declare const analyze: ({ analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, streamer, unreferencedFiles, options, }: AnalyzeOptions) => Promise<() => Promise<void>>;
 export {};