knip 5.55.1 → 5.56.0

package/README.md

@@ -41,4 +41,4 @@ Special thanks to [the wonderful people who have contributed to Knip][8]!
 [5]: https://github.com/webpro-nl/knip/blob/main/.github/CONTRIBUTING.md
 [6]: https://knip.dev/sponsors
 [7]: https://www.youtube.com/watch?v=PE7h7KvQoUI&t=9s
-[8]: https://knip.dev/#-contributors
+[8]: https://knip.dev/#created-by-awesome-contributors

package/dist/CacheConsultant.d.ts

@@ -3,6 +3,7 @@ type CacheOptions = {
     name: string;
     isEnabled: boolean;
     cacheLocation: string;
+    isProduction: boolean;
 };
 export declare class CacheConsultant<T> {
     private isEnabled;

package/dist/CacheConsultant.js

@@ -8,7 +8,7 @@ export class CacheConsultant {
     constructor(options) {
         this.isEnabled = options.isEnabled;
         if (this.isEnabled) {
-            const cacheName = `${options.name.replace(/[^a-z0-9]/g, '-').replace(/-*$/, '')}-${version}`;
+            const cacheName = `${options.name.replace(/[^a-z0-9]/g, '-').replace(/-*$/, '')}-${options.isProduction ? '-prod' : ''}-${version}`;
             this.cache = new FileEntryCache(cacheName, options.cacheLocation);
             this.reconcile = timerify(this.cache.reconcile).bind(this.cache);
             this.getFileDescriptor = timerify(this.cache.getFileDescriptor).bind(this.cache);

package/dist/ConfigurationChief.d.ts

@@ -88,6 +88,7 @@ export declare class ConfigurationChief {
         cucumber?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         cypress?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "dependency-cruiser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        docusaurus?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         dotenv?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         drizzle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         eleventy?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -74,5 +74,7 @@ export declare class DependencyDeputy {
         counters: Counters;
     }): void;
     getConfigurationHints(): ConfigurationHints;
+    addIgnoredDependencies(workspaceName: string, identifier: string): void;
+    addIgnoredBinaries(workspaceName: string, identifier: string): void;
 }
 export {};

package/dist/DependencyDeputy.js

@@ -350,4 +350,10 @@ export class DependencyDeputy {
         }
         return configurationHints;
     }
+    addIgnoredDependencies(workspaceName, identifier) {
+        this._manifests.get(workspaceName)?.ignoreDependencies.push(toRegexOrString(identifier));
+    }
+    addIgnoredBinaries(workspaceName, identifier) {
+        this._manifests.get(workspaceName)?.ignoreBinaries.push(toRegexOrString(identifier));
+    }
 }

package/dist/PrincipalFactory.d.ts

@@ -1,14 +1,8 @@
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import type { PrincipalOptions } from './types/project.js';
-type Principal = {
-    principal: ProjectPrincipal;
-    wsDirs: Set<string>;
-    pathKeys: Set<string>;
-    pkgNames: Set<string>;
-};
-type Principals = Set<Principal>;
 export declare class PrincipalFactory {
-    principals: Principals;
+    private principals;
+    getPrincipalCount(): number;
     createPrincipal(options: PrincipalOptions): ProjectPrincipal;
     private findReusablePrincipal;
     private linkPrincipal;
@@ -17,4 +11,3 @@ export declare class PrincipalFactory {
     getPrincipalByPackageName(packageName: string): ProjectPrincipal | undefined;
     deletePrincipal(principal: ProjectPrincipal): void;
 }
-export {};

package/dist/PrincipalFactory.js

@@ -4,20 +4,25 @@ import { debugLog } from './util/debug.js';
 import { toRelative } from './util/path.js';
 export class PrincipalFactory {
     principals = new Set();
+    getPrincipalCount() {
+        return this.principals.size;
+    }
     createPrincipal(options) {
         const { cwd, compilerOptions, isFile, pkgName, isIsolateWorkspaces, compilers } = options;
         if (isFile && compilerOptions.module !== ts.ModuleKind.CommonJS)
             compilerOptions.moduleResolution ??= ts.ModuleResolutionKind.Bundler;
-        const principal = this.findReusablePrincipal(compilerOptions);
-        if (!isIsolateWorkspaces && principal) {
-            this.linkPrincipal(principal, cwd, compilerOptions, pkgName, compilers);
-            return principal.principal;
+        if (!isIsolateWorkspaces) {
+            const principal = this.findReusablePrincipal(compilerOptions);
+            if (principal) {
+                this.linkPrincipal(principal, cwd, compilerOptions, pkgName, compilers);
+                return principal.principal;
+            }
         }
         return this.addNewPrincipal(options);
     }
     findReusablePrincipal(compilerOptions) {
         const workspacePaths = compilerOptions?.paths ? Object.keys(compilerOptions.paths) : [];
-        const principal = Array.from(this.principals).find(principal => {
+        return Array.from(this.principals).find(principal => {
             if (compilerOptions.pathsBasePath && principal.principal.compilerOptions.pathsBasePath)
                 return false;
             if (compilerOptions.baseUrl === principal.principal.compilerOptions.baseUrl) {
@@ -25,7 +30,6 @@ export class PrincipalFactory {
             }
             return !compilerOptions.baseUrl;
         });
-        return principal;
     }
     linkPrincipal(principal, cwd, compilerOptions, pkgName, compilers) {
         const { pathsBasePath, paths } = compilerOptions;

package/dist/ProjectPrincipal.d.ts

@@ -30,7 +30,7 @@ export declare class ProjectPrincipal {
         languageServiceHost: ts.LanguageServiceHost;
     };
     findReferences?: ts.LanguageService['findReferences'];
-    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, }: PrincipalOptions);
+    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, isProduction, }: PrincipalOptions);
     init(): void;
     addPaths(paths: Paths, basePath: string): void;
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;

package/dist/ProjectPrincipal.js

@@ -43,7 +43,7 @@ export class ProjectPrincipal {
     toSourceFilePath;
     backend;
     findReferences;
-    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, }) {
+    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, isProduction, }) {
         this.cwd = cwd;
         this.compilerOptions = {
             ...compilerOptions,
@@ -57,7 +57,7 @@ export class ProjectPrincipal {
         this.asyncCompilers = asyncCompilers;
         this.isSkipLibs = isSkipLibs;
         this.isWatch = isWatch;
-        this.cache = new CacheConsultant({ name: pkgName || ANONYMOUS, isEnabled: isCache, cacheLocation });
+        this.cache = new CacheConsultant({ name: pkgName || ANONYMOUS, isEnabled: isCache, cacheLocation, isProduction });
         this.toSourceFilePath = toSourceFilePath;
         this.backend = {
             fileManager: new SourceFileManager({ compilers, isSkipLibs }),
@@ -162,7 +162,7 @@ export class ProjectPrincipal {
             return fd.meta.data;
         const typeChecker = this.backend.typeChecker;
         if (!typeChecker)
-            throw new Error('Must initialize TypeChecker before source file analysis');
+            throw new Error('TypeChecker must be initialized before source file analysis');
         const sourceFile = this.backend.fileManager.getSourceFile(filePath);
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);

package/dist/WorkspaceWorker.js

@@ -49,7 +49,7 @@ export class WorkspaceWorker {
         this.getReferencedInternalFilePath = getReferencedInternalFilePath;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
         this.getSourceFile = getSourceFile;
-        this.cache = new CacheConsultant({ name: `plugins-${name}`, isEnabled: isCache, cacheLocation });
+        this.cache = new CacheConsultant({ name: `plugins-${name}`, isEnabled: isCache, cacheLocation, isProduction });
     }
     async init() {
         this.enabledPlugins = await this.determineEnabledPlugins();

package/dist/cli.js

@@ -10,7 +10,7 @@ import { splitTags } from './util/tag.js';
 import { isTrace } from './util/trace.js';
 import { version } from './version.js';
 const defaultCacheLocation = join(cwd, 'node_modules', '.cache', 'knip');
-const { 'allow-remove-files': isRemoveFiles = false, cache: isCache = false, 'cache-location': cacheLocation = defaultCacheLocation, debug: isDebug = false, dependencies: isDependenciesShorthand = false, exclude: excludedIssueTypes = [], 'experimental-tags': experimentalTags = [], exports: isExportsShorthand = false, files: isFilesShorthand = false, fix: isFix = false, format: isFormat = false, 'fix-type': fixTypes = [], help: isHelp, include: includedIssueTypes = [], 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, 'max-issues': maxIssues = '0', 'no-config-hints': isDisableConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace, preprocessor = [], 'preprocessor-options': preprocessorOptions = '', production: isProduction = false, reporter = ['symbols'], 'reporter-options': reporterOptions = '', strict: isStrict = false, tags = [], 'treat-config-hints-as-errors': treatConfigHintsAsErrors = false, tsConfig, version: isVersion, watch: isWatch = false, workspace: rawWorkspaceArg, } = parsedArgValues;
+const { 'allow-remove-files': isRemoveFiles = false, cache: isCache = false, 'cache-location': cacheLocation = defaultCacheLocation, debug: isDebug = false, dependencies: isDependenciesShorthand = false, exclude: excludedIssueTypes = [], 'experimental-tags': experimentalTags = [], exports: isExportsShorthand = false, files: isFilesShorthand = false, fix: isFix = false, format: isFormat = false, 'fix-type': fixTypes = [], help: isHelp, include: includedIssueTypes = [], 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, 'max-issues': maxIssues = '0', 'memory-realtime': memoryRealtime = false, 'no-config-hints': isDisableConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace || memoryRealtime, preprocessor = [], 'preprocessor-options': preprocessorOptions = '', production: isProduction = false, reporter = ['symbols'], 'reporter-options': reporterOptions = '', strict: isStrict = false, tags = [], 'treat-config-hints-as-errors': treatConfigHintsAsErrors = false, tsConfig, version: isVersion, watch: isWatch = false, workspace: rawWorkspaceArg, } = parsedArgValues;
 if (isHelp) {
     console.log(helpText);
     process.exit(0);
@@ -73,10 +73,10 @@ const run = async () => {
             .reduce((errorCount, reportGroup) => errorCount + finalData.counters[reportGroup], 0);
         if (perfObserver.isEnabled)
             await perfObserver.finalize();
-        if (perfObserver.isPerformanceEnabled)
-            console.log(`\n${perfObserver.getPerformanceTable()}`);
-        if (perfObserver.isMemoryEnabled)
-            console.log(`\n${perfObserver.getMemoryTable()}`);
+        if (perfObserver.isTimerifyFunctions)
+            console.log(`\n${perfObserver.getTimerifiedFunctionsTable()}`);
+        if (perfObserver.isMemoryUsageEnabled)
+            console.log(`\n${perfObserver.getMemoryUsageTable()}`);
         if (perfObserver.isEnabled) {
             const duration = perfObserver.getCurrentDurationInMs();
             console.log('\nTotal running time:', prettyMilliseconds(duration));
@@ -106,5 +106,6 @@ const run = async () => {
         }
         throw error;
     }
+    process.exit(0);
 };
 await run();

package/dist/compilers/index.d.ts

@@ -89,6 +89,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    docusaurus?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     dotenv?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -615,6 +620,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        docusaurus?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         dotenv?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/graph/build.js

@@ -6,7 +6,7 @@ import { perfObserver } from '../util/Performance.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { getReferencedInputsHandler } from '../util/get-referenced-inputs.js';
 import { _glob, negate } from '../util/glob.js';
-import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
+import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
 import { getOrCreateFileNode, updateImportMap } from '../util/module-graph.js';
 import { getEntryPathsFromManifest } from '../util/package-json.js';
 import { dirname, isAbsolute, join, relative, toRelative } from '../util/path.js';
@@ -89,6 +89,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             toSourceFilePath,
             isCache,
             cacheLocation,
+            isProduction,
         });
         principal.addPaths(config.paths, dir);
         const inputsFromPlugins = await worker.runPlugins();
@@ -126,6 +127,14 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             else if (isAlias(input)) {
                 principal.addPaths({ [input.specifier]: input.prefixes }, input.dir ?? dir);
             }
+            else if (isIgnore(input)) {
+                if (input.issueType === 'dependencies' || input.issueType === 'unlisted') {
+                    deputy.addIgnoredDependencies(name, input.specifier);
+                }
+                else if (input.issueType === 'binaries') {
+                    deputy.addIgnoredBinaries(name, input.specifier);
+                }
+            }
             else if (!isConfig(input)) {
                 const ws = (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) || workspace;
                 const resolvedFilePath = getReferencedInternalFilePath(input, ws);
@@ -299,7 +308,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             factory.deletePrincipal(principal);
             principals[i] = undefined;
         }
-        perfObserver.addMemoryMark(factory.principals.size);
+        perfObserver.addMemoryMark(factory.getPrincipalCount());
     }
     if (!isWatch && isSkipLibs && !isIsolateWorkspaces) {
         for (const principal of principals) {

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

@@ -0,0 +1,5 @@
+import type { PluginOptions as Options } from '../../types/config.js';
+import { type Input } from '../../util/input.js';
+import type { ConfigItem, ModuleType } from './types.js';
+export declare const CORE_CLIENT_API: string[];
+export declare const resolveConfigItems: (items: ConfigItem[], type: ModuleType, options: Options) => Promise<Set<Input>>;

package/dist/plugins/docusaurus/helpers.js

@@ -0,0 +1,89 @@
+import { toDeferResolve, toProductionEntry } from '../../util/input.js';
+import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
+const FIRST_PARTY_MODULES = new Set([
+    'content-docs',
+    'content-blog',
+    'content-pages',
+    'debug',
+    'sitemap',
+    'svgr',
+    'rsdoctor',
+    'pwa',
+    'client-redirects',
+    'ideal-image',
+    'google-analytics',
+    'google-gtag',
+    'google-tag-manager',
+    'classic',
+    'live-codeblock',
+    'search-algolia',
+    'mermaid',
+]);
+export const CORE_CLIENT_API = [
+    'BrowserOnly',
+    'ComponentCreator',
+    'constants',
+    'ExecutionEnvironment',
+    'Head',
+    'Interpolate',
+    'isInternalUrl',
+    'Link',
+    'Noop',
+    'renderRoutes',
+    'router',
+    'Translate',
+    'useBaseUrl',
+    'useBrokenLinks',
+    'useDocusaurusContext',
+    'useGlobalData',
+    'useIsBrowser',
+    'useIsomorphicLayoutEffect',
+    'useRouteContext',
+];
+const resolveModuleName = (name, type) => {
+    if (name.includes(`${type}-`))
+        return name;
+    if (!name.startsWith('@')) {
+        const prefix = FIRST_PARTY_MODULES.has(name) ? '@docusaurus/' : 'docusaurus-';
+        return `${prefix}${type}-${name}`;
+    }
+    const [scope, ...rest] = name.split('/');
+    const baseName = rest.length ? `-${rest.join('/')}` : '';
+    return `${scope}/docusaurus-${type}${baseName}`;
+};
+const resolveSidebarPath = (config) => {
+    const path = config?.sidebarPath ?? config?.docs?.sidebarPath;
+    return typeof path === 'string' ? path : undefined;
+};
+const resolveArrayConfig = ([name, config], type) => {
+    if (typeof name !== 'string')
+        return [];
+    const resolvedName = resolveModuleName(name, type);
+    const sidebarPath = type !== 'theme' ? resolveSidebarPath(config) : undefined;
+    return [toDeferResolve(resolvedName), ...(sidebarPath ? [toProductionEntry(sidebarPath)] : [])];
+};
+export const resolveConfigItems = async (items, type, options) => {
+    const inputs = new Set();
+    for (let item of items) {
+        if (typeof item === 'function')
+            item = item();
+        if (!item)
+            continue;
+        if (typeof item === 'string') {
+            inputs.add(toDeferResolve(resolveModuleName(item, type)));
+        }
+        else if (Array.isArray(item)) {
+            for (const input of resolveArrayConfig(item, type))
+                inputs.add(input);
+        }
+        else if (typeof item.configureWebpack === 'function') {
+            const utils = { getStyleLoaders: () => [], getJSLoader: () => null };
+            const config = item.configureWebpack({}, false, utils);
+            for (const input of await findWebpackDependenciesFromConfig(config, options))
+                inputs.add(input);
+        }
+        else if (typeof item.configurePostCss === 'function') {
+        }
+    }
+    return inputs;
+};

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

@@ -0,0 +1,12 @@
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+import type { DocusaurusConfig } from './types.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    entry: string[];
+    production: string[];
+    resolveConfig: ResolveConfig<DocusaurusConfig>;
+};
+export default _default;

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/index.d.ts

@@ -117,6 +117,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: {

package/dist/plugins/index.js

@@ -13,6 +13,7 @@ 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';
@@ -116,6 +117,7 @@ export const Plugins = {
     cucumber,
     cypress,
     'dependency-cruiser': dependencyCruiser,
+    docusaurus,
     dotenv,
     drizzle,
     eleventy,

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]));
                 }