knip 5.55.0 → 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/ConsoleStreamer.d.ts

@@ -7,6 +7,6 @@ export declare class ConsoleStreamer {
     private clearLines;
     private resetLines;
     private update;
-    cast(message: string | string[]): void;
+    cast(message: string | string[], sub?: string): void;
     clear(): void;
 }

package/dist/ConsoleStreamer.js

@@ -21,13 +21,13 @@ export class ConsoleStreamer {
         process.stdout.write(`${messages.join('\n')}\n`);
         this.lines = messages.length;
     }
-    cast(message) {
+    cast(message, sub) {
         if (!this.isEnabled)
             return;
         if (Array.isArray(message))
             this.update(message);
         else
-            this.update([message]);
+            this.update([`${message}${!sub || sub === '.' ? '' : ` (${sub})`}…`]);
     }
     clear() {
         if (!this.isEnabled)

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/constants.js

@@ -50,6 +50,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'exec',
     'exit',
     'expand',
+    'export',
     'expr',
     'factor',
     'false',

package/dist/graph/analyze.js

@@ -23,7 +23,7 @@ export const analyze = async (options) => {
                 : ignoreExportsUsedInFile));
     const analyzeGraph = async () => {
         if (isReportValues || isReportTypes) {
-            streamer.cast('Connecting the dots...');
+            streamer.cast('Connecting the dots');
             for (const [filePath, file] of graph.entries()) {
                 const exportItems = file.exports;
                 if (!exportItems || exportItems.size === 0)

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';
@@ -29,7 +29,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
     }
     for (const workspace of workspaces) {
         const { name, dir, ancestors, pkgName } = workspace;
-        streamer.cast(`Analyzing workspace (${name})...`);
+        streamer.cast('Analyzing workspace', name);
         const manifest = chief.getManifestForWorkspace(name);
         if (!manifest) {
             continue;
@@ -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);
@@ -276,10 +285,10 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             continue;
         principal.init();
         if (principal.asyncCompilers.size > 0) {
-            streamer.cast('Running async compilers...');
+            streamer.cast('Running async compilers');
             await principal.runAsyncCompilers();
         }
-        streamer.cast(`Analyzing source files (${toRelative(principal.cwd) || '.'})...`);
+        streamer.cast('Analyzing source files', toRelative(principal.cwd));
         let size = principal.entryPaths.size;
         let round = 0;
         do {
@@ -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/index.js

@@ -18,7 +18,7 @@ export const main = async (unresolvedConfiguration) => {
     const deputy = new DependencyDeputy({ isProduction, isStrict });
     const factory = new PrincipalFactory();
     const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
-    streamer.cast('Reading workspace configuration(s)...');
+    streamer.cast('Reading workspace configuration');
     await chief.init();
     const workspaces = chief.getWorkspaces();
     const report = chief.getIncludedIssueTypes({

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/plugins/webpack/index.js

@@ -57,8 +57,8 @@ const resolveUseItem = (use) => {
     return [];
 };
 export const findWebpackDependenciesFromConfig = async (config, options) => {
-    const { cwd } = options;
-    const passes = typeof config === 'function' ? [false, true] : [false];
+    const { cwd, isProduction } = options;
+    const passes = typeof config === 'function' ? [false, true] : [isProduction];
     const inputs = new Set();
     for (const isProduction of passes) {
         const mode = isProduction ? 'production' : 'development';
@@ -98,16 +98,16 @@ export const findWebpackDependenciesFromConfig = async (config, options) => {
                 }
             }
             for (const entry of entries) {
-                if (!isInternal(entry)) {
-                    inputs.add(toDependency(entry));
-                }
-                else {
+                if (isInternal(entry)) {
                     const dir = opts.context ? opts.context : cwd;
-                    const input = opts.mode === 'development'
-                        ? toDeferResolveEntry(entry, { dir })
-                        : toDeferResolveProductionEntry(entry, { dir });
+                    const input = isProduction
+                        ? toDeferResolveProductionEntry(entry, { dir })
+                        : toDeferResolveEntry(entry, { dir });
                     inputs.add(input);
                 }
+                else {
+                    inputs.add(toDeferResolve(entry));
+                }
             }
             if (opts.resolve?.alias) {
                 const addStar = (value) => (value.endsWith('*') ? value : join(value, '*').replace(/\/\*\*$/, '/*'));

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),