knip 5.63.0 → 5.63.1

package/dist/ProjectPrincipal.js

@@ -43,8 +43,7 @@ export class ProjectPrincipal {
     backend;
     findReferences;
     getImplementationAtPosition;
-    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, isProduction, }) {
-        this.cwd = cwd;
+    constructor(options, { compilerOptions, compilers, pkgName, toSourceFilePath }) {
         this.compilerOptions = {
             ...compilerOptions,
             ...baseCompilerOptions,
@@ -55,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() {
@@ -156,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;
@@ -168,7 +168,7 @@ 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);

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

@@ -7,7 +7,7 @@ const positionals = new Set(['babel-node', 'esbuild', 'execa', 'jiti', 'oxnode',
 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) : binary.includes('*') ? undefined : 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['--']) : [];

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,103 +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, configFilePath, } = 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: treatConfigHintsAsErrors ?? isTreatConfigHintsAsErrors,
-            cwd,
-            isProduction,
-            isShowProgress,
-            options: reporterOptions,
-            preprocessorOptions,
-            includedWorkspaces,
-            configFilePath,
+            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;
@@ -324,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;
@@ -564,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;
@@ -576,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;
@@ -895,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;

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 {};

package/dist/graph/analyze.js

@@ -4,16 +4,10 @@ import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
 import { createAndPrintTrace, printTrace } from '../util/trace.js';
-export const analyze = async (options) => {
-    const { analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, isFix, isIncludeLibs, isProduction, report, streamer, tags, unreferencedFiles, } = options;
-    const isReportDependencies = report.dependencies || report.unlisted || report.unresolved || report.binaries;
-    const isReportValues = report.exports || report.nsExports || report.classMembers;
-    const isReportTypes = report.types || report.nsTypes || report.enumMembers;
-    const isReportClassMembers = report.classMembers;
-    const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
-    const shouldIgnore = getShouldIgnoreHandler(isProduction);
-    const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
-    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths);
+export const analyze = async ({ analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, streamer, unreferencedFiles, options, }) => {
+    const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
+    const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
+    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths, options.isTrace);
     const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
     const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
         (exportedItem.refs[0] > 0 &&
@@ -21,7 +15,7 @@ export const analyze = async (options) => {
                 ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
                 : ignoreExportsUsedInFile));
     const analyzeGraph = async () => {
-        if (isReportValues || isReportTypes) {
+        if (options.isReportValues || options.isReportTypes) {
             streamer.cast('Connecting the dots');
             for (const [filePath, file] of graph.entries()) {
                 const exportItems = file.exports;
@@ -33,7 +27,7 @@ export const analyze = async (options) => {
                     const principal = factory.getPrincipalByPackageName(workspace.pkgName);
                     const isEntry = entryPaths.has(filePath);
                     if (!isIncludeEntryExports && isEntry) {
-                        createAndPrintTrace(filePath, { isEntry });
+                        createAndPrintTrace(filePath, options, { isEntry });
                         continue;
                     }
                     const importsForExport = file.imported;
@@ -45,7 +39,7 @@ export const analyze = async (options) => {
                             const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
                             if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
                                 for (const tagName of exportedItem.jsDocTags) {
-                                    if (tags[1].includes(tagName.replace(/^@/, ''))) {
+                                    if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                         collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
                                     }
                                 }
@@ -54,7 +48,7 @@ export const analyze = async (options) => {
                                 continue;
                             if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
-                                    createAndPrintTrace(filePath, { identifier, isEntry, hasRef: isReferenced });
+                                    createAndPrintTrace(filePath, options, { identifier, isEntry, hasRef: isReferenced });
                                     continue;
                                 }
                                 const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
@@ -62,10 +56,10 @@ export const analyze = async (options) => {
                                     continue;
                             }
                             if (traceNode)
-                                printTrace(traceNode, filePath, identifier);
+                                printTrace(traceNode, filePath, options, identifier);
                             if (isReferenced) {
-                                if (report.enumMembers && exportedItem.type === 'enum') {
-                                    if (!report.nsTypes && importsForExport.refs.has(identifier))
+                                if (options.includedIssueTypes.enumMembers && exportedItem.type === 'enum') {
+                                    if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
                                         continue;
                                     if (hasStrictlyEnumReferences(importsForExport, identifier))
                                         continue;
@@ -91,12 +85,12 @@ export const analyze = async (options) => {
                                                     line: member.line,
                                                     col: member.col,
                                                 });
-                                                if (isFix && isIssueAdded && member.fix)
+                                                if (options.isFix && isIssueAdded && member.fix)
                                                     fixer.addUnusedTypeNode(filePath, [member.fix]);
                                             }
                                             else if (isIgnored) {
                                                 for (const tagName of exportedItem.jsDocTags) {
-                                                    if (tags[1].includes(tagName.replace(/^@/, ''))) {
+                                                    if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                                         collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
                                                     }
                                                 }
@@ -104,13 +98,13 @@ export const analyze = async (options) => {
                                         }
                                     }
                                 }
-                                if (principal && isReportClassMembers && exportedItem.type === 'class') {
+                                if (principal && options.isReportClassMembers && exportedItem.type === 'class') {
                                     const members = exportedItem.members.filter(member => !(findMatch(workspace.ignoreMembers, member.identifier) || shouldIgnore(member.jsDocTags)));
                                     for (const member of principal.findUnusedMembers(filePath, members)) {
                                         if (shouldIgnoreTags(member.jsDocTags)) {
                                             const identifier = `${exportedItem.identifier}.${member.identifier}`;
                                             for (const tagName of exportedItem.jsDocTags) {
-                                                if (tags[1].includes(tagName.replace(/^@/, ''))) {
+                                                if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                                     collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
                                                 }
                                             }
@@ -126,7 +120,7 @@ export const analyze = async (options) => {
                                             line: member.line,
                                             col: member.col,
                                         });
-                                        if (isFix && isIssueAdded && member.fix)
+                                        if (options.isFix && isIssueAdded && member.fix)
                                             fixer.addUnusedTypeNode(filePath, [member.fix]);
                                     }
                                 }
@@ -135,12 +129,13 @@ export const analyze = async (options) => {
                         }
                         const [hasStrictlyNsRefs, namespace] = hasStrictlyNsReferences(graph, importsForExport, identifier);
                         const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
-                        if (hasStrictlyNsRefs && ((!report.nsTypes && isType) || !(report.nsExports || isType)))
+                        if (hasStrictlyNsRefs &&
+                            ((!options.includedIssueTypes.nsTypes && isType) || !(options.includedIssueTypes.nsExports || isType)))
                             continue;
                         if (!isExportedItemReferenced(exportedItem)) {
                             if (isIgnored)
                                 continue;
-                            if (!isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
+                            if (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
                                 continue;
                             const type = getType(hasStrictlyNsRefs, isType);
                             const isIssueAdded = collector.addIssue({
@@ -154,7 +149,7 @@ export const analyze = async (options) => {
                                 line: exportedItem.line,
                                 col: exportedItem.col,
                             });
-                            if (isFix && isIssueAdded) {
+                            if (options.isFix && isIssueAdded) {
                                 if (isType)
                                     fixer.addUnusedTypeNode(filePath, exportedItem.fixes);
                                 else
@@ -201,11 +196,11 @@ export const analyze = async (options) => {
         const unusedFiles = [...unreferencedFiles].filter(filePath => !analyzedFiles.has(filePath));
         collector.addFilesIssues(unusedFiles);
         collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
-        if (isReportDependencies) {
+        if (options.isReportDependencies) {
             const { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues } = deputy.settleDependencyIssues();
             for (const issue of dependencyIssues)
                 collector.addIssue(issue);
-            if (!isProduction)
+            if (!options.isProduction)
                 for (const issue of devDependencyIssues)
                     collector.addIssue(issue);
             for (const issue of optionalPeerDependencyIssues)
@@ -219,6 +214,8 @@ export const analyze = async (options) => {
         for (const identifier of unusedIgnoredWorkspaces) {
             collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier });
         }
+        for (const hint of chief.getConfigurationHints())
+            collector.addConfigurationHint(hint);
     };
     await analyzeGraph();
     return analyzeGraph;