knip 5.55.1 → 5.57.0

package/dist/plugins/docusaurus/index.js

@@ -0,0 +1,36 @@
+import { toAlias, toDependency, toEntry, toIgnore, toProductionEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
+import { CORE_CLIENT_API, resolveConfigItems } from './helpers.js';
+const title = 'Docusaurus';
+const enablers = ['@docusaurus/core'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['docusaurus.config.{js,mjs,ts}'];
+const production = ['src/pages/**/*.{js,ts,jsx,tsx}', '{blog,docs}/**/*.mdx', 'versioned_docs/**/*.{mdx,jsx,tsx}'];
+const entry = ['babel.config.{js,cjs,mjs,cts}'];
+const resolveConfig = async (config, options) => {
+    const themes = await resolveConfigItems(config.themes ?? [], 'theme', options);
+    const plugins = await resolveConfigItems(config.plugins ?? [], 'plugin', options);
+    const presets = await resolveConfigItems(config.presets ?? [], 'preset', options);
+    const hasClassicTheme = options.manifest.dependencies?.['@docusaurus/theme-classic'] ||
+        options.manifest.dependencies?.['@docusaurus/preset-classic'];
+    return [
+        toAlias('@site/*', './*'),
+        toDependency('@docusaurus/module-type-aliases', { optional: true }),
+        ...(hasClassicTheme ? [toIgnore('(@theme|@theme-init|@theme-original)/*', 'dependencies')] : []),
+        toIgnore(`@docusaurus/(${CORE_CLIENT_API.join('|')})`, 'dependencies'),
+        ...production.map(id => toProductionEntry(id)),
+        ...entry.map(id => toEntry(id)),
+        ...themes,
+        ...plugins,
+        ...presets,
+    ];
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    entry,
+    production,
+    resolveConfig,
+};

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

@@ -0,0 +1,40 @@
+import type { WebpackConfig } from '../webpack/types.js';
+export type ModuleType = 'plugin' | 'theme' | 'preset';
+type DocsConfig = {
+    sidebarPath?: string;
+    [key: string]: unknown;
+};
+export type PluginOptions = {
+    sidebarPath?: string;
+    [key: string]: unknown;
+};
+export type PresetOptions = {
+    docs?: DocsConfig;
+    [key: string]: unknown;
+};
+type Loader = unknown;
+type PluginConfig = string | [string, PluginOptions] | false | null | {
+    name?: string;
+    configureWebpack?: (config?: PluginConfig, isServer?: boolean, utils?: {
+        getStyleLoaders(isServer: boolean, cssOptions: {
+            [key: string]: any;
+        }): Loader[];
+        getJSLoader(isServer: boolean, cacheOptions?: {}): Loader | null;
+    }, content?: unknown) => WebpackConfig;
+    configurePostCss?: (postcssOptions: {
+        plugins: unknown[];
+    }) => {
+        plugins: unknown[];
+    };
+};
+type PresetConfig = string | [string, PresetOptions] | false | null;
+type Config = PresetConfig | PluginConfig;
+export type ConfigItem = Config | (() => Config);
+export type DocusaurusConfig = {
+    title: string;
+    url: string;
+    themes?: PluginConfig[];
+    plugins?: PluginConfig[];
+    presets: PresetConfig[];
+};
+export {};

package/dist/plugins/docusaurus/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import type { IsPluginEnabled, Resolve } from '../../types/config.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    entry: string[];
+    resolve: Resolve;
+};
+export default _default;

package/dist/plugins/hardhat/index.js

@@ -0,0 +1,16 @@
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Hardhat';
+const enablers = ['hardhat'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const entry = ['hardhat.config.{js,cjs,mjs,ts}'];
+const resolve = async () => {
+    return [toDependency('hardhat')];
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    entry,
+    resolve,
+};

package/dist/plugins/index.d.ts

@@ -54,6 +54,20 @@ export declare const Plugins: {
         config: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("./capacitor/types.js").CapacitorConfig>;
     };
+    changelogen: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        isRootOnly: true;
+        entry: string[];
+    };
+    changelogithub: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        isRootOnly: true;
+        entry: string[];
+    };
     changesets: {
         title: string;
         enablers: string[];
@@ -78,6 +92,12 @@ export declare const Plugins: {
         config: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("./commitlint/types.js").CommitLintConfig>;
     };
+    convex: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        entry: string[];
+    };
     'create-typescript-app': {
         enablers: string[];
         entry: string[];
@@ -117,6 +137,15 @@ export declare const Plugins: {
             config: boolean;
         };
     };
+    docusaurus: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
+        entry: string[];
+        production: string[];
+        resolveConfig: import("../types/config.js").ResolveConfig<import("./docusaurus/types.js").DocusaurusConfig>;
+    };
     dotenv: {
         title: string;
         args: {
@@ -197,6 +226,13 @@ export declare const Plugins: {
         config: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("./graphql-codegen/types.js").GraphqlCodegenTypes | import("./graphql-codegen/types.js").GraphqlConfigTypes | import("./graphql-codegen/types.js").GraphqlProjectsConfigTypes>;
     };
+    hardhat: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        entry: string[];
+        resolve: import("../types/config.js").Resolve;
+    };
     husky: {
         title: string;
         enablers: string[];
@@ -687,6 +723,10 @@ export declare const Plugins: {
     };
     tsx: {
         title: string;
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        packageJsonPath: (id: import("../types/package-json.js").PackageJson) => import("../types/package-json.js").PackageJson;
+        config: string[];
+        resolveConfig: import("../types/config.js").ResolveConfig<import("../types/package-json.js").PackageJson>;
         args: {
             positional: boolean;
             nodeImportArgs: boolean;

package/dist/plugins/index.js

@@ -5,14 +5,18 @@ import { default as babel } from './babel/index.js';
 import { default as bun } from './bun/index.js';
 import { default as c8 } from './c8/index.js';
 import { default as capacitor } from './capacitor/index.js';
+import { default as changelogen } from './changelogen/index.js';
+import { default as changelogithub } from './changelogithub/index.js';
 import { default as changesets } from './changesets/index.js';
 import { default as commitizen } from './commitizen/index.js';
 import { default as commitlint } from './commitlint/index.js';
+import { default as convex } from './convex/index.js';
 import { default as createTypescriptApp } from './create-typescript-app/index.js';
 import { default as cspell } from './cspell/index.js';
 import { default as cucumber } from './cucumber/index.js';
 import { default as cypress } from './cypress/index.js';
 import { default as dependencyCruiser } from './dependency-cruiser/index.js';
+import { default as docusaurus } from './docusaurus/index.js';
 import { default as dotenv } from './dotenv/index.js';
 import { default as drizzle } from './drizzle/index.js';
 import { default as eleventy } from './eleventy/index.js';
@@ -23,6 +27,7 @@ import { default as githubAction } from './github-action/index.js';
 import { default as githubActions } from './github-actions/index.js';
 import { default as glob } from './glob/index.js';
 import { default as graphqlCodegen } from './graphql-codegen/index.js';
+import { default as hardhat } from './hardhat/index.js';
 import { default as husky } from './husky/index.js';
 import { default as i18nextParser } from './i18next-parser/index.js';
 import { default as jest } from './jest/index.js';
@@ -108,14 +113,18 @@ export const Plugins = {
     bun,
     c8,
     capacitor,
+    changelogen,
+    changelogithub,
     changesets,
     commitizen,
     commitlint,
+    convex,
     'create-typescript-app': createTypescriptApp,
     cspell,
     cucumber,
     cypress,
     'dependency-cruiser': dependencyCruiser,
+    docusaurus,
     dotenv,
     drizzle,
     eleventy,
@@ -126,6 +135,7 @@ export const Plugins = {
     'github-actions': githubActions,
     glob,
     'graphql-codegen': graphqlCodegen,
+    hardhat,
     husky,
     'i18next-parser': i18nextParser,
     jest,

package/dist/plugins/mocha/index.js

@@ -1,4 +1,4 @@
-import { toEntry } from '../../util/input.js';
+import { toDeferResolve, toEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Mocha';
 const enablers = ['mocha'];
@@ -8,7 +8,10 @@ const entry = ['**/test/*.{js,cjs,mjs}'];
 const resolveConfig = localConfig => {
     const entryPatterns = localConfig.spec ? [localConfig.spec].flat() : entry;
     const require = localConfig.require ? [localConfig.require].flat() : [];
-    return [...entryPatterns, ...require].map(id => toEntry(id));
+    const inputs = [];
+    inputs.push(...entryPatterns.map(id => toEntry(id)));
+    inputs.push(...require.map(id => toDeferResolve(id)));
+    return inputs;
 };
 const args = {
     nodeImportArgs: true,

package/dist/plugins/nx/index.js

@@ -42,7 +42,7 @@ const resolveConfig = async (localConfig, options) => {
         if (target.options?.command)
             return [target.options.command];
         if (target.options?.commands)
-            return target.options.commands;
+            return target.options.commands.map(commandConfig => typeof commandConfig === 'string' ? commandConfig : commandConfig.command);
         return [];
     });
     const inputs = options.getInputsFromScripts(scripts);

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

@@ -5,7 +5,9 @@ export interface NxProjectConfiguration {
             executor?: string;
             options?: {
                 command?: string;
-                commands?: string[];
+                commands?: Array<string | {
+                    command: string;
+                }>;
             };
         };
     };

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

@@ -1,5 +1,11 @@
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+import type { PackageJson } from '../../types/package-json.js';
 declare const _default: {
     title: string;
+    isEnabled: IsPluginEnabled;
+    packageJsonPath: (id: PackageJson) => PackageJson;
+    config: string[];
+    resolveConfig: ResolveConfig<PackageJson>;
     args: {
         positional: boolean;
         nodeImportArgs: boolean;

package/dist/plugins/tsx/index.js

@@ -1,4 +1,24 @@
+import { toEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'tsx';
+const enablers = ['tsx'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['package.json'];
+const packageJsonPath = (id) => id;
+const resolveConfig = localConfig => {
+    const scripts = localConfig.scripts;
+    const entries = [];
+    if (scripts && Object.keys(scripts).some(script => /(?<=^|\s)tsx\s(.*)--test/.test(scripts[script]))) {
+        const patterns = [
+            '**/*{.,-,_}test.?(c|m)(j|t)s',
+            '**/test-*.?(c|m)(j|t)s',
+            '**/test.?(c|m)(j|t)s',
+            '**/test/**/*.?(c|m)(j|t)s',
+        ];
+        entries.push(...patterns.map(id => toEntry(id)));
+    }
+    return entries;
+};
 const args = {
     positional: true,
     nodeImportArgs: true,
@@ -6,5 +26,9 @@ const args = {
 };
 export default {
     title,
+    isEnabled,
+    packageJsonPath,
+    config,
+    resolveConfig,
     args,
 };

package/dist/reporters/codeclimate.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { ISSUE_TYPE_TITLE } from '../constants.js';
 import { toRelative } from '../util/path.js';
-import { getTitle } from './util.js';
+import { getIssueTypeTitle } from './util.js';
 export default async ({ report, issues }) => {
     const entries = [];
     for (const [type, isReportType] of Object.entries(report)) {
@@ -14,7 +14,7 @@ export default async ({ report, issues }) => {
             if (fixedType === 'duplicates' && issue.symbols) {
                 entries.push(...issue.symbols.map(symbol => ({
                     type: 'issue',
-                    check_name: getTitle(fixedType),
+                    check_name: getIssueTypeTitle(fixedType),
                     description: getSymbolDescription({ type: issue.type, symbol, parentSymbol: issue.parentSymbol }),
                     categories: ['Duplication'],
                     location: createLocation(filePath, symbol.line, symbol.col),
@@ -25,7 +25,7 @@ export default async ({ report, issues }) => {
             else {
                 entries.push({
                     type: 'issue',
-                    check_name: getTitle(fixedType),
+                    check_name: getIssueTypeTitle(fixedType),
                     description: getIssueDescription(issue),
                     categories: ['Bug Risk'],
                     location: createLocation(filePath, issue.line, issue.col),

package/dist/reporters/codeowners.js

@@ -1,16 +1,10 @@
-import picocolors from 'picocolors';
 import { createOwnershipEngine } from '../util/codeowners.js';
-import { relative, resolve, toRelative } from '../util/path.js';
-import { getTitle, logIssueLine, logTitle } from './util.js';
-const logIssueSet = (issues) => {
-    for (const issue of issues.sort((a, b) => (a.owner < b.owner ? -1 : 1))) {
-        console.log(picocolors.cyan(issue.owner), toRelative(issue.symbol));
-    }
-};
+import { relative, resolve } from '../util/path.js';
+import { getColoredTitle, getIssueLine, getIssueTypeTitle } from './util.js';
 const logIssueRecord = (issues) => {
     const sortedByFilePath = issues.sort((a, b) => (a.owner < b.owner ? -1 : 1));
     for (const { filePath, symbols, owner, parentSymbol } of sortedByFilePath) {
-        logIssueLine({ owner, filePath, symbols, parentSymbol });
+        console.log(getIssueLine({ owner, filePath, symbols, parentSymbol }));
     }
 };
 export default ({ report, issues, isShowProgress, options }) => {
@@ -31,31 +25,22 @@ export default ({ report, issues, isShowProgress, options }) => {
         ...issue,
         owner: calcFileOwnership(issue.filePath),
     });
-    for (const [reportType, isReportType] of Object.entries(report)) {
+    for (let [reportType, isReportType] of Object.entries(report)) {
+        if (reportType === 'files')
+            reportType = '_files';
         if (isReportType) {
-            const title = reportMultipleGroups && getTitle(reportType);
-            const isSet = issues[reportType] instanceof Set;
-            const toIssue = (filePath) => ({ type: reportType, filePath, symbol: filePath });
-            const issuesForType = issues[reportType] instanceof Set
-                ? Array.from(issues[reportType])
-                    .map(toIssue)
-                    .map(addOwner)
-                : reportType === 'duplicates'
-                    ? Object.values(issues[reportType]).flatMap(Object.values).map(addOwner)
-                    : Object.values(issues[reportType]).map(issues => {
-                        const symbols = Object.values(issues);
-                        return addOwner({ ...symbols[0], symbols });
-                    });
+            const title = reportMultipleGroups && getIssueTypeTitle(reportType);
+            const issuesForType = Object.values(issues[reportType]).flatMap(issues => {
+                if (reportType === 'duplicates')
+                    return Object.values(issues).map(addOwner);
+                const symbols = Object.values(issues);
+                return addOwner({ ...symbols[0], symbols });
+            });
             if (issuesForType.length > 0) {
                 if (totalIssues)
                     console.log();
-                title && logTitle(title, issuesForType.length);
-                if (isSet) {
-                    logIssueSet(issuesForType);
-                }
-                else {
-                    logIssueRecord(issuesForType);
-                }
+                title && console.log(getColoredTitle(title, issuesForType.length));
+                logIssueRecord(issuesForType);
             }
             totalIssues = totalIssues + issuesForType.length;
         }

package/dist/reporters/compact.js

@@ -1,14 +1,20 @@
-import { getTitle, logIssueLine, logIssueSet, logTitle } from './util.js';
+import { toRelative } from '../util/path.js';
+import { getColoredTitle, getIssueLine, getIssueTypeTitle } from './util.js';
+const logIssueSet = (issues) => {
+    for (const filePath of issues.sort())
+        console.log(toRelative(filePath));
+};
 const logIssueRecord = (issues) => {
     const sortedByFilePath = issues.sort((a, b) => (a.filePath > b.filePath ? 1 : -1));
-    sortedByFilePath.forEach(logIssueLine);
+    for (const issue of sortedByFilePath)
+        console.log(getIssueLine(issue));
 };
 export default ({ report, issues, isShowProgress }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {
-            const title = reportMultipleGroups && getTitle(reportType);
+            const title = reportMultipleGroups && getIssueTypeTitle(reportType);
             const isSet = issues[reportType] instanceof Set;
             const issuesForType = isSet
                 ? Array.from(issues[reportType])
@@ -19,7 +25,7 @@ export default ({ report, issues, isShowProgress }) => {
                         return { ...items[0], symbols: items };
                     });
             if (issuesForType.length > 0) {
-                title && logTitle(title, issuesForType.length);
+                title && console.log(getColoredTitle(title, issuesForType.length));
                 if (isSet) {
                     logIssueSet(Array.from(issues[reportType]));
                 }

package/dist/reporters/disclosure.js

@@ -1,35 +1,16 @@
-import { relative } from '../util/path.js';
-import { Table } from '../util/table.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');
-const logIssueRecord = (issues) => {
-    const table = new Table();
-    for (const issue of issues) {
-        table.cell('symbol', issue.symbols ? issue.symbols.map(s => s.symbol).join(', ') : issue.symbol);
-        table.cell('parentSymbol', issue.parentSymbol && issue.parentSymbol);
-        table.cell('symbolType', issue.symbolType && issue.symbolType);
-        const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
-        const cell = issue.type === 'files' ? '' : `${relative(issue.filePath)}${pos}`;
-        table.cell('filePath', cell);
-        table.newRow();
-    }
-    console.log(table.sort('filePath').toString());
-};
+import { getIssueTypeTitle, getTableForType } from './util.js';
 export default ({ report, issues }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
-    let totalIssues = 0;
     for (let [reportType, isReportType] of Object.entries(report)) {
         if (reportType === 'files')
             reportType = '_files';
         if (isReportType) {
-            const title = reportMultipleGroups ? getTitle(reportType) : undefined;
+            const title = reportMultipleGroups ? getIssueTypeTitle(reportType) : undefined;
             const issuesForType = Object.values(issues[reportType]).flatMap(Object.values);
             if (issuesForType.length > 0) {
-                printHeader(issuesForType.length, title);
-                logIssueRecord(issuesForType);
-                totalIssues = totalIssues + issuesForType.length;
-                printFooter();
+                console.log(`<details>\n${title ? `<summary>${title} (${issuesForType.length})</summary>\n` : ''}\n\`\`\``);
+                console.log(getTableForType(issuesForType, { isUseColors: false }).toString());
+                console.log('```\n\n</details>\n');
             }
         }
     }

package/dist/reporters/markdown.js

@@ -1,5 +1,5 @@
 import { relative, toRelative } from '../util/path.js';
-import { getTitle } from './util.js';
+import { getIssueTypeTitle } from './util.js';
 export default ({ report, issues }) => {
     console.log('# Knip report\n');
     const getFilePath = (issue) => {
@@ -11,7 +11,7 @@ export default ({ report, issues }) => {
     const sortLongestFilePath = (a, b) => getFilePath(b).length - getFilePath(a).length;
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {
-            const title = getTitle(reportType);
+            const title = getIssueTypeTitle(reportType);
             const isSet = issues[reportType] instanceof Set;
             const issuesForType = isSet
                 ? Array.from(issues[reportType])

package/dist/reporters/symbols.d.ts

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

package/dist/reporters/symbols.js

@@ -1,41 +1,6 @@
-import picocolors from 'picocolors';
 import { ROOT_WORKSPACE_NAME } from '../constants.js';
-import { SymbolType } from '../types/issues.js';
-import { relative, toRelative } from '../util/path.js';
-import { Table } from '../util/table.js';
-import { getTitle, identity, logTitle, logTitleDimmed } from './util.js';
-const dim = picocolors.gray;
-const bright = picocolors.whiteBright;
-const sortByPos = (a, b) => {
-    const [f, r, c] = a.filePath.value.split(':');
-    const [f2, r2, c2] = b.filePath.value.split(':');
-    return f === f2 ? (Number(r) === Number(r2) ? Number(c) - Number(c2) : Number(r) - Number(r2)) : f.localeCompare(f2);
-};
-const highlightPkg = (issue) => (_) => {
-    if (issue.specifier && issue.specifier !== issue.symbol && issue.specifier.includes(issue.symbol)) {
-        const parts = issue.specifier.split(issue.symbol);
-        const left = parts[0];
-        const right = parts.slice(1).join('');
-        return [dim(left), bright(issue.symbol), dim(right)].join('');
-    }
-    return issue.symbol;
-};
-const logIssueRecord = (issues) => {
-    const table = new Table({ truncateStart: ['filePath'], noTruncate: ['symbolType'] });
-    for (const issue of issues) {
-        table.newRow();
-        const print = issue.isFixed || issue.severity === 'warn' ? dim : identity;
-        const symbols = issue.symbols;
-        table.cell('symbol', print(symbols ? symbols.map(s => s.symbol).join(', ') : issue.symbol), highlightPkg(issue));
-        table.cell('parentSymbol', issue.parentSymbol && print(issue.parentSymbol));
-        table.cell('symbolType', issue.symbolType && issue.symbolType !== SymbolType.UNKNOWN && print(issue.symbolType));
-        const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
-        const cell = issue.type === 'files' ? '' : `${relative(issue.filePath)}${pos}`;
-        table.cell('filePath', print(cell));
-        table.cell('fixed', issue.isFixed && print('(removed)'));
-    }
-    console.log(table.sort(sortByPos).toString());
-};
+import { toRelative } from '../util/path.js';
+import { dim, getColoredTitle, getDimmedTitle, getIssueTypeTitle, getTableForType, plain } from './util.js';
 export default ({ report, issues, tagHints, configurationHints, isDisableConfigHints, isTreatConfigHintsAsErrors, isShowProgress, }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
@@ -43,29 +8,29 @@ export default ({ report, issues, tagHints, configurationHints, isDisableConfigH
         if (reportType === 'files')
             reportType = '_files';
         if (isReportType) {
-            const title = reportMultipleGroups && getTitle(reportType);
+            const title = reportMultipleGroups && getIssueTypeTitle(reportType);
             const issuesForType = Object.values(issues[reportType]).flatMap(Object.values);
             if (issuesForType.length > 0) {
-                title && logTitle(title, issuesForType.length);
-                logIssueRecord(issuesForType);
+                title && console.log(getColoredTitle(title, issuesForType.length));
+                console.log(getTableForType(issuesForType).toString());
                 totalIssues = totalIssues + issuesForType.length;
             }
         }
     }
     if (!isDisableConfigHints) {
         if (configurationHints.size > 0) {
-            const _logTitle = isTreatConfigHintsAsErrors ? logTitle : logTitleDimmed;
-            const _color = isTreatConfigHintsAsErrors ? identity : dim;
-            _logTitle('Configuration hints', configurationHints.size);
+            const getTitle = isTreatConfigHintsAsErrors ? getColoredTitle : getDimmedTitle;
+            console.log(getTitle('Configuration hints', configurationHints.size));
+            const style = isTreatConfigHintsAsErrors ? plain : dim;
             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(_color(`${message}${workspace}:`), identifier);
+                console.warn(style(`${message}${workspace}:`), identifier);
             }
         }
         if (tagHints.size > 0) {
-            logTitle('Tag issues', tagHints.size);
+            console.log(getColoredTitle('Tag issues', tagHints.size));
             for (const hint of tagHints) {
                 const { filePath, identifier, tagName } = hint;
                 const message = `Unused tag in ${toRelative(filePath)}:`;

package/dist/reporters/util.d.ts

@@ -1,9 +1,11 @@
 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 logTitle: (title: string, count: number) => void;
-export declare const logTitleDimmed: (title: string) => void;
+import { type Issue, type IssueSeverity, type IssueSymbol } from '../types/issues.js';
+import { Table } from '../util/table.js';
+export declare const plain: (text: string) => string;
+export declare const dim: import("picocolors/types.js").Formatter;
+export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => string;
+export declare const getColoredTitle: (title: string, count: number) => string;
+export declare const getDimmedTitle: (title: string) => string;
 type LogIssueLine = {
     owner?: string;
     filePath: string;
@@ -11,12 +13,14 @@ type LogIssueLine = {
     parentSymbol?: string;
     severity?: IssueSeverity;
 };
-export declare const logIssueLine: ({ owner, filePath, symbols, parentSymbol, severity }: LogIssueLine) => void;
-export declare const logIssueSet: (issues: string[]) => void;
+export declare const getIssueLine: ({ owner, filePath, symbols, parentSymbol, severity }: LogIssueLine) => string;
 export declare const convert: (issue: Issue | IssueSymbol) => {
     name: string;
     line: number | undefined;
     col: number | undefined;
     pos: number | undefined;
 };
+export declare const getTableForType: (issues: Issue[], options?: {
+    isUseColors?: boolean;
+}) => Table;
 export {};