knip 5.65.0 → 5.66.1

package/dist/util/loader.js

@@ -1,5 +1,5 @@
 import { LoaderError } from './errors.js';
-import { loadFile, loadJSON, loadTOML, loadYAML, parseJSON, parseYAML } from './fs.js';
+import { loadFile, loadJSON, loadJSONC, loadTOML, loadYAML, parseJSONC, parseYAML } from './fs.js';
 import { jiti } from './jiti.js';
 import { timerify } from './Performance.js';
 import { extname, isInternal } from './path.js';
@@ -12,7 +12,7 @@ const load = async (filePath) => {
                 return parseYAML(contents);
             }
             catch {
-                return parseJSON(filePath, contents);
+                return parseJSONC(filePath, contents);
             }
         }
         if (ext === '.yaml' || ext === '.yml') {
@@ -21,9 +21,12 @@ const load = async (filePath) => {
         if (ext === '' && isInternal(filePath)) {
             return await loadFile(filePath);
         }
-        if (ext === '.json' || ext === '.jsonc' || ext === '.json5') {
+        if (ext === '.json') {
             return await loadJSON(filePath);
         }
+        if (ext === '.jsonc' || ext === '.json5') {
+            return await loadJSONC(filePath);
+        }
         if (typeof Bun !== 'undefined') {
             const imported = await import(filePath);
             return imported.default ?? imported;

package/dist/util/string.js

@@ -64,5 +64,9 @@ export const prettyMilliseconds = (ms) => {
         return `${hours}h ${minutes % 60}m ${Math.floor(seconds % 60)}s`;
     if (minutes > 0)
         return `${minutes}m ${Math.floor(seconds % 60)}s`;
-    return seconds % 1 ? `${seconds.toFixed(1)}s` : `${Math.floor(seconds)}s`;
+    if (seconds > 10)
+        return `${Math.round(seconds)}s`;
+    if (seconds > 1)
+        return `${seconds.toFixed(1)}s`;
+    return `${Math.round(ms)}ms`;
 };

package/dist/util/watch.d.ts

@@ -1,11 +1,15 @@
 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 { Issues } from '../types/issues.js';
 import type { ModuleGraph } from '../types/module-graph.js';
 import type { MainOptions } from './create-options.js';
+export type OnUpdate = (options: {
+    issues: Issues;
+    duration?: number;
+}) => void;
 type Watch = {
     analyzedFiles: Set<string>;
     analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
@@ -15,8 +19,8 @@ type Watch = {
     factory: PrincipalFactory;
     graph: ModuleGraph;
     isIgnored: (path: string) => boolean;
-    streamer: ConsoleStreamer;
+    onUpdate: OnUpdate;
     unreferencedFiles: Set<string>;
 };
-export declare const getWatchHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, streamer, unreferencedFiles, }: Watch) => Promise<WatchListener<string | Buffer<ArrayBufferLike>>>;
+export declare const getWatchHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onUpdate, unreferencedFiles, }: Watch) => Promise<WatchListener<string | Buffer<ArrayBufferLike>>>;
 export {};

package/dist/util/watch.js

@@ -1,85 +1,124 @@
-import watchReporter from '../reporters/watch.js';
 import { debugLog } from './debug.js';
 import { isFile } from './fs.js';
 import { updateImportMap } from './module-graph.js';
-import { join, toPosix } from './path.js';
-export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, streamer, unreferencedFiles, }) => {
-    const reportIssues = async (startTime) => {
-        const { issues } = collector.getIssues();
-        watchReporter(options, { issues, streamer, startTime, size: analyzedFiles.size });
-    };
-    const listener = async (eventType, filename) => {
-        debugLog('*', `(raw) ${eventType} ${filename}`);
-        if (typeof filename === 'string') {
-            const startTime = performance.now();
-            const filePath = join(options.cwd, toPosix(filename));
+import { join, toAbsolute, toRelative } from './path.js';
+export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onUpdate, unreferencedFiles, }) => {
+    const getIssues = () => collector.getIssues().issues;
+    const processBatch = async (changes) => {
+        const startTime = performance.now();
+        const added = new Set();
+        const deleted = new Set();
+        const modified = new Set();
+        for (const [type, _path] of changes) {
+            const filePath = toAbsolute(_path, options.cwd);
+            const relativePath = toRelative(_path, options.cwd);
             if (isIgnored(filePath)) {
-                debugLog('*', `ignoring ${eventType} ${filename}`);
-                return;
+                debugLog('*', `ignoring ${type} ${relativePath}`);
+                continue;
             }
             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);
+            if (!workspace)
+                continue;
+            const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+            if (!principal)
+                continue;
+            switch (type) {
+                case 'added':
+                    added.add(filePath);
+                    principal.addProjectPath(filePath);
+                    principal.deletedFiles.delete(filePath);
+                    debugLog(workspace.name, `Watcher: + ${relativePath}`);
+                    break;
+                case 'deleted':
+                    deleted.add(filePath);
+                    analyzedFiles.delete(filePath);
+                    principal.removeProjectPath(filePath);
+                    debugLog(workspace.name, `Watcher: - ${relativePath}`);
+                    break;
+                case 'modified':
+                    modified.add(filePath);
+                    debugLog(workspace.name, `Watcher: ± ${relativePath}`);
+                    break;
+            }
+            principal.invalidateFile(filePath);
+        }
+        if (added.size === 0 && deleted.size === 0 && modified.size === 0)
+            return;
+        unreferencedFiles.clear();
+        const cachedUnusedFiles = collector.purge();
+        for (const filePath of added)
+            cachedUnusedFiles.add(filePath);
+        for (const filePath of deleted)
+            cachedUnusedFiles.delete(filePath);
+        const filePaths = factory.getPrincipals().flatMap(p => p.getUsedResolvedFiles());
+        if (added.size > 0 || deleted.size > 0) {
+            graph.clear();
+            for (const filePath of filePaths) {
+                const workspace = chief.findWorkspaceByFilePath(filePath);
+                if (workspace) {
+                    const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                    if (principal)
+                        analyzeSourceFile(filePath, principal);
+                }
+            }
+        }
+        else {
+            for (const [filePath, file] of graph) {
+                if (filePaths.includes(filePath)) {
+                    file.imported = undefined;
+                }
+                else {
+                    graph.delete(filePath);
+                    analyzedFiles.delete(filePath);
+                    const workspace = chief.findWorkspaceByFilePath(filePath);
+                    if (workspace) {
+                        const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                        if (principal?.projectPaths.has(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 = factory.getPrincipals().flatMap(p => p.getUsedResolvedFiles());
-                    if (event === 'added' || event === 'deleted') {
-                        graph.clear();
-                        for (const filePath of filePaths)
+                }
+            }
+            for (const filePath of filePaths) {
+                if (!graph.has(filePath)) {
+                    const workspace = chief.findWorkspaceByFilePath(filePath);
+                    if (workspace) {
+                        const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                        if (principal)
                             analyzeSourceFile(filePath, principal);
                     }
-                    else {
-                        for (const [filePath, file] of graph) {
-                            if (filePaths.includes(filePath)) {
-                                file.imported = undefined;
-                            }
-                            else {
-                                graph.delete(filePath);
-                                analyzedFiles.delete(filePath);
-                                if (principal.projectPaths.has(filePath))
-                                    cachedUnusedFiles.add(filePath);
-                            }
-                        }
-                        for (const filePath of filePaths)
-                            if (!graph.has(filePath))
-                                analyzeSourceFile(filePath, principal);
-                        if (!cachedUnusedFiles.has(filePath))
+                }
+            }
+            for (const filePath of modified) {
+                if (!cachedUnusedFiles.has(filePath)) {
+                    const workspace = chief.findWorkspaceByFilePath(filePath);
+                    if (workspace) {
+                        const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                        if (principal)
                             analyzeSourceFile(filePath, principal);
-                        for (const filePath of filePaths) {
-                            const file = graph.get(filePath);
-                            if (file?.internalImportCache)
-                                updateImportMap(file, file.internalImportCache, graph);
-                        }
                     }
-                    await analyze();
-                    const unusedFiles = [...cachedUnusedFiles].filter(filePath => !analyzedFiles.has(filePath));
-                    collector.addFilesIssues(unusedFiles);
-                    collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
-                    await reportIssues(startTime);
                 }
             }
+            for (const filePath of filePaths) {
+                const file = graph.get(filePath);
+                if (file?.internalImportCache)
+                    updateImportMap(file, file.internalImportCache, graph);
+            }
+        }
+        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);
+        onUpdate({ issues: getIssues(), duration: performance.now() - startTime });
+    };
+    const listener = (eventType, filename) => {
+        debugLog('*', `(raw) ${eventType} ${filename}`);
+        if (typeof filename === 'string') {
+            const event = eventType === 'rename' ? (isFile(join(options.cwd, filename)) ? 'added' : 'deleted') : 'modified';
+            processBatch([[event, filename]]);
         }
     };
-    await reportIssues();
+    onUpdate({ issues: getIssues() });
     return listener;
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.65.0";
+export declare const version = "5.66.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.65.0';
+export const version = '5.66.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.65.0",
+  "version": "5.66.1",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {

package/schema.json

@@ -98,11 +98,27 @@
             },
             "type": {
               "type": "boolean"
+            },
+            "variable": {
+              "type": "boolean"
             }
           }
         }
       ]
     },
+    "ignoreIssues": {
+      "title": " Ignore specific issue types for specific file patterns",
+      "examples": [
+        {
+          "src/generated/**": ["exports", "types"],
+          "**/*.generated.ts": ["exports", "classMembers"]
+        }
+      ],
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/issueTypes"
+      }
+    },
     "includeEntryExports": {
       "title": "Include entry files when reporting unused exports",
       "type": "boolean"
@@ -386,6 +402,10 @@
           "title": "Cypress plugin configuration (https://knip.dev/reference/plugins/cypress)",
           "$ref": "#/definitions/plugin"
         },
+        "danger": {
+          "title": "danger plugin configuration (https://knip.dev/reference/plugins/danger)",
+          "$ref": "#/definitions/plugin"
+        },
         "dependency-cruiser": {
           "title": "dependency-cruiser plugin configuration (https://knip.dev/reference/plugins/dependency-cruiser)",
           "$ref": "#/definitions/plugin"