knip 5.22.3 → 5.23.1

package/dist/compilers/mdx.d.ts

@@ -1,6 +1,6 @@
 import type { HasDependency } from './types.js';
 declare const _default: {
     condition: (hasDependency: HasDependency) => boolean;
-    compiler: (text: string) => string;
+    compiler: (text: string) => any;
 };
 export default _default;

package/dist/constants.d.ts

@@ -5,10 +5,10 @@ export declare const ANONYMOUS = "__anonymous";
 export declare const KNIP_CONFIG_LOCATIONS: string[];
 export declare const DEFAULT_EXTENSIONS: string[];
 export declare const GLOBAL_IGNORE_PATTERNS: string[];
-export declare const IGNORED_GLOBAL_BINARIES: Set<string>;
-export declare const IGNORED_DEPENDENCIES: Set<string>;
-export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
-export declare const FOREIGN_FILE_EXTENSIONS: Set<string>;
+export declare const IGNORED_GLOBAL_BINARIES: any;
+export declare const IGNORED_DEPENDENCIES: any;
+export declare const IGNORED_RUNTIME_DEPENDENCIES: any;
+export declare const FOREIGN_FILE_EXTENSIONS: any;
 export declare const IGNORE_DEFINITELY_TYPED: string[];
 export declare const ISSUE_TYPES: IssueType[];
 export declare const ISSUE_TYPE_TITLE: Record<IssueType, string>;

package/dist/index.d.ts

@@ -1,10 +1,4 @@
 import type { CommandLineOptions } from './types/cli.js';
 export type { RawConfiguration as KnipConfig } from './types/config.js';
 export type { Preprocessor, Reporter, ReporterOptions } from './types/issues.js';
-export declare const main: (unresolvedConfiguration: CommandLineOptions) => Promise<{
-    report: import("./types/issues.js").Report;
-    issues: import("./types/issues.js").Issues;
-    counters: import("./types/issues.js").Counters;
-    rules: import("./types/issues.js").Rules;
-    configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
-}>;
+export declare const main: (unresolvedConfiguration: CommandLineOptions) => unknown;

package/dist/index.js

@@ -22,7 +22,7 @@ import { getIsIdentifierReferencedHandler } from './util/is-identifier-reference
 import { getEntryPathFromManifest, getPackageNameFromModuleSpecifier } from './util/modules.js';
 import { dirname, join, toPosix } from './util/path.js';
 import { findMatch } from './util/regex.js';
-import { getShouldIgnoreHandler } from './util/tag.js';
+import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from './util/tag.js';
 import { augmentWorkspace, getToSourcePathHandler } from './util/to-source-path.js';
 import { createAndPrintTrace, printTrace } from './util/trace.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
@@ -285,12 +285,15 @@ export const main = async (unresolvedConfiguration) => {
     if (isIsolateWorkspaces)
         for (const principal of principals)
             factory.deletePrincipal(principal);
-    const shouldIgnore = getShouldIgnoreHandler(tags, isProduction);
+    const shouldIgnore = getShouldIgnoreHandler(isProduction);
+    const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
     const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths);
-    const isExportedItemReferenced = (exportedItem) => exportedItem.refs > 0 &&
-        (typeof chief.config.ignoreExportsUsedInFile === 'object'
-            ? exportedItem.type !== 'unknown' && !!chief.config.ignoreExportsUsedInFile[exportedItem.type]
-            : chief.config.ignoreExportsUsedInFile);
+    const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
+    const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
+        (exportedItem.refs[0] > 0 &&
+            (typeof ignoreExportsUsedInFile === 'object'
+                ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
+                : ignoreExportsUsedInFile));
     const findUnusedExports = async () => {
         if (isReportValues || isReportTypes) {
             streamer.cast('Connecting the dots...');
@@ -313,8 +316,18 @@ export const main = async (unresolvedConfiguration) => {
                             continue;
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;
+                        const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
                         if (importsForExport) {
                             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(/^\@/, ''))) {
+                                        collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                    }
+                                }
+                            }
+                            if (isIgnored)
+                                continue;
                             if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
                                     createAndPrintTrace(filePath, { identifier, isEntry, hasRef: isReferenced });
@@ -333,10 +346,13 @@ export const main = async (unresolvedConfiguration) => {
                                             continue;
                                         if (shouldIgnore(member.jsDocTags))
                                             continue;
-                                        if (member.refs === 0) {
+                                        if (member.refs[0] === 0) {
                                             const id = `${identifier}.${member.identifier}`;
-                                            const { isReferenced } = isIdentifierReferenced(filePath, id);
+                                            const { isReferenced } = isIdentifierReferenced(filePath, id, true);
+                                            const isIgnored = shouldIgnoreTags(member.jsDocTags);
                                             if (!isReferenced) {
+                                                if (isIgnored)
+                                                    continue;
                                                 collector.addIssue({
                                                     type: 'enumMembers',
                                                     filePath,
@@ -348,12 +364,28 @@ export const main = async (unresolvedConfiguration) => {
                                                     col: member.col,
                                                 });
                                             }
+                                            else if (isIgnored) {
+                                                for (const tagName of exportedItem.jsDocTags) {
+                                                    if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                                        collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
+                                                    }
+                                                }
+                                            }
                                         }
                                     }
                                 }
                                 if (principal && 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(/^\@/, ''))) {
+                                                    collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                                }
+                                            }
+                                            continue;
+                                        }
                                         collector.addIssue({
                                             type: 'classMembers',
                                             filePath,
@@ -374,6 +406,8 @@ export const main = async (unresolvedConfiguration) => {
                         if (hasStrictlyNsRefs && ((!report.nsTypes && isType) || !(report.nsExports || isType)))
                             continue;
                         if (!isExportedItemReferenced(exportedItem)) {
+                            if (isIgnored)
+                                continue;
                             if (!isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
                                 continue;
                             const type = getType(hasStrictlyNsRefs, isType);
@@ -388,7 +422,7 @@ export const main = async (unresolvedConfiguration) => {
                                 line: exportedItem.line,
                                 col: exportedItem.col,
                             });
-                            if (isIssueAdded) {
+                            if (isFix && isIssueAdded) {
                                 if (isType)
                                     fixer.addUnusedTypeNode(filePath, exportedItem.fixes);
                                 else
@@ -523,7 +557,7 @@ export const main = async (unresolvedConfiguration) => {
         });
     }
     await findUnusedExports();
-    const { issues, counters, configurationHints } = collector.getIssues();
+    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
     if (isFix) {
         await fixer.fixIssues(issues);
     }
@@ -531,5 +565,5 @@ export const main = async (unresolvedConfiguration) => {
         watchReporter({ report, issues, streamer, size: analyzedFiles.size, isDebug });
     else
         streamer.clear();
-    return { report, issues, counters, rules, configurationHints };
+    return { report, issues, counters, rules, tagHints, configurationHints };
 };

package/dist/manifest/helpers.d.ts

@@ -9,5 +9,5 @@ type GetFilteredScriptsOptions = {
     isProduction: boolean;
     scripts?: Scripts;
 };
-export declare const getFilteredScripts: ({ isProduction, scripts }: GetFilteredScriptsOptions) => Scripts;
+export declare const getFilteredScripts: ({ isProduction, scripts }: GetFilteredScriptsOptions) => any;
 export {};

package/dist/manifest/index.d.ts

@@ -1,12 +1,14 @@
-import type { HostDependencies, InstalledBinaries } from '../types/workspace.js';
 type Options = {
     packageNames: string[];
     dir: string;
     cwd: string;
 };
 export declare const getDependencyMetaData: ({ cwd, dir, packageNames }: Options) => {
-    hostDependencies: HostDependencies;
-    installedBinaries: InstalledBinaries;
-    hasTypesIncluded: Set<string>;
+    hostDependencies: Map<string, {
+        name: string;
+        isPeerOptional: boolean;
+    }[]>;
+    installedBinaries: Map<string, Set<string>>;
+    hasTypesIncluded: any;
 };
 export {};

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

@@ -1,4 +1,4 @@
-export declare const resolveName: (identifier: string, namespace: "preset" | "plugin") => string;
+export declare const resolveName: (identifier: string, namespace: "preset" | "plugin") => any;
 export declare const api: {
     assertVersion: () => boolean;
     cache: {

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

@@ -3,7 +3,7 @@ import type { BabelConfig, BabelConfigObj } from './types.js';
 export declare const getDependenciesFromConfig: (config: BabelConfigObj) => string[];
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     resolveConfig: ResolveConfig<BabelConfig>;

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

@@ -2,7 +2,7 @@ import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { CapacitorConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     resolveConfig: ResolveConfig<CapacitorConfig>;

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

@@ -4,7 +4,7 @@ declare const _default: {
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    entry: string[];
+    entry: any[];
     resolveEntryPaths: ResolveEntryPaths;
 };
 export default _default;

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

@@ -109,22 +109,22 @@ export declare class DummyEleventyConfig {
     DateTime: {};
     dynamicPermalinks: boolean;
     useGitIgnore: boolean;
-    ignores: Set<unknown>;
-    watchIgnores: Set<unknown>;
+    ignores: any;
+    watchIgnores: any;
     dataDeepMerge: boolean;
-    extensionMap: Set<unknown>;
+    extensionMap: any;
     watchJavaScriptDependencies: boolean;
     additionalWatchTargets: never[];
     serverOptions: {};
     globalData: {};
     chokidarConfig: {};
     watchThrottleWaitTime: number;
-    dataExtensions: Map<any, any>;
+    dataExtensions: any;
     quietMode: boolean;
     plugins: never[];
     _pluginExecution: boolean;
     useTemplateCache: boolean;
-    dataFilterSelectors: Set<unknown>;
+    dataFilterSelectors: any;
     libraryAmendments: {};
     serverPassthroughCopyBehavior: string;
     urlTransforms: never[];

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

@@ -1,14 +1,11 @@
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
-import { DummyEleventyConfig } from './helpers.js';
-import type { EleventyConfig } from './types.js';
-type T = Partial<EleventyConfig> | ((arg: DummyEleventyConfig) => Promise<Partial<EleventyConfig>>);
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
     production: string[];
-    resolveEntryPaths: ResolveEntryPaths<T>;
-    resolveConfig: ResolveConfig<T>;
+    resolveEntryPaths: ResolveEntryPaths<any>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

package/dist/plugins/graphql-codegen/index.d.ts

@@ -2,7 +2,7 @@ import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { GraphqlCodegenTypes, GraphqlConfigTypes, GraphqlProjectsConfigTypes } from './types.js';
 declare const _default: {
     title: string;
-    enablers: (string | RegExp)[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: (manifest: import("../../types/package-json.js").PackageJson) => string;
     config: string[];

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

@@ -3,7 +3,7 @@ declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    config: string[];
+    config: any[];
     resolveConfig: ResolveConfig<string>;
 };
 export default _default;

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

@@ -1,12 +1,11 @@
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
-import type { JestConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];
-    resolveEntryPaths: ResolveEntryPaths<JestConfig>;
-    resolveConfig: ResolveConfig<JestConfig>;
+    resolveEntryPaths: ResolveEntryPaths<any>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

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

@@ -3,7 +3,7 @@ declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    config: string[];
+    config: any[];
     resolveConfig: ResolveConfig;
 };
 export default _default;

package/dist/plugins/lint-staged/index.d.ts

@@ -1,11 +1,10 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { LintStagedConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<LintStagedConfig>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

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

@@ -1 +1 @@
-export declare const getArgumentValues: (value: string, matcher: RegExp) => string[];
+export declare const getArgumentValues: (value: string, matcher: RegExp) => any;

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

@@ -1,2 +1,2 @@
 import type { FunctionsConfig } from './types.js';
-export declare const extractFunctionsConfigProperty: (config: FunctionsConfig, property: keyof FunctionsConfig) => string[];
+export declare const extractFunctionsConfigProperty: (config: FunctionsConfig, property: keyof FunctionsConfig) => any[];

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

@@ -2,7 +2,7 @@ import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types
 import type { NetlifyConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: (string | RegExp)[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     production: string[];

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

@@ -4,6 +4,6 @@ declare const _default: {
     enablers: string[];
     isEnabled: IsPluginEnabled;
     entry: string[];
-    production: string[];
+    production: any[];
 };
 export default _default;

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

@@ -2,7 +2,7 @@ import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { NxConfigRoot, NxProjectConfiguration } from './types.js';
 declare const _default: {
     title: string;
-    enablers: (string | RegExp)[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     resolveConfig: ResolveConfig<NxProjectConfiguration | NxConfigRoot>;

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

@@ -1,7 +1,7 @@
 import type { IsPluginEnabled } from '#p/types/plugins.js';
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];

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

@@ -1,7 +1,7 @@
 import type { IsPluginEnabled } from '#p/types/plugins.js';
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     entry: string[];
     production: string[];

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

@@ -1,7 +1,7 @@
 import type { IsPluginEnabled } from '#p/types/plugins.js';
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     entry: string[];
 };

package/dist/plugins/simple-git-hooks/index.d.ts

@@ -1,11 +1,10 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { PluginConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: import("#p/types/config.js").IgnorePatterns;
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<PluginConfig>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

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

@@ -2,10 +2,10 @@ import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types
 import type { StorybookConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: (string | RegExp)[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    entry: string[];
+    entry: any[];
     project: string[];
     resolveEntryPaths: ResolveEntryPaths<StorybookConfig>;
     resolveConfig: ResolveConfig<StorybookConfig>;

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

@@ -3,7 +3,7 @@ declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    entry: string[];
+    entry: any[];
     production: string[];
     project: string[];
 };

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

@@ -1,10 +1,9 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { UnbuildConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    resolveConfig: ResolveConfig<UnbuildConfig>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

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

@@ -1,3 +1,3 @@
 import type { ViteConfig } from './types.js';
-export declare const getEnvPackageName: (env: string) => string;
-export declare const getExternalReporters: (reporters?: ViteConfig["test"]["reporters"]) => string[];
+export declare const getEnvPackageName: (env: string) => any;
+export declare const getExternalReporters: (reporters?: ViteConfig["test"]["reporters"]) => any;

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

@@ -3,10 +3,7 @@ import type { WebpackConfig } from './types.js';
 export declare const findWebpackDependenciesFromConfig: ({ config, cwd }: {
     config: WebpackConfig;
     cwd: string;
-}) => Promise<{
-    dependencies: Set<string>;
-    entryPatterns: Set<string>;
-}>;
+}) => unknown;
 declare const _default: {
     title: string;
     enablers: string[];

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

@@ -1,11 +1,12 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { WireitConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<WireitConfig>;
+    resolveConfig: ResolveConfig<Record<string, {
+        command?: string;
+    }>>;
 };
 export default _default;

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

@@ -1,11 +1,10 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { LintStagedConfig } from '../lint-staged/types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<LintStagedConfig>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

package/dist/reporters/index.d.ts

@@ -1,8 +1,8 @@
 declare const _default: {
-    symbols: ({ report, issues, configurationHints, noConfigHints, isShowProgress }: import("../index.js").ReporterOptions) => void;
+    symbols: ({ report, issues, tagHints, configurationHints, noConfigHints, 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;
-    json: ({ report, issues, options }: import("../index.js").ReporterOptions) => Promise<void>;
+    json: ({ report, issues, options }: import("../index.js").ReporterOptions) => any;
     markdown: ({ report, issues }: import("../index.js").ReporterOptions) => void;
 };
 export default _default;

package/dist/reporters/json.d.ts

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

package/dist/reporters/symbols.d.ts

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

package/dist/reporters/symbols.js

@@ -20,7 +20,7 @@ const logIssueRecord = (issues) => {
     }
     console.log(table.sort(['filePath', 'parentSymbol', 'symbol']).print().trim());
 };
-export default ({ report, issues, configurationHints, noConfigHints, isShowProgress }) => {
+export default ({ report, issues, tagHints, configurationHints, noConfigHints, isShowProgress }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
@@ -52,13 +52,23 @@ export default ({ report, issues, configurationHints, noConfigHints, isShowProgr
             }
         }
     }
-    if (!noConfigHints && configurationHints.size > 0) {
-        logTitle('Configuration issues', 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(picocolors.gray(`${message}${workspace}:`), identifier);
+    if (!noConfigHints) {
+        if (configurationHints.size > 0) {
+            logTitle('Configuration issues', 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(picocolors.gray(`${message}${workspace}:`), identifier);
+            }
+        }
+        if (tagHints.size > 0) {
+            logTitle('Tag issues', tagHints.size);
+            for (const hint of tagHints) {
+                const { filePath, identifier, tagName } = hint;
+                const message = `Unused tag in ${toRelative(filePath)}:`;
+                console.warn(picocolors.gray(message), `${identifier} → ${tagName}`);
+            }
         }
     }
     if (totalIssues === 0 && isShowProgress) {

package/dist/reporters/util.d.ts

@@ -1,7 +1,7 @@
 import { ISSUE_TYPE_TITLE } from '../constants.js';
 import type { Issue, IssueSeverity, IssueSymbol } 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 getTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => Record<keyof import("../types/issues.js").Issues, string>;
 export declare const logTitle: (title: string, count: number) => void;
 type LogIssueLine = {
     owner?: string;

package/dist/types/dependency-graph.d.ts

@@ -33,7 +33,7 @@ export interface Export {
     type: SymbolType;
     members: ExportMember[];
     jsDocTags: Tags;
-    refs: number;
+    refs: [number, boolean];
     fixes: Fixes;
     symbol?: ts.Symbol;
     isReExport: boolean;
@@ -44,7 +44,7 @@ export type ExportMember = {
     line: number;
     col: number;
     type: SymbolType;
-    refs: number;
+    refs: [number, boolean];
     fix: Fix;
     symbol?: ts.Symbol;
     jsDocTags: Tags;

package/dist/types/issues.d.ts

@@ -56,6 +56,7 @@ export type ReporterOptions = {
     report: Report;
     issues: Issues;
     counters: Counters;
+    tagHints: TagHints;
     configurationHints: ConfigurationHints;
     noConfigHints: boolean;
     cwd: string;
@@ -74,3 +75,11 @@ export type ConfigurationHint = {
     identifier: string | RegExp;
     workspaceName?: string;
 };
+type TagHints = Set<TagHint>;
+export type TagHint = {
+    type: 'tag';
+    filePath: string;
+    identifier: string;
+    tagName: string;
+};
+export {};