knip 5.66.0 → 5.66.2

package/dist/typescript/visitors/exports/exportKeyword.js

@@ -1,6 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../../../constants.js';
-import { SymbolType } from '../../../types/issues.js';
+import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { compact } from '../../../util/array.js';
 import { getClassMember, getDefaultKeywordNode, getEnumMember, getExportKeywordNode, isNonPrivatePropertyOrMethodDeclaration, } from '../../ast-helpers.js';
 import { isModule } from '../helpers.js';
@@ -20,7 +19,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                                 node: element,
                                 symbol: element.symbol,
                                 identifier: element.name.escapedText.toString(),
-                                type: SymbolType.UNKNOWN,
+                                type: SYMBOL_TYPE.UNKNOWN,
                                 pos: element.name.getStart(),
                                 fix,
                             };
@@ -35,7 +34,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                                 node: element,
                                 symbol: element.symbol,
                                 identifier: element.getText(),
-                                type: SymbolType.UNKNOWN,
+                                type: SYMBOL_TYPE.UNKNOWN,
                                 pos: element.getStart(),
                                 fix,
                             };
@@ -45,7 +44,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                 const identifier = declaration.name.getText();
                 const pos = declaration.name.getStart();
                 const fix = getFix(exportKeyword);
-                return { node: declaration, identifier, type: SymbolType.UNKNOWN, pos, fix };
+                return { node: declaration, identifier, type: SYMBOL_TYPE.UNKNOWN, pos, fix };
             });
         }
         const defaultKeyword = getDefaultKeywordNode(node);
@@ -53,7 +52,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = (node.name ?? node.body ?? node).getStart();
             const fix = getFix(exportKeyword, defaultKeyword);
-            return { node, identifier, pos, type: SymbolType.FUNCTION, fix };
+            return { node, identifier, pos, type: SYMBOL_TYPE.FUNCTION, fix };
         }
         if (ts.isClassDeclaration(node) && node.name) {
             const identifier = defaultKeyword ? 'default' : node.name.getText();
@@ -62,26 +61,26 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
             const members = isReportClassMembers
                 ? node.members.filter(isNonPrivatePropertyOrMethodDeclaration).map(member => getClassMember(member, isFixTypes))
                 : [];
-            return { node, identifier, type: SymbolType.CLASS, pos, members, fix };
+            return { node, identifier, type: SYMBOL_TYPE.CLASS, pos, members, fix };
         }
         if (ts.isTypeAliasDeclaration(node)) {
             const identifier = node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
-            return { node, identifier, type: SymbolType.TYPE, pos, fix };
+            return { node, identifier, type: SYMBOL_TYPE.TYPE, pos, fix };
         }
         if (ts.isInterfaceDeclaration(node)) {
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
-            return { node, identifier, type: SymbolType.INTERFACE, pos, fix };
+            return { node, identifier, type: SYMBOL_TYPE.INTERFACE, pos, fix };
         }
         if (ts.isEnumDeclaration(node)) {
             const identifier = node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
             const members = node.members.map(member => getEnumMember(member, isFixExports));
-            return { node, identifier, type: SymbolType.ENUM, pos, members, fix };
+            return { node, identifier, type: SYMBOL_TYPE.ENUM, pos, members, fix };
         }
     }
 });

package/dist/typescript/visitors/exports/exportsAccessExpression.js

@@ -1,6 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../../../constants.js';
-import { SymbolType } from '../../../types/issues.js';
+import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isJS, (node, { isFixExports }) => {
@@ -12,7 +11,7 @@ export default visit(isJS, (node, { isFixExports }) => {
             return {
                 node: node.left.name,
                 identifier,
-                type: SymbolType.UNKNOWN,
+                type: SYMBOL_TYPE.UNKNOWN,
                 pos,
                 fix,
             };

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.js

@@ -1,6 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../../../constants.js';
-import { SymbolType } from '../../../types/issues.js';
+import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { hasRequireCall, isModuleExportsAccess, stripQuotes } from '../../ast-helpers.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
@@ -16,7 +15,7 @@ export default visit(isJS, (node, { isFixExports }) => {
                     return {
                         node: node.expression.left.name,
                         identifier,
-                        type: SymbolType.UNKNOWN,
+                        type: SYMBOL_TYPE.UNKNOWN,
                         pos,
                         fix,
                     };
@@ -26,13 +25,13 @@ export default visit(isJS, (node, { isFixExports }) => {
                     if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
                         return expr.properties.map(node => {
                             const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
-                            return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.getStart(), fix };
+                            return { node, identifier: node.getText(), type: SYMBOL_TYPE.UNKNOWN, pos: node.getStart(), fix };
                         });
                     }
                     if (ts.isCallExpression(node.expression.right) && hasRequireCall(node.expression.right)) {
                         return;
                     }
-                    return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos + 1, fix: undefined };
+                    return { node, identifier: 'default', type: SYMBOL_TYPE.UNKNOWN, pos: expr.pos + 1, fix: undefined };
                 }
             }
             else if (ts.isElementAccessExpression(node.expression.left) &&
@@ -45,7 +44,7 @@ export default visit(isJS, (node, { isFixExports }) => {
                 return {
                     node: node.expression.left.argumentExpression,
                     identifier,
-                    type: SymbolType.UNKNOWN,
+                    type: SYMBOL_TYPE.UNKNOWN,
                     pos,
                     fix,
                 };

package/dist/util/Performance.d.ts

@@ -34,7 +34,7 @@ declare class Performance {
     getTimerifiedFunctionsTable(): string;
     addMemoryMark(index: number): void;
     getMemoryUsageTable(): string;
-    getCurrentDurationInMs(startTime?: number): number;
+    getCurrentDurationInMs(): number;
     getMemHeapUsage(): number;
     getCurrentMemUsageInMb(): any;
     finalize(): Promise<void>;

package/dist/util/Performance.js

@@ -133,8 +133,8 @@ class Performance {
         }
         return table.toString();
     }
-    getCurrentDurationInMs(startTime) {
-        return performance.now() - (startTime ?? this.startTime);
+    getCurrentDurationInMs() {
+        return performance.now() - this.startTime;
     }
     getMemHeapUsage() {
         return (memoryUsage().heapUsed ?? 0) - (this.memoryUsageStart?.heapUsed ?? 0);

package/dist/util/create-options.d.ts

@@ -1200,10 +1200,10 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             ignoreUnresolved?: (string | RegExp)[] | undefined;
             includeEntryExports?: boolean | undefined;
         }> | undefined;
-        include?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
-        exclude?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
+        include?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[] | undefined;
+        exclude?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[] | undefined;
         $schema?: string | undefined;
-        rules?: Partial<Record<"files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers", "error" | "warn" | "off">> | undefined;
+        rules?: Partial<Record<"files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates", "error" | "warn" | "off">> | undefined;
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
         paths?: Record<string, string[]> | undefined;
@@ -1213,15 +1213,8 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         ignoreDependencies?: (string | RegExp)[] | undefined;
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
-        ignoreExportsUsedInFile?: boolean | {
-            class?: boolean | undefined;
-            enum?: boolean | undefined;
-            function?: boolean | undefined;
-            interface?: boolean | undefined;
-            member?: boolean | undefined;
-            type?: boolean | undefined;
-        } | undefined;
-        ignoreIssues?: Record<string, ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[]> | undefined;
+        ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
+        ignoreIssues?: Record<string, ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[]> | undefined;
         ignoreWorkspaces?: string[] | undefined;
         includeEntryExports?: boolean | undefined;
         compilers?: Record<string, true | ((filename: string, contents: string) => string) | ((filename: string, contents: string) => Promise<string>)> | undefined;
@@ -1239,12 +1232,12 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         binaries: import("../types/issues.js").IssueSeverity;
         unresolved: import("../types/issues.js").IssueSeverity;
         exports: import("../types/issues.js").IssueSeverity;
-        types: import("../types/issues.js").IssueSeverity;
         nsExports: import("../types/issues.js").IssueSeverity;
+        types: import("../types/issues.js").IssueSeverity;
         nsTypes: import("../types/issues.js").IssueSeverity;
-        duplicates: import("../types/issues.js").IssueSeverity;
         enumMembers: import("../types/issues.js").IssueSeverity;
         classMembers: import("../types/issues.js").IssueSeverity;
+        duplicates: import("../types/issues.js").IssueSeverity;
         _files: import("../types/issues.js").IssueSeverity;
     };
     tags: import("../types/options.js").Tags;

package/dist/util/create-options.js

@@ -94,7 +94,7 @@ export const createOptions = async (options) => {
             includedIssueTypes.binaries,
         isReportTypes: includedIssueTypes.types || includedIssueTypes.nsTypes || includedIssueTypes.enumMembers,
         isReportValues: includedIssueTypes.exports || includedIssueTypes.nsExports || isReportClassMembers,
-        isShowProgress: parsedCLIArgs['no-progress'] === false && process.stdout.isTTY && typeof process.stdout.cursorTo === 'function',
+        isShowProgress: parsedCLIArgs['no-progress'] !== true && process.stdout.isTTY && typeof process.stdout.cursorTo === 'function',
         isSkipLibs: !(isIncludeLibs || includedIssueTypes.classMembers),
         isStrict,
         isTrace: Boolean(parsedCLIArgs.trace ?? parsedCLIArgs['trace-file'] ?? parsedCLIArgs['trace-export']),

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

@@ -31,8 +31,5 @@ export const getIncludedIssueTypes = (options) => {
             ? _include
             : [..._include, ...defaultIssueTypes]
         : defaultIssueTypes).filter(group => !_exclude.includes(group));
-    return ISSUE_TYPES.filter(i => i !== '_files').reduce((types, group) => {
-        types[group] = included.includes(group);
-        return types;
-    }, {});
+    return Object.fromEntries(ISSUE_TYPES.map(group => [group, included.includes(group)]));
 };

package/dist/util/get-referenced-inputs.d.ts

@@ -1,5 +1,5 @@
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 import type { DependencyDeputy } from '../DependencyDeputy.js';
-import type { IssueCollector } from '../IssueCollector.js';
+import type { Issue } from '../types/issues.js';
 import { type Input } from './input.js';
-export declare const getReferencedInputsHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (s: string) => boolean) => (input: Input, workspace: Workspace) => string | undefined;
+export declare const getReferencedInputsHandler: (deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (s: string) => boolean, addIssue: (issue: Issue) => void) => (input: Input, workspace: Workspace) => string | undefined;

package/dist/util/get-referenced-inputs.js

@@ -7,7 +7,7 @@ import { _resolveSync } from './resolve.js';
 const getWorkspaceFor = (input, chief, workspace) => (input.dir && chief.findWorkspaceByFilePath(`${input.dir}/`)) ||
     (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) ||
     workspace;
-export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnored) => (input, workspace) => {
+export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue) => (input, workspace) => {
     const { specifier, containingFilePath } = input;
     if (!containingFilePath || IGNORED_RUNTIME_DEPENDENCIES.has(specifier))
         return;
@@ -17,7 +17,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
         const isHandled = deputy.maybeAddReferencedBinary(inputWorkspace, binaryName);
         if (isHandled || input.optional)
             return;
-        collector.addIssue({
+        addIssue({
             type: 'binaries',
             filePath: containingFilePath,
             workspace: workspace.name,
@@ -35,7 +35,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
             if (isWorkspace || isDependency(input)) {
                 if (!isHandled) {
                     if (!input.optional && ((deputy.isProduction && input.production) || !deputy.isProduction)) {
-                        collector.addIssue({
+                        addIssue({
                             type: 'unlisted',
                             filePath: containingFilePath,
                             workspace: inputWorkspace.name,
@@ -65,7 +65,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
     if (input.optional)
         return;
     if (!isInternal(filePath)) {
-        collector.addIssue({
+        addIssue({
             type: 'unlisted',
             filePath: containingFilePath,
             workspace: workspace.name,
@@ -75,7 +75,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
     }
     else if (!isGitIgnored(filePath)) {
         if (!isDeferResolveEntry(input) && !isConfig(input)) {
-            collector.addIssue({
+            addIssue({
                 type: 'unresolved',
                 filePath: containingFilePath,
                 workspace: workspace.name,

package/dist/util/has-strictly-ns-references.d.ts

@@ -1,4 +1,4 @@
 import type { ImportDetails, ModuleGraph } from '../types/module-graph.js';
 export declare const hasStrictlyEnumReferences: (importsForExport: ImportDetails | undefined, id: string) => boolean;
 export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportDetails | undefined, id: string) => [boolean, string?];
-export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "types" | "nsExports" | "nsTypes";
+export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";

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/to-source-path.d.ts

@@ -2,5 +2,5 @@ import type { CompilerOptions } from 'typescript';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions) => void;
 export declare const getToSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
-export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions?: string) => Promise<string[]>;
+export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions: string | undefined, label: string) => Promise<string[]>;
 export type ToSourceFilePath = ReturnType<typeof getToSourcePathHandler>;

package/dist/util/to-source-path.js

@@ -1,7 +1,7 @@
 import { DEFAULT_EXTENSIONS } from '../constants.js';
 import { debugLog, debugLogArray } from './debug.js';
 import { isDirectory } from './fs.js';
-import { _glob, _syncGlob } from './glob.js';
+import { _glob, _syncGlob, prependDirToPattern } from './glob.js';
 import { isAbsolute, isInternal, join, toRelative } from './path.js';
 const defaultExtensions = `.{${DEFAULT_EXTENSIONS.map(ext => ext.slice(1)).join(',')}}`;
 const hasTSExt = /(?<!\.d)\.(m|c)?tsx?$/;
@@ -35,10 +35,10 @@ export const getToSourcePathHandler = (chief) => {
     };
 };
 export const getToSourcePathsHandler = (chief) => {
-    return async (specifiers, dir, extensions = defaultExtensions) => {
+    return async (specifiers, dir, extensions = defaultExtensions, label) => {
         const patterns = new Set();
         for (const specifier of specifiers) {
-            const absSpecifier = isAbsolute(specifier) ? specifier : join(dir, specifier);
+            const absSpecifier = isAbsolute(specifier) ? specifier : prependDirToPattern(dir, specifier);
             const ws = chief.findWorkspaceByFilePath(absSpecifier);
             if (ws?.srcDir && ws.outDir && !absSpecifier.startsWith(ws.srcDir) && absSpecifier.startsWith(ws.outDir)) {
                 const pattern = absSpecifier.replace(ws.outDir, ws.srcDir).replace(matchExt, extensions);
@@ -48,7 +48,7 @@ export const getToSourcePathsHandler = (chief) => {
                 patterns.add(absSpecifier);
             }
         }
-        const filePaths = await _glob({ patterns: Array.from(patterns), cwd: dir });
+        const filePaths = await _glob({ patterns: Array.from(patterns), cwd: dir, label });
         debugLogArray(toRelative(dir, chief.cwd), 'Source mapping (package.json)', filePaths);
         return filePaths;
     };

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.66.0";
+export declare const version = "5.66.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.66.0';
+export const version = '5.66.2';

package/package.json

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

package/schema.json

@@ -98,6 +98,9 @@
             },
             "type": {
               "type": "boolean"
+            },
+            "variable": {
+              "type": "boolean"
             }
           }
         }