knip 5.66.0 → 5.66.1

package/dist/ConfigurationChief.d.ts

@@ -644,13 +644,18 @@ export declare class ConfigurationChief {
         ignoreUnresolved: (string | RegExp)[];
     };
     getConfigForWorkspace(workspaceName: string, extensions?: string[]): {
+        bun?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        node?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        pnpm?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        yarn?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        typescript?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        jest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         angular?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         astro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         ava?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         babel?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         biome?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         bumpp?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        bun?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         c8?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         capacitor?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         changelogen?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -679,7 +684,6 @@ export declare class ConfigurationChief {
         hardhat?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         husky?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "i18next-parser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        jest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         karma?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         ladle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         lefthook?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -696,7 +700,6 @@ export declare class ConfigurationChief {
         nest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         netlify?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         next?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        node?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "node-modules-inspector"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         nodemon?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "npm-package-json-lint"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -709,7 +712,6 @@ export declare class ConfigurationChief {
         "playwright-ct"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "playwright-test"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         plop?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        pnpm?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         postcss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         preconstruct?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         prettier?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -744,7 +746,6 @@ export declare class ConfigurationChief {
         tsup?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tsx?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         typedoc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        typescript?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         unbuild?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         unocss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "vercel-og"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -757,7 +758,6 @@ export declare class ConfigurationChief {
         wireit?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         wrangler?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         xo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        yarn?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         yorkie?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         entry: string[];
         project: string[];

package/dist/ConsoleStreamer.d.ts

@@ -1,10 +1,11 @@
 import type { MainOptions } from './util/create-options.js';
 export declare class ConsoleStreamer {
     isEnabled: boolean;
+    isWatch: boolean;
     private lines;
     constructor(options: MainOptions);
     private clearLines;
-    private resetLines;
+    private clearScreen;
     private update;
     cast(message: string | string[], sub?: string): void;
     clear(): void;

package/dist/ConsoleStreamer.js

@@ -1,8 +1,10 @@
 export class ConsoleStreamer {
     isEnabled = false;
+    isWatch = false;
     lines = 0;
     constructor(options) {
-        this.isEnabled = options.isShowProgress;
+        this.isEnabled = options.isShowProgress && !options.isDebug;
+        this.isWatch = options.isWatch;
     }
     clearLines(count) {
         if (count > 0) {
@@ -13,11 +15,11 @@ export class ConsoleStreamer {
         }
         process.stdout.cursorTo(0);
     }
-    resetLines() {
-        this.clearLines(this.lines);
+    clearScreen() {
+        process.stdout.write('\x1b[2J\x1b[1;1f');
     }
     update(messages) {
-        this.resetLines();
+        this.clear();
         process.stdout.write(`${messages.join('\n')}\n`);
         this.lines = messages.length;
     }
@@ -32,6 +34,9 @@ export class ConsoleStreamer {
     clear() {
         if (!this.isEnabled)
             return;
-        this.resetLines();
+        if (this.isWatch)
+            this.clearScreen();
+        else
+            this.clearLines(this.lines);
     }
 }

package/dist/IssueCollector.d.ts

@@ -25,7 +25,7 @@ export declare class IssueCollector {
         unused: number;
     }): void;
     addFilesIssues(filePaths: string[]): void;
-    addIssue(issue: Issue): Issue | undefined;
+    addIssue(issue: Issue): true | undefined;
     addConfigurationHint(issue: ConfigurationHint): void;
     addTagHint(issue: TagHint): void;
     purge(): import("./types/issues.js").IssueSet;
@@ -35,4 +35,7 @@ export declare class IssueCollector {
         tagHints: Set<TagHint>;
         configurationHints: Set<ConfigurationHint>;
     };
+    private retainedIssues;
+    retainIssue(issue: Issue): void;
+    getRetainedIssues(): Issue[];
 }

package/dist/IssueCollector.js

@@ -99,7 +99,7 @@ export class IssueCollector {
             issues[key][symbol] = issue;
             this.counters[issue.type]++;
         }
-        return issue;
+        return true;
     }
     addConfigurationHint(issue) {
         const key = `${issue.workspaceName}::${issue.type}::${issue.identifier}`;
@@ -123,4 +123,11 @@ export class IssueCollector {
             configurationHints: new Set(this.configurationHints.values()),
         };
     }
+    retainedIssues = [];
+    retainIssue(issue) {
+        this.retainedIssues.push(issue);
+    }
+    getRetainedIssues() {
+        return this.retainedIssues;
+    }
 }

package/dist/compilers/index.d.ts

@@ -1166,10 +1166,10 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         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;
@@ -1179,15 +1179,8 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     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;

package/dist/constants.d.ts

@@ -1,4 +1,3 @@
-import type { IssueType } from './types/issues.js';
 export declare const ROOT_WORKSPACE_NAME = ".";
 export declare const IMPORT_STAR = "*";
 export declare const ANONYMOUS = "__anonymous";
@@ -16,8 +15,34 @@ export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
 export declare const FOREIGN_FILE_EXTENSIONS: Set<string>;
 export declare const IGNORE_DEFINITELY_TYPED: Set<string>;
-export declare const ISSUE_TYPES: IssueType[];
-export declare const ISSUE_TYPE_TITLE: Record<IssueType, string>;
+export declare const ISSUE_TYPES: readonly ["files", "dependencies", "devDependencies", "optionalPeerDependencies", "unlisted", "binaries", "unresolved", "exports", "nsExports", "types", "nsTypes", "enumMembers", "classMembers", "duplicates"];
+export declare const ISSUE_TYPE_TITLE: {
+    readonly files: "Unused files";
+    readonly _files: "Unused files";
+    readonly dependencies: "Unused dependencies";
+    readonly devDependencies: "Unused devDependencies";
+    readonly optionalPeerDependencies: "Referenced optional peerDependencies";
+    readonly unlisted: "Unlisted dependencies";
+    readonly binaries: "Unlisted binaries";
+    readonly unresolved: "Unresolved imports";
+    readonly exports: "Unused exports";
+    readonly nsExports: "Exports in used namespace";
+    readonly types: "Unused exported types";
+    readonly nsTypes: "Exported types in used namespace";
+    readonly enumMembers: "Unused exported enum members";
+    readonly classMembers: "Unused exported class members";
+    readonly duplicates: "Duplicate exports";
+};
+export declare const SYMBOL_TYPE: {
+    readonly CLASS: "class";
+    readonly ENUM: "enum";
+    readonly FUNCTION: "function";
+    readonly INTERFACE: "interface";
+    readonly MEMBER: "member";
+    readonly TYPE: "type";
+    readonly UNKNOWN: "unknown";
+    readonly VARIABLE: "variable";
+};
 export declare const FIX_FLAGS: {
     readonly NONE: 0;
     readonly OBJECT_BINDING: number;

package/dist/constants.js

@@ -190,6 +190,16 @@ export const ISSUE_TYPE_TITLE = {
     classMembers: 'Unused exported class members',
     duplicates: 'Duplicate exports',
 };
+export const SYMBOL_TYPE = {
+    CLASS: 'class',
+    ENUM: 'enum',
+    FUNCTION: 'function',
+    INTERFACE: 'interface',
+    MEMBER: 'member',
+    TYPE: 'type',
+    UNKNOWN: 'unknown',
+    VARIABLE: 'variable',
+};
 export const FIX_FLAGS = {
     NONE: 0,
     OBJECT_BINDING: 1 << 0,

package/dist/graph/build.js

@@ -18,7 +18,8 @@ export async function build({ chief, collector, deputy, factory, isGitIgnored, s
     const enabledPluginsStore = new Map();
     const toSourceFilePath = getToSourcePathHandler(chief);
     const toSourceFilePaths = getToSourcePathsHandler(chief);
-    const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
+    const addIssue = (issue) => collector.addIssue(issue) && options.isWatch && collector.retainIssue(issue);
+    const getReferencedInternalFilePath = getReferencedInputsHandler(deputy, chief, isGitIgnored, addIssue);
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);

package/dist/index.js

@@ -8,6 +8,7 @@ import { build } from './graph/build.js';
 import { IssueCollector } from './IssueCollector.js';
 import { IssueFixer } from './IssueFixer.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
+import watchReporter from './reporters/watch.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getWatchHandler } from './util/watch.js';
@@ -52,6 +53,9 @@ export const main = async (options) => {
     });
     if (options.isWatch) {
         const isIgnored = (filePath) => filePath.startsWith(options.cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
+        const onUpdate = options.isWatch
+            ? ({ issues, duration }) => watchReporter(options, { issues, streamer, size: analyzedFiles.size, duration })
+            : () => { };
         const watchHandler = await getWatchHandler(options, {
             analyzedFiles,
             analyzeSourceFile,
@@ -61,7 +65,7 @@ export const main = async (options) => {
             factory,
             graph,
             isIgnored,
-            streamer,
+            onUpdate,
             unreferencedFiles,
         });
         watch('.', { recursive: true }, watchHandler);

package/dist/plugins/nuxt/index.js

@@ -18,7 +18,11 @@ const production = [
 ];
 const setup = async () => {
     if (globalThis && !('defineNuxtConfig' in globalThis)) {
-        Object.defineProperty(globalThis, 'defineNuxtConfig', { value: (id) => id });
+        Object.defineProperty(globalThis, 'defineNuxtConfig', {
+            value: (id) => id,
+            writable: true,
+            configurable: true,
+        });
     }
 };
 const resolveConfig = async (localConfig) => {

package/dist/reporters/util/util.d.ts

@@ -1,9 +1,9 @@
 import { ISSUE_TYPE_TITLE } from '../../constants.js';
-import { type Issue, type IssueSeverity, type IssueSymbol } from '../../types/issues.js';
+import type { Issue, IssueSeverity, IssueSymbol } from '../../types/issues.js';
 import { Table } from '../../util/table.js';
 export declare const dim: import("picocolors/types.js").Formatter;
 export declare const bright: import("picocolors/types.js").Formatter;
-export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => string;
+export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => "Unused files" | "Unused dependencies" | "Unused devDependencies" | "Referenced optional peerDependencies" | "Unlisted dependencies" | "Unlisted binaries" | "Unresolved imports" | "Unused exports" | "Exports in used namespace" | "Unused exported types" | "Exported types in used namespace" | "Unused exported enum members" | "Unused exported class members" | "Duplicate exports";
 export declare const getColoredTitle: (title: string, count: number) => string;
 export declare const getDimmedTitle: (title: string, count: number) => string;
 type LogIssueLine = {

package/dist/reporters/util/util.js

@@ -1,6 +1,5 @@
 import picocolors from 'picocolors';
-import { ISSUE_TYPE_TITLE } from '../../constants.js';
-import { SymbolType } from '../../types/issues.js';
+import { ISSUE_TYPE_TITLE, SYMBOL_TYPE } from '../../constants.js';
 import { relative } from '../../util/path.js';
 import { Table } from '../../util/table.js';
 const plain = (text) => text;
@@ -47,7 +46,7 @@ export const getTableForType = (issues, cwd, options = { isUseColors: true }) =>
         const symbol = issue.symbols ? issue.symbols.map(s => s.symbol).join(', ') : issue.symbol;
         table.cell('symbol', print(symbol), options.isUseColors ? highlightSymbol(issue) : () => symbol);
         table.cell('parentSymbol', issue.parentSymbol && print(issue.parentSymbol));
-        table.cell('symbolType', issue.symbolType && issue.symbolType !== SymbolType.UNKNOWN && print(issue.symbolType));
+        table.cell('symbolType', issue.symbolType && issue.symbolType !== SYMBOL_TYPE.UNKNOWN && print(issue.symbolType));
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
         const cell = issue.type === 'files' ? '' : `${relative(cwd, issue.filePath)}${pos}`;
         table.cell('filePath', print(cell));

package/dist/reporters/watch.d.ts

@@ -4,8 +4,8 @@ import type { MainOptions } from '../util/create-options.js';
 interface WatchReporter {
     issues: Issues;
     streamer: ConsoleStreamer;
-    startTime?: number;
+    duration?: number;
     size: number;
 }
-declare const _default: (options: MainOptions, { issues, streamer, startTime, size }: WatchReporter) => void;
+declare const _default: (options: MainOptions, { issues, streamer, duration, size }: WatchReporter) => void;
 export default _default;

package/dist/reporters/watch.js

@@ -2,7 +2,7 @@ import picocolors from 'picocolors';
 import { perfObserver } from '../util/Performance.js';
 import { prettyMilliseconds } from '../util/string.js';
 import { getIssueTypeTitle, getTableForType } from './util/util.js';
-export default (options, { issues, streamer, startTime, size }) => {
+export default (options, { issues, streamer, duration, size }) => {
     const reportMultipleGroups = Object.values(options.includedIssueTypes).filter(Boolean).length > 1;
     let totalIssues = 0;
     const lines = [];
@@ -22,8 +22,8 @@ export default (options, { issues, streamer, startTime, size }) => {
         }
     }
     const mem = perfObserver.getCurrentMemUsageInMb();
-    const duration = perfObserver.getCurrentDurationInMs(startTime);
-    const summary = `${size} files in ${prettyMilliseconds(duration)} (${mem}MB)`;
+    const ms = duration ?? perfObserver.getCurrentDurationInMs();
+    const summary = `${size} files in ${prettyMilliseconds(ms)} (${mem}MB)`;
     const messages = totalIssues === 0
         ? ['✂️  Excellent, Knip found no issues.', '', picocolors.gray(summary)]
         : [...lines, '', picocolors.gray(summary)];

package/dist/schema/configuration.d.ts

@@ -1182,12 +1182,7 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
     ignoreMembers: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
     ignoreUnresolved: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
     ignoreExportsUsedInFile: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniObject<{
-        class: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        enum: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        function: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        interface: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        member: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        type: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        [k: string]: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     }, z.core.$strict>]>>;
     ignoreIssues: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"files">, z.ZodMiniLiteral<"dependencies">, z.ZodMiniLiteral<"devDependencies">, z.ZodMiniLiteral<"optionalPeerDependencies">, z.ZodMiniLiteral<"unlisted">, z.ZodMiniLiteral<"binaries">, z.ZodMiniLiteral<"unresolved">, z.ZodMiniLiteral<"exports">, z.ZodMiniLiteral<"types">, z.ZodMiniLiteral<"nsExports">, z.ZodMiniLiteral<"nsTypes">, z.ZodMiniLiteral<"duplicates">, z.ZodMiniLiteral<"enumMembers">, z.ZodMiniLiteral<"classMembers">]>>>>;
     ignoreWorkspaces: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;

package/dist/schema/configuration.js

@@ -1,4 +1,5 @@
 import { z } from 'zod/mini';
+import { SYMBOL_TYPE } from '../constants.js';
 import { globSchema, pluginsSchema } from './plugins.js';
 const pathsSchema = z.record(z.string(), z.array(z.string()));
 const syncCompilerSchema = z.union([z.literal(true), z.custom()]);
@@ -23,14 +24,8 @@ const issueTypeSchema = z.union([
     z.literal('classMembers'),
 ]);
 const rulesSchema = z.partialRecord(issueTypeSchema, z.enum(['error', 'warn', 'off']));
-const ignoreExportsUsedInFileObjectSchema = z.strictObject({
-    class: z.optional(z.boolean()),
-    enum: z.optional(z.boolean()),
-    function: z.optional(z.boolean()),
-    interface: z.optional(z.boolean()),
-    member: z.optional(z.boolean()),
-    type: z.optional(z.boolean()),
-});
+const ignorableSymbolTypes = Object.values(SYMBOL_TYPE).filter(type => type !== 'unknown');
+const ignoreExportsUsedInFileObjectSchema = z.strictObject(Object.fromEntries(ignorableSymbolTypes.map(type => [type, z.optional(z.boolean())])));
 const ignoreExportsUsedInFileSchema = z.union([z.boolean(), ignoreExportsUsedInFileObjectSchema]);
 const ignoreIssuesSchema = z.record(z.string(), z.array(issueTypeSchema));
 const rootConfigurationSchema = z.object({

package/dist/types/config.d.ts

@@ -23,7 +23,7 @@ export type BinaryResolver = (binary: string, args: string[], options: BinaryRes
 export type RawConfiguration = z.infer<typeof knipConfigurationSchema>;
 export type RawPluginConfiguration = z.infer<typeof pluginSchema>;
 export type IgnorePatterns = (string | RegExp)[];
-type IgnorableExport = Exclude<SymbolType, SymbolType.UNKNOWN>;
+type IgnorableExport = Exclude<SymbolType, 'unknown'>;
 export type IgnoreExportsUsedInFile = boolean | Partial<Record<IgnorableExport, boolean>>;
 export type IgnoreIssues = Record<string, IssueType[]>;
 export type GetImportsAndExportsOptions = {

package/dist/types/issues.d.ts

@@ -1,13 +1,5 @@
-export declare enum SymbolType {
-    VARIABLE = "variable",
-    TYPE = "type",
-    INTERFACE = "interface",
-    ENUM = "enum",
-    FUNCTION = "function",
-    CLASS = "class",
-    MEMBER = "member",
-    UNKNOWN = "unknown"
-}
+import type { SYMBOL_TYPE } from '../constants.js';
+export type SymbolType = (typeof SYMBOL_TYPE)[keyof typeof SYMBOL_TYPE];
 export type IssueSymbol = {
     symbol: string;
     pos?: number;

package/dist/types/issues.js

@@ -1,11 +1 @@
-export var SymbolType;
-(function (SymbolType) {
-    SymbolType["VARIABLE"] = "variable";
-    SymbolType["TYPE"] = "type";
-    SymbolType["INTERFACE"] = "interface";
-    SymbolType["ENUM"] = "enum";
-    SymbolType["FUNCTION"] = "function";
-    SymbolType["CLASS"] = "class";
-    SymbolType["MEMBER"] = "member";
-    SymbolType["UNKNOWN"] = "unknown";
-})(SymbolType || (SymbolType = {}));
+export {};

package/dist/typescript/ast-helpers.d.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import type { Fix } from '../types/exports.js';
-import { SymbolType } from '../types/issues.js';
+import type { SymbolType } from '../types/issues.js';
 export declare function isDefaultImport(node: ts.ImportDeclaration | ts.ImportEqualsDeclaration | ts.ExportDeclaration): boolean;
 export declare function isAccessExpression(node: ts.Node): node is ts.AccessExpression;
 export declare function isImportCall(node: ts.Node): node is ts.ImportCall;
@@ -12,14 +12,14 @@ export declare const getClassMember: (member: ts.MethodDeclaration | ts.Property
     node: ts.MethodDeclaration | ts.PropertyDeclaration;
     identifier: string;
     pos: number;
-    type: SymbolType;
+    type: "member";
     fix: Fix;
 };
 export declare const getEnumMember: (member: ts.EnumMember, isFixTypes: boolean) => {
     node: ts.EnumMember;
     identifier: string;
     pos: number;
-    type: SymbolType;
+    type: "member";
     fix: Fix;
 };
 export declare function stripQuotes(name: string): string;

package/dist/typescript/ast-helpers.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';
 function isGetOrSetAccessorDeclaration(node) {
     return node.kind === ts.SyntaxKind.SetAccessor || node.kind === ts.SyntaxKind.GetAccessor;
 }
@@ -34,20 +33,20 @@ export function isPropertyAccessCall(node, identifier) {
 }
 export const getNodeType = (node) => {
     if (!node)
-        return SymbolType.UNKNOWN;
+        return SYMBOL_TYPE.UNKNOWN;
     if (ts.isFunctionDeclaration(node))
-        return SymbolType.FUNCTION;
+        return SYMBOL_TYPE.FUNCTION;
     if (ts.isClassDeclaration(node))
-        return SymbolType.CLASS;
+        return SYMBOL_TYPE.CLASS;
     if (ts.isInterfaceDeclaration(node))
-        return SymbolType.INTERFACE;
+        return SYMBOL_TYPE.INTERFACE;
     if (ts.isTypeAliasDeclaration(node))
-        return SymbolType.TYPE;
+        return SYMBOL_TYPE.TYPE;
     if (ts.isEnumDeclaration(node))
-        return SymbolType.ENUM;
+        return SYMBOL_TYPE.ENUM;
     if (ts.isVariableDeclaration(node))
-        return SymbolType.VARIABLE;
-    return SymbolType.UNKNOWN;
+        return SYMBOL_TYPE.VARIABLE;
+    return SYMBOL_TYPE.UNKNOWN;
 };
 export const isNonPrivatePropertyOrMethodDeclaration = (member) => (ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member) || isGetOrSetAccessorDeclaration(member)) &&
     !isPrivateMember(member);
@@ -55,14 +54,14 @@ export const getClassMember = (member, isFixTypes) => ({
     node: member,
     identifier: member.name.getText(),
     pos: member.name.getStart() + (ts.isComputedPropertyName(member.name) ? 1 : 0),
-    type: SymbolType.MEMBER,
+    type: SYMBOL_TYPE.MEMBER,
     fix: isFixTypes ? [member.getStart(), member.getEnd(), FIX_FLAGS.NONE] : undefined,
 });
 export const getEnumMember = (member, isFixTypes) => ({
     node: member,
     identifier: stripQuotes(member.name.getText()),
     pos: member.name.getStart(),
-    type: SymbolType.MEMBER,
+    type: SYMBOL_TYPE.MEMBER,
     fix: isFixTypes
         ? [member.getStart(), member.getEnd(), FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.WITH_NEWLINE]
         : undefined,

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

@@ -1,12 +1,11 @@
 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 { isModule } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isModule, (node, { isFixExports, isFixTypes }) => {
     if (ts.isExportDeclaration(node)) {
         if (node.exportClause && ts.isNamedExports(node.exportClause)) {
-            const nodeType = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
+            const nodeType = node.isTypeOnly ? SYMBOL_TYPE.TYPE : SYMBOL_TYPE.UNKNOWN;
             const sourceFile = node.getSourceFile();
             const declarations = sourceFile.getNamedDeclarations?.();
             return node.exportClause.elements.map(element => {
@@ -14,8 +13,8 @@ export default visit(isModule, (node, { isFixExports, isFixTypes }) => {
                 const propName = element.propertyName?.text;
                 const symbol = declarations?.get(propName ?? identifier)?.[0]?.symbol;
                 const pos = element.name.pos;
-                const type = element.isTypeOnly ? SymbolType.TYPE : nodeType;
-                const fix = (isFixExports && type !== SymbolType.TYPE) || (isFixTypes && type === SymbolType.TYPE)
+                const type = element.isTypeOnly ? SYMBOL_TYPE.TYPE : nodeType;
+                const fix = (isFixExports && type !== SYMBOL_TYPE.TYPE) || (isFixTypes && type === SYMBOL_TYPE.TYPE)
                     ? [element.getStart(), element.getEnd(), FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.EMPTY_DECLARATION]
                     : undefined;
                 return { node: element, symbol, identifier, type, pos, fix };

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/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.1";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.66.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,6 +98,9 @@
             },
             "type": {
               "type": "boolean"
+            },
+            "variable": {
+              "type": "boolean"
             }
           }
         }