knip 6.6.2 → 6.7.0

package/dist/ConsoleStreamer.d.ts

@@ -3,9 +3,13 @@ export declare class ConsoleStreamer {
     isEnabled: boolean;
     isWatch: boolean;
     private lines;
+    private stdoutBaseline;
+    private stderrBaseline;
     constructor(options: MainOptions);
     private clearLines;
     private clearScreen;
+    private snapshot;
+    private hadExternalWrites;
     private update;
     cast(message: string | string[], sub?: string): void;
     clear(): void;

package/dist/ConsoleStreamer.js

@@ -2,9 +2,12 @@ export class ConsoleStreamer {
     isEnabled = false;
     isWatch = false;
     lines = 0;
+    stdoutBaseline = 0;
+    stderrBaseline = 0;
     constructor(options) {
         this.isEnabled = options.isShowProgress;
         this.isWatch = options.isWatch;
+        this.snapshot();
     }
     clearLines(count) {
         if (count > 0) {
@@ -18,6 +21,14 @@ export class ConsoleStreamer {
     clearScreen() {
         process.stdout.write('\x1b[2J\x1b[1;1f');
     }
+    snapshot() {
+        this.stdoutBaseline = process.stdout.bytesWritten ?? 0;
+        this.stderrBaseline = process.stderr.bytesWritten ?? 0;
+    }
+    hadExternalWrites() {
+        return ((process.stdout.bytesWritten ?? 0) > this.stdoutBaseline ||
+            (process.stderr.bytesWritten ?? 0) > this.stderrBaseline);
+    }
     update(messages) {
         this.clear();
         process.stdout.write(`${messages.join('\n')}\n`);
@@ -26,17 +37,24 @@ export class ConsoleStreamer {
     cast(message, sub) {
         if (!this.isEnabled)
             return;
+        if (this.hadExternalWrites())
+            this.lines = 0;
         if (Array.isArray(message))
             this.update(message);
         else
             this.update([`${message}${!sub || sub === '.' ? '' : ` (${sub})`}…`]);
+        this.snapshot();
     }
     clear() {
         if (!this.isEnabled)
             return;
+        if (this.hadExternalWrites())
+            this.lines = 0;
         if (this.isWatch)
             this.clearScreen();
         else
             this.clearLines(this.lines);
+        this.lines = 0;
+        this.snapshot();
     }
 }

package/dist/IssueFixer.js

@@ -5,6 +5,7 @@ import { debugLogArray, debugLogObject } from './util/debug.js';
 import { load, save } from './util/package-json.js';
 import { extname, join } from './util/path.js';
 import { removeExport } from './util/remove-export.js';
+const MODULE_MARKER = /^[ \t]*(import|export)\b/m;
 export const fix = async (issues, counters, options) => {
     const fixer = new IssueFixer(options);
     const touchedFiles = await fixer.fixIssues(issues);
@@ -73,9 +74,13 @@ class IssueFixer {
             if (fixes.length === 0)
                 continue;
             const absFilePath = join(this.options.cwd, filePath);
-            const sourceFileText = fixes
+            const originalSource = await readFile(absFilePath, 'utf-8');
+            let sourceFileText = fixes
                 .sort((a, b) => b[0] - a[0])
-                .reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), await readFile(absFilePath, 'utf-8'));
+                .reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), originalSource);
+            if (MODULE_MARKER.test(originalSource) && !MODULE_MARKER.test(sourceFileText)) {
+                sourceFileText = `${sourceFileText.trimEnd()}\n\nexport {};\n`;
+            }
             await writeFile(absFilePath, sourceFileText);
             touchedFiles.add(absFilePath);
             for (const type of types) {

package/dist/WorkspaceWorker.js

@@ -15,8 +15,10 @@ import { isConfig, isDeferResolve, isDependency, toConfig, toDebugString, toEntr
 import { getPackageNameFromSpecifier } from './util/modules.js';
 import { getKeysByValue } from './util/object.js';
 import { timerify } from './util/Performance.js';
-import { basename, dirname, isInternal, join } from './util/path.js';
+import { basename, dirname, isInternal, join, toRelative } from './util/path.js';
 import { extractPatternExtensions } from './util/pattern-extensions.js';
+import { formatCauseMessage } from './util/errors.js';
+import { logError } from './util/log.js';
 import { loadConfigForPlugin } from './util/plugin.js';
 import { ELLIPSIS } from './util/string.js';
 const nullConfig = { config: null, entry: null, project: null };
@@ -327,15 +329,27 @@ export class WorkspaceWorker {
                     }
                     if (!cache.resolveConfig) {
                         const isLoad = typeof plugin.isLoadConfig === 'function' ? plugin.isLoadConfig(resolveOpts, this.dependencies) : true;
-                        const localConfig = isLoad && (await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName));
-                        if (localConfig) {
-                            const inputs = await plugin.resolveConfig(localConfig, resolveOpts);
-                            if (plugin.isFilterTransitiveDependencies && !isManifest) {
-                                this.filterTransitiveDependencies(inputs, configFilePath);
+                        if (isLoad) {
+                            try {
+                                const localConfig = await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName);
+                                if (localConfig) {
+                                    const inputs = await plugin.resolveConfig(localConfig, resolveOpts);
+                                    if (plugin.isFilterTransitiveDependencies && !isManifest) {
+                                        this.filterTransitiveDependencies(inputs, configFilePath);
+                                    }
+                                    for (const input of inputs)
+                                        addInput(input, configFilePath);
+                                    cache.resolveConfig = inputs;
+                                }
+                            }
+                            catch (error) {
+                                if (!(error instanceof Error))
+                                    throw error;
+                                const relPath = toRelative(configFilePath, this.options.cwd);
+                                const cause = formatCauseMessage(error, this.options.cwd);
+                                logError(`Error loading ${relPath} (${cause})`);
+                                logError('Please fix or visit https://knip.dev/reference/known-issues');
                             }
-                            for (const input of inputs)
-                                addInput(input, configFilePath);
-                            cache.resolveConfig = inputs;
                         }
                     }
                 }

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) {
@@ -82,7 +83,7 @@ const main = async () => {
         if (!args.debug && error instanceof Error && isKnownError(error)) {
             const knownErrors = getKnownErrors(error);
             for (const knownError of knownErrors)
-                logError('ERROR', knownError.message);
+                logError(knownError.message);
             if (hasErrorCause(knownErrors[0])) {
                 console.error('Reason:', knownErrors[0].cause.message);
                 if (isModuleNotFoundError(knownErrors[0].cause))
@@ -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/plugins/vitest/helpers.js

@@ -17,6 +17,7 @@ export const getEnvSpecifier = (env) => {
     return `vitest-environment-${env}`;
 };
 const builtInReporters = [
+    'agent',
     'basic',
     'blob',
     'default',
@@ -26,6 +27,7 @@ const builtInReporters = [
     'html',
     'json',
     'junit',
+    'minimal',
     'tap',
     'tap-flat',
     'tree',

package/dist/reporters/markdown.js

@@ -18,10 +18,12 @@ export default ({ report, issues, cwd }) => {
                 const longestSymbol = issuesForType.sort(sortLongestSymbol)[0].symbol.length;
                 const sortedByFilePath = issuesForType.sort(sortLongestFilePath);
                 const longestFilePath = getFilePath(sortedByFilePath[0]).length;
-                console.log(`| ${'Name'.padEnd(longestSymbol)} | ${'Location'.padEnd(longestFilePath)} | Severity |`);
-                console.log(`| :${'-'.repeat(longestSymbol - 1)} | :${'-'.repeat(longestFilePath - 1)} | :------- |`);
+                const nameWidth = Math.max(longestSymbol, 'Name'.length);
+                const locationWidth = Math.max(longestFilePath, 'Location'.length);
+                console.log(`| ${'Name'.padEnd(nameWidth)} | ${'Location'.padEnd(locationWidth)} | Severity |`);
+                console.log(`| :${'-'.repeat(nameWidth - 1)} | :${'-'.repeat(locationWidth - 1)} | :------- |`);
                 for (const issue of sortedByFilePath) {
-                    console.log(`| ${issue.symbol.padEnd(longestSymbol)} | ${getFilePath(issue).padEnd(longestFilePath)} | ${(issue.severity ?? '').padEnd(8)} |`);
+                    console.log(`| ${issue.symbol.padEnd(nameWidth)} | ${getFilePath(issue).padEnd(locationWidth)} | ${(issue.severity ?? '').padEnd(8)} |`);
                 }
                 console.log('');
             }

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/create-options.js

@@ -43,14 +43,14 @@ export const createOptions = async (options) => {
             if (invalid.length > 0) {
                 loadedConfig[key] = value.filter((v) => validIssueTypes.has(v));
                 for (const name of invalid)
-                    logWarning('WARNING', `Ignored unknown issue type "${name}" in ${key}`);
+                    logWarning(`Ignored unknown issue type "${name}" in ${key}`);
             }
         }
         else if (typeof value === 'object') {
             for (const name in value) {
                 if (!validIssueTypes.has(name)) {
                     delete value[name];
-                    logWarning('WARNING', `Ignored unknown issue type "${name}" in ${key}`);
+                    logWarning(`Ignored unknown issue type "${name}" in ${key}`);
                 }
             }
         }

package/dist/util/errors.d.ts

@@ -11,5 +11,6 @@ export declare const hasErrorCause: (error: Error) => error is ErrorWithCause;
 export declare const isConfigurationError: (error: Error) => error is ConfigurationError;
 export declare const isModuleNotFoundError: (error: Error) => boolean;
 export declare const isLoaderError: (error: Error) => error is LoaderError;
+export declare const formatCauseMessage: (error: Error, cwd: string) => string;
 export declare const getKnownErrors: (error: Error) => Error[];
 export {};

package/dist/util/errors.js

@@ -9,6 +9,12 @@ export const hasErrorCause = (error) => !isZodErrorLike(error) && error.cause in
 export const isConfigurationError = (error) => error instanceof ConfigurationError;
 export const isModuleNotFoundError = (error) => 'code' in error && error.code === 'MODULE_NOT_FOUND';
 export const isLoaderError = (error) => error instanceof LoaderError;
+export const formatCauseMessage = (error, cwd) => {
+    let root = error;
+    while (root.cause instanceof Error)
+        root = root.cause;
+    return root.message.split('\n', 1)[0].replace(`${cwd}/`, '');
+};
 export const getKnownErrors = (error) => {
     if (isZodErrorLike(error))
         return [...error.issues].map(error => {

package/dist/util/fs.js

@@ -54,7 +54,7 @@ export const hasFileWithExtension = (cwd, dirName, extensions) => {
     return false;
 };
 export const loadJSON = async (filePath) => {
-    const contents = await loadFile(filePath);
+    const contents = (await loadFile(filePath)).replace(/^/, '');
     try {
         return JSON.parse(contents);
     }

package/dist/util/log.d.ts

@@ -1,2 +1,2 @@
-export declare const logWarning: (prefix: string, message: string) => void;
-export declare const logError: (prefix: string, message: string) => void;
+export declare const logWarning: (message: string) => void;
+export declare const logError: (message: string) => void;

package/dist/util/log.js

@@ -1,7 +1,7 @@
 import st from './colors.js';
-export const logWarning = (prefix, message) => {
-    console.warn(`${st.yellow(prefix)}: ${message}`);
+export const logWarning = (message) => {
+    console.warn(`${st.yellow('WARNING')}: ${message}`);
 };
-export const logError = (prefix, message) => {
-    console.error(`${st.red(prefix)}: ${message}`);
+export const logError = (message) => {
+    console.error(`${st.red('ERROR')}: ${message}`);
 };

package/dist/util/map-workspaces.js

@@ -1,7 +1,9 @@
 import { readFile } from 'node:fs/promises';
 import { glob } from 'tinyglobby';
 import { partition } from './array.js';
+import { debugLog } from './debug.js';
 import { ConfigurationError } from './errors.js';
+import { logWarning } from './log.js';
 import { getPackageName } from './package-name.js';
 import { join } from './path.js';
 export default async function mapWorkspaces(cwd, workspaces) {
@@ -20,7 +22,7 @@ export default async function mapWorkspaces(cwd, workspaces) {
         const dir = join(cwd, name);
         const manifestPath = join(cwd, match);
         try {
-            const manifestStr = await readFile(manifestPath, 'utf8');
+            const manifestStr = (await readFile(manifestPath, 'utf8')).replace(/^/, '');
             const manifest = JSON.parse(manifestStr);
             const pkgName = getPackageName(manifest, dir);
             const pkg = { dir, name, pkgName, manifestPath, manifestStr, manifest };
@@ -31,8 +33,12 @@ export default async function mapWorkspaces(cwd, workspaces) {
                 throw new ConfigurationError(`Missing package name in ${manifestPath}`);
         }
         catch (error) {
-            if (error?.code === 'ENOENT')
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
                 debugLog('*', `Unable to load package.json for ${name}`);
+            }
+            else if (error instanceof SyntaxError) {
+                logWarning(`Skipping workspace ${name}: invalid JSON in ${manifestPath} (${error.message})`);
+            }
             else
                 throw error;
         }

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.7.0";

package/dist/version.js

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

package/package.json

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