knip 5.26.0 → 5.27.1

package/dist/util/get-included-issue-types.js

@@ -4,21 +4,21 @@ export const defaultExcludedIssueTypes = ['classMembers', 'nsExports', 'nsTypes'
 const defaultIssueTypes = ISSUE_TYPES.filter(type => !defaultExcludedIssueTypes.includes(type));
 const normalize = (values) => values.flatMap(value => value.split(','));
 export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {
-    let incl = normalize(cliArgs.include);
-    const excl = normalize(cliArgs.exclude);
+    let incl = normalize(cliArgs.includedIssueTypes);
+    const excl = normalize(cliArgs.excludedIssueTypes);
     for (const type of [...incl, ...excl, ...include, ...exclude]) {
         if (!ISSUE_TYPES.includes(type))
             throw new ConfigurationError(`Invalid issue type: ${type}`);
     }
     const excludes = exclude.filter(exclude => !incl.includes(exclude));
     const includes = include.filter(include => !excl.includes(include));
-    if (cliArgs.dependencies) {
+    if (cliArgs.isDependenciesShorthand) {
         incl = [...incl, 'dependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved'];
     }
-    if (cliArgs.exports) {
+    if (cliArgs.isExportsShorthand) {
         incl = [...incl, 'exports', 'types', 'enumMembers', 'duplicates'];
     }
-    if (cliArgs.files) {
+    if (cliArgs.isFilesShorthand) {
         incl = [...incl, 'files'];
     }
     const _include = [...incl, ...includes];

package/dist/util/globby.js

@@ -7,7 +7,7 @@ import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
 import { timerify } from './Performance.js';
 import { debugLogObject } from './debug.js';
 import { isFile } from './fs.js';
-import { dirname, join, relative, toPosix } from './path.js';
+import { dirname, join, relative, toPosix, toRelative } from './path.js';
 const walk = promisify(_walk);
 const _picomatch = timerify(picomatch);
 const cachedIgnores = new Map();
@@ -53,7 +53,7 @@ async function parseFindGitignores(options) {
         return false;
     };
     const addFile = (filePath) => {
-        gitignoreFiles.push(filePath);
+        gitignoreFiles.push(toRelative(filePath));
         const dir = dirname(toPosix(filePath));
         const base = relative(options.cwd, dir);
         const dirIgnores = base === '' ? ['.git', ...GLOBAL_IGNORE_PATTERNS] : [];

package/dist/util/handle-dependency.d.ts

@@ -1,4 +1,4 @@
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 import type { DependencyDeputy } from '../DependencyDeputy.js';
 import type { IssueCollector } from '../IssueCollector.js';
-export declare const getHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief) => (specifier: string, containingFilePath: string, workspace: Workspace) => string | undefined;
+export declare const getReferencedDependencyHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief) => (specifier: string, containingFilePath: string, workspace: Workspace) => string | undefined;

package/dist/util/handle-dependency.js

@@ -1,9 +1,8 @@
-import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, normalizeSpecifierFromFilePath, } from './modules.js';
-import { isInNodeModules, isInternal } from './path.js';
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from './modules.js';
+import { dirname, isInNodeModules, isInternal } from './path.js';
 import { fromBinary, isBinary } from './protocols.js';
-import { _resolveSpecifier } from './require.js';
-import { resolveSync } from './resolve.js';
-export const getHandler = (collector, deputy, chief) => (specifier, containingFilePath, workspace) => {
+import { _resolveSync } from './resolve.js';
+export const getReferencedDependencyHandler = (collector, deputy, chief) => (specifier, containingFilePath, workspace) => {
     if (isBinary(specifier)) {
         const binaryName = fromBinary(specifier);
         const isHandled = deputy.maybeAddReferencedBinary(workspace, binaryName);
@@ -17,7 +16,7 @@ export const getHandler = (collector, deputy, chief) => (specifier, containingFi
     }
     else {
         if (isInternal(specifier)) {
-            const resolvedFilePath = resolveSync(specifier, containingFilePath);
+            const resolvedFilePath = _resolveSync(specifier, dirname(containingFilePath));
             if (resolvedFilePath)
                 return resolvedFilePath;
             collector.addIssue({
@@ -40,9 +39,8 @@ export const getHandler = (collector, deputy, chief) => (specifier, containingFi
                     symbol: specifier,
                 });
             if (packageName && specifier !== packageName) {
-                const otherWorkspace = chief.workspacePackagesByName.get(packageName);
-                if (otherWorkspace) {
-                    const filePath = _resolveSpecifier(otherWorkspace.dir, normalizeSpecifierFromFilePath(specifier));
+                if (chief.workspacePackagesByName.get(packageName)) {
+                    const filePath = _resolveSync(specifier, dirname(containingFilePath));
                     if (filePath)
                         return filePath;
                     collector.addIssue({

package/dist/util/loader.js

@@ -3,8 +3,8 @@ import { timerify } from './Performance.js';
 import { LoaderError } from './errors.js';
 import { loadFile, loadJSON, loadTOML, loadYAML, parseJSON, parseYAML } from './fs.js';
 import { isTypeModule } from './fs.js';
+import { jitiCJS, jitiESM } from './jiti.js';
 import { extname, isInternal } from './path.js';
-import { jitiCJS, jitiESM } from './register.js';
 const load = async (filePath) => {
     try {
         const ext = extname(filePath);

package/dist/util/modules.d.ts

@@ -1,7 +1,6 @@
 import type { PackageJson } from '../types/package-json.js';
 export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string) => string | undefined;
 export declare const getPackageNameFromFilePath: (value: string) => string;
-export declare const normalizeSpecifierFromFilePath: (value: string) => string;
 export declare const isStartsLikePackageName: (specifier: string) => boolean;
 export declare const isDefinitelyTyped: (packageName: string) => boolean;
 export declare const getDefinitelyTypedFor: (packageName: string) => string;

package/dist/util/modules.js

@@ -16,13 +16,6 @@ export const getPackageNameFromFilePath = (value) => {
         return match[match.length - 1];
     return value;
 };
-const packageNameMatch = /.*\/node_modules\/(.+)/;
-export const normalizeSpecifierFromFilePath = (value) => {
-    const match = toPosix(value).match(packageNameMatch);
-    if (match)
-        return match[match.length - 1];
-    return value;
-};
 export const isStartsLikePackageName = (specifier) => /^@?[a-z0-9]/.test(specifier);
 export const isDefinitelyTyped = (packageName) => packageName.startsWith(`${DT_SCOPE}/`);
 export const getDefinitelyTypedFor = (packageName) => {

package/dist/util/plugin.d.ts

@@ -1,6 +1,7 @@
 export { _getDependenciesFromScripts as getDependenciesFromScripts } from '../binaries/index.js';
 export { _loadJSON as loadJSON } from './fs.js';
 export { _load as load } from './loader.js';
+export { _resolveSync as resolve } from './resolve.js';
 import type { RawPluginConfiguration } from '../types/config.js';
 import type { Plugin, PluginOptions } from '../types/plugins.js';
 export declare const toCamelCase: (name: string) => string;

package/dist/util/plugin.js

@@ -1,12 +1,13 @@
 export { _getDependenciesFromScripts as getDependenciesFromScripts } from '../binaries/index.js';
 export { _loadJSON as loadJSON } from './fs.js';
 export { _load as load } from './loader.js';
+export { _resolveSync as resolve } from './resolve.js';
 import { arrayify } from './array.js';
 import { _load as load } from './loader.js';
 import { get } from './object.js';
 import { basename, isAbsolute, join, relative } from './path.js';
 import { toEntryPattern, toProductionEntryPattern } from './protocols.js';
-import { _tryResolve as tryResolve } from './require.js';
+import { _resolveSync } from './resolve.js';
 export const toCamelCase = (name) => name.toLowerCase().replace(/(-[a-z])/g, group => group.toUpperCase().replace('-', ''));
 export const hasDependency = (dependencies, values) => values.some(value => {
     if (typeof value === 'string') {
@@ -77,9 +78,9 @@ const toConfigMap = (defaultExtensions, builderConfig) => (moduleName, options)
     ];
     const rcFiles = `${rcPrefix}${moduleName}${rcSuffix}.{${extensions.join(',')}}`;
     const configExtensions = extensions.filter(ext => config.configFilesAllExtensions || jsTypeExtensions.includes(ext));
-    const configFiles = !!config.configFiles && `${moduleName}.config.{${configExtensions.join(',')}}`;
-    const configDirFiles = !!config.configDir && `.config/${moduleName}${rcSuffix}.{${extensions.join(',')}}`;
-    return [...baseFiles, rcFiles, configFiles, configDirFiles].filter(item => item !== false);
+    const configFiles = config.configFiles ? [`${moduleName}.config.{${configExtensions.join(',')}}`] : [];
+    const configDirFiles = config.configDir ? [`.config/${moduleName}${rcSuffix}.{${extensions.join(',')}}`] : [];
+    return [...baseFiles, rcFiles, ...configFiles, ...configDirFiles];
 };
 export const toCosmiconfig = toConfigMap(['json', 'yaml', 'yml', 'js', 'ts', 'cjs', 'mjs'], { configDir: true });
 export const toLilconfig = toConfigMap(['json', 'js', 'cjs', 'mjs'], { configDir: true });
@@ -90,10 +91,10 @@ export const toUnconfig = toConfigMap(['json', 'ts', 'mts', 'cts', 'js', 'mjs',
     configFiles: false,
 });
 export const resolveEntry = (options, specifier, rootDir = '.') => {
-    const { configFileDir, configFileName } = options;
+    const { configFileDir } = options;
     const resolvedPath = isAbsolute(specifier)
         ? specifier
-        : tryResolve(join(configFileDir, rootDir, specifier), join(configFileDir, rootDir, configFileName));
+        : _resolveSync(join(configFileDir, rootDir, specifier), join(configFileDir, rootDir));
     if (resolvedPath)
         return toEntryPattern(relative(configFileDir, resolvedPath));
     return specifier;

package/dist/util/reporter.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
-export declare const runPreprocessors: (data: ReporterOptions, processors?: any) => Promise<ReporterOptions>;
-export declare const runReporters: (options: ReporterOptions) => Promise<void>;
+export declare const runPreprocessors: (processors: string[], data: ReporterOptions) => Promise<ReporterOptions>;
+export declare const runReporters: (reporter: string[], options: ReporterOptions) => Promise<void>;

package/dist/util/reporter.js

@@ -1,16 +1,18 @@
 import internalReporters from '../reporters/index.js';
-import parsedArgValues from '../util/cli-arguments.js';
 import { _load } from './loader.js';
 import { isInternal, resolve } from './path.js';
-const { preprocessor = [], reporter = ['symbols'] } = parsedArgValues;
-const preprocessors = await Promise.all(preprocessor.map(proc => _load(isInternal(proc) ? resolve(proc) : proc)));
-export const runPreprocessors = (data, processors = preprocessors) => processors.length === 0 ? Promise.resolve(data) : runPreprocessors(processors[0](data), processors.slice(1));
-const reporters = await Promise.all(reporter.map(async (reporter) => {
-    return reporter in internalReporters
-        ? internalReporters[reporter]
-        : await _load(isInternal(reporter) ? resolve(reporter) : reporter);
-}));
-export const runReporters = async (options) => {
+export const runPreprocessors = async (processors, data) => {
+    const preprocessors = await Promise.all(processors.map(proc => _load(isInternal(proc) ? resolve(proc) : proc)));
+    return preprocessors.length === 0
+        ? Promise.resolve(data)
+        : runPreprocessors(preprocessors.slice(1), preprocessors[0](data));
+};
+export const runReporters = async (reporter, options) => {
+    const reporters = await Promise.all(reporter.map(async (reporter) => {
+        return reporter in internalReporters
+            ? internalReporters[reporter]
+            : await _load(isInternal(reporter) ? resolve(reporter) : reporter);
+    }));
     for (const reporter of reporters)
         await reporter(options);
 };

package/dist/util/require.d.ts

@@ -1,4 +1 @@
 export declare const _require: NodeRequire;
-export declare const _resolve: (specifier: string) => string;
-export declare const _tryResolve: (specifier: string, from: string) => string | undefined;
-export declare const _resolveSpecifier: (dir: string, specifier: string) => string | undefined;

package/dist/util/require.js

@@ -1,36 +1,5 @@
-import { createRequire as nodeCreateRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
-import createJITI from 'jiti';
+import { createRequire } from 'node:module';
 import { timerify } from './Performance.js';
-import { debugLog } from './debug.js';
-import { getPackageNameFromModuleSpecifier } from './modules.js';
-import { cwd, join, toPosix } from './path.js';
-import { jitiCJS } from './register.js';
-const createRequire = (path) => nodeCreateRequire(pathToFileURL(path ?? cwd));
-const require = createRequire();
+import { cwd } from './path.js';
+const require = createRequire(cwd);
 export const _require = timerify(require);
-const resolve = (specifier) => toPosix(jitiCJS.resolve(specifier));
-const tryResolve = (specifier, from) => {
-    try {
-        return resolve(specifier);
-    }
-    catch {
-        debugLog('*', `Unable to resolve ${specifier} (from ${from})`);
-    }
-};
-const resolveSpecifier = (dir, specifier) => {
-    try {
-        const jiti = createJITI(dir);
-        return toPosix(jiti.resolve(specifier));
-    }
-    catch {
-        const packageName = getPackageNameFromModuleSpecifier(specifier);
-        if (packageName) {
-            const relativeSpecifier = specifier.replace(packageName, '.');
-            return tryResolve(join(dir, relativeSpecifier), dir);
-        }
-    }
-};
-export const _resolve = timerify(resolve);
-export const _tryResolve = timerify(tryResolve);
-export const _resolveSpecifier = timerify(resolveSpecifier);

package/dist/util/resolve.d.ts

@@ -1 +1,2 @@
-export declare const resolveSync: (specifier: string, containingFile: string, extensions?: string[]) => string | undefined;
+export declare const createSyncResolver: (extensions: string[]) => (specifier: string, baseDir: string) => string | undefined;
+export declare const _resolveSync: (specifier: string, baseDir: string) => string | undefined;

package/dist/util/resolve.js

@@ -1,14 +1,23 @@
-import resolve from 'resolve';
+import fs from 'node:fs';
+import ER from 'enhanced-resolve';
 import { DEFAULT_EXTENSIONS } from '../constants.js';
-import { dirname, toPosix } from './path.js';
-export const resolveSync = (specifier, containingFile, extensions = DEFAULT_EXTENSIONS) => {
-    try {
-        const resolved = resolve.sync(specifier, {
-            basedir: dirname(containingFile),
-            extensions,
-            preserveSymlinks: false,
-        });
-        return toPosix(resolved);
-    }
-    catch (_error) { }
+import { timerify } from './Performance.js';
+import { toPosix } from './path.js';
+const fileSystem = new ER.CachedInputFileSystem(fs, 9999999);
+export const createSyncResolver = (extensions) => {
+    const resolver = ER.create.sync({
+        fileSystem,
+        extensions,
+        conditionNames: ['require', 'import', 'node', 'default'],
+    });
+    return function resolveSync(specifier, baseDir) {
+        try {
+            const resolved = resolver({}, baseDir, specifier);
+            if (resolved)
+                return toPosix(resolved);
+        }
+        catch (_error) { }
+    };
 };
+const resolveSync = createSyncResolver([...DEFAULT_EXTENSIONS, '.json']);
+export const _resolveSync = timerify(resolveSync);

package/dist/util/to-source-path.d.ts

@@ -1,5 +1,5 @@
 import type { CompilerOptions } from 'typescript';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
-export type ToSourceFilePath = (filePath: string) => undefined | string;
 export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions) => void;
-export declare const getToSourcePathHandler: (chief: ConfigurationChief) => ToSourceFilePath;
+export declare const getToSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
+export type ToSourceFilePath = ReturnType<typeof getToSourcePathHandler>;

package/dist/util/watch.d.ts

@@ -0,0 +1,25 @@
+import type { WatchListener } from 'node:fs';
+import type { ConfigurationChief } from '../ConfigurationChief.js';
+import type { ConsoleStreamer } from '../ConsoleStreamer.js';
+import type { IssueCollector } from '../IssueCollector.js';
+import type { PrincipalFactory } from '../PrincipalFactory.js';
+import type { ProjectPrincipal } from '../ProjectPrincipal.js';
+import type { DependencyGraph } from '../types/dependency-graph.js';
+import type { Report } from '../types/issues.js';
+type Watch = {
+    analyzedFiles: Set<string>;
+    analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
+    chief: ConfigurationChief;
+    collector: IssueCollector;
+    collectUnusedExports: () => Promise<void>;
+    cwd: string;
+    factory: PrincipalFactory;
+    graph: DependencyGraph;
+    isDebug: boolean;
+    isIgnored: (path: string) => boolean;
+    report: Report;
+    streamer: ConsoleStreamer;
+    unreferencedFiles: Set<string>;
+};
+export declare const getWatchHandler: ({ analyzedFiles, analyzeSourceFile, chief, collector, collectUnusedExports, cwd, factory, graph, isDebug, isIgnored, report, streamer, unreferencedFiles, }: Watch) => Promise<WatchListener<string | Buffer>>;
+export {};

package/dist/util/watch.js

@@ -0,0 +1,85 @@
+import watchReporter from '../reporters/watch.js';
+import { debugLog } from './debug.js';
+import { updateImportMap } from './dependency-graph.js';
+import { isFile } from './fs.js';
+import { join, toPosix } from './path.js';
+export const getWatchHandler = async ({ analyzedFiles, analyzeSourceFile, chief, collector, collectUnusedExports, cwd, factory, graph, isDebug, isIgnored, report, streamer, unreferencedFiles, }) => {
+    const reportIssues = async (startTime) => {
+        const { issues } = collector.getIssues();
+        watchReporter({ report, issues, streamer, startTime, size: analyzedFiles.size, isDebug });
+    };
+    const listener = async (eventType, filename) => {
+        debugLog('*', `(raw) ${eventType} ${filename}`);
+        if (typeof filename === 'string') {
+            const startTime = performance.now();
+            const filePath = join(cwd, toPosix(filename));
+            if (isIgnored(filePath)) {
+                debugLog('*', `ignoring ${eventType} ${filename}`);
+                return;
+            }
+            const workspace = chief.findWorkspaceByFilePath(filePath);
+            if (workspace) {
+                const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                if (principal) {
+                    const event = eventType === 'rename' ? (isFile(filePath) ? 'added' : 'deleted') : 'modified';
+                    principal.invalidateFile(filePath);
+                    unreferencedFiles.clear();
+                    const cachedUnusedFiles = collector.purge();
+                    switch (event) {
+                        case 'added':
+                            principal.addProjectPath(filePath);
+                            principal.deletedFiles.delete(filePath);
+                            cachedUnusedFiles.add(filePath);
+                            debugLog(workspace.name, `Watcher: + ${filename}`);
+                            break;
+                        case 'deleted':
+                            analyzedFiles.delete(filePath);
+                            principal.removeProjectPath(filePath);
+                            cachedUnusedFiles.delete(filePath);
+                            debugLog(workspace.name, `Watcher: - ${filename}`);
+                            break;
+                        case 'modified':
+                            debugLog(workspace.name, `Watcher: ± ${filename}`);
+                            break;
+                    }
+                    const filePaths = principal.getUsedResolvedFiles();
+                    if (event === 'added' || event === 'deleted') {
+                        graph.clear();
+                        for (const filePath of filePaths)
+                            analyzeSourceFile(filePath, principal);
+                    }
+                    else {
+                        for (const [filePath, file] of graph) {
+                            if (filePaths.includes(filePath)) {
+                                file.imported = undefined;
+                            }
+                            else {
+                                graph.delete(filePath);
+                                analyzedFiles.delete(filePath);
+                                cachedUnusedFiles.add(filePath);
+                            }
+                        }
+                        for (const filePath of filePaths)
+                            if (!graph.has(filePath))
+                                analyzeSourceFile(filePath, principal);
+                        if (!cachedUnusedFiles.has(filePath))
+                            analyzeSourceFile(filePath, principal);
+                        for (const filePath of filePaths) {
+                            const file = graph.get(filePath);
+                            if (file?.internalImportCache)
+                                updateImportMap(file, file.internalImportCache, graph);
+                        }
+                    }
+                    await collectUnusedExports();
+                    const unusedFiles = [...cachedUnusedFiles].filter(filePath => !analyzedFiles.has(filePath));
+                    collector.addFilesIssues(unusedFiles);
+                    collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
+                    await reportIssues(startTime);
+                }
+            }
+        }
+    };
+    await collectUnusedExports();
+    await reportIssues();
+    return listener;
+};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.26.0";
+export declare const version = "5.27.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.26.0';
+export const version = '5.27.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.26.0",
+  "version": "5.27.1",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -45,7 +45,7 @@
     "lint": "biome lint ../..",
     "format": "biome format --write .",
     "test": "bun test test/*.test.ts test/**/*.test.ts",
-    "test:node": "glob -c \"npx -y tsx@4.7.1 --test --import ./transform-test.js\" \"test/**/*.test.ts\"",
+    "test:node": "glob -c \"npx -y tsx --test --import ./transform-test.js\" \"test/**/*.test.ts\"",
     "watch": "npm link && tsc --watch",
     "prebuild": "node rmdir.js dist",
     "build": "tsc",
@@ -64,6 +64,7 @@
     "@nodelib/fs.walk": "1.2.8",
     "@snyk/github-codeowners": "1.1.0",
     "easy-table": "1.2.0",
+    "enhanced-resolve": "^5.17.1",
     "fast-glob": "^3.3.2",
     "jiti": "^1.21.6",
     "js-yaml": "^4.1.0",
@@ -71,7 +72,6 @@
     "picocolors": "^1.0.0",
     "picomatch": "^4.0.1",
     "pretty-ms": "^9.0.0",
-    "resolve": "^1.22.8",
     "smol-toml": "^1.1.4",
     "strip-json-comments": "5.0.1",
     "summary": "2.1.0",
@@ -89,11 +89,9 @@
     "@types/js-yaml": "^4.0.9",
     "@types/minimist": "^1.2.5",
     "@types/picomatch": "2.3.4",
-    "@types/resolve": "^1.20.6",
     "@types/webpack": "^5.28.5",
     "@wdio/types": "^8.39.0",
     "glob": "^10.4.2",
-    "playwright": "^1.44.1",
     "release-it": "^17.4.1",
     "type-fest": "^4.20.0",
     "typescript": "^5.5.2"

package/schema.json

@@ -356,6 +356,10 @@
           "title": "Jest plugin configuration (https://knip.dev/reference/plugins/jest)",
           "$ref": "#/definitions/plugin"
         },
+        "ladle": {
+          "title": "ladle plugin configuration (https://knip.dev/reference/plugins/ladle)",
+          "$ref": "#/definitions/plugin"
+        },
         "lefthook": {
           "title": "lefthook plugin configuration (https://knip.dev/reference/plugins/lefthook)",
           "$ref": "#/definitions/plugin"
@@ -436,6 +440,10 @@
           "title": "Prettier plugin configuration (https://knip.dev/reference/plugins/prettier)",
           "$ref": "#/definitions/plugin"
         },
+        "react-cosmos": {
+          "title": "react-cosmos plugin configuration (https://knip.dev/reference/plugins/react-cosmos)",
+          "$ref": "#/definitions/plugin"
+        },
         "release-it": {
           "title": "Release It plugin configuration (https://knip.dev/reference/plugins/release-it)",
           "$ref": "#/definitions/plugin"
@@ -452,6 +460,14 @@
           "title": "Rollup plugin configuration (https://knip.dev/reference/plugins/rollup)",
           "$ref": "#/definitions/plugin"
         },
+        "rsbuild": {
+          "title": "rsbuild plugin configuration (https://knip.dev/reference/plugins/rsbuild)",
+          "$ref": "#/definitions/plugin"
+        },
+        "rspack": {
+          "title": "rspack plugin configuration (https://knip.dev/reference/plugins/rspack)",
+          "$ref": "#/definitions/plugin"
+        },
         "semantic-release": {
           "title": "semantic-release plugin configuration (https://knip.dev/reference/plugins/semantic-release)",
           "$ref": "#/definitions/plugin"

package/dist/util/pkgs-graph.d.ts

@@ -1,8 +0,0 @@
-import type { PackageJson } from '../types/package-json.js';
-interface Package {
-    manifest: PackageJson;
-    dir: string;
-}
-export type Graph = Record<string, Set<string>>;
-export declare function createPkgGraph(cwd: string, wsNames: string[], wsPkgNames: Set<string>, byPkgName: Map<string, Package>, byName: Map<string, Package>): Graph;
-export {};