knip 5.51.0 → 5.52.0

package/dist/ConfigurationChief.js

@@ -307,7 +307,7 @@ export class ConfigurationChief {
     getNegatedWorkspacePatterns(name) {
         const descendentWorkspaces = this.getDescendentWorkspaces(name);
         const matchName = new RegExp(`^${name}/`);
-        const ignoredWorkspaces = this.getIgnoredWorkspacesFor(name);
+        const ignoredWorkspaces = this.getIgnoredWorkspacesFor(name).map(p => p.replace(/\/\*$/, '/**'));
         return [...ignoredWorkspaces, ...descendentWorkspaces]
             .map(workspaceName => workspaceName.replace(matchName, ''))
             .map(workspaceName => `!${workspaceName}`);

package/dist/WorkspaceWorker.js

@@ -236,7 +236,7 @@ export class WorkspaceWorker {
                     addInput(toInput(id));
             }
             else if ((!plugin.resolveEntryPaths && !plugin.resolveFromAST) ||
-                (configFilePaths.length === 0 &&
+                (configFilePaths.filter(path => basename(path) !== 'package.json').length === 0 &&
                     (!this.configFilesMap.get(wsName)?.get(pluginName) ||
                         this.configFilesMap.get(wsName)?.get(pluginName)?.size === 0))) {
                 if (plugin.entry)

package/dist/binaries/package-manager/pnpm.js

@@ -30,6 +30,7 @@ const commands = [
     'patch-commit',
     'patch-remove',
     'patch',
+    'prepare',
     'prune',
     'publish',
     'rb',
@@ -57,20 +58,19 @@ const commands = [
 export const resolve = (_binary, args, options) => {
     const parsed = parseArgs(args, {
         boolean: ['recursive', 'silent', 'shell-mode'],
-        alias: { recursive: 'r', silent: 's', 'shell-mode': 'c' },
+        alias: { recursive: 'r', silent: 's', 'shell-mode': 'c', filter: 'F' },
     });
-    const [command, binary] = parsed._;
+    const [command] = parsed._;
     if (command === 'dlx') {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
     const { manifestScriptNames, fromArgs } = options;
+    if (parsed.filter && !parsed.recursive)
+        return [];
     if (manifestScriptNames.has(command) || commands.includes(command))
         return [];
-    if (command === 'exec') {
-        if (parsed._.length > 2)
-            return [toBinary(binary), ...fromArgs(parsed._.slice(1))];
-        return [toBinary(binary)];
-    }
+    if (command === 'exec')
+        return fromArgs(parsed._.slice(1));
     return command ? [toBinary(command)] : [];
 };

package/dist/graph/build.js

@@ -10,12 +10,13 @@ import { getOrCreateFileNode, updateImportMap } from '../util/module-graph.js';
 import { getEntryPathsFromManifest } from '../util/package-json.js';
 import { dirname, isAbsolute, join, relative } from '../util/path.js';
 import {} from '../util/tag.js';
-import { augmentWorkspace, getToSourcePathHandler } from '../util/to-source-path.js';
+import { augmentWorkspace, getToSourcePathHandler, getToSourcePathsHandler } from '../util/to-source-path.js';
 import { loadTSConfig } from '../util/tsconfig-loader.js';
 export async function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }) {
     const configFilesMap = new Map();
     const enabledPluginsStore = new Map();
     const toSourceFilePath = getToSourcePathHandler(chief);
+    const toSourceFilePaths = getToSourcePathsHandler(chief);
     const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
     const isReportClassMembers = report.classMembers;
     for (const workspace of workspaces) {
@@ -71,9 +72,9 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         const ignore = worker.getIgnorePatterns();
         const sharedGlobOptions = { cwd, dir, gitignore };
         collector.addIgnorePatterns(ignore.map(pattern => join(cwd, pattern)));
-        const entryPathsFromManifest = await getEntryPathsFromManifest(manifest, { cwd: dir, ignore });
-        for (const filePath of entryPathsFromManifest) {
-            inputs.add(toProductionEntry(toSourceFilePath(filePath, extensionGlobStr) ?? filePath));
+        const entryPathsFromManifest = getEntryPathsFromManifest(manifest);
+        for (const filePath of await toSourceFilePaths(entryPathsFromManifest, dir, extensionGlobStr)) {
+            inputs.add(toProductionEntry(filePath));
         }
         const principal = factory.createPrincipal({
             cwd: dir,

package/dist/plugins/astro/index.d.ts

@@ -1,4 +1,5 @@
 import type { IsPluginEnabled, Resolve } from '../../types/config.js';
+export declare const config: string[];
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/astro/index.js

@@ -3,7 +3,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Astro';
 const enablers = ['astro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['astro.config.{js,cjs,mjs,ts}'];
+export const config = ['astro.config.{js,cjs,mjs,ts,mts}'];
 const entry = ['src/content/config.ts', 'src/content.config.ts'];
 const production = [
     'src/pages/**/*.{astro,mdx,js,ts}',

package/dist/plugins/prettier/index.js

@@ -5,8 +5,8 @@ const enablers = ['prettier'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = [
     '.prettierrc',
-    '.prettierrc.{json,js,cjs,mjs,yml,yaml,toml,json5}',
-    'prettier.config.{js,cjs,mjs}',
+    '.prettierrc.{json,js,cjs,mjs,ts,cts,mts,yml,yaml,toml,json5}',
+    'prettier.config.{js,cjs,mjs,ts,cts,mts}',
     'package.{json,yaml}',
 ];
 const resolveConfig = config => {

package/dist/plugins/starlight/index.js

@@ -1,10 +1,10 @@
 import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { config } from '../astro/index.js';
 import { getComponentPathsFromSourceFile } from './resolveFromAST.js';
 const title = 'Starlight';
 const enablers = ['@astrojs/starlight'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['astro.config.{js,cjs,mjs,ts}'];
 const resolveFromAST = (sourceFile) => {
     const componentPaths = getComponentPathsFromSourceFile(sourceFile);
     return Array.from(componentPaths).map(id => toProductionEntry(id));

package/dist/reporters/disclosure.js

@@ -1,20 +1,20 @@
-import EasyTable from 'easy-table';
 import { relative } from '../util/path.js';
+import { Table } from '../util/table.js';
 import { getTitle } from './util.js';
 const printHeader = (size, title) => console.log(`<details>\n${title ? `<summary>${title} (${size})</summary>\n` : ''}\n\`\`\``);
 const printFooter = () => console.log('```\n\n</details>\n');
 const logIssueRecord = (issues) => {
-    const table = new EasyTable();
+    const table = new Table();
     for (const issue of issues) {
         table.cell('symbol', issue.symbols ? issue.symbols.map(s => s.symbol).join(', ') : issue.symbol);
-        issue.parentSymbol && table.cell('parentSymbol', issue.parentSymbol);
-        issue.symbolType && table.cell('symbolType', issue.symbolType);
+        table.cell('parentSymbol', issue.parentSymbol && issue.parentSymbol);
+        table.cell('symbolType', issue.symbolType && issue.symbolType);
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
         const cell = issue.type === 'files' ? '' : `${relative(issue.filePath)}${pos}`;
         table.cell('filePath', cell);
         table.newRow();
     }
-    console.log(table.sort(['filePath', 'parentSymbol', 'symbol']).print().trim());
+    console.log(table.sort('filePath').toString());
 };
 export default ({ report, issues }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;

package/dist/reporters/symbols.js

@@ -1,17 +1,17 @@
-import EasyTable from 'easy-table';
 import picocolors from 'picocolors';
 import { ROOT_WORKSPACE_NAME } from '../constants.js';
 import { SymbolType } from '../types/issues.js';
 import { relative, toRelative } from '../util/path.js';
 import { truncate } from '../util/string.js';
+import { Table } from '../util/table.js';
 import { getTitle, identity, logTitle, logTitleDimmed } from './util.js';
 const dim = picocolors.gray;
 const bright = picocolors.whiteBright;
 const TRUNCATE_WIDTH = 40;
 const truncateStart = (text, width) => (text.length > width ? `...${text.slice(-(width - 3))}` : text);
 const sortByPos = (a, b) => {
-    const [f, r, c] = a.filePath.split(':');
-    const [f2, r2, c2] = b.filePath.split(':');
+    const [f, r, c] = a.filePath.value.split(':');
+    const [f2, r2, c2] = b.filePath.value.split(':');
     return f === f2 ? (Number(r) === Number(r2) ? Number(c) - Number(c2) : Number(r) - Number(r2)) : f.localeCompare(f2);
 };
 const hl = (issue) => {
@@ -26,20 +26,20 @@ const hl = (issue) => {
     return issue.symbol;
 };
 const logIssueRecord = (issues) => {
-    const table = new EasyTable();
+    const table = new Table({ truncateStart: ['filePath'], noTruncate: ['symbolType'] });
     for (const issue of issues) {
+        table.newRow();
         const print = issue.isFixed || issue.severity === 'warn' ? dim : identity;
         const symbols = issue.symbols;
         table.cell('symbol', print(symbols ? truncate(symbols.map(s => s.symbol).join(', '), TRUNCATE_WIDTH) : hl(issue)));
-        issue.parentSymbol && table.cell('parentSymbol', print(issue.parentSymbol));
-        issue.symbolType && issue.symbolType !== SymbolType.UNKNOWN && table.cell('symbolType', print(issue.symbolType));
+        table.cell('parentSymbol', issue.parentSymbol && print(issue.parentSymbol));
+        table.cell('symbolType', issue.symbolType && issue.symbolType !== SymbolType.UNKNOWN && print(issue.symbolType));
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
         const cell = issue.type === 'files' ? '' : `${relative(issue.filePath)}${pos}`;
         table.cell('filePath', print(cell));
-        issue.isFixed && table.cell('fixed', print('(removed)'));
-        table.newRow();
+        table.cell('fixed', issue.isFixed && print('(removed)'));
     }
-    console.log(table.sort(sortByPos).print().trim());
+    console.log(table.sort(sortByPos).toString());
 };
 export default ({ report, issues, tagHints, configurationHints, isDisableConfigHints, isTreatConfigHintsAsErrors, isShowProgress, }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;

package/dist/schema/configuration.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const knipConfigurationSchema: z.ZodObject<{
+export declare const knipConfigurationSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
     $schema: z.ZodOptional<z.ZodString>;
     rules: z.ZodOptional<z.ZodRecord<z.ZodUnion<[z.ZodLiteral<"files">, z.ZodLiteral<"dependencies">, z.ZodLiteral<"devDependencies">, z.ZodLiteral<"optionalPeerDependencies">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"binaries">, z.ZodLiteral<"unresolved">, z.ZodLiteral<"exports">, z.ZodLiteral<"types">, z.ZodLiteral<"nsExports">, z.ZodLiteral<"nsTypes">, z.ZodLiteral<"duplicates">, z.ZodLiteral<"enumMembers">, z.ZodLiteral<"classMembers">]>, z.ZodEnum<["error", "warn", "off"]>>>;
     entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -18,11 +18,11 @@ export declare const knipConfigurationSchema: z.ZodObject<{
     asyncCompilers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodString>>>>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     treatConfigHintsAsErrors: z.ZodOptional<z.ZodBoolean>;
-} & {
+}, {
     include: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"files">, z.ZodLiteral<"dependencies">, z.ZodLiteral<"devDependencies">, z.ZodLiteral<"optionalPeerDependencies">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"binaries">, z.ZodLiteral<"unresolved">, z.ZodLiteral<"exports">, z.ZodLiteral<"types">, z.ZodLiteral<"nsExports">, z.ZodLiteral<"nsTypes">, z.ZodLiteral<"duplicates">, z.ZodLiteral<"enumMembers">, z.ZodLiteral<"classMembers">]>, "many">>;
     exclude: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"files">, z.ZodLiteral<"dependencies">, z.ZodLiteral<"devDependencies">, z.ZodLiteral<"optionalPeerDependencies">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"binaries">, z.ZodLiteral<"unresolved">, z.ZodLiteral<"exports">, z.ZodLiteral<"types">, z.ZodLiteral<"nsExports">, z.ZodLiteral<"nsTypes">, z.ZodLiteral<"duplicates">, z.ZodLiteral<"enumMembers">, z.ZodLiteral<"classMembers">]>, "many">>;
-} & {
-    workspaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+}>, {
+    workspaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<z.objectUtil.extendShape<{
         entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         paths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
@@ -32,7 +32,7 @@ export declare const knipConfigurationSchema: z.ZodObject<{
         ignoreMembers: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
         ignoreUnresolved: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
         includeEntryExports: z.ZodOptional<z.ZodBoolean>;
-    } & {
+    }, {
         angular: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
             config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
             entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -1333,7 +1333,7 @@ export declare const knipConfigurationSchema: z.ZodObject<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         }>]>>;
-    }, "strip", z.ZodTypeAny, {
+    }>, "strip", z.ZodTypeAny, {
         node?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -2354,7 +2354,7 @@ export declare const knipConfigurationSchema: z.ZodObject<{
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
     }>>>;
-} & {
+}>, {
     angular: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
         config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -3655,7 +3655,7 @@ export declare const knipConfigurationSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     }>]>>;
-}, "strict", z.ZodTypeAny, {
+}>, "strict", z.ZodTypeAny, {
     exclude?: ("dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
     tags?: string[] | undefined;
     include?: ("dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;

package/dist/util/Performance.js

@@ -1,11 +1,11 @@
 import { PerformanceObserver, performance } from 'node:perf_hooks';
 import { constants } from 'node:perf_hooks';
 import { memoryUsage } from 'node:process';
-import EasyTable from 'easy-table';
 import prettyMilliseconds from 'pretty-ms';
 import parsedArgValues from './cli-arguments.js';
 import { debugLog } from './debug.js';
 import { getStats } from './math.js';
+import { Table } from './table.js';
 const { performance: isEnabled = false } = parsedArgValues;
 export const timerify = (fn, name = fn.name) => {
     if (!isEnabled)
@@ -69,18 +69,19 @@ class Performance {
     }
     getTable() {
         const entriesByName = this.getEntriesByName();
-        const table = new EasyTable();
+        const table = new Table({ header: true });
+        const twoFixed = (value) => (typeof value === 'number' ? value.toFixed(2) : value);
         for (const [name, values] of Object.entries(entriesByName)) {
             const stats = getStats(values);
-            table.cell('Name', name);
-            table.cell('size', values.length, EasyTable.number(0));
-            table.cell('min', stats.min, EasyTable.number(2));
-            table.cell('max', stats.max, EasyTable.number(2));
-            table.cell('median', stats.median, EasyTable.number(2));
-            table.cell('sum', stats.sum, EasyTable.number(2));
             table.newRow();
+            table.cell('Name', name);
+            table.cell('size', values.length);
+            table.cell('min', stats.min, twoFixed);
+            table.cell('max', stats.max, twoFixed);
+            table.cell('median', stats.median, twoFixed);
+            table.cell('sum', stats.sum, twoFixed);
         }
-        table.sort(['sum|des']);
+        table.sort('sum|desc');
         return table.toString().trim();
     }
     getCurrentDurationInMs(startTime) {

package/dist/util/glob.d.ts

@@ -11,6 +11,10 @@ export declare const negate: (pattern: string) => string;
 export declare const hasProductionSuffix: (pattern: string) => boolean;
 export declare const hasNoProductionSuffix: (pattern: string) => boolean;
 export declare const _glob: ({ cwd, dir, patterns, gitignore, label }: GlobOptions) => Promise<string[]>;
+export declare const _syncGlob: ({ cwd, patterns }: {
+    cwd?: string;
+    patterns: string | string[];
+}) => string[];
 export declare const _firstGlob: ({ cwd, patterns }: GlobOptions) => Promise<string | Buffer<ArrayBufferLike> | undefined>;
 export declare const _dirGlob: ({ cwd, patterns, gitignore }: GlobOptions) => Promise<string[]>;
 export {};

package/dist/util/glob.js

@@ -34,6 +34,7 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
         label,
     });
 };
+const syncGlob = ({ cwd, patterns }) => fg.sync(patterns, { cwd });
 const firstGlob = async ({ cwd, patterns }) => {
     const stream = fg.globStream(patterns.map(removeProductionSuffix), { cwd, ignore: GLOBAL_IGNORE_PATTERNS });
     for await (const entry of stream) {
@@ -47,5 +48,6 @@ const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns, {
     gitignore,
 });
 export const _glob = timerify(defaultGlob);
+export const _syncGlob = timerify(syncGlob);
 export const _firstGlob = timerify(firstGlob);
 export const _dirGlob = timerify(dirGlob);

package/dist/util/package-json.d.ts

@@ -7,8 +7,5 @@ interface ExtendedPackageJson extends PackageJson {
 }
 export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
 export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
-export declare const getEntryPathsFromManifest: (manifest: PackageJson, options: {
-    cwd: string;
-    ignore: string[];
-}) => Promise<string[]>;
+export declare const getEntryPathsFromManifest: (manifest: PackageJson) => Set<string>;
 export {};

package/dist/util/package-json.js

@@ -1,5 +1,4 @@
 import { readFile, writeFile } from 'node:fs/promises';
-import { _glob } from './glob.js';
 const INDENT = Symbol.for('indent');
 const NEWLINE = Symbol.for('newline');
 const DEFAULT_NEWLINE = '\n';
@@ -46,7 +45,7 @@ export const save = async (filePath, content) => {
     const fileContent = `${JSON.stringify(content, null, space)}\n`.replace(/\n/g, EOL);
     await writeFile(filePath, fileContent);
 };
-export const getEntryPathsFromManifest = (manifest, options) => {
+export const getEntryPathsFromManifest = (manifest) => {
     const { main, module, browser, bin, exports, types, typings } = manifest;
     const entryPaths = new Set();
     if (typeof main === 'string')
@@ -77,5 +76,5 @@ export const getEntryPathsFromManifest = (manifest, options) => {
         entryPaths.add(types);
     if (typeof typings === 'string')
         entryPaths.add(typings);
-    return _glob({ patterns: Array.from(entryPaths), ...options, gitignore: false, label: 'package.json entry paths' });
+    return entryPaths;
 };

package/dist/util/string.d.ts

@@ -1 +1,3 @@
 export declare const truncate: (text: string, width: number) => string;
+export declare const truncateStart: (text: string, width: number) => string;
+export declare const pad: (value: string, width: number, fillString?: string, align?: "left" | "center" | "right") => string;

package/dist/util/string.js

@@ -1 +1,7 @@
 export const truncate = (text, width) => text.length > width ? `${text.slice(0, width - 3)}...` : text;
+export const truncateStart = (text, width) => text.length > width ? `...${text.slice(-(width - 3))}` : text;
+export const pad = (value, width, fillString, align) => align === 'right'
+    ? value.padStart(width, fillString)
+    : align === 'center'
+        ? value.padStart((value.length + width) / 2, fillString).padEnd(width, fillString)
+        : value.padEnd(width, fillString);

package/dist/util/table.d.ts

@@ -0,0 +1,20 @@
+type Value = string | number | undefined | false | null;
+export declare class Table {
+    private columns;
+    private rows;
+    private header;
+    private maxWidth;
+    private truncateStart;
+    private noTruncate;
+    constructor(options?: {
+        maxWidth?: number;
+        header?: boolean;
+        truncateStart?: string[];
+        noTruncate?: string[];
+    });
+    cell(column: string, value: Value, formatter?: (value: Value) => string): this;
+    newRow(): this;
+    sort(compareFn: ((a: any, b: any) => number) | string): this;
+    toString(): string;
+}
+export {};

package/dist/util/table.js

@@ -0,0 +1,100 @@
+import { pad, truncate, truncateStart } from './string.js';
+const DEFAULT_MAX_WIDTH = process.stdout.columns || 120;
+const MIN_TRUNCATED_WIDTH = 4;
+const COLUMN_SEPARATOR = '  ';
+export class Table {
+    columns = [];
+    rows = [];
+    header;
+    maxWidth;
+    truncateStart = [];
+    noTruncate = [];
+    constructor(options) {
+        this.header = options?.header ?? false;
+        this.maxWidth = options?.maxWidth || DEFAULT_MAX_WIDTH;
+        this.truncateStart = options?.truncateStart || [];
+        this.noTruncate = options?.noTruncate || [];
+    }
+    cell(column, value, formatter) {
+        if (!this.columns.includes(column))
+            this.columns.push(column);
+        const row = this.rows[this.rows.length - 1];
+        row[column] = {
+            value,
+            formatted: formatter ? formatter(value) : undefined,
+            align: typeof value === 'number' ? 'right' : 'left',
+        };
+        return this;
+    }
+    newRow() {
+        this.rows.push({});
+        return this;
+    }
+    sort(compareFn) {
+        if (typeof compareFn === 'function') {
+            this.rows.sort(compareFn);
+            return this;
+        }
+        this.rows.sort((a, b) => {
+            const [col, order] = compareFn.split('|');
+            const vA = a[col].value;
+            const vB = b[col].value;
+            if (typeof vA === 'string' && typeof vB === 'string')
+                return (order === 'desc' ? -1 : 1) * vA.localeCompare(vB);
+            if (typeof vA === 'number' && typeof vB === 'number')
+                return order === 'desc' ? vB - vA : vA - vB;
+            return !vA ? 1 : !vB ? -1 : 0;
+        });
+        return this;
+    }
+    toString() {
+        const columns = this.columns.filter(col => this.rows.some(row => typeof row[col].value === 'string' || typeof row[col].value === 'number'));
+        if (this.header) {
+            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: '-' };
+            }
+            this.rows.unshift(linesRow);
+            this.rows.unshift(headerRow);
+        }
+        const columnWidths = columns.reduce((acc, col) => {
+            acc[col] = Math.max(...this.rows.map(row => String(row[col]?.formatted || 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;
+            }
+        }
+        return this.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;
+        })
+            .join(''))
+            .join('\n');
+    }
+}

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

@@ -1,5 +1,6 @@
 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, extensions?: string) => string | undefined;
+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 type ToSourceFilePath = ReturnType<typeof getToSourcePathHandler>;

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

@@ -1,8 +1,8 @@
-import fastGlob from 'fast-glob';
 import { DEFAULT_EXTENSIONS } from '../constants.js';
-import { debugLog } from './debug.js';
+import { debugLog, debugLogArray } from './debug.js';
 import { isDirectory } from './fs.js';
-import { isInternal, join, toRelative } from './path.js';
+import { _glob, _syncGlob } from './glob.js';
+import { isAbsolute, isInternal, join, toRelative } from './path.js';
 const defaultExtensions = `.{${DEFAULT_EXTENSIONS.map(ext => ext.slice(1)).join(',')}}`;
 const hasTSExt = /(?<!\.d)\.(m|c)?tsx?$/;
 const hasDTSExt = /.d\.(m|c)?ts$/;
@@ -14,7 +14,7 @@ export const augmentWorkspace = (workspace, dir, compilerOptions) => {
 };
 export const getToSourcePathHandler = (chief) => {
     const toSourceMapCache = new Map();
-    return (filePath, extensions = defaultExtensions) => {
+    return (filePath) => {
         if (!isInternal(filePath) || hasTSExt.test(filePath))
             return;
         if (toSourceMapCache.has(filePath))
@@ -23,8 +23,8 @@ export const getToSourcePathHandler = (chief) => {
         if (workspace?.srcDir && workspace.outDir) {
             if ((!filePath.startsWith(workspace.srcDir) && filePath.startsWith(workspace.outDir)) ||
                 (workspace.srcDir === workspace.outDir && hasDTSExt.test(filePath))) {
-                const pattern = filePath.replace(workspace.outDir, workspace.srcDir).replace(matchExt, extensions);
-                const [srcFilePath] = fastGlob.sync(pattern);
+                const pattern = filePath.replace(workspace.outDir, workspace.srcDir).replace(matchExt, defaultExtensions);
+                const srcFilePath = _syncGlob({ patterns: pattern })[0];
                 toSourceMapCache.set(filePath, srcFilePath);
                 if (srcFilePath && srcFilePath !== filePath) {
                     debugLog('*', `Source mapping ${toRelative(filePath)} → ${toRelative(srcFilePath)}`);
@@ -34,3 +34,22 @@ export const getToSourcePathHandler = (chief) => {
         }
     };
 };
+export const getToSourcePathsHandler = (chief) => {
+    return async (specifiers, cwd, extensions = defaultExtensions) => {
+        const patterns = new Set();
+        for (const specifier of specifiers) {
+            const absSpecifier = isAbsolute(specifier) ? specifier : join(cwd, 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);
+                patterns.add(pattern);
+            }
+            else {
+                patterns.add(absSpecifier);
+            }
+        }
+        const filePaths = await _glob({ patterns: Array.from(patterns), cwd });
+        debugLogArray(toRelative(cwd), 'Source mapping (package.json)', filePaths);
+        return filePaths;
+    };
+};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.51.0";
+export declare const version = "5.52.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.51.0';
+export const version = '5.52.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.51.0",
+  "version": "5.52.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -61,7 +61,6 @@
   ],
   "dependencies": {
     "@nodelib/fs.walk": "^1.2.3",
-    "easy-table": "1.2.0",
     "enhanced-resolve": "^5.18.1",
     "fast-glob": "^3.3.3",
     "jiti": "^2.4.2",