knip 5.44.5 → 5.46.0

package/dist/plugins/eslint/helpers.js

@@ -1,13 +1,21 @@
 import { compact } from '../../util/array.js';
 import { toConfig, toDeferResolve } from '../../util/input.js';
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-import { isAbsolute, isInternal } from '../../util/path.js';
+import { extname, isAbsolute, isInternal } from '../../util/path.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
-export const getDependencies = (config, options) => {
+export const getInputs = (config, options) => {
+    const { configFileName } = options;
+    if (extname(configFileName) === '.json' || !/eslint\.config/.test(configFileName)) {
+        return getInputsDeprecated(config, options);
+    }
+    const dependencies = config.flatMap(config => config.settings ? getDependenciesFromSettings(config.settings).filter(id => id !== '@typescript-eslint/parser') : []);
+    return compact(dependencies).map(id => toDeferResolve(id));
+};
+const getInputsDeprecated = (config, options) => {
     const extendsSpecifiers = config.extends ? compact([config.extends].flat().map(resolveExtendSpecifier)) : [];
     if (extendsSpecifiers.some(specifier => specifier?.startsWith('eslint-plugin-prettier')))
         extendsSpecifiers.push('eslint-config-prettier');
-    const extendConfigs = extendsSpecifiers.map(specifier => toConfig('eslint', specifier, options.configFilePath));
+    const extendConfigs = extendsSpecifiers.map(specifier => toConfig('eslint', specifier, { containingFilePath: options.configFilePath }));
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
     const parser = config.parser ?? config.parserOptions?.parser;
     const babelDependencies = config.parserOptions?.babelOptions
@@ -15,9 +23,9 @@ export const getDependencies = (config, options) => {
         : [];
     const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
     const rules = getDependenciesFromRules({});
-    const overrides = config.overrides ? [config.overrides].flat().flatMap(d => getDependencies(d, options)) : [];
-    const x = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(toDeferResolve);
-    return [...extendConfigs, ...x, ...babelDependencies, ...overrides];
+    const overrides = config.overrides ? [config.overrides].flat().flatMap(d => getInputsDeprecated(d, options)) : [];
+    const deferred = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(toDeferResolve);
+    return [...extendConfigs, ...deferred, ...babelDependencies, ...overrides];
 };
 const isQualifiedSpecifier = (specifier) => specifier === 'eslint' ||
     /\/eslint-(config|plugin)$/.test(specifier) ||

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

@@ -1,5 +1,8 @@
 import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
-import type { ESLintConfig } from './types.js';
+import type { ESLintConfigDeprecated } from './types.js';
+export declare const docs: {
+    note: string;
+};
 declare const _default: {
     title: string;
     enablers: string[];
@@ -7,6 +10,6 @@ declare const _default: {
     packageJsonPath: string;
     entry: string[];
     config: string[];
-    resolveConfig: ResolveConfig<ESLintConfig>;
+    resolveConfig: ResolveConfig<ESLintConfigDeprecated>;
 };
 export default _default;

package/dist/plugins/eslint/index.js

@@ -1,14 +1,42 @@
 import { hasDependency } from '../../util/plugin.js';
-import { getDependencies } from './helpers.js';
+import { getInputs } from './helpers.js';
 const title = 'ESLint';
 const enablers = ['eslint', '@eslint/js'];
 const isEnabled = ({ dependencies, manifest, config }) => hasDependency(dependencies, enablers) ||
     'eslint' in config ||
     Boolean(manifest.name && /(^eslint-config|\/eslint-config)/.test(manifest.name));
 const packageJsonPath = 'eslintConfig';
-const entry = ['eslint.config.{js,cjs,mjs}'];
+const entry = ['eslint.config.{js,cjs,mjs,ts,cts,mts}'];
 const config = ['.eslintrc', '.eslintrc.{js,json,cjs}', '.eslintrc.{yml,yaml}', 'package.json'];
-const resolveConfig = (localConfig, options) => getDependencies(localConfig, options);
+const resolveConfig = (localConfig, options) => getInputs(localConfig, options);
+const note = `### ESLint v9
+
+Only regular \`import\` statements are considered by default.
+The configuration object is not resolved to find dependencies for \`settings\` such as \`"eslint-import-resolver-typescript"\`.
+To enable this, lift the \`entry\` to a \`config\` file like so:
+
+\`\`\`json
+{
+  "eslint": ["eslint.config.ts"]
+}
+\`\`\`
+
+This is not enabled by default, since this exception may be thrown by a \`@rushstack/eslint-*\` package:
+
+> \`Error: Failed to patch ESLint because the calling module was not recognized.\`
+
+### ESLint v8
+
+If relying on [configuration cascading](https://eslint.org/docs/v8.x/use/configure/configuration-files#cascading-and-hierarchy),
+consider using an extended glob pattern like this:
+
+\`\`\`json
+{
+  "eslint": ["**/.eslintrc.js"]
+}
+\`\`\`
+`;
+export const docs = { note };
 export default {
     title,
     enablers,

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

@@ -17,12 +17,13 @@ type BaseConfig = {
     settings?: Settings;
     rules?: Rules;
 };
-export type OverrideConfig = BaseConfig & {
+export type ESLintConfig = BaseConfig[];
+export type OverrideConfigDeprecated = BaseConfig & {
     files: string[];
-    overrides: OverrideConfig;
+    overrides: OverrideConfigDeprecated;
 };
-export type ESLintConfig = BaseConfig & {
+export type ESLintConfigDeprecated = BaseConfig & {
     env?: Record<string, boolean>;
-    overrides?: OverrideConfig[];
+    overrides?: OverrideConfigDeprecated[];
 };
 export {};

package/dist/plugins/index.d.ts

@@ -133,7 +133,7 @@ export declare const Plugins: {
         packageJsonPath: string;
         entry: string[];
         config: string[];
-        resolveConfig: import("../types/config.js").ResolveConfig<import("./eslint/types.js").ESLintConfig>;
+        resolveConfig: import("../types/config.js").ResolveConfig<import("./eslint/types.js").ESLintConfigDeprecated>;
     };
     expo: {
         title: string;
@@ -403,12 +403,6 @@ export declare const Plugins: {
         entry: string[];
         resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<import("./playwright/types.js").PlaywrightTestConfig>;
         resolveConfig: import("../types/config.js").ResolveConfig<import("./playwright/types.js").PlaywrightTestConfig>;
-        args: {
-            binaries: string[];
-            positional: boolean;
-            args: (args: string[]) => string[];
-            config: boolean;
-        };
     };
     'playwright-test': {
         title: string;

package/dist/plugins/playwright/index.d.ts

@@ -3,12 +3,6 @@ import type { PlaywrightTestConfig } from './types.js';
 export declare const entry: string[];
 export declare const resolveEntryPaths: ResolveEntryPaths<PlaywrightTestConfig>;
 export declare const resolveConfig: ResolveConfig<PlaywrightTestConfig>;
-export declare const args: {
-    binaries: string[];
-    positional: boolean;
-    args: (args: string[]) => string[];
-    config: boolean;
-};
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/playwright/index.js

@@ -29,7 +29,7 @@ export const resolveConfig = async (config) => {
     });
     return [...reporters].map(toDeferResolve);
 };
-export const args = {
+const args = {
     binaries: ['playwright'],
     positional: true,
     args: (args) => args.filter(arg => arg !== 'install' && arg !== 'test'),

package/dist/plugins/playwright-ct/index.d.ts

@@ -7,11 +7,5 @@ declare const _default: {
     entry: string[];
     resolveEntryPaths: import("../../types/config.js").ResolveEntryPaths<import("../playwright/types.js").PlaywrightTestConfig>;
     resolveConfig: import("../../types/config.js").ResolveConfig<import("../playwright/types.js").PlaywrightTestConfig>;
-    args: {
-        binaries: string[];
-        positional: boolean;
-        args: (args: string[]) => string[];
-        config: boolean;
-    };
 };
 export default _default;

package/dist/plugins/playwright-ct/index.js

@@ -1,5 +1,5 @@
 import { hasDependency } from '../../util/plugin.js';
-import { args, entry, resolveConfig, resolveEntryPaths } from '../playwright/index.js';
+import { entry, resolveConfig, resolveEntryPaths } from '../playwright/index.js';
 const title = 'Playwright for components';
 const enablers = [/^@playwright\/experimental-ct-/];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -12,5 +12,4 @@ export default {
     entry,
     resolveEntryPaths,
     resolveConfig,
-    args,
 };

package/dist/plugins/storybook/index.js

@@ -4,11 +4,11 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Storybook';
 const enablers = [/^@storybook\//, '@nrwl/storybook'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.storybook/{main,test-runner}.{js,ts}'];
+const config = ['.storybook/{main,test-runner}.{js,ts,mts}'];
 const stories = ['**/*.@(mdx|stories.@(mdx|js|jsx|mjs|ts|tsx))'];
 const restEntry = ['.storybook/{manager,preview}.{js,jsx,ts,tsx}'];
 const entry = [...restEntry, ...stories];
-const project = ['.storybook/**/*.{js,jsx,ts,tsx}'];
+const project = ['.storybook/**/*.{js,jsx,ts,tsx,mts}'];
 const resolveEntryPaths = async (localConfig, options) => {
     const { cwd, configFileDir } = options;
     const strs = typeof localConfig?.stories === 'function' ? await localConfig.stories(stories) : localConfig?.stories;

package/dist/plugins/typescript/index.js

@@ -9,11 +9,13 @@ const config = ['tsconfig.json'];
 const resolveConfig = async (localConfig, options) => {
     const { compilerOptions } = localConfig;
     const extend = localConfig.extends
-        ? [localConfig.extends].flat().map(specifier => toConfig('typescript', specifier, options.configFilePath))
+        ? [localConfig.extends]
+            .flat()
+            .map(specifier => toConfig('typescript', specifier, { containingFilePath: options.configFilePath }))
         : [];
     const references = localConfig.references
         ?.filter(reference => reference.path.endsWith('.json'))
-        .map(reference => toConfig('typescript', reference.path, options.configFilePath)) ?? [];
+        .map(reference => toConfig('typescript', reference.path, { containingFilePath: options.configFilePath })) ?? [];
     if (!(compilerOptions && localConfig))
         return compact([...extend, ...references]);
     const jsx = (compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : []).map(toProductionDependency);

package/dist/plugins/xo/index.js

@@ -1,12 +1,12 @@
 import { hasDependency } from '../../util/plugin.js';
-import { getDependencies } from '../eslint/helpers.js';
+import { getInputs } from '../eslint/helpers.js';
 const title = 'xo';
 const enablers = ['xo'];
 const isEnabled = ({ dependencies, config }) => hasDependency(dependencies, enablers) || 'xo' in config;
 const config = ['package.json', '.xo-config', '.xo-config.{js,cjs,json}', 'xo.config.{js,cjs}'];
 const entry = ['.xo-config.{js,cjs}', 'xo.config.{js,cjs}'];
 const resolveConfig = async (config, options) => {
-    const inputs = getDependencies(config, options);
+    const inputs = getInputs(config, options);
     return [...inputs];
 };
 export default {

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

@@ -1,5 +1,5 @@
-import type { ESLintConfig } from '../eslint/types.js';
-export type XOConfig = ESLintConfig & {
+import type { ESLintConfigDeprecated } from '../eslint/types.js';
+export type XOConfig = ESLintConfigDeprecated & {
     envs?: string[] | undefined;
     globals?: string[] | undefined;
     ignores?: string[] | undefined;

package/dist/reporters/codeclimate.d.ts

@@ -0,0 +1,3 @@
+import type { ReporterOptions } from '../types/issues.js';
+declare const _default: ({ report, issues }: ReporterOptions) => Promise<void>;
+export default _default;

package/dist/reporters/codeclimate.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { toRelative } from '../util/path.js';
+import { getTitle } from './util.js';
+export default async ({ report, issues }) => {
+    const entries = [];
+    for (const [type, isReportType] of Object.entries(report)) {
+        if (!isReportType) {
+            continue;
+        }
+        const fixedType = type === 'files' ? '_files' : type;
+        for (const issue of flatten(issues[fixedType])) {
+            const { filePath } = issue;
+            if (fixedType === 'duplicates' && issue.symbols) {
+                entries.push(...issue.symbols.map(symbol => ({
+                    type: 'issue',
+                    check_name: getTitle(fixedType),
+                    description: getSymbolDescription({ symbol, parentSymbol: issue.parentSymbol }),
+                    categories: ['Duplication'],
+                    location: createLocation(filePath, symbol.line, symbol.col),
+                    severity: convertSeverity(issue.severity),
+                    fingerprint: createFingerprint(filePath, symbol.symbol, symbol.pos),
+                })));
+            }
+            else {
+                entries.push({
+                    type: 'issue',
+                    check_name: getTitle(fixedType),
+                    description: getIssueDescription(issue),
+                    categories: ['Bug Risk'],
+                    location: createLocation(filePath, issue.line, issue.col),
+                    severity: convertSeverity(issue.severity),
+                    fingerprint: createFingerprint(filePath, issue.symbol, issue.pos),
+                });
+            }
+        }
+    }
+    const output = JSON.stringify(entries);
+    process.stdout._handle?.setBlocking?.(true);
+    process.stdout.write(`${output}\n`);
+};
+function flatten(issues) {
+    return Object.values(issues).flatMap(Object.values);
+}
+function convertSeverity(severity) {
+    switch (severity) {
+        case 'error':
+            return 'major';
+        case 'warn':
+            return 'minor';
+        default:
+            return 'info';
+    }
+}
+function getIssueDescription({ symbol, symbols, parentSymbol }) {
+    const symbolDescription = symbols ? `${symbols.map(s => s.symbol).join(', ')}` : symbol;
+    return `${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+}
+function getSymbolDescription({ symbol, parentSymbol }) {
+    return `${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+}
+function createLocation(filePath, line, col) {
+    if (col !== undefined) {
+        return {
+            path: toRelative(filePath),
+            positions: {
+                begin: {
+                    line: line ?? 0,
+                    column: col,
+                },
+            },
+        };
+    }
+    return {
+        path: toRelative(filePath),
+        lines: {
+            begin: line ?? 0,
+            end: line ?? 0,
+        },
+    };
+}
+function createFingerprint(filePath, message, pos) {
+    const md5 = createHash('md5');
+    md5.update(filePath);
+    md5.update(message);
+    md5.update(pos?.toString() ?? '');
+    return md5.digest('hex');
+}

package/dist/reporters/compact.js

@@ -16,7 +16,7 @@ export default ({ report, issues, isShowProgress }) => {
                     ? Object.values(issues[reportType]).flatMap(Object.values)
                     : Object.values(issues[reportType]).map(issues => {
                         const items = Object.values(issues);
-                        return { ...items[0], symbols: items.map(issue => issue.symbol) };
+                        return { ...items[0], symbols: items };
                     });
             if (issuesForType.length > 0) {
                 title && logTitle(title, issuesForType.length);

package/dist/reporters/disclosure.js

@@ -1,5 +1,5 @@
 import EasyTable from 'easy-table';
-import { relative, toRelative } from '../util/path.js';
+import { relative } from '../util/path.js';
 import { getTitle } from './util.js';
 const printHeader = (size, title) => console.log(`<details>\n${title ? `<summary>${title} (${size})</summary>\n` : ''}\n\`\`\``);
 const printFooter = () => console.log('```\n\n</details>\n');
@@ -10,7 +10,7 @@ const logIssueRecord = (issues) => {
         issue.parentSymbol && table.cell('parentSymbol', issue.parentSymbol);
         issue.symbolType && table.cell('symbolType', issue.symbolType);
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
-        const cell = `${relative(issue.filePath)}${pos}`;
+        const cell = issue.type === 'files' ? '' : `${relative(issue.filePath)}${pos}`;
         table.cell('filePath', cell);
         table.newRow();
     }
@@ -19,30 +19,17 @@ const logIssueRecord = (issues) => {
 export default ({ report, issues }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
-    for (const [reportType, isReportType] of Object.entries(report)) {
-        if (reportType === '_files')
-            continue;
+    for (let [reportType, isReportType] of Object.entries(report)) {
+        if (reportType === 'files')
+            reportType = '_files';
         if (isReportType) {
             const title = reportMultipleGroups ? getTitle(reportType) : undefined;
-            if (reportType === 'files') {
-                const issuesForType = Array.from(issues._files);
-                if (issuesForType.length > 0) {
-                    printHeader(issuesForType.length, title);
-                    const sortedIssues = issuesForType.sort((a, b) => a.filePath.localeCompare(b.filePath));
-                    for (const issue of sortedIssues)
-                        console.log(toRelative(issue.filePath));
-                    totalIssues = totalIssues + issuesForType.length;
-                    printFooter();
-                }
-            }
-            else {
-                const issuesForType = Object.values(issues[reportType]).flatMap(Object.values);
-                if (issuesForType.length > 0) {
-                    printHeader(issuesForType.length, title);
-                    logIssueRecord(issuesForType);
-                    totalIssues = totalIssues + issuesForType.length;
-                    printFooter();
-                }
+            const issuesForType = Object.values(issues[reportType]).flatMap(Object.values);
+            if (issuesForType.length > 0) {
+                printHeader(issuesForType.length, title);
+                logIssueRecord(issuesForType);
+                totalIssues = totalIssues + issuesForType.length;
+                printFooter();
             }
         }
     }

package/dist/reporters/index.d.ts

@@ -1,8 +1,9 @@
 declare const _default: {
-    symbols: ({ report, issues, tagHints, configurationHints, noConfigHints, isShowProgress }: import("../index.js").ReporterOptions) => void;
+    symbols: ({ report, issues, tagHints, configurationHints, isDisableConfigHints, isTreatConfigHintsAsErrors, isShowProgress, }: import("../index.js").ReporterOptions) => void;
     compact: ({ report, issues, isShowProgress }: import("../index.js").ReporterOptions) => void;
     codeowners: ({ report, issues, isShowProgress, options }: import("../index.js").ReporterOptions) => void;
     disclosure: ({ report, issues }: import("../index.js").ReporterOptions) => void;
+    codeclimate: ({ report, issues }: import("../index.js").ReporterOptions) => Promise<void>;
     json: ({ report, issues, options }: import("../index.js").ReporterOptions) => Promise<void>;
     markdown: ({ report, issues }: import("../index.js").ReporterOptions) => void;
 };

package/dist/reporters/index.js

@@ -1,3 +1,4 @@
+import codeclimate from './codeclimate.js';
 import codeowners from './codeowners.js';
 import compact from './compact.js';
 import disclosure from './disclosure.js';
@@ -9,6 +10,7 @@ export default {
     compact,
     codeowners,
     disclosure,
+    codeclimate,
     json,
     markdown,
 };

package/dist/reporters/symbols.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
-declare const _default: ({ report, issues, tagHints, configurationHints, noConfigHints, isShowProgress }: ReporterOptions) => void;
+declare const _default: ({ report, issues, tagHints, configurationHints, isDisableConfigHints, isTreatConfigHintsAsErrors, isShowProgress, }: ReporterOptions) => void;
 export default _default;

package/dist/reporters/symbols.js

@@ -33,56 +33,39 @@ const logIssueRecord = (issues) => {
         issue.parentSymbol && table.cell('parentSymbol', print(issue.parentSymbol));
         issue.symbolType && table.cell('symbolType', print(issue.symbolType));
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
-        const cell = `${relative(issue.filePath)}${pos}`;
+        const cell = issue.type === 'files' ? '' : `${relative(issue.filePath)}${pos}`;
         table.cell('filePath', print(cell));
         issue.isFixed && table.cell('fixed', print('(removed)'));
         table.newRow();
     }
     console.log(table.sort(sortByPos).print().trim());
 };
-export default ({ report, issues, tagHints, configurationHints, noConfigHints, isShowProgress }) => {
+export default ({ report, issues, tagHints, configurationHints, isDisableConfigHints, isTreatConfigHintsAsErrors, isShowProgress, }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
-    for (const [reportType, isReportType] of Object.entries(report)) {
-        if (reportType === '_files')
-            continue;
+    for (let [reportType, isReportType] of Object.entries(report)) {
+        if (reportType === 'files')
+            reportType = '_files';
         if (isReportType) {
             const title = reportMultipleGroups && getTitle(reportType);
-            if (reportType === 'files') {
-                const issuesForType = Array.from(issues._files);
-                if (issuesForType.length > 0) {
-                    title && logTitle(title, issuesForType.length);
-                    const sortedIssues = issuesForType.sort((a, b) => a.filePath.localeCompare(b.filePath));
-                    for (const issue of sortedIssues) {
-                        const relPath = toRelative(issue.filePath);
-                        if (issue.isFixed)
-                            console.log(dim(`${relPath} (removed)`));
-                        else if (issue.severity === 'warn')
-                            console.log(dim(relPath));
-                        else
-                            console.log(relPath);
-                    }
-                    totalIssues = totalIssues + issuesForType.length;
-                }
-            }
-            else {
-                const issuesForType = Object.values(issues[reportType]).flatMap(Object.values);
-                if (issuesForType.length > 0) {
-                    title && logTitle(title, issuesForType.length);
-                    logIssueRecord(issuesForType);
-                    totalIssues = totalIssues + issuesForType.length;
-                }
+            const issuesForType = Object.values(issues[reportType]).flatMap(Object.values);
+            if (issuesForType.length > 0) {
+                title && logTitle(title, issuesForType.length);
+                logIssueRecord(issuesForType);
+                totalIssues = totalIssues + issuesForType.length;
             }
         }
     }
-    if (!noConfigHints) {
+    if (!isDisableConfigHints) {
         if (configurationHints.size > 0) {
-            logTitleDimmed('Configuration hints');
+            const _logTitle = isTreatConfigHintsAsErrors ? logTitle : logTitleDimmed;
+            const _color = isTreatConfigHintsAsErrors ? identity : dim;
+            _logTitle('Configuration hints', configurationHints.size);
             for (const hint of configurationHints) {
                 const { type, workspaceName, identifier } = hint;
                 const message = `Unused item in ${type}`;
                 const workspace = workspaceName && workspaceName !== ROOT_WORKSPACE_NAME ? ` (workspace: ${workspaceName})` : '';
-                console.warn(dim(`${message}${workspace}:`), identifier);
+                console.warn(_color(`${message}${workspace}:`), identifier);
             }
         }
         if (tagHints.size > 0) {

package/dist/schema/configuration.d.ts

@@ -15,6 +15,7 @@ export declare const knipConfigurationSchema: z.ZodObject<z.objectUtil.extendSha
     compilers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodString], z.ZodUnknown>, z.ZodString>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodString>>]>>>;
     syncCompilers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodString], z.ZodUnknown>, z.ZodString>>>;
     asyncCompilers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodString>>>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, {
     include: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"files">, z.ZodLiteral<"dependencies">, z.ZodLiteral<"devDependencies">, z.ZodLiteral<"optionalPeerDependencies">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"binaries">, z.ZodLiteral<"unresolved">, z.ZodLiteral<"exports">, z.ZodLiteral<"types">, z.ZodLiteral<"nsExports">, z.ZodLiteral<"nsTypes">, z.ZodLiteral<"duplicates">, z.ZodLiteral<"enumMembers">, z.ZodLiteral<"classMembers">]>, "many">>;
     exclude: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"files">, z.ZodLiteral<"dependencies">, z.ZodLiteral<"devDependencies">, z.ZodLiteral<"optionalPeerDependencies">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"binaries">, z.ZodLiteral<"unresolved">, z.ZodLiteral<"exports">, z.ZodLiteral<"types">, z.ZodLiteral<"nsExports">, z.ZodLiteral<"nsTypes">, z.ZodLiteral<"duplicates">, z.ZodLiteral<"enumMembers">, z.ZodLiteral<"classMembers">]>, "many">>;
@@ -3330,6 +3331,7 @@ export declare const knipConfigurationSchema: z.ZodObject<z.objectUtil.extendSha
     }>]>>;
 }>, "strip", z.ZodTypeAny, {
     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;
@@ -4269,6 +4271,7 @@ export declare const knipConfigurationSchema: z.ZodObject<z.objectUtil.extendSha
     }> | undefined;
 }, {
     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;

package/dist/schema/configuration.js

@@ -50,6 +50,7 @@ const rootConfigurationSchema = z.object({
     compilers: compilersSchema.optional(),
     syncCompilers: z.record(z.string(), syncCompilerSchema).optional(),
     asyncCompilers: z.record(z.string(), asyncCompilerSchema).optional(),
+    tags: z.array(z.string()).optional(),
 });
 const reportConfigSchema = z.object({
     include: z.array(issueTypeSchema).optional(),

package/dist/types/cli.d.ts

@@ -11,7 +11,7 @@ export interface CommandLineOptions {
     isExportsShorthand: boolean;
     isFilesShorthand: boolean;
     isFix: boolean;
-    isHideConfigHints: boolean;
+    isDisableConfigHints: boolean;
     isIncludeEntryExports: boolean;
     isIncludeLibs: boolean;
     isIsolateWorkspaces: boolean;

package/dist/types/config.d.ts

@@ -14,7 +14,7 @@ export interface GetInputsFromScriptsOptions extends BaseOptions {
 }
 export type GetInputsFromScripts<T = GetInputsFromScriptsOptions> = (npmScripts: string | string[] | Set<string>, options: T) => Input[];
 export type GetInputsFromScriptsPartial = (npmScripts: string | string[] | Set<string>, options?: Partial<GetInputsFromScriptsOptions>) => Input[];
-type FromArgs = (args: string[]) => Input[];
+export type FromArgs = (args: string[], options?: Partial<GetInputsFromScriptsOptions>) => Input[];
 export interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
     fromArgs: FromArgs;
 }
@@ -47,6 +47,7 @@ export interface Configuration {
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
     rootPluginConfigs: Partial<PluginsConfiguration>;
+    tags: string[];
 }
 type NormalizedGlob = string[];
 export type EnsuredPluginConfiguration = {

package/dist/types/issues.d.ts

@@ -32,7 +32,7 @@ export type IssueSet = Set<string>;
 export type IssueRecords = Record<string, Record<string, Issue>>;
 export type Issues = {
     files: IssueSet;
-    _files: Set<Issue>;
+    _files: IssueRecords;
     dependencies: IssueRecords;
     devDependencies: IssueRecords;
     optionalPeerDependencies: IssueRecords;
@@ -48,7 +48,7 @@ export type Issues = {
     classMembers: IssueRecords;
 };
 export type IssueType = keyof Issues;
-export type SymbolIssueType = Exclude<IssueType, 'files' | '_files'>;
+export type SymbolIssueType = Exclude<IssueType, 'files'>;
 export type Report = {
     [key in keyof Issues]: boolean;
 };
@@ -59,7 +59,8 @@ export type ReporterOptions = {
     counters: Counters;
     tagHints: TagHints;
     configurationHints: ConfigurationHints;
-    noConfigHints: boolean;
+    isDisableConfigHints: boolean;
+    isTreatConfigHintsAsErrors: boolean;
     cwd: string;
     isProduction: boolean;
     isShowProgress: boolean;

package/dist/typescript/SourceFile.d.ts

@@ -27,7 +27,6 @@ type PragmaMap = {
 };
 export interface BoundSourceFile extends ts.SourceFile {
     symbol?: SymbolWithExports;
-    resolvedModules?: ts.ModeAwareCache<ts.ResolvedModuleWithFailedLookupLocations>;
     locals?: SymbolTable;
     getNamedDeclarations?(): Map<string, readonly ts.Declaration[]>;
     scriptKind?: ts.ScriptKind;