knip 5.63.0 → 5.64.0

package/dist/util/create-options.js

@@ -0,0 +1,112 @@
+import { partitionCompilers } from '../compilers/index.js';
+import { KNIP_CONFIG_LOCATIONS } from '../constants.js';
+import { knipConfigurationSchema } from '../schema/configuration.js';
+import { ConfigurationError } from './errors.js';
+import { findFile, loadJSON } from './fs.js';
+import { getIncludedIssueTypes, shorthandDeps, shorthandFiles, shorthandTypes } from './get-included-issue-types.js';
+import { defaultRules } from './issue-initializers.js';
+import { loadResolvedConfigFile } from './load-config.js';
+import { _load } from './loader.js';
+import { getKeysByValue } from './object.js';
+import { isAbsolute, join, normalize, toAbsolute, toPosix } from './path.js';
+import { splitTags } from './tag.js';
+const pcwd = process.cwd();
+export const createOptions = async (options) => {
+    const { parsedCLIArgs = {}, ...rest } = options;
+    const cwd = normalize(toPosix(toAbsolute(options.cwd ?? parsedCLIArgs.directory ?? pcwd, pcwd)));
+    const manifestPath = findFile(cwd, 'package.json');
+    const manifest = manifestPath && (await loadJSON(manifestPath));
+    if (!(manifestPath && manifest)) {
+        throw new ConfigurationError('Unable to find package.json');
+    }
+    let configFilePath;
+    for (const configPath of parsedCLIArgs.config ? [parsedCLIArgs.config] : KNIP_CONFIG_LOCATIONS) {
+        const resolvedConfigFilePath = isAbsolute(configPath) ? configPath : findFile(cwd, configPath);
+        if (resolvedConfigFilePath) {
+            configFilePath = resolvedConfigFilePath;
+            break;
+        }
+    }
+    if (parsedCLIArgs.config && !configFilePath && !manifest.knip) {
+        throw new ConfigurationError(`Unable to find ${parsedCLIArgs.config} or package.json#knip`);
+    }
+    const loadedConfig = Object.assign({}, manifest.knip, configFilePath ? await loadResolvedConfigFile(configFilePath, parsedCLIArgs) : {});
+    const parsedConfig = knipConfigurationSchema.parse(partitionCompilers(loadedConfig));
+    if (!configFilePath && manifest.knip)
+        configFilePath = manifestPath;
+    const pnpmWorkspacesPath = findFile(cwd, 'pnpm-workspace.yaml');
+    const pnpmWorkspaces = pnpmWorkspacesPath && (await _load(pnpmWorkspacesPath));
+    const workspaces = pnpmWorkspaces?.packages ??
+        (manifest.workspaces
+            ? Array.isArray(manifest.workspaces)
+                ? manifest.workspaces
+                : (manifest.workspaces.packages ?? [])
+            : []);
+    const isStrict = rest.isStrict ?? parsedCLIArgs.strict ?? false;
+    const isProduction = rest.isProduction ?? parsedCLIArgs.production ?? isStrict;
+    const rules = { ...defaultRules, ...parsedConfig.rules };
+    const excludesFromRules = getKeysByValue(rules, 'off');
+    const includedIssueTypes = getIncludedIssueTypes({
+        isProduction,
+        exclude: [...excludesFromRules, ...(parsedConfig.exclude ?? [])],
+        include: parsedConfig.include ?? [],
+        excludeOverrides: rest.excludedIssueTypes ?? parsedCLIArgs.exclude ?? [],
+        includeOverrides: [
+            ...(rest.includedIssueTypes ?? parsedCLIArgs.include ?? []),
+            ...(parsedCLIArgs.dependencies ? shorthandDeps : []),
+            ...(parsedCLIArgs.exports ? shorthandTypes : []),
+            ...(parsedCLIArgs.files ? shorthandFiles : []),
+        ],
+    });
+    const fixTypes = rest.fixTypes ?? parsedCLIArgs['fix-type'] ?? [];
+    const isFixFiles = parsedCLIArgs['allow-remove-files'] && (fixTypes.length === 0 || fixTypes.includes('files'));
+    const isIncludeLibs = parsedCLIArgs['include-libs'] ?? rest.isIncludeLibs ?? false;
+    const isReportClassMembers = includedIssueTypes.classMembers;
+    const tags = splitTags(parsedCLIArgs.tags ?? rest.tags ?? parsedConfig.tags ?? parsedCLIArgs['experimental-tags'] ?? []);
+    return {
+        cacheLocation: parsedCLIArgs['cache-location'] ?? join(cwd, 'node_modules', '.cache', 'knip'),
+        config: parsedCLIArgs.config,
+        configFilePath,
+        cwd,
+        dependencies: parsedCLIArgs.dependencies ?? false,
+        experimentalTags: tags,
+        exports: parsedCLIArgs.exports ?? false,
+        files: parsedCLIArgs.files ?? false,
+        fixTypes,
+        gitignore: parsedCLIArgs['no-gitignore'] ? false : (rest.gitignore ?? true),
+        includedIssueTypes,
+        isCache: parsedCLIArgs.cache ?? false,
+        isDebug: parsedCLIArgs.debug ?? false,
+        isDisableConfigHints: parsedCLIArgs['no-config-hints'] || isProduction || Boolean(parsedCLIArgs.workspace),
+        isFix: parsedCLIArgs.fix ?? rest.isFix ?? false,
+        isFixDependencies: fixTypes.length === 0 || fixTypes.includes('dependencies'),
+        isFixFiles,
+        isFixUnusedExports: fixTypes.length === 0 || fixTypes.includes('exports'),
+        isFixUnusedTypes: fixTypes.length === 0 || fixTypes.includes('types'),
+        isFormat: parsedCLIArgs.format ?? rest.isFormat ?? false,
+        isIncludeEntryExports: parsedCLIArgs['include-entry-exports'] ?? rest.isIncludeEntryExports ?? false,
+        isIsolateWorkspaces: rest.isIsolateWorkspaces ?? parsedCLIArgs['isolate-workspaces'] ?? false,
+        isProduction,
+        isReportClassMembers,
+        isReportDependencies: includedIssueTypes.dependencies ||
+            includedIssueTypes.unlisted ||
+            includedIssueTypes.unresolved ||
+            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',
+        isSkipLibs: !(isIncludeLibs || includedIssueTypes.classMembers),
+        isStrict,
+        isTrace: parsedCLIArgs.trace ?? false,
+        isTreatConfigHintsAsErrors: parsedCLIArgs['treat-config-hints-as-errors'] ?? parsedConfig.treatConfigHintsAsErrors ?? false,
+        isWatch: parsedCLIArgs.watch ?? rest.isWatch ?? false,
+        parsedConfig,
+        rules,
+        tags,
+        traceExport: parsedCLIArgs['trace-export'],
+        traceFile: parsedCLIArgs['trace-file'],
+        tsConfigFile: parsedCLIArgs.tsConfig,
+        workspace: rest.workspace ?? parsedCLIArgs.workspace,
+        workspaces,
+    };
+};

package/dist/util/debug.js

@@ -1,8 +1,7 @@
-import util from 'node:util';
+import util, { parseArgs } from 'node:util';
 import picocolors from 'picocolors';
-import parsedArgValues from './cli-arguments.js';
-const { debug } = parsedArgValues;
-const IS_DEBUG_ENABLED = debug ?? false;
+const { values } = parseArgs({ strict: false, options: { debug: { type: 'boolean' } } });
+const IS_DEBUG_ENABLED = values.debug ?? false;
 const IS_COLORS = !process.env.NO_COLOR;
 const noop = () => { };
 const inspectOptions = { maxArrayLength: null, depth: null, colors: IS_COLORS };

package/dist/util/errors.d.ts

@@ -6,7 +6,7 @@ export declare class ConfigurationError extends Error {
 }
 export declare class LoaderError extends Error {
 }
-export declare const isKnownError: (error: Error) => error is ConfigurationError | LoaderError | ZodError<any>;
+export declare const isKnownError: (error: Error) => error is ZodError<any> | ConfigurationError | LoaderError;
 export declare const isDisplayReason: (error: Error) => error is ErrorWithCause;
 export declare const isConfigurationError: (error: Error) => error is ConfigurationError;
 export declare const getKnownError: (error: Error) => Error;

package/dist/util/file-entry-cache.js

@@ -4,7 +4,7 @@ import { deserialize, serialize } from 'node:v8';
 import { timerify } from './Performance.js';
 import { debugLog } from './debug.js';
 import { isDirectory, isFile } from './fs.js';
-import { cwd, dirname, isAbsolute, resolve } from './path.js';
+import { dirname, isAbsolute, resolve } from './path.js';
 const createCache = (filePath) => {
     try {
         return deserialize(fs.readFileSync(filePath));
@@ -19,7 +19,7 @@ export class FileEntryCache {
     cache = new Map();
     normalizedEntries = new Map();
     constructor(cacheId, _path) {
-        this.filePath = isAbsolute(_path) ? path.resolve(_path, cacheId) : path.resolve(cwd, _path, cacheId);
+        this.filePath = path.resolve(_path, cacheId);
         if (isFile(this.filePath))
             this.cache = create(this.filePath);
         this.removeNotFoundFiles();
@@ -72,7 +72,7 @@ export class FileEntryCache {
     }
     removeEntry(entryName) {
         if (!isAbsolute(entryName))
-            entryName = resolve(cwd, entryName);
+            entryName = resolve(entryName);
         this.normalizedEntries.delete(entryName);
         this.cache.delete(entryName);
     }

package/dist/util/get-included-issue-types.d.ts

@@ -1,18 +1,14 @@
 import type { Report } from '../types/issues.js';
-export type CLIArguments = {
-    includedIssueTypes: string[];
-    excludedIssueTypes: string[];
-    isDependenciesShorthand: boolean;
-    isExportsShorthand: boolean;
-    isFilesShorthand: boolean;
-};
-type Options = {
+type GetIncludedIssueTypesOptions = {
     isProduction?: boolean;
-    include?: string[];
-    exclude?: string[];
-    dependencies?: boolean;
-    exports?: boolean;
+    include: string[];
+    exclude: string[];
+    includeOverrides?: string[];
+    excludeOverrides?: string[];
 };
 export declare const defaultExcludedIssueTypes: string[];
-export declare const getIncludedIssueTypes: (cliArgs: CLIArguments, { include, exclude, isProduction }?: Options) => Report;
+export declare const shorthandDeps: string[];
+export declare const shorthandTypes: string[];
+export declare const shorthandFiles: string[];
+export declare const getIncludedIssueTypes: (options: GetIncludedIssueTypesOptions) => Report;
 export {};

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

@@ -3,27 +3,21 @@ import { ConfigurationError } from './errors.js';
 export const defaultExcludedIssueTypes = ['classMembers', 'nsExports', 'nsTypes'];
 const defaultIssueTypes = ISSUE_TYPES.filter(type => !defaultExcludedIssueTypes.includes(type));
 const normalize = (values) => values.flatMap(value => value.split(','));
-export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {
-    let incl = normalize(cliArgs.includedIssueTypes);
-    const excl = normalize(cliArgs.excludedIssueTypes);
-    for (const type of [...incl, ...excl, ...include, ...exclude]) {
+export const shorthandDeps = ['dependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved'];
+export const shorthandTypes = ['types', 'nsTypes', 'enumMembers', 'duplicates'];
+export const shorthandFiles = ['files'];
+export const getIncludedIssueTypes = (options) => {
+    const incl = normalize(options.includeOverrides ?? []);
+    const excl = normalize(options.excludeOverrides ?? []);
+    for (const type of [...incl, ...excl, ...options.include, ...options.exclude]) {
         if (!ISSUE_TYPES.includes(type))
             throw new ConfigurationError(`Invalid issue type: ${type}`);
     }
-    const excludes = exclude.filter(exclude => !incl.includes(exclude));
-    const includes = include.filter(include => !excl.includes(include));
-    if (cliArgs.isDependenciesShorthand) {
-        incl = [...incl, 'dependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved'];
-    }
-    if (cliArgs.isExportsShorthand) {
-        incl = [...incl, 'exports', 'types', 'enumMembers', 'duplicates'];
-    }
-    if (cliArgs.isFilesShorthand) {
-        incl = [...incl, 'files'];
-    }
+    const excludes = options.exclude.filter(exclude => !incl.includes(exclude));
+    const includes = options.include.filter(include => !excl.includes(include));
     const _include = [...incl, ...includes];
     const _exclude = [...excl, ...excludes];
-    if (isProduction) {
+    if (options.isProduction) {
         _exclude.push('devDependencies');
     }
     else {

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

@@ -83,7 +83,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
             });
         }
         else {
-            debugLog(workspace.name, `Unable to resolve ${toDebugString(input)}`);
+            debugLog(workspace.name, `Unable to resolve ${toDebugString(input, chief.cwd)}`);
         }
     }
 };

package/dist/util/input.d.ts

@@ -54,5 +54,5 @@ export declare const toAlias: (specifier: string, prefix: string | string[], opt
 export declare const isAlias: (input: Input) => input is AliasInput;
 export declare const toIgnore: (specifier: string, issueType: IssueType) => IgnoreInput;
 export declare const isIgnore: (input: Input) => input is IgnoreInput;
-export declare const toDebugString: (input: Input) => string;
+export declare const toDebugString: (input: Input, cwd: string) => string;
 export {};

package/dist/util/input.js

@@ -67,4 +67,4 @@ export const toIgnore = (specifier, issueType) => ({
     issueType,
 });
 export const isIgnore = (input) => input.type === 'ignore';
-export const toDebugString = (input) => `${input.type}:${isAbsolute(input.specifier) ? toRelative(input.specifier) : input.specifier}${input.containingFilePath ? ` (${toRelative(input.containingFilePath)})` : ''}`;
+export const toDebugString = (input, cwd) => `${input.type}:${isAbsolute(input.specifier) ? toRelative(input.specifier, cwd) : input.specifier}${input.containingFilePath ? ` (${toRelative(input.containingFilePath, cwd)})` : ''}`;

package/dist/util/is-identifier-referenced.d.ts

@@ -5,5 +5,5 @@ type Result = {
     reExportingEntryFile: undefined | string;
     traceNode: TraceNode;
 };
-export declare const getIsIdentifierReferencedHandler: (graph: ModuleGraph, entryPaths: Set<string>) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
+export declare const getIsIdentifierReferencedHandler: (graph: ModuleGraph, entryPaths: Set<string>, isTrace: boolean) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
 export {};

package/dist/util/is-identifier-referenced.js

@@ -1,6 +1,6 @@
 import { IMPORT_STAR } from '../constants.js';
-import { addNodes, createNode, isTrace } from './trace.js';
-export const getIsIdentifierReferencedHandler = (graph, entryPaths) => {
+import { addNodes, createNode } from './trace.js';
+export const getIsIdentifierReferencedHandler = (graph, entryPaths, isTrace) => {
     const isIdentifierReferenced = (filePath, id, isIncludeEntryExports = false, traceNode = createNode(filePath), seen = new Set()) => {
         let isReferenced = false;
         let reExportingEntryFile = entryPaths.has(filePath) ? filePath : undefined;

package/dist/util/load-config.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedCLIArgs } from './cli-arguments.js';
+export declare function loadResolvedConfigFile(configPath: string, options: ParsedCLIArgs): Promise<any>;

package/dist/util/load-config.js

@@ -0,0 +1,24 @@
+import { debugLogObject } from './debug.js';
+import { ConfigurationError } from './errors.js';
+import { _load } from './loader.js';
+const unwrapFunction = async (maybeFunction, options) => {
+    if (typeof maybeFunction === 'function') {
+        try {
+            return await maybeFunction(options);
+        }
+        catch (error) {
+            debugLogObject('*', 'Error executing function:', error);
+            throw error;
+        }
+    }
+    return maybeFunction;
+};
+export async function loadResolvedConfigFile(configPath, options) {
+    const loadedValue = await _load(configPath);
+    try {
+        return await unwrapFunction(loadedValue, options);
+    }
+    catch (_error) {
+        throw new ConfigurationError(`Error running the function from ${configPath}`);
+    }
+}

package/dist/util/modules.js

@@ -38,13 +38,24 @@ export const getPackageFromDefinitelyTyped = (typedDependency) => {
     }
     return typedDependency;
 };
-const matchDirectives = /^([?!|-]+)?([^!?:]+).*/;
 export const sanitizeSpecifier = (specifier) => {
-    if (isBuiltin(specifier))
+    if (isBuiltin(specifier) || isAbsolute(specifier) || specifier.startsWith(PROTOCOL_VIRTUAL))
         return specifier;
-    if (isAbsolute(specifier))
-        return specifier;
-    if (specifier.startsWith(PROTOCOL_VIRTUAL))
-        return specifier;
-    return specifier.replace(matchDirectives, '$2');
+    let s = specifier;
+    let end = s.length;
+    let i = 0;
+    while (i < s.length && (s[i] === '!' || s[i] === '-'))
+        i++;
+    s = s.substring(i);
+    for (let j = 0; j < s.length; j++) {
+        const char = s[j];
+        if (char === '!' || char === '?' || (char === '#' && j > 0)) {
+            end = j;
+            break;
+        }
+    }
+    s = s.substring(0, end);
+    if (s.includes(':') && !s.includes('/'))
+        s = s.split(':')[0];
+    return s;
 };

package/dist/util/path.d.ts

@@ -4,10 +4,10 @@ export declare const extname: (path: string) => string;
 export declare const basename: (path: string, suffix?: string) => string;
 export declare const join: (...paths: string[]) => string;
 export declare const toPosix: (value: string) => string;
-export declare const cwd: string;
 export declare const resolve: (...paths: string[]) => string;
-export declare const relative: (from: string, to?: string) => string;
+export declare const relative: (from: string, to: string) => string;
 export declare const isInNodeModules: (filePath: string) => boolean;
-export declare const toAbsolute: (id: string, base?: string) => string;
-export declare const toRelative: (id: string) => string;
+export declare const toAbsolute: (id: string, base: string) => string;
+export declare const toRelative: (id: string, base: string) => string;
 export declare const isInternal: (id: string) => boolean;
+export declare const normalize: (path: string) => string;

package/dist/util/path.js

@@ -1,16 +1,14 @@
 import path from 'node:path';
-import parsedArgValues from './cli-arguments.js';
-const { directory } = parsedArgValues;
 export const isAbsolute = path.isAbsolute;
 export const dirname = path.posix.dirname;
 export const extname = path.posix.extname;
 export const basename = path.posix.basename;
 export const join = path.posix.join;
 export const toPosix = (value) => value.split(path.sep).join(path.posix.sep);
-export const cwd = directory ? path.posix.resolve(directory) : toPosix(process.cwd());
-export const resolve = (...paths) => paths.length === 1 ? path.posix.join(cwd, paths[0]) : path.posix.resolve(...paths);
-export const relative = (from, to) => toPosix(path.relative(to ? from : cwd, to ?? from));
+export const resolve = path.posix.resolve;
+export const relative = (from, to) => toPosix(path.relative(from, to));
 export const isInNodeModules = (filePath) => filePath.includes('node_modules');
-export const toAbsolute = (id, base = cwd) => (isAbsolute(id) ? id : join(base, id));
-export const toRelative = (id) => (isAbsolute(id) ? relative(id) : id);
+export const toAbsolute = (id, base) => (isAbsolute(id) ? id : join(base, id));
+export const toRelative = (id, base) => (isAbsolute(id) ? relative(base, id) : id);
 export const isInternal = (id) => (id.startsWith('.') || isAbsolute(id)) && !isInNodeModules(id);
+export const normalize = path.posix.normalize;

package/dist/util/require.js

@@ -1,5 +1,4 @@
 import { createRequire } from 'node:module';
 import { timerify } from './Performance.js';
-import { cwd } from './path.js';
-const require = createRequire(cwd);
+const require = createRequire(process.cwd());
 export const _require = timerify(require);

package/dist/util/tag.d.ts

@@ -1,4 +1,4 @@
-import type { Tags } from '../types/cli.js';
+import type { Tags } from '../types/options.js';
 export declare const splitTags: (rawTags: string[]) => Tags;
 export declare const shouldIgnore: (jsDocTags: Set<string>, tags: Tags) => boolean;
 export declare const getShouldIgnoreHandler: (isProduction: boolean) => (jsDocTags: Set<string>) => boolean;

package/dist/util/to-source-path.d.ts

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

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

@@ -27,7 +27,7 @@ export const getToSourcePathHandler = (chief) => {
                 const srcFilePath = _syncGlob({ patterns: pattern })[0];
                 toSourceMapCache.set(filePath, srcFilePath);
                 if (srcFilePath && srcFilePath !== filePath) {
-                    debugLog('*', `Source mapping ${toRelative(filePath)} → ${toRelative(srcFilePath)}`);
+                    debugLog('*', `Source mapping ${toRelative(filePath, chief.cwd)} → ${toRelative(srcFilePath, chief.cwd)}`);
                     return srcFilePath;
                 }
             }
@@ -35,10 +35,10 @@ export const getToSourcePathHandler = (chief) => {
     };
 };
 export const getToSourcePathsHandler = (chief) => {
-    return async (specifiers, cwd, extensions = defaultExtensions) => {
+    return async (specifiers, dir, extensions = defaultExtensions) => {
         const patterns = new Set();
         for (const specifier of specifiers) {
-            const absSpecifier = isAbsolute(specifier) ? specifier : join(cwd, specifier);
+            const absSpecifier = isAbsolute(specifier) ? specifier : join(dir, specifier);
             const ws = chief.findWorkspaceByFilePath(absSpecifier);
             if (ws?.srcDir && ws.outDir && !absSpecifier.startsWith(ws.srcDir) && absSpecifier.startsWith(ws.outDir)) {
                 const pattern = absSpecifier.replace(ws.outDir, ws.srcDir).replace(matchExt, extensions);
@@ -48,8 +48,8 @@ export const getToSourcePathsHandler = (chief) => {
                 patterns.add(absSpecifier);
             }
         }
-        const filePaths = await _glob({ patterns: Array.from(patterns), cwd });
-        debugLogArray(toRelative(cwd), 'Source mapping (package.json)', filePaths);
+        const filePaths = await _glob({ patterns: Array.from(patterns), cwd: dir });
+        debugLogArray(toRelative(dir, chief.cwd), 'Source mapping (package.json)', filePaths);
         return filePaths;
     };
 };

package/dist/util/trace.d.ts

@@ -1,11 +1,11 @@
 import type { ModuleGraph } from '../types/module-graph.js';
-declare const isTrace: boolean;
-type CreateNode = {
+import type { MainOptions } from './create-options.js';
+type CreateNodeOpts = {
     identifier?: string;
     hasRef?: boolean;
     isEntry?: boolean;
 };
-type Create = (filePath: string, options?: CreateNode) => TraceNode;
+type Create = (filePath: string, options?: CreateNodeOpts) => TraceNode;
 export type TraceNode = {
     filePath: string;
     identifier?: string;
@@ -13,8 +13,8 @@ export type TraceNode = {
     isEntry: boolean;
     children: Set<TraceNode>;
 };
-export { isTrace };
-export declare const printTrace: (node: TraceNode, filePath: string, identifier?: string) => void;
+export declare const printTrace: (node: TraceNode, filePath: string, options: MainOptions, identifier?: string) => void;
 export declare const createNode: Create;
 export declare const addNodes: (node: TraceNode, id: string, importedSymbols: ModuleGraph, filePaths?: Set<string>) => void;
-export declare const createAndPrintTrace: (filePath: string, options?: CreateNode) => void;
+export declare const createAndPrintTrace: (filePath: string, options: MainOptions, opts?: CreateNodeOpts) => void;
+export {};

package/dist/util/trace.js

@@ -1,12 +1,8 @@
 import picocolors from 'picocolors';
-import parsedArgValues from './cli-arguments.js';
 import { toAbsolute, toRelative } from './path.js';
 const IS_ENTRY = ' ◯';
 const HAS_REF = ' ✓';
 const HAS_NO_REF = ' x';
-const { 'trace-export': traceExport, 'trace-file': traceFile, trace } = parsedArgValues;
-const isTrace = Boolean(trace || traceExport || traceFile);
-export { isTrace };
 const getPadding = (level, levels) => {
     let padding = '';
     for (let i = 0; i < level; i++)
@@ -20,7 +16,7 @@ const renderTrace = (node, level = 0, levels = new Set()) => {
     for (const child of node.children) {
         const isLast = ++index === size;
         const hasRef = child.hasRef === true;
-        const rel = toRelative(child.filePath);
+        const rel = child.filePath;
         const file = hasRef ? rel : picocolors.dim(rel);
         const suffix = (hasRef ? HAS_REF : '') + (child.isEntry ? IS_ENTRY : '');
         const text = `${padding}${picocolors.dim(isLast ? '└─' : '├─')} ${file}${suffix}`;
@@ -34,19 +30,19 @@ const renderTrace = (node, level = 0, levels = new Set()) => {
         }
     }
 };
-export const printTrace = isTrace
-    ? (node, filePath, identifier) => {
-        if (traceExport && identifier && identifier !== traceExport)
-            return;
-        if (traceFile && filePath !== toAbsolute(traceFile))
-            return;
-        const suffix = (node.isEntry ? IS_ENTRY : '') + (node.children.size === 0 ? HAS_NO_REF : '');
-        const header = `${toRelative(filePath)}${identifier ? `:${identifier}` : ''}${suffix}`;
-        console.log(header);
-        renderTrace(node);
-        console.log();
-    }
-    : () => { };
+export const printTrace = (node, filePath, options, identifier) => {
+    if (!options.isTrace)
+        return;
+    if (options.traceExport && identifier && identifier !== options.traceExport)
+        return;
+    if (options.traceFile && filePath !== toAbsolute(options.traceFile, options.cwd))
+        return;
+    const suffix = (node.isEntry ? IS_ENTRY : '') + (node.children.size === 0 ? HAS_NO_REF : '');
+    const header = `${toRelative(filePath, options.cwd)}${identifier ? `:${identifier}` : ''}${suffix}`;
+    console.log(header);
+    renderTrace(node);
+    console.log();
+};
 export const createNode = (filePath, { hasRef = false, isEntry = false, identifier } = {}) => ({
     filePath,
     identifier,
@@ -66,9 +62,9 @@ export const addNodes = (node, id, importedSymbols, filePaths) => {
         addNode(node, filePath, { hasRef: Boolean(importedSymbols.get(filePath)?.traceRefs?.has(id)) });
     }
 };
-export const createAndPrintTrace = (filePath, options = {}) => {
-    if (!isTrace || traceExport || traceFile)
+export const createAndPrintTrace = (filePath, options, opts = {}) => {
+    if (!options.isTrace)
         return;
-    const traceNode = createNode(filePath, options);
-    printTrace(traceNode, filePath, options.identifier);
+    const traceNode = createNode(filePath, opts);
+    printTrace(traceNode, filePath, options, opts.identifier);
 };

package/dist/util/watch.d.ts

@@ -4,22 +4,19 @@ 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 { Report } from '../types/issues.js';
 import type { ModuleGraph } from '../types/module-graph.js';
+import type { MainOptions } from './create-options.js';
 type Watch = {
     analyzedFiles: Set<string>;
     analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
     chief: ConfigurationChief;
     collector: IssueCollector;
     analyze: () => Promise<void>;
-    cwd: string;
     factory: PrincipalFactory;
     graph: ModuleGraph;
-    isDebug: boolean;
     isIgnored: (path: string) => boolean;
-    report: Report;
     streamer: ConsoleStreamer;
     unreferencedFiles: Set<string>;
 };
-export declare const getWatchHandler: ({ analyzedFiles, analyzeSourceFile, chief, collector, analyze, cwd, factory, graph, isDebug, isIgnored, report, streamer, unreferencedFiles, }: Watch) => Promise<WatchListener<string | Buffer<ArrayBufferLike>>>;
+export declare const getWatchHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, streamer, unreferencedFiles, }: Watch) => Promise<WatchListener<string | Buffer<ArrayBufferLike>>>;
 export {};

package/dist/util/watch.js

@@ -3,16 +3,16 @@ 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 ({ analyzedFiles, analyzeSourceFile, chief, collector, analyze, cwd, factory, graph, isDebug, isIgnored, report, streamer, unreferencedFiles, }) => {
+export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, streamer, unreferencedFiles, }) => {
     const reportIssues = async (startTime) => {
         const { issues } = collector.getIssues();
-        watchReporter({ report, issues, streamer, startTime, size: analyzedFiles.size, isDebug });
+        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(cwd, toPosix(filename));
+            const filePath = join(options.cwd, toPosix(filename));
             if (isIgnored(filePath)) {
                 debugLog('*', `ignoring ${eventType} ${filename}`);
                 return;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.63.0";
+export declare const version = "5.64.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.63.0';
+export const version = '5.64.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.63.0",
+  "version": "5.64.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -63,12 +63,12 @@
     "jiti": "^2.5.1",
     "js-yaml": "^4.1.0",
     "minimist": "^1.2.8",
-    "oxc-resolver": "^11.6.2",
+    "oxc-resolver": "^11.8.2",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.1",
     "smol-toml": "^1.4.1",
     "strip-json-comments": "5.0.2",
-    "zod": "^3.22.4",
+    "zod": "^3.25.0",
     "zod-validation-error": "^3.0.3"
   },
   "peerDependencies": {
@@ -86,7 +86,7 @@
     "@wdio/types": "^9.16.2",
     "codeclimate-types": "^0.3.1",
     "glob": "^11.0.2",
-    "release-it": "^19.0.4",
+    "release-it": "^19.0.5",
     "tsx": "^4.20.3",
     "typescript": "^5.5.2"
   },