knip 2.3.2 → 2.6.0

package/dist/IssueCollector.d.ts

@@ -1,14 +1,19 @@
-import type { Issue } from './types/issues.js';
+import type { Issue, Rules } from './types/issues.js';
 type IssueCollectorOptions = {
     cwd: string;
+    rules: Rules;
 };
 export declare class IssueCollector {
-    cwd: string;
-    issues: import("./types/issues.js").Issues;
-    counters: import("./types/issues.js").Counters;
-    referencedFiles: Set<string>;
-    constructor({ cwd }: IssueCollectorOptions);
-    addTotalFileCount(count: number): void;
+    private cwd;
+    private rules;
+    private issues;
+    private counters;
+    private referencedFiles;
+    constructor({ cwd, rules }: IssueCollectorOptions);
+    addFileCounts({ processed, unused }: {
+        processed: number;
+        unused: number;
+    }): void;
     addFilesIssues(filePaths: string[]): void;
     addIssue(issue: Issue): void;
     getIssues(): {

package/dist/IssueCollector.js

@@ -2,14 +2,17 @@ import { initIssues, initCounters } from './issues/initializers.js';
 import { relative } from './util/path.js';
 export class IssueCollector {
     cwd;
+    rules;
     issues = initIssues();
     counters = initCounters();
     referencedFiles = new Set();
-    constructor({ cwd }) {
+    constructor({ cwd, rules }) {
         this.cwd = cwd;
+        this.rules = rules;
     }
-    addTotalFileCount(count) {
-        this.counters.total += count;
+    addFileCounts({ processed, unused }) {
+        this.counters.processed += processed;
+        this.counters.total += processed + unused;
     }
     addFilesIssues(filePaths) {
         filePaths.forEach(filePath => {
@@ -22,6 +25,7 @@ export class IssueCollector {
     }
     addIssue(issue) {
         const key = relative(this.cwd, issue.filePath);
+        issue.severity = this.rules[issue.type];
         this.issues[issue.type][key] = this.issues[issue.type][key] ?? {};
         if (!this.issues[issue.type][key][issue.symbol]) {
             this.issues[issue.type][key][issue.symbol] = issue;

package/dist/PrincipalFactory.d.ts

@@ -1,7 +1,6 @@
 import ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
-import type { Report } from './types/issues.js';
 type Paths = ts.CompilerOptions['paths'];
 type Principal = {
     principal: ProjectPrincipal;
@@ -12,13 +11,12 @@ type Principals = Set<Principal>;
 type Options = {
     cwd: string;
     compilerOptions: ts.CompilerOptions;
-    report: Report;
     paths: Paths;
     compilers: [SyncCompilers, AsyncCompilers];
 };
 export declare class PrincipalFactory {
     principals: Principals;
-    getPrincipal({ cwd, compilerOptions, report, paths, compilers }: Options): ProjectPrincipal;
+    getPrincipal({ cwd, compilerOptions, paths, compilers }: Options): ProjectPrincipal;
     private findReusablePrincipal;
     private linkPrincipal;
     private addNewPrincipal;

package/dist/PrincipalFactory.js

@@ -1,8 +1,8 @@
 import { ProjectPrincipal } from './ProjectPrincipal.js';
-import { join, isAbsolute } from './util/path.js';
+import { join, toAbsolute } from './util/path.js';
 const mergePaths = (cwd, compilerOptions, paths = {}) => {
     const overridePaths = Object.keys(paths).reduce((overridePaths, key) => {
-        overridePaths[key] = paths[key].map(entry => (isAbsolute(entry) ? entry : join(cwd, entry)));
+        overridePaths[key] = paths[key].map(entry => toAbsolute(entry, cwd));
         return overridePaths;
     }, {});
     compilerOptions.paths = { ...compilerOptions.paths, ...overridePaths };
@@ -10,7 +10,7 @@ const mergePaths = (cwd, compilerOptions, paths = {}) => {
 };
 export class PrincipalFactory {
     principals = new Set();
-    getPrincipal({ cwd, compilerOptions, report, paths, compilers }) {
+    getPrincipal({ cwd, compilerOptions, paths, compilers }) {
         compilerOptions = mergePaths(cwd, compilerOptions, paths);
         const principal = this.findReusablePrincipal(compilerOptions);
         if (principal) {
@@ -18,7 +18,7 @@ export class PrincipalFactory {
             return principal.principal;
         }
         else {
-            return this.addNewPrincipal({ cwd, compilerOptions, report, paths, compilers });
+            return this.addNewPrincipal({ cwd, compilerOptions, paths, compilers });
         }
     }
     findReusablePrincipal(compilerOptions) {
@@ -36,8 +36,8 @@ export class PrincipalFactory {
         principal.principal.compilerOptions.paths = { ...principal.principal.compilerOptions.paths, ...paths };
         principal.cwds.add(cwd);
     }
-    addNewPrincipal({ cwd, compilerOptions, report, compilers }) {
-        const principal = new ProjectPrincipal({ cwd, compilerOptions, report, compilers });
+    addNewPrincipal({ cwd, compilerOptions, compilers }) {
+        const principal = new ProjectPrincipal({ cwd, compilerOptions, compilers });
         const pathKeys = new Set(Object.keys(compilerOptions?.paths ?? {}));
         compilerOptions.baseUrl = join(cwd, compilerOptions.baseUrl ?? '.');
         this.principals.add({ principal, cwds: new Set([cwd]), pathKeys });

package/dist/ProjectPrincipal.d.ts

@@ -2,11 +2,9 @@ import ts from 'typescript';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
 import type { ExportItem, ExportItemMember } from './types/exports.js';
-import type { Report } from './types/issues.js';
 type ProjectPrincipalOptions = {
     compilerOptions: ts.CompilerOptions;
     cwd: string;
-    report: Report;
     compilers: [SyncCompilers, AsyncCompilers];
 };
 export declare class ProjectPrincipal {
@@ -15,7 +13,6 @@ export declare class ProjectPrincipal {
     skipExportsAnalysis: Set<string>;
     cwd: string;
     compilerOptions: ts.CompilerOptions;
-    isReportTypes: boolean;
     extensions: Set<string>;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
@@ -26,7 +23,7 @@ export declare class ProjectPrincipal {
         lsFindReferences: ts.LanguageService['findReferences'];
         program?: ts.Program;
     };
-    constructor({ compilerOptions, cwd, report, compilers }: ProjectPrincipalOptions);
+    constructor({ compilerOptions, cwd, compilers }: ProjectPrincipalOptions);
     private createProgram;
     private hasAcceptedExtension;
     addEntryPath(filePath: string): void;
@@ -37,7 +34,9 @@ export declare class ProjectPrincipal {
     getUsedResolvedFiles(): string[];
     private getProgramSourceFiles;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string): {
+    analyzeSourceFile(filePath: string, { skipTypeOnly }: {
+        skipTypeOnly: boolean;
+    }): {
         imports: {
             internal: import("./types/imports.js").Imports;
             unresolved: Set<string>;

package/dist/ProjectPrincipal.js

@@ -25,12 +25,11 @@ export class ProjectPrincipal {
     skipExportsAnalysis = new Set();
     cwd;
     compilerOptions;
-    isReportTypes;
     extensions;
     syncCompilers;
     asyncCompilers;
     backend;
-    constructor({ compilerOptions, cwd, report, compilers }) {
+    constructor({ compilerOptions, cwd, compilers }) {
         this.cwd = cwd;
         this.compilerOptions = {
             ...compilerOptions,
@@ -38,7 +37,6 @@ export class ProjectPrincipal {
             allowNonTsExtensions: [...compilers].flat().length > 0,
         };
         const [syncCompilers, asyncCompilers] = compilers;
-        this.isReportTypes = report.types || report.nsTypes || report.enumMembers;
         this.extensions = new Set([...DEFAULT_EXTENSIONS, ...syncCompilers.keys(), ...asyncCompilers.keys()]);
         this.syncCompilers = syncCompilers;
         this.asyncCompilers = asyncCompilers;
@@ -103,11 +101,10 @@ export class ProjectPrincipal {
         const sourceFiles = this.getProgramSourceFiles();
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
-    analyzeSourceFile(filePath) {
+    analyzeSourceFile(filePath, { skipTypeOnly }) {
         const sourceFile = this.backend.program?.getSourceFile(filePath);
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
-        const skipTypeOnly = !this.isReportTypes;
         const skipExports = this.skipExportsAnalysis.has(filePath);
         const { imports, exports, scripts } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
         const { internal, unresolved, external } = imports;

package/dist/WorkspaceWorker.js

@@ -3,7 +3,8 @@ import * as npm from './manifest/index.js';
 import * as plugins from './plugins/index.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix, prependDirToPattern } from './util/glob.js';
-import { join } from './util/path.js';
+import { getKeysByValue } from './util/object.js';
+import { join, toPosix } from './util/path.js';
 const negatedTestFilePatterns = TEST_FILE_PATTERNS.map(negate);
 export class WorkspaceWorker {
     name;
@@ -52,7 +53,7 @@ export class WorkspaceWorker {
                 this.enabled[pluginName] = true;
             }
         }
-        this.enabledPlugins = pluginEntries.filter(([name]) => this.enabled[name]).map(([name]) => name);
+        this.enabledPlugins = getKeysByValue(this.enabled, true);
         const enabledPluginNames = this.enabledPlugins.map(name => plugins[name].NAME);
         debugLogObject(`Enabled plugins (${this.name})`, enabledPluginNames);
     }
@@ -219,7 +220,7 @@ export class WorkspaceWorker {
                             config: pluginConfig,
                             isProduction: this.isProduction,
                         });
-                        dependencies.forEach(specifier => {
+                        dependencies.map(toPosix).forEach(specifier => {
                             pluginDependencies.add(specifier);
                             this.referencedDependencies.add([configFilePath, specifier]);
                         });

package/dist/binaries/resolvers/fallback.js

@@ -1,11 +1,12 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { toBinary, tryResolveFilePaths } from '../util.js';
+import { toBinary, tryResolveFilePath, tryResolveFilePaths } from '../util.js';
 const withPositional = parsed => [parsed._[0], parsed.require].flat();
 const withoutPositional = parsed => [parsed.require].flat();
 const argFilters = {
     'babel-node': withPositional,
     esbuild: withPositional,
+    execa: withPositional,
     nodemon: withPositional,
     'ts-node': withPositional,
     zx: withPositional,
@@ -16,5 +17,6 @@ export const resolve = (binary, args, { cwd }) => {
     const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] }, boolean: ['quiet', 'verbose'] });
     const argFilter = argFilters[binary] ?? argFilters.default;
     const filteredArgs = compact(argFilter(parsed));
-    return [toBinary(binary), ...tryResolveFilePaths(cwd, filteredArgs)];
+    const bin = binary.startsWith('.') ? tryResolveFilePath(cwd, binary, binary) : [toBinary(binary)];
+    return [...bin, ...tryResolveFilePaths(cwd, filteredArgs)];
 };

package/dist/binaries/resolvers/yarn.js

@@ -25,6 +25,7 @@ const commands = [
     'unlink',
     'unplug',
     'up',
+    'upgrade',
     'upgrade-interactive',
     'version',
     'why',

package/dist/cli.js

@@ -23,7 +23,7 @@ const printReport = reporter in reporters ? reporters[reporter] : await _load(re
 const run = async () => {
     try {
         const perfObserver = new Performance(isObservePerf);
-        const { report, issues, counters } = await main({
+        const { report, issues, counters, rules } = await main({
             cwd,
             tsConfigFile: tsConfig,
             gitignore: !isNoGitIgnore,
@@ -33,7 +33,7 @@ const run = async () => {
         });
         await printReport({ report, issues, cwd, isProduction, options: reporterOptions });
         const totalErrorCount = Object.keys(report)
-            .filter(reportGroup => report[reportGroup])
+            .filter(reportGroup => report[reportGroup] && rules[reportGroup] === 'error')
             .reduce((errorCount, reportGroup) => errorCount + counters[reportGroup], 0);
         if (isObservePerf) {
             await perfObserver.finalize();

package/dist/constants.js

@@ -2,9 +2,8 @@ export const ROOT_WORKSPACE_NAME = '.';
 export const KNIP_CONFIG_LOCATIONS = ['knip.json', 'knip.jsonc', '.knip.json', '.knip.jsonc', 'knip.ts', 'knip.js'];
 export const DEFAULT_EXTENSIONS = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
 export const TEST_FILE_PATTERNS = [
-    '**/*.{test,spec}.{js,jsx,ts,tsx,mjs,cjs}',
-    '**/__tests__/**/*.{js,jsx,ts,tsx,mjs,cjs}',
-    '**/test/**/*.{js,jsx,ts,tsx,mjs,cjs}',
+    '**/*{.,-}{test,spec}.{js,jsx,ts,tsx,mjs,cjs}',
+    '**/{test,__tests__}/**/*.{js,jsx,ts,tsx,mjs,cjs}',
 ];
 export const IGNORED_GLOBAL_BINARIES = [
     'bun',

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export declare const main: (unresolvedConfiguration: CommandLineOptions) => Prom
     report: import("./types/issues.js").Report;
     issues: import("./types/issues.js").Issues;
     counters: import("./types/issues.js").Counters;
+    rules: import("./types/issues.js").Rules;
 }>;

package/dist/index.js

@@ -11,7 +11,7 @@ import { LoaderError } from './util/errors.js';
 import { findFile } from './util/fs.js';
 import { _glob } from './util/glob.js';
 import { getEntryPathFromManifest, getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, } from './util/modules.js';
-import { dirname, isInNodeModules, join, isInternal, isAbsolute } from './util/path.js';
+import { dirname, isInNodeModules, join, isInternal, toAbsolute } from './util/path.js';
 import { _resolveSpecifier, _tryResolve } from './util/require.js';
 import { _require } from './util/require.js';
 import { loadTSConfig as loadCompilerOptions } from './util/tsconfig-loader.js';
@@ -22,17 +22,22 @@ export const main = async (unresolvedConfiguration) => {
     const chief = new ConfigurationChief({ cwd, isProduction });
     const deputy = new DependencyDeputy({ isStrict });
     const factory = new PrincipalFactory();
-    const collector = new IssueCollector({ cwd });
     const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
     streamer.cast('Reading workspace configuration(s)...');
     await chief.init();
     const compilers = chief.getCompilers();
     const workspaces = chief.getEnabledWorkspaces();
     const report = chief.getIssueTypesToReport();
+    const rules = chief.getRules();
+    const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;
+    const isReportValues = report.exports || report.nsExports || report.classMembers;
+    const isReportTypes = report.types || report.nsTypes || report.enumMembers;
+    const collector = new IssueCollector({ cwd, rules });
+    const enabledPluginsStore = new Map();
     debugLogObject('Included workspaces', workspaces);
     const handleReferencedDependency = ({ specifier, containingFilePath, principal, workspace, }) => {
         if (isInternal(specifier)) {
-            const absSpecifier = isAbsolute(specifier) ? specifier : join(dirname(containingFilePath), specifier);
+            const absSpecifier = toAbsolute(specifier, dirname(containingFilePath));
             const filePath = _tryResolve(absSpecifier, containingFilePath);
             if (filePath) {
                 principal.addEntryPath(filePath);
@@ -68,7 +73,6 @@ export const main = async (unresolvedConfiguration) => {
             }
         }
     };
-    const enabledPluginsStore = new Map();
     for (const workspace of workspaces) {
         const { name, dir, config, ancestors } = workspace;
         const { paths, ignoreDependencies, ignoreBinaries } = config;
@@ -80,7 +84,7 @@ export const main = async (unresolvedConfiguration) => {
             throw new LoaderError(`Unable to load package.json for ${name}`);
         deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries });
         const compilerOptions = await loadCompilerOptions(join(dir, tsConfigFile ?? 'tsconfig.json'));
-        const principal = factory.getPrincipal({ cwd: dir, report: report, paths, compilerOptions, compilers });
+        const principal = factory.getPrincipal({ cwd: dir, paths, compilerOptions, compilers });
         const worker = new WorkspaceWorker({
             name,
             dir,
@@ -173,10 +177,9 @@ export const main = async (unresolvedConfiguration) => {
         const exportedSymbols = new Map();
         const importedSymbols = new Map();
         const analyzeSourceFile = (filePath) => {
-            collector.counters.processed++;
             const workspace = chief.findWorkspaceByFilePath(filePath);
             if (workspace) {
-                const { imports, exports, scripts } = principal.analyzeSourceFile(filePath);
+                const { imports, exports, scripts } = principal.analyzeSourceFile(filePath, { skipTypeOnly: !isReportTypes });
                 const { internal, external, unresolved } = imports;
                 const { exported, duplicate } = exports;
                 if (exported.size > 0)
@@ -246,51 +249,53 @@ export const main = async (unresolvedConfiguration) => {
         } while (size !== principal.entryPaths.size);
         const unusedFiles = principal.getUnreferencedFiles();
         collector.addFilesIssues(unusedFiles);
-        collector.addTotalFileCount(analyzedFiles.size + unusedFiles.length);
-        streamer.cast('Analyzing source files...');
-        for (const [filePath, exportItems] of exportedSymbols.entries()) {
-            const importedModule = importedSymbols.get(filePath);
-            if (importedModule) {
-                for (const [symbol, exportedItem] of exportItems.entries()) {
-                    if (principal.isPublicExport(exportedItem))
-                        continue;
-                    if (importedModule.symbols.has(symbol)) {
-                        if (report.enumMembers && exportedItem.type === 'enum' && exportedItem.members) {
-                            principal.findUnusedMembers(filePath, exportedItem.members).forEach(member => {
-                                collector.addIssue({ type: 'enumMembers', filePath, symbol: member, parentSymbol: symbol });
-                            });
+        collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
+        if (isReportValues || isReportTypes) {
+            streamer.cast('Analyzing source files...');
+            for (const [filePath, exportItems] of exportedSymbols.entries()) {
+                const importedModule = importedSymbols.get(filePath);
+                if (importedModule) {
+                    for (const [symbol, exportedItem] of exportItems.entries()) {
+                        if (principal.isPublicExport(exportedItem))
+                            continue;
+                        if (importedModule.symbols.has(symbol)) {
+                            if (report.enumMembers && exportedItem.type === 'enum' && exportedItem.members) {
+                                principal.findUnusedMembers(filePath, exportedItem.members).forEach(member => {
+                                    collector.addIssue({ type: 'enumMembers', filePath, symbol: member, parentSymbol: symbol });
+                                });
+                            }
+                            if (report.classMembers && exportedItem.type === 'class' && exportedItem.members) {
+                                principal.findUnusedMembers(filePath, exportedItem.members).forEach(member => {
+                                    collector.addIssue({ type: 'classMembers', filePath, symbol: member, parentSymbol: symbol });
+                                });
+                            }
+                            continue;
                         }
-                        if (report.classMembers && exportedItem.type === 'class' && exportedItem.members) {
-                            principal.findUnusedMembers(filePath, exportedItem.members).forEach(member => {
-                                collector.addIssue({ type: 'classMembers', filePath, symbol: member, parentSymbol: symbol });
-                            });
+                        if (importedModule.isReExported || importedModule.isStar) {
+                            const isReExportedByEntryFile = isExportedInEntryFile(importedModule);
+                            if (!isReExportedByEntryFile && !principal.hasExternalReferences(filePath, exportedItem)) {
+                                if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
+                                    collector.addIssue({ type: 'nsTypes', filePath, symbol, symbolType: exportedItem.type });
+                                }
+                                else {
+                                    collector.addIssue({ type: 'nsExports', filePath, symbol });
+                                }
+                            }
                         }
-                        continue;
-                    }
-                    if (importedModule.isReExported || importedModule.isStar) {
-                        const isReExportedByEntryFile = isExportedInEntryFile(importedModule);
-                        if (!isReExportedByEntryFile && !principal.hasExternalReferences(filePath, exportedItem)) {
+                        else {
                             if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
-                                collector.addIssue({ type: 'nsTypes', filePath, symbol, symbolType: exportedItem.type });
+                                collector.addIssue({ type: 'types', filePath, symbol, symbolType: exportedItem.type });
                             }
-                            else {
-                                collector.addIssue({ type: 'nsExports', filePath, symbol });
+                            else if (!importedModule.isDynamic || !principal.hasExternalReferences(filePath, exportedItem)) {
+                                collector.addIssue({ type: 'exports', filePath, symbol });
                             }
                         }
                     }
-                    else {
-                        if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
-                            collector.addIssue({ type: 'types', filePath, symbol, symbolType: exportedItem.type });
-                        }
-                        else if (!importedModule.isDynamic || !principal.hasExternalReferences(filePath, exportedItem)) {
-                            collector.addIssue({ type: 'exports', filePath, symbol });
-                        }
-                    }
                 }
             }
         }
     }
-    if (report.dependencies) {
+    if (isReportDependencies) {
         const { dependencyIssues, devDependencyIssues } = deputy.settleDependencyIssues();
         dependencyIssues.forEach(issue => collector.addIssue(issue));
         if (!isProduction)
@@ -298,5 +303,5 @@ export const main = async (unresolvedConfiguration) => {
     }
     const { issues, counters } = collector.getIssues();
     streamer.clear();
-    return { report, issues, counters };
+    return { report, issues, counters, rules };
 };

package/dist/issues/initializers.d.ts

@@ -1,3 +1,4 @@
-import { Issues, Counters } from '../types/issues.js';
+import { Issues, Counters, Rules } from '../types/issues.js';
 export declare const initIssues: () => Issues;
 export declare const initCounters: () => Counters;
+export declare const defaultRules: Rules;

package/dist/issues/initializers.js

@@ -8,3 +8,4 @@ export const initCounters = () => ({
     processed: 0,
     total: 0,
 });
+export const defaultRules = Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, 'error']));

package/dist/plugins/eslint/helpers.js

@@ -1,6 +1,6 @@
 import { compact } from '../../util/array.js';
 import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-import { isAbsolute, isInternal, join, dirname } from '../../util/path.js';
+import { isInternal, dirname, toAbsolute } from '../../util/path.js';
 import { load } from '../../util/plugin.js';
 import { _resolve } from '../../util/require.js';
 import { fallback } from './fallback.js';
@@ -36,7 +36,7 @@ export const getDependenciesDeep = async (configFilePath, dependencies = new Set
         if (config.extends) {
             for (const extend of [config.extends].flat()) {
                 if (isInternal(extend)) {
-                    const filePath = isAbsolute(extend) ? extend : join(dirname(configFilePath), extend);
+                    const filePath = toAbsolute(extend, dirname(configFilePath));
                     const extendConfigFilePath = _resolve(filePath);
                     dependencies.add(extendConfigFilePath);
                     addAll(await getDependenciesDeep(extendConfigFilePath, dependencies, options));
@@ -82,7 +82,7 @@ const getImportPluginDependencies = (settings) => {
 };
 export const getDependenciesFromSettings = (settings = {}) => {
     return compact(Object.entries(settings).reduce((packageNames, [settingKey, settings]) => {
-        if (/^import\/(parsers|resolvers)?/.test(settingKey)) {
+        if (/^import\/(parsers|resolvers)?/.test(settingKey) && typeof settings !== 'string') {
             return [...packageNames, ...getImportPluginDependencies(settings)];
         }
         return packageNames;

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

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

package/dist/plugins/jest/index.js

@@ -1,17 +1,16 @@
-import { isAbsolute, join, dirname, isInternal } from '../../util/path.js';
+import { join, isInternal, toAbsolute, dirname } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 export const NAME = 'Jest';
 export const ENABLERS = ['jest'];
 export const isEnabled = ({ dependencies, manifest }) => hasDependency(dependencies, ENABLERS) || Boolean(manifest.name?.startsWith('jest-presets'));
 export const CONFIG_FILE_PATTERNS = ['jest.config.{js,ts,mjs,cjs,json}', 'package.json'];
-const maybeJoin = (base, id) => (isAbsolute(id) ? id : join(dirname(base), id));
 const resolveExtensibleConfig = async (configFilePath) => {
     const config = await load(configFilePath);
     if (config?.preset) {
         const { preset } = config;
         if (isInternal(preset)) {
-            const presetConfigPath = maybeJoin(configFilePath, preset);
+            const presetConfigPath = toAbsolute(preset, dirname(configFilePath));
             const presetConfig = await resolveExtensibleConfig(presetConfigPath);
             Object.assign(config, presetConfig);
         }

package/dist/reporters/codeowners.js

@@ -1,11 +1,11 @@
 import { OwnershipEngine } from '@snyk/github-codeowners/dist/lib/ownership/index.js';
 import chalk from 'chalk';
-import { isAbsolute, relative, resolve } from '../util/path.js';
+import { toRelative, relative, resolve } from '../util/path.js';
 import { getTitle, logTitle, logIssueLine } from './util.js';
 const logIssueSet = (issues) => {
     issues
         .sort((a, b) => (a.owner < b.owner ? -1 : 1))
-        .forEach(issue => console.log(chalk.cyan(issue.owner), isAbsolute(issue.symbol) ? relative(issue.symbol) : issue.symbol));
+        .forEach(issue => console.log(chalk.cyan(issue.owner), toRelative(issue.symbol)));
 };
 const logIssueRecord = (issues) => {
     const sortedByFilePath = issues.sort((a, b) => (a.owner < b.owner ? -1 : 1));

package/dist/reporters/compact.js

@@ -1,7 +1,7 @@
 import { getTitle, logTitle, logIssueLine, logIssueSet } from './util.js';
 const logIssueRecord = (issues) => {
     const sortedByFilePath = issues.sort((a, b) => (a.filePath > b.filePath ? 1 : -1));
-    sortedByFilePath.forEach(({ filePath, symbols, parentSymbol }) => logIssueLine({ filePath, symbols, parentSymbol }));
+    sortedByFilePath.forEach(logIssueLine);
 };
 export default ({ report, issues }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;

package/dist/reporters/symbols.js

@@ -1,15 +1,17 @@
+import chalk from 'chalk';
 import EasyTable from 'easy-table';
 import { relative } from '../util/path.js';
-import { getTitle, logTitle, logIssueSet } from './util.js';
+import { getTitle, logTitle, logIssueSet, identity } from './util.js';
 const TRUNCATE_WIDTH = 40;
 const truncate = (text) => (text.length > TRUNCATE_WIDTH ? text.slice(0, TRUNCATE_WIDTH - 3) + '...' : text);
 const logIssueRecord = (issues) => {
     const table = new EasyTable();
     issues.forEach(issue => {
-        table.cell('symbol', issue.symbols ? truncate(issue.symbols.join(', ')) : issue.symbol);
-        issue.parentSymbol && table.cell('parentSymbol', issue.parentSymbol);
-        issue.symbolType && table.cell('symbolType', issue.symbolType);
-        table.cell('filePath', relative(issue.filePath));
+        const print = issue.severity === 'warn' ? chalk.grey : identity;
+        table.cell('symbol', print(issue.symbols ? truncate(issue.symbols.join(', ')) : issue.symbol));
+        issue.parentSymbol && table.cell('parentSymbol', print(issue.parentSymbol));
+        issue.symbolType && table.cell('symbolType', print(issue.symbolType));
+        table.cell('filePath', print(relative(issue.filePath)));
         table.newRow();
     });
     console.log(table.sort(['filePath', 'parentSymbol', 'symbol']).print().trim());

package/dist/reporters/util.d.ts

@@ -1,4 +1,6 @@
 import { ISSUE_TYPE_TITLE } from '../constants.js';
+import { IssueSeverity } from '../types/issues.js';
+export declare const identity: (text: string) => string;
 export declare const getTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => string;
 export declare const logTitle: (title: string, count: number) => void;
 type LogIssueLine = {
@@ -6,7 +8,8 @@ type LogIssueLine = {
     filePath: string;
     symbols?: string[];
     parentSymbol?: string;
+    severity?: IssueSeverity;
 };
-export declare const logIssueLine: ({ owner, filePath, symbols, parentSymbol }: LogIssueLine) => void;
+export declare const logIssueLine: ({ owner, filePath, symbols, parentSymbol, severity }: LogIssueLine) => void;
 export declare const logIssueSet: (issues: string[]) => void;
 export {};

package/dist/reporters/util.js

@@ -1,15 +1,17 @@
 import chalk from 'chalk';
 import { ISSUE_TYPE_TITLE } from '../constants.js';
-import { isAbsolute, relative } from '../util/path.js';
+import { toRelative, relative } from '../util/path.js';
+export const identity = (text) => text;
 export const getTitle = (reportType) => {
     return ISSUE_TYPE_TITLE[reportType];
 };
 export const logTitle = (title, count) => console.log(`${chalk.bold.yellow.underline(title)} (${count})`);
-export const logIssueLine = ({ owner, filePath, symbols, parentSymbol }) => {
+export const logIssueLine = ({ owner, filePath, symbols, parentSymbol, severity }) => {
     const symbol = symbols ? `: ${symbols.join(', ')}` : '';
     const parent = parentSymbol ? ` (${parentSymbol})` : '';
-    console.log(`${owner ? `${chalk.cyan(owner)} ` : ''}${relative(filePath)}${symbol}${parent}`);
+    const print = severity === 'warn' ? chalk.grey : identity;
+    console.log(`${owner ? `${chalk.cyan(owner)} ` : ''}${print(`${relative(filePath)}${symbol}${parent}`)}`);
 };
 export const logIssueSet = (issues) => {
-    issues.sort().forEach(value => console.log(isAbsolute(value) ? relative(value) : value));
+    issues.sort().forEach(value => console.log(toRelative(value)));
 };

package/dist/types/config.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ConfigurationValidator } from '../ConfigurationValidator.js';
 import * as Plugins from '../plugins/index.js';
+import { Rules } from './issues.js';
 import type { SyncCompilers, AsyncCompilers } from '../types/compilers.js';
 export type RawConfiguration = z.infer<typeof ConfigurationValidator>;
 type NormalizedGlob = string[];
@@ -22,6 +23,7 @@ interface BaseWorkspaceConfiguration {
 export interface WorkspaceConfiguration extends BaseWorkspaceConfiguration, Partial<PluginsConfiguration> {
 }
 export interface Configuration {
+    rules: Rules;
     include: string[];
     exclude: string[];
     ignore: NormalizedGlob;