knip 6.43.0 → 6.44.1

package/dist/util/path.d.ts

@@ -5,6 +5,7 @@ export declare const extname: typeof path.extname;
 export declare const basename: typeof path.basename;
 export declare const join: typeof path.join;
 export declare const toPosix: (value: string) => string;
+export declare const toNative: (value: string) => string;
 export declare const resolve: typeof path.resolve;
 export declare const resolveCwd: (dir: string) => string;
 export declare const relative: (from: string, to: string) => string;

package/dist/util/path.js

@@ -6,6 +6,7 @@ export const extname = path.posix.extname;
 export const basename = path.posix.basename;
 export const join = path.posix.join;
 export const toPosix = isWin ? (value) => value.split(path.sep).join(path.posix.sep) : (value) => value;
+export const toNative = isWin ? path.win32.normalize : (value) => value;
 export const resolve = path.posix.resolve;
 export const resolveCwd = (dir) => toPosix(path.resolve(dir));
 export const relative = (from, to) => {

package/dist/util/reporter.d.ts

@@ -1,2 +1,2 @@
 import type { ReporterOptions } from '../types/issues.ts';
-export declare const runReporters: (reporter: string[], options: ReporterOptions) => Promise<void>;
+export declare const runReporters: (reporter: string[], outputFiles: string[], options: ReporterOptions) => Promise<void>;

package/dist/util/reporter.js

@@ -1,12 +1,56 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { stripVTControlCharacters } from 'node:util';
 import internalReporters from '../reporters/index.js';
+import { ConfigurationError } from './errors.js';
 import { _load } from './loader.js';
-import { isAbsolute, isInternal, resolve } from './path.js';
-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) && !isAbsolute(reporter) ? resolve(reporter) : reporter);
-    }));
-    for (const reporter of reporters)
-        await reporter(options);
+import { dirname, isAbsolute, isInternal, resolve, toAbsolute, toPosix } from './path.js';
+const writeStdout = (output) => {
+    if (!output)
+        return;
+    process.stdout._handle?.setBlocking?.(true);
+    process.stdout.write(`${output}\n`);
+};
+const getOutputFiles = (reporters, outputFiles, cwd) => {
+    const targets = new Map();
+    for (const outputFile of outputFiles) {
+        const index = outputFile.indexOf('=');
+        const name = index === -1 ? reporters[0] : outputFile.slice(0, index);
+        const filePath = index === -1 ? outputFile : outputFile.slice(index + 1);
+        if (index === -1 && reporters.length > 1) {
+            throw new ConfigurationError(`Option --output-file needs a reporter prefix when using multiple reporters (${reporters.join(', ')}), e.g. --output-file ${reporters[0]}=${outputFile}`);
+        }
+        if (!reporters.includes(name)) {
+            throw new ConfigurationError(`Option --output-file refers to reporter "${name}", but it is not selected with --reporter`);
+        }
+        targets.set(name, toAbsolute(toPosix(filePath), cwd));
+    }
+    return targets;
+};
+const loadReporter = (reporter) => reporter in internalReporters
+    ? Promise.resolve(internalReporters[reporter])
+    : _load(isInternal(reporter) && !isAbsolute(reporter) ? resolve(reporter) : reporter);
+export const runReporters = async (reporter, outputFiles, options) => {
+    const targets = getOutputFiles(reporter, outputFiles, options.cwd);
+    const reporters = await Promise.all(reporter.map(loadReporter));
+    for (let i = 0; i < reporters.length; i++) {
+        const target = targets.get(reporter[i]);
+        if (!target) {
+            await reporters[i]({ ...options, write: writeStdout });
+            continue;
+        }
+        let output = '';
+        const write = (text) => {
+            if (text)
+                output += `${text}\n`;
+        };
+        await reporters[i]({ ...options, write });
+        try {
+            await mkdir(dirname(target), { recursive: true });
+            await writeFile(target, stripVTControlCharacters(output));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new ConfigurationError(`Option --output-file failed to write: ${message}`);
+        }
+    }
 };

package/dist/util/watch.d.ts

@@ -1,15 +1,9 @@
-import type { WatchListener } from 'node:fs';
 import type { ConfigurationChief } from '../ConfigurationChief.ts';
 import type { IssueCollector } from '../IssueCollector.ts';
 import type { ProjectPrincipal } from '../ProjectPrincipal.ts';
-import type { Issues } from '../types/issues.ts';
+import type { ConfigurationFiles } from '../session/configuration.ts';
 import type { ModuleGraph } from '../types/module-graph.ts';
 import type { MainOptions } from './create-options.ts';
-export type OnFileChange = (options: {
-    issues: Issues;
-    duration?: number;
-    mem?: number;
-}) => void;
 export type WatchChange = {
     type: 'added' | 'deleted' | 'modified';
     filePath: string;
@@ -23,13 +17,12 @@ type WatchOptions = {
     analyze: () => Promise<void>;
     principal: ProjectPrincipal;
     graph: ModuleGraph;
+    configurationFiles?: ConfigurationFiles;
     isIgnored: (path: string) => boolean;
-    onFileChange?: OnFileChange;
     unreferencedFiles: Set<string>;
     entryPaths: Set<string>;
 };
-export declare const getSessionHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, principal, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }: WatchOptions) => Promise<{
-    listener: WatchListener<string | Buffer<ArrayBufferLike>>;
+export declare const getSessionHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, principal, graph, configurationFiles, isIgnored, unreferencedFiles, entryPaths, }: WatchOptions) => Promise<{
     handleFileChanges: (changes: WatchChange[]) => Promise<{
         duration: number;
         mem: number;
@@ -37,11 +30,12 @@ export declare const getSessionHandler: (options: MainOptions, { analyzedFiles,
     getEntryPaths: () => Set<string>;
     getGraph: () => ModuleGraph;
     getIssues: () => {
-        issues: Issues;
+        issues: import("../types/issues.ts").Issues;
         counters: import("../types/issues.ts").Counters;
         tagHints: Set<import("../types/issues.ts").TagHint>;
         configurationHints: import("../types/issues.ts").ConfigurationHint[];
         hasConfigLoadErrors: boolean;
     };
+    configurationFiles: ConfigurationFiles | undefined;
 }>;
 export {};

package/dist/util/watch.js

@@ -1,10 +1,8 @@
 import { invalidateCache } from '../graph-explorer/cache.js';
+import { getFileTopology, hasSameTopology, isIncrementalFile } from '../session/incremental.js';
 import { debugLog } from './debug.js';
-import { hasErrorCause } from './errors.js';
-import { isFile } from './fs.js';
-import { logError } from './log.js';
 import { updateImportMap } from './module-graph.js';
-import { toAbsolute, toPosix, toRelative } from './path.js';
+import { toAbsolute, toRelative } from './path.js';
 import { clearModuleResolutionCaches } from '../typescript/resolve-module-names.js';
 import { clearGlobCache } from './glob-cache.js';
 import { clearResolverCache } from './resolve.js';
@@ -13,13 +11,18 @@ const createUpdate = (options) => {
     const mem = process.memoryUsage().heapUsed;
     return { duration, mem };
 };
-export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, principal, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }) => {
+export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, principal, graph, configurationFiles, isIgnored, unreferencedFiles, entryPaths, }) => {
     const added = new Set();
     const deleted = new Set();
     const modified = new Set();
+    if (configurationFiles)
+        principal.collectConfigurationImports(configurationFiles);
     const processFileChanges = async (changes) => {
         const startTime = performance.now();
         let hasRelevantChanges = false;
+        const configurationChange = configurationFiles?.getChange(changes, options.cwd);
+        if (configurationChange)
+            throw configurationChange;
         for (const change of changes) {
             const filePath = toAbsolute(change.filePath, options.cwd);
             const relativePath = toRelative(change.filePath, options.cwd);
@@ -60,76 +63,104 @@ export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceF
         }
         if (!hasRelevantChanges || (added.size === 0 && deleted.size === 0 && modified.size === 0))
             return;
-        clearResolverCache();
-        clearModuleResolutionCaches();
-        clearGlobCache();
-        invalidateCache(graph);
-        const filePaths = await principal.getUsedResolvedFiles();
-        unreferencedFiles.clear();
-        const cachedUnusedFiles = collector.purge();
-        for (const filePath of added)
-            cachedUnusedFiles.add(filePath);
-        for (const filePath of deleted)
-            cachedUnusedFiles.delete(filePath);
-        if (added.size > 0 || deleted.size > 0) {
-            graph.clear();
-            for (const filePath of filePaths) {
-                const workspace = chief.findWorkspaceByFilePath(filePath);
-                if (workspace) {
-                    await analyzeSourceFile(filePath);
+        let incremental = added.size === 0 && deleted.size === 0;
+        if (incremental) {
+            for (const filePath of modified) {
+                const file = graph.get(filePath);
+                if (!file || !analyzedFiles.has(filePath) || !isIncrementalFile(file)) {
+                    incremental = false;
+                    break;
                 }
             }
         }
-        else {
-            for (const [filePath, file] of graph) {
-                if (filePaths.has(filePath)) {
-                    file.importedBy = undefined;
+        if (incremental) {
+            for (const filePath of modified) {
+                const file = graph.get(filePath);
+                if (!file) {
+                    incremental = false;
+                    break;
                 }
-                else {
-                    graph.delete(filePath);
-                    analyzedFiles.delete(filePath);
-                    const workspace = chief.findWorkspaceByFilePath(filePath);
-                    if (workspace && principal.projectPaths.has(filePath))
-                        cachedUnusedFiles.add(filePath);
+                const before = getFileTopology(file);
+                await analyzeSourceFile(filePath);
+                if (!hasSameTopology(before, file)) {
+                    incremental = false;
+                    break;
                 }
             }
-            for (const filePath of filePaths) {
-                if (!graph.has(filePath)) {
+        }
+        if (incremental) {
+            invalidateCache(graph, true);
+            collector.purge();
+        }
+        else {
+            clearResolverCache();
+            clearModuleResolutionCaches();
+            clearGlobCache();
+            invalidateCache(graph);
+            const filePaths = await principal.getUsedResolvedFiles();
+            const cachedUnusedFiles = collector.purge();
+            for (const filePath of added)
+                cachedUnusedFiles.add(filePath);
+            for (const filePath of deleted)
+                cachedUnusedFiles.delete(filePath);
+            if (added.size > 0 || deleted.size > 0) {
+                graph.clear();
+                for (const filePath of filePaths) {
                     const workspace = chief.findWorkspaceByFilePath(filePath);
                     if (workspace) {
                         await analyzeSourceFile(filePath);
                     }
                 }
             }
-            for (const filePath of modified) {
-                if (!cachedUnusedFiles.has(filePath)) {
-                    const workspace = chief.findWorkspaceByFilePath(filePath);
-                    if (workspace) {
-                        if (principal.projectPaths.has(filePath) || graph.has(filePath)) {
+            else {
+                for (const [filePath, file] of graph) {
+                    if (filePaths.has(filePath)) {
+                        file.importedBy = undefined;
+                    }
+                    else {
+                        graph.delete(filePath);
+                        analyzedFiles.delete(filePath);
+                        const workspace = chief.findWorkspaceByFilePath(filePath);
+                        if (workspace && principal.projectPaths.has(filePath))
+                            cachedUnusedFiles.add(filePath);
+                    }
+                }
+                for (const filePath of filePaths) {
+                    if (!graph.has(filePath) || !analyzedFiles.has(filePath)) {
+                        const workspace = chief.findWorkspaceByFilePath(filePath);
+                        if (workspace) {
                             await analyzeSourceFile(filePath);
                         }
                     }
                 }
+                for (const filePath of modified) {
+                    if (!cachedUnusedFiles.has(filePath)) {
+                        const workspace = chief.findWorkspaceByFilePath(filePath);
+                        if (workspace) {
+                            if (principal.projectPaths.has(filePath) || graph.has(filePath)) {
+                                await analyzeSourceFile(filePath);
+                            }
+                        }
+                    }
+                }
+                for (const filePath of filePaths) {
+                    const file = graph.get(filePath);
+                    if (file?.internalImportCache)
+                        updateImportMap(file, file.internalImportCache, graph);
+                }
             }
-            for (const filePath of filePaths) {
-                const file = graph.get(filePath);
-                if (file?.internalImportCache)
-                    updateImportMap(file, file.internalImportCache, graph);
-            }
+            const unusedFiles = [...cachedUnusedFiles].filter(filePath => !analyzedFiles.has(filePath));
+            unreferencedFiles.clear();
+            for (const filePath of unusedFiles)
+                unreferencedFiles.add(filePath);
         }
-        await analyze();
-        const unusedFiles = [...cachedUnusedFiles].filter(filePath => !analyzedFiles.has(filePath));
-        collector.addFilesIssues(unusedFiles);
-        collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
         for (const issue of collector.getRetainedIssues())
             collector.addIssue(issue);
+        await analyze();
         added.clear();
         deleted.clear();
         modified.clear();
-        const update = createUpdate({ startTime });
-        if (onFileChange)
-            onFileChange(Object.assign({ issues: getIssues().issues }, update));
-        return update;
+        return createUpdate({ startTime });
     };
     const clearSourceText = () => principal.fileManager.sourceTextCache.clear();
     let pending = Promise.resolve();
@@ -138,23 +169,8 @@ export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceF
         pending = update.then(clearSourceText, clearSourceText);
         return update;
     };
-    const listener = (eventType, filePath) => {
-        debugLog('*', `(raw) ${eventType} ${filePath}`);
-        if (typeof filePath === 'string') {
-            const normalizedPath = toPosix(filePath);
-            const type = eventType === 'rename' ? (isFile(options.cwd, normalizedPath) ? 'added' : 'deleted') : 'modified';
-            handleFileChanges([{ type, filePath: normalizedPath }]).catch(error => {
-                const message = error instanceof Error ? error.message : String(error);
-                const reason = error instanceof Error && hasErrorCause(error) ? `\nReason: ${error.cause.message}` : '';
-                logError(message + reason);
-                process.exitCode = 2;
-            });
-        }
-    };
     const getIssues = () => collector.getIssues();
     const getEntryPaths = () => entryPaths;
     const getGraph = () => graph;
-    if (onFileChange)
-        onFileChange({ issues: getIssues().issues });
-    return { listener, handleFileChanges, getEntryPaths, getGraph, getIssues };
+    return { handleFileChanges, getEntryPaths, getGraph, getIssues, configurationFiles };
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.43.0";
+export declare const version = "6.44.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.43.0';
+export const version = '6.44.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.43.0",
+  "version": "6.44.1",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",

package/schema.json

@@ -638,6 +638,10 @@
           "title": "knex plugin configuration (https://knip.dev/reference/plugins/knex)",
           "$ref": "#/definitions/plugin"
         },
+        "kysely-codegen": {
+          "title": "kysely-codegen plugin configuration (https://knip.dev/reference/plugins/kysely-codegen)",
+          "$ref": "#/definitions/plugin"
+        },
         "ladle": {
           "title": "ladle plugin configuration (https://knip.dev/reference/plugins/ladle)",
           "$ref": "#/definitions/plugin"
@@ -650,6 +654,10 @@
           "title": "lefthook plugin configuration (https://knip.dev/reference/plugins/lefthook)",
           "$ref": "#/definitions/plugin"
         },
+        "lingui": {
+          "title": "lingui plugin configuration (https://knip.dev/reference/plugins/lingui)",
+          "$ref": "#/definitions/plugin"
+        },
         "lint-staged": {
           "title": "lint-staged plugin configuration (https://knip.dev/reference/plugins/lint-staged)",
           "$ref": "#/definitions/plugin"
@@ -682,6 +690,10 @@
           "title": "marko plugin configuration (https://knip.dev/reference/plugins/marko)",
           "$ref": "#/definitions/plugin"
         },
+        "mastra": {
+          "title": "mastra plugin configuration (https://knip.dev/reference/plugins/mastra)",
+          "$ref": "#/definitions/plugin"
+        },
         "mcp": {
           "title": "mcp plugin configuration (https://knip.dev/reference/plugins/mcp)",
           "$ref": "#/definitions/plugin"
@@ -862,6 +874,10 @@
           "title": "Prisma plugin configuration (https://knip.dev/reference/plugins/prisma)",
           "$ref": "#/definitions/plugin"
         },
+        "purgecss": {
+          "title": "purgecss plugin configuration (https://knip.dev/reference/plugins/purgecss)",
+          "$ref": "#/definitions/plugin"
+        },
         "quasar": {
           "title": "quasar plugin configuration (https://knip.dev/reference/plugins/quasar)",
           "$ref": "#/definitions/plugin"