knip 5.66.0 → 5.66.2

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);
@@ -77,7 +78,8 @@ export async function build({ chief, collector, deputy, factory, isGitIgnored, s
         collector.addIgnorePatterns(config.ignore.map(p => join(options.cwd, prependDirToPattern(name, p))));
         collector.addIgnoreFilesPatterns(config.ignoreFiles.map(p => join(options.cwd, prependDirToPattern(name, p))));
         const entrySpecifiersFromManifest = getEntrySpecifiersFromManifest(manifest);
-        for (const filePath of await toSourceFilePaths(entrySpecifiersFromManifest, dir, extensionGlobStr)) {
+        const label = 'entry paths from package.json';
+        for (const filePath of await toSourceFilePaths(entrySpecifiersFromManifest, dir, extensionGlobStr, label)) {
             inputs.add(toProductionEntry(filePath));
         }
         for (const identifier of entrySpecifiersFromManifest) {

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/plugins/rsbuild/index.js

@@ -1,25 +1,25 @@
-import { toEntry } from '../../util/input.js';
+import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Rsbuild';
 const enablers = ['@rsbuild/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rsbuild*.config.{mjs,ts,js,cjs,mts,cts}'];
 const resolveConfig = async (config) => {
-    const inputs = new Set();
+    const entries = new Set();
     const checkSource = (source) => {
         if (source?.entry) {
             for (const entry of Object.values(source.entry)) {
                 if (typeof entry === 'string')
-                    inputs.add(toEntry(entry));
+                    entries.add(entry);
                 else if (Array.isArray(entry))
                     for (const e of entry)
-                        inputs.add(toEntry(e));
+                        entries.add(e);
                 else {
                     if (typeof entry.import === 'string')
-                        inputs.add(toEntry(entry.import));
+                        entries.add(entry.import);
                     else if (Array.isArray(entry.import))
                         for (const e of entry.import)
-                            inputs.add(toEntry(e));
+                            entries.add(e);
                 }
             }
         }
@@ -30,7 +30,7 @@ const resolveConfig = async (config) => {
             checkSource(environment.source);
         }
     }
-    return Array.from(inputs);
+    return Array.from(entries).map(input => toProductionEntry(input));
 };
 export default {
     title,

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 };