knip 6.6.2 → 6.6.3

package/dist/cli.js

@@ -74,7 +74,8 @@ const main = async () => {
         }
         if ((!args['no-exit-code'] && totalErrorCount > Number(args['max-issues'] ?? 0)) ||
             (!options.isDisableConfigHints && options.isTreatConfigHintsAsErrors && configurationHints.length > 0)) {
-            process.exit(1);
+            process.exitCode = 1;
+            return;
         }
     }
     catch (error) {
@@ -92,10 +93,11 @@ const main = async () => {
             }
             if (isConfigurationError(knownErrors[0]))
                 console.log('\nRun `knip --help` or visit https://knip.dev for help');
-            process.exit(2);
+            process.exitCode = 2;
+            return;
         }
         throw error;
     }
-    process.exit(0);
+    process.exitCode = 0;
 };
 await main();

package/dist/graph/analyze.js

@@ -1,6 +1,7 @@
 import { createGraphExplorer } from '../graph-explorer/explorer.js';
 import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
 import traceReporter from '../reporters/trace.js';
+import { shouldCountRefs } from '../typescript/visitors/helpers.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { perfObserver } from '../util/Performance.js';
 import { findMatch } from '../util/regex.js';
@@ -9,6 +10,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
     const explorer = createGraphExplorer(graph, entryPaths);
+    const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
     const isReferencedInUsedExport = (exportedItem, filePath, includeEntryExports, visited) => {
         if (!exportedItem.referencedIn)
             return false;
@@ -16,13 +18,15 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
         if (!file)
             return false;
         for (const containingExport of exportedItem.referencedIn) {
-            if (explorer.isReferenced(filePath, containingExport, { includeEntryExports })[0])
-                return true;
             const inExport = file.exports.get(containingExport);
             if (!inExport)
                 continue;
-            if (inExport.hasRefsInFile && (inExport.type === 'type' || inExport.type === 'interface'))
-                return true;
+            if (shouldCountRefs(ignoreExportsUsedInFile, inExport.type)) {
+                if (inExport.hasRefsInFile)
+                    return true;
+                if (explorer.isReferenced(filePath, containingExport, { includeEntryExports })[0])
+                    return true;
+            }
             if (inExport.referencedIn) {
                 const v = visited ?? new Set();
                 if (!v.has(containingExport)) {

package/dist/plugins/nuxt/types.d.ts

@@ -25,11 +25,11 @@ export interface NuxtConfig {
     css?: string[];
     alias?: Record<string, string>;
 }
-export interface TemplateExpressionNode {
+interface TemplateExpressionNode {
     content: string;
     isStatic: boolean;
 }
-export interface TemplateAstProp {
+interface TemplateAstProp {
     type: number;
     exp?: TemplateExpressionNode;
     arg?: TemplateExpressionNode;
@@ -41,7 +41,7 @@ export interface TemplateAstNode {
     content?: TemplateExpressionNode;
     children?: TemplateAstNode[];
 }
-export interface Descriptor {
+interface Descriptor {
     script: {
         content: string;
     } | null;
@@ -58,3 +58,4 @@ export type VueSfc = {
         descriptor: Descriptor;
     };
 };
+export {};

package/dist/plugins/raycast/types.d.ts

@@ -1,10 +1,11 @@
-export type RaycastManifestCommand = {
+type RaycastManifestCommand = {
     name?: unknown;
 };
-export type RaycastManifestTool = {
+type RaycastManifestTool = {
     name?: unknown;
 };
 export type RaycastManifest = {
     commands?: RaycastManifestCommand[];
     tools?: RaycastManifestTool[];
 };
+export {};

package/dist/reporters/trace.js

@@ -7,7 +7,7 @@ export default ({ graph, explorer, options, workspaceFilePathFilter }) => {
     if (options.traceDependency) {
         const pattern = toRegexOrString(options.traceDependency);
         const toRel = (path) => toRelative(path, options.cwd);
-        const table = new Table({ truncateStart: ['filePath'] });
+        const table = new Table({ truncate: { filePath: 'start' } });
         const seen = new Set();
         for (const [packageName, { imports }] of explorer.getDependencyUsage(pattern)) {
             const filtered = imports.filter(i => workspaceFilePathFilter(i.filePath));

package/dist/reporters/util/configuration-hints.js

@@ -17,7 +17,7 @@ const getIdentifier = (hint) => {
     return hint.identifier.toString();
 };
 const getTableForHints = (hints) => {
-    const table = new Table({ truncateStart: ['identifier', 'workspace', 'filePath'] });
+    const table = new Table({ truncate: { identifier: 'start', workspace: 'start', filePath: 'start' } });
     for (const hint of hints) {
         table.row();
         table.cell('identifier', getIdentifier(hint));

package/dist/reporters/util/util.js

@@ -41,7 +41,7 @@ const highlightSymbol = (issue) => (_) => {
     return symbol;
 };
 export const getTableForType = (issues, cwd, options = { isUseColors: true }) => {
-    const table = new Table({ truncateStart: ['filePath'], noTruncate: ['symbolType'] });
+    const table = new Table({ truncate: { filePath: 'start', symbolType: 'none' } });
     for (const issue of issues.sort(sortByPos)) {
         table.row();
         const print = options.isUseColors && (issue.isFixed || issue.severity === 'warn') ? dim : plain;

package/dist/types/config.d.ts

@@ -100,7 +100,7 @@ export type SourceMap = {
     srcDir: string;
     outDir: string;
 };
-export interface ResolveSourceMapOptions {
+interface ResolveSourceMapOptions {
     cwd: string;
     manifest: Manifest;
     dependencies: Set<string>;
@@ -109,7 +109,7 @@ export interface ResolveSourceMapOptions {
 }
 export type ResolveSourceMap = (options: ResolveSourceMapOptions) => Promise<SourceMap[]> | SourceMap[];
 export type HandleInput = (input: Input) => string | undefined;
-export type RegisterCompilerInput = {
+type RegisterCompilerInput = {
     extension: string;
     compiler: CompilerSync;
 };
@@ -117,7 +117,7 @@ export type RegisterCompiler = (input: RegisterCompilerInput) => void;
 export type ResolveFromAST = (program: Program, options: PluginOptions & {
     readFile: (filePath: string) => string;
 }) => Input[];
-export type RegisterCompilersOptions = {
+type RegisterCompilersOptions = {
     cwd: string;
     hasDependency: HasDependency;
     registerCompiler: RegisterCompiler;

package/dist/types/module-graph.d.ts

@@ -52,7 +52,7 @@ export interface ExportMember extends Position {
     readonly flags: number;
     hasRefsInFile: boolean;
 }
-export type ExportMap = Map<Identifier, Export>;
+type ExportMap = Map<Identifier, Export>;
 export type Imports = Set<Import>;
 export type FileNode = {
     imports: {

package/dist/typescript/visitors/walk.d.ts

@@ -63,7 +63,7 @@ export interface WalkState extends WalkContext {
     addExport: (identifier: string, type: SymbolType, pos: number, members: ExportMember[], fix: Fix, isReExport: boolean, jsDocTags: Set<string>) => void;
     getFix: (start: number, end: number, flags?: number) => Fix;
     getTypeFix: (start: number, end: number) => Fix;
-    collectRefsInType: (node: any, exportName: string, signatureOnly: boolean, inMember?: boolean) => void;
+    collectRefsInType: (node: any, exportName: string, signatureOnly: boolean) => void;
     addRefInExport: (name: string, exportName: string) => void;
     isInNamespace: (node: Span) => boolean;
 }

package/dist/typescript/visitors/walk.js

@@ -47,26 +47,17 @@ const _addExport = (identifier, type, pos, members, fix, isReExport, jsDocTags)
         });
     }
 };
-const MEMBER_CONTAINERS = new Set([
-    'TSPropertySignature',
-    'TSMethodSignature',
-    'TSIndexSignature',
-    'TSCallSignatureDeclaration',
-    'TSConstructSignatureDeclaration',
-]);
-const _collectRefsInType = (node, exportName, signatureOnly, inMember = false) => {
+const _collectRefsInType = (node, exportName, signatureOnly) => {
     if (!node || typeof node !== 'object')
         return;
     if (node.type === 'TSTypeQuery') {
-        if (inMember) {
-            const name = node.exprName.type === 'Identifier' ? node.exprName.name : undefined;
-            if (name) {
-                const refs = state.referencedInExport.get(name);
-                if (refs)
-                    refs.add(exportName);
-                else
-                    state.referencedInExport.set(name, new Set([exportName]));
-            }
+        const name = node.exprName.type === 'Identifier' ? node.exprName.name : undefined;
+        if (name) {
+            const refs = state.referencedInExport.get(name);
+            if (refs)
+                refs.add(exportName);
+            else
+                state.referencedInExport.set(name, new Set([exportName]));
         }
         return;
     }
@@ -80,7 +71,6 @@ const _collectRefsInType = (node, exportName, signatureOnly, inMember = false) =
         else
             state.referencedInExport.set(name, new Set([exportName]));
     }
-    const nextInMember = inMember || MEMBER_CONTAINERS.has(node.type);
     for (const key in node) {
         if (key === 'type' || key === 'parent')
             continue;
@@ -88,11 +78,11 @@ const _collectRefsInType = (node, exportName, signatureOnly, inMember = false) =
         if (Array.isArray(val)) {
             for (const item of val) {
                 if (item && typeof item === 'object' && item.type)
-                    _collectRefsInType(item, exportName, signatureOnly, nextInMember);
+                    _collectRefsInType(item, exportName, signatureOnly);
             }
         }
         else if (val && typeof val === 'object' && val.type) {
-            _collectRefsInType(val, exportName, signatureOnly, nextInMember);
+            _collectRefsInType(val, exportName, signatureOnly);
         }
     }
 };

package/dist/util/Performance.js

@@ -111,7 +111,7 @@ class Performance {
             table.cell('sum', stats.sum, twoFixed);
             table.cell('%', (stats.sum / totalDuration) * 100, v => (typeof v === 'number' ? `${v.toFixed(0)}%` : ''));
         }
-        table.sort('sum|desc');
+        table.sort('sum', 'desc');
         return table.toString();
     }
     addMemoryMark(label) {

package/dist/util/table.d.ts

@@ -1,20 +1,22 @@
 type Value = string | number | undefined | false | null;
+type TruncateMode = 'start' | 'end' | 'none';
+type SortOrder = 'asc' | 'desc';
 export declare class Table {
     private columns;
     private rows;
     private header;
     private maxWidth;
-    private truncateStart;
-    private noTruncate;
+    private truncateModes;
     constructor(options?: {
         maxWidth?: number;
         header?: boolean;
-        truncateStart?: string[];
-        noTruncate?: string[];
+        truncate?: Record<string, TruncateMode>;
     });
     row(): this;
     cell(column: string, value: Value, formatter?: (value: Value) => string): this;
-    sort(column: string): this;
+    sort(column: string, order?: SortOrder): this;
+    private modeFor;
+    private distributeWidths;
     toCells(): string[][];
     toRows(): string[];
     toString(): string;

package/dist/util/table.js

@@ -1,20 +1,20 @@
 import { stripVTControlCharacters } from 'node:util';
 import { pad, truncate, truncateStart } from './string.js';
-const DEFAULT_MAX_WIDTH = process.stdout.columns || 120;
 const MIN_TRUNCATED_WIDTH = 4;
 const COLUMN_SEPARATOR = '  ';
+const visibleLength = (text) => stripVTControlCharacters(text).length;
+const isPrintable = (value) => typeof value === 'string' || typeof value === 'number';
+const toDisplay = (value) => (isPrintable(value) ? String(value) : '');
 export class Table {
     columns = [];
     rows = [];
     header;
     maxWidth;
-    truncateStart = [];
-    noTruncate = [];
+    truncateModes;
     constructor(options) {
         this.header = options?.header ?? false;
-        this.maxWidth = options?.maxWidth || DEFAULT_MAX_WIDTH;
-        this.truncateStart = options?.truncateStart || [];
-        this.noTruncate = options?.noTruncate || [];
+        this.maxWidth = options?.maxWidth || process.stdout.columns || 120;
+        this.truncateModes = options?.truncate ?? {};
     }
     row() {
         this.rows.push({});
@@ -25,67 +25,103 @@ export class Table {
             this.columns.push(column);
         const row = this.rows[this.rows.length - 1];
         const align = typeof value === 'number' ? 'right' : 'left';
-        const formatted = formatter ? formatter(value) : undefined;
-        row[column] = { value, formatted, align };
+        const formatted = formatter?.(value);
+        const display = formatted ?? toDisplay(value);
+        row[column] = { value, formatted, align, width: visibleLength(display) };
         return this;
     }
-    sort(column) {
+    sort(column, order = 'asc') {
+        const dir = order === 'desc' ? -1 : 1;
         this.rows.sort((a, b) => {
-            const [columnName, order] = column.split('|');
-            const vA = a[columnName].value;
-            const vB = b[columnName].value;
+            const vA = a[column]?.value;
+            const vB = b[column]?.value;
             if (typeof vA === 'string' && typeof vB === 'string')
-                return (order === 'desc' ? -1 : 1) * vA.localeCompare(vB);
+                return dir * vA.localeCompare(vB);
             if (typeof vA === 'number' && typeof vB === 'number')
-                return order === 'desc' ? vB - vA : vA - vB;
-            return !vA ? 1 : !vB ? -1 : 0;
+                return dir * (vA - vB);
+            return !isPrintable(vA) ? 1 : !isPrintable(vB) ? -1 : 0;
         });
         return this;
     }
+    modeFor(column) {
+        return this.truncateModes[column] ?? 'end';
+    }
+    distributeWidths(columns, widths, separatorWidth) {
+        const truncatable = columns.filter(col => this.modeFor(col) !== 'none');
+        if (truncatable.length === 0)
+            return;
+        const reserved = columns.filter(col => this.modeFor(col) === 'none').reduce((sum, col) => sum + widths[col], 0);
+        const budget = Math.max(0, this.maxWidth - separatorWidth - reserved);
+        const original = {};
+        for (const col of truncatable)
+            original[col] = widths[col];
+        const unresolved = new Set(truncatable);
+        let remainingBudget = budget;
+        let changed = true;
+        while (changed && unresolved.size > 0) {
+            changed = false;
+            const share = Math.floor(remainingBudget / unresolved.size);
+            for (const col of unresolved) {
+                if (original[col] <= share) {
+                    widths[col] = original[col];
+                    remainingBudget -= original[col];
+                    unresolved.delete(col);
+                    changed = true;
+                }
+            }
+        }
+        if (unresolved.size === 0)
+            return;
+        const overMin = [...unresolved].reduce((sum, col) => sum + (original[col] - MIN_TRUNCATED_WIDTH), 0);
+        const excess = Math.max(0, remainingBudget - unresolved.size * MIN_TRUNCATED_WIDTH);
+        let distributed = 0;
+        for (const col of unresolved) {
+            const share = overMin > 0 ? Math.floor(((original[col] - MIN_TRUNCATED_WIDTH) * excess) / overMin) : 0;
+            widths[col] = MIN_TRUNCATED_WIDTH + share;
+            distributed += share;
+        }
+        const leftover = excess - distributed;
+        if (leftover > 0)
+            widths[[...unresolved][0]] += leftover;
+    }
     toCells() {
-        const columns = this.columns.filter(col => this.rows.some(row => typeof row[col].value === 'string' || typeof row[col].value === 'number'));
-        if (this.header) {
+        const columns = this.columns.filter(col => this.rows.some(row => isPrintable(row[col]?.value)));
+        const rows = [];
+        if (this.header && this.rows.length > 0) {
             const headerRow = {};
             const linesRow = {};
             for (const col of columns) {
-                headerRow[col] = { value: col, align: this.rows[0][col].align === 'right' ? 'center' : 'left' };
-                linesRow[col] = { value: '', fill: '-' };
+                const align = this.rows[0][col]?.align === 'right' ? 'center' : 'left';
+                headerRow[col] = { value: col, align, width: col.length };
+                linesRow[col] = { value: '', fill: '-', width: 0 };
             }
-            this.rows.unshift(linesRow);
-            this.rows.unshift(headerRow);
+            rows.push(headerRow, linesRow);
         }
-        const columnWidths = columns.reduce((acc, col) => {
-            acc[col] = Math.max(...this.rows.map(row => stripVTControlCharacters(row[col]?.formatted ?? String(row[col].value || '')).length));
-            return acc;
-        }, {});
-        const separatorWidth = (columns.length - 1) * COLUMN_SEPARATOR.length;
-        const totalWidth = Object.values(columnWidths).reduce((sum, width) => sum + width, 0) + separatorWidth;
-        if (totalWidth > this.maxWidth) {
-            const reservedWidth = columns
-                .filter(col => this.noTruncate.includes(col))
-                .reduce((sum, col) => sum + columnWidths[col], 0);
-            const truncatableColumns = columns.filter(col => !this.noTruncate.includes(col));
-            const minWidth = truncatableColumns.length * 4;
-            const availableWidth = this.maxWidth - separatorWidth - reservedWidth - minWidth;
-            const truncatableWidth = truncatableColumns.reduce((sum, col) => sum + columnWidths[col], 0) - minWidth;
-            const reduction = availableWidth / truncatableWidth;
-            let roundingDiff = availableWidth;
-            for (const col of truncatableColumns) {
-                const reducedWidth = MIN_TRUNCATED_WIDTH + Math.floor((columnWidths[col] - MIN_TRUNCATED_WIDTH) * reduction);
-                columnWidths[col] = reducedWidth;
-                roundingDiff -= reducedWidth - MIN_TRUNCATED_WIDTH;
-            }
-            if (roundingDiff > 0) {
-                columnWidths[truncatableColumns.length > 0 ? truncatableColumns[0] : columns[0]] += roundingDiff;
+        rows.push(...this.rows);
+        const columnWidths = {};
+        for (const col of columns) {
+            let max = 0;
+            for (const row of rows) {
+                const w = row[col]?.width ?? 0;
+                if (w > max)
+                    max = w;
             }
+            columnWidths[col] = max;
+        }
+        const separatorWidth = columns.length > 1 ? (columns.length - 1) * COLUMN_SEPARATOR.length : 0;
+        const totalWidth = columns.reduce((sum, col) => sum + columnWidths[col], 0) + separatorWidth;
+        if (totalWidth > this.maxWidth) {
+            this.distributeWidths(columns, columnWidths, separatorWidth);
         }
-        return this.rows.map(row => columns.map((col, index) => {
+        return rows.map(row => columns.map((col, index) => {
             const cell = row[col];
             const width = columnWidths[col];
-            const fill = cell.fill || ' ';
-            const padded = pad(String(cell.formatted || cell.value || ''), width, fill, cell.align);
-            const truncated = this.truncateStart.includes(col) ? truncateStart(padded, width) : truncate(padded, width);
-            return index === 0 ? truncated : COLUMN_SEPARATOR + truncated;
+            const fill = cell?.fill || ' ';
+            const display = cell?.formatted ?? toDisplay(cell?.value);
+            const padded = pad(display, width, fill, cell?.align);
+            const mode = this.modeFor(col);
+            const rendered = mode === 'none' ? padded : mode === 'start' ? truncateStart(padded, width) : truncate(padded, width);
+            return index === 0 ? rendered : COLUMN_SEPARATOR + rendered;
         }));
     }
     toRows() {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.6.2";
+export declare const version = "6.6.3";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.6.2';
+export const version = '6.6.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.6.2",
+  "version": "6.6.3",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",