knip 2.33.2 → 2.33.4

package/dist/plugins/typescript/index.js

@@ -8,27 +8,30 @@ export const ENABLERS = ['typescript'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['tsconfig.json', 'tsconfig.*.json'];
 const resolveExtensibleConfig = async (configFilePath) => {
-    const config = await load(configFilePath);
-    config.extends = config.extends ? [config.extends].flat() : [];
-    if (config?.extends) {
-        for (const extend of [config.extends].flat()) {
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return;
+    localConfig.extends = localConfig.extends ? [localConfig.extends].flat() : [];
+    if (localConfig?.extends) {
+        for (const extend of [localConfig.extends].flat()) {
             if (isInternal(extend)) {
                 const presetConfigPath = toAbsolute(extend, dirname(configFilePath));
                 const presetConfig = await resolveExtensibleConfig(presetConfigPath);
-                config.extends.push(...(presetConfig.extends ? [presetConfig.extends].flat() : []));
+                localConfig.extends.push(...(presetConfig?.extends ? [presetConfig.extends].flat() : []));
             }
         }
     }
-    return config;
+    return localConfig;
 };
-export const findTypeScriptDependencies = async (configFilePath, { isProduction }) => {
+export const findTypeScriptDependencies = async (configFilePath, options) => {
+    const { isProduction } = options;
     if (isProduction)
         return [];
     const { compilerOptions } = await loadTSConfig(configFilePath);
-    const config = await resolveExtensibleConfig(configFilePath);
-    if (!compilerOptions || !config)
+    const localConfig = await resolveExtensibleConfig(configFilePath);
+    if (!compilerOptions || !localConfig)
         return [];
-    const extend = config.extends ? [config.extends].flat().filter(extend => !isInternal(extend)) : [];
+    const extend = localConfig.extends ? [localConfig.extends].flat().filter(extend => !isInternal(extend)) : [];
     const types = compilerOptions.types ?? [];
     const plugins = Array.isArray(compilerOptions?.plugins)
         ? compilerOptions.plugins.map(plugin => (typeof plugin === 'object' && 'name' in plugin ? plugin.name : ''))

package/dist/plugins/vite/index.js

@@ -6,7 +6,9 @@ export const ENABLERS = ['vite'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['vite.config.{js,ts}'];
 const findViteDependencies = async (configFilePath, options) => {
-    const config = await load(configFilePath);
-    return findVitestDeps(config, options);
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    return findVitestDeps(localConfig, options);
 };
 export const findDependencies = timerify(findViteDependencies);

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

@@ -1,9 +1,9 @@
-import type { VitestConfig } from './types.js';
+import type { VitestConfigOrFn } from './types.js';
 import type { IsPluginEnabledCallback, GenericPluginCallback, GenericPluginCallbackOptions } from '../../types/plugins.js';
 export declare const NAME = "Vitest";
 export declare const ENABLERS: string[];
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
 export declare const ENTRY_FILE_PATTERNS: string[];
-export declare const findVitestDeps: (config: VitestConfig, options: GenericPluginCallbackOptions) => any[];
+export declare const findVitestDeps: (localConfig: VitestConfigOrFn, options: GenericPluginCallbackOptions) => any[];
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/vitest/index.js

@@ -8,11 +8,12 @@ export const ENABLERS = ['vitest'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['vitest.config.ts', 'vitest.{workspace,projects}.{ts,js,json}'];
 export const ENTRY_FILE_PATTERNS = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
-export const findVitestDeps = (config, options) => {
+export const findVitestDeps = (localConfig, options) => {
     const { isProduction } = options;
-    if (!config || !config.test)
+    localConfig = typeof localConfig === 'function' ? localConfig() : localConfig;
+    if (!localConfig || !localConfig.test)
         return [];
-    const testConfig = config.test;
+    const testConfig = localConfig.test;
     const entryPatterns = (options.config?.entry ?? testConfig.include ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
     if (isProduction)
         return entryPatterns;
@@ -24,7 +25,9 @@ export const findVitestDeps = (config, options) => {
     return [...entryPatterns, ...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup];
 };
 const findVitestDependencies = async (configFilePath, options) => {
-    const config = await load(configFilePath);
-    return compact([config].flat().flatMap(cfg => (!cfg || typeof cfg === 'string' ? [] : findVitestDeps(cfg, options))));
+    const localConfig = await load(configFilePath);
+    return compact([localConfig]
+        .flat()
+        .flatMap(config => (!config || typeof config === 'string' ? [] : findVitestDeps(config, options))));
 };
 export const findDependencies = timerify(findVitestDependencies);

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

@@ -10,4 +10,5 @@ export interface VitestConfig {
         setupFiles?: string | string[];
     };
 }
+export type VitestConfigOrFn = VitestConfig | (() => VitestConfig);
 export type VitestWorkspaceConfig = (string | VitestConfig)[];

package/dist/plugins/webpack/index.js

@@ -1,7 +1,8 @@
 import { compact } from '../../util/array.js';
-import { join } from '../../util/path.js';
+import { join, relative } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
+import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 export const NAME = 'Webpack';
 export const ENABLERS = ['webpack'];
@@ -43,20 +44,23 @@ const resolveUseItem = (use) => {
         return [use.loader];
     return [];
 };
-const findWebpackDependencies = async (configFilePath, { manifest, isProduction }) => {
-    if (isProduction)
-        return [];
-    const config = await load(configFilePath);
-    if (!config)
+const findWebpackDependencies = async (configFilePath, options) => {
+    const { manifest, isProduction, cwd } = options;
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
         return [];
-    const passes = typeof config === 'function' ? [false, true] : [false];
-    const dependencies = passes.flatMap(isProduction => {
+    const passes = typeof localConfig === 'function' ? [false, true] : [false];
+    const dependencies = new Set();
+    const entryPatterns = new Set();
+    for (const isProduction of passes) {
         const env = { production: isProduction };
         const argv = { mode: isProduction ? 'production' : 'development' };
-        const resolvedConfig = typeof config === 'function' ? config(env, argv) : config;
-        return [resolvedConfig].flat().flatMap(options => {
-            const dependencies = (options.module?.rules?.flatMap(resolveRuleSetDependencies) ?? []).map(loader => loader.replace(/\?.*/, ''));
+        const resolvedConfig = typeof localConfig === 'function' ? await localConfig(env, argv) : localConfig;
+        for (const options of [resolvedConfig].flat()) {
             const entries = [];
+            for (const loader of options.module?.rules?.flatMap(resolveRuleSetDependencies) ?? []) {
+                dependencies.add(loader.replace(/\?.*/, ''));
+            }
             if (typeof options.entry === 'string')
                 entries.push(options.entry);
             else if (Array.isArray(options.entry))
@@ -73,12 +77,18 @@ const findWebpackDependencies = async (configFilePath, { manifest, isProduction
                         entries.push(entry['filename']);
                 });
             }
-            return [...dependencies, ...entries.map(entry => (options.context ? join(options.context, entry) : entry))];
-        });
-    });
+            entries.forEach(entry => {
+                const item = relative(cwd, join(options.context ? options.context : cwd, entry));
+                const value = options.mode === 'development' ? toEntryPattern(item) : toProductionEntryPattern(item);
+                entryPatterns.add(value);
+            });
+        }
+    }
+    if (isProduction)
+        return [...entryPatterns];
     const scripts = Object.values(manifest.scripts ?? {});
     const webpackCLI = scripts.some(script => script?.includes('webpack ')) ? ['webpack-cli'] : [];
     const webpackDevServer = scripts.some(script => script?.includes('webpack serve')) ? ['webpack-dev-server'] : [];
-    return compact([...dependencies, ...webpackCLI, ...webpackDevServer]);
+    return compact([...entryPatterns, ...dependencies, ...webpackCLI, ...webpackDevServer]);
 };
 export const findDependencies = timerify(findWebpackDependencies);

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

@@ -6,5 +6,6 @@ export type Env = {
 export type Argv = {
     mode: Mode;
 };
-export type WebpackConfig = Configuration | ((env: Env, argv: Argv) => Configuration);
+type Configurations = Configuration | Configuration[];
+export type WebpackConfig = Configurations | ((env: Env, argv: Argv) => Configurations) | (() => Promise<Configuration>);
 export {};

package/dist/types/config.d.ts

@@ -12,7 +12,7 @@ export type EnsuredPluginConfiguration = {
     entry: NormalizedGlob | null;
     project: NormalizedGlob | null;
 };
-export type PluginConfiguration = EnsuredPluginConfiguration | boolean;
+type PluginConfiguration = EnsuredPluginConfiguration | boolean;
 export type PluginsConfiguration = Record<PluginName, PluginConfiguration>;
 interface BaseWorkspaceConfiguration {
     entry: NormalizedGlob;

package/dist/types/plugins.d.ts

@@ -12,7 +12,7 @@ export type IsPluginEnabledCallback = (options: IsPluginEnabledCallbackOptions)
 export type GenericPluginCallbackOptions = {
     cwd: string;
     manifest: PackageJsonWithPlugins;
-    config?: EnsuredPluginConfiguration;
+    config: EnsuredPluginConfiguration;
     isProduction: boolean;
 };
 export type GenericPluginCallback = (configFilePath: string, options: GenericPluginCallbackOptions) => Promise<string[]> | string[];

package/dist/typescript/SourceFileManager.js

@@ -22,14 +22,14 @@ export class SourceFileManager {
         const contents = ts.sys.readFile(filePath);
         if (typeof contents !== 'string') {
             if (isInternal(filePath))
-                debugLog(`Unable to read ${filePath}`);
+                debugLog('*', `Unable to read ${filePath}`);
             return this.createSourceFile(filePath, '');
         }
         const ext = extname(filePath);
         const compiler = this.syncCompilers?.get(ext);
         const compiled = compiler ? compiler(contents, filePath) : contents;
         if (compiler)
-            debugLog(`Compiled ${filePath}`);
+            debugLog('*', `Compiled ${filePath}`);
         return this.createSourceFile(filePath, compiled);
     }
     getSnapshot(filePath) {
@@ -50,7 +50,7 @@ export class SourceFileManager {
         const compiler = this.asyncCompilers?.get(ext);
         if (compiler) {
             const compiled = await compiler(contents, filePath);
-            debugLog(`Compiled ${filePath}`);
+            debugLog('*', `Compiled ${filePath}`);
             this.createSourceFile(filePath, compiled);
         }
     }

package/dist/util/debug.d.ts

@@ -1,3 +1,3 @@
-export declare const debugLog: (message: string) => void;
-export declare const debugLogObject: (name: string, obj: unknown) => void;
-export declare const debugLogArray: (name: string, sourceFiles: string[] | Set<string>) => void;
+export declare const debugLog: (context: string, message: string) => void;
+export declare const debugLogObject: (context: string, name: string, obj: unknown | (() => unknown)) => void;
+export declare const debugLogArray: (context: string | [string, string], message: string, elements: string[] | Set<string>) => void;

package/dist/util/debug.js

@@ -1,9 +1,11 @@
 import util from 'node:util';
+import chalk from 'chalk';
 import parsedArgValues from './cli-arguments.js';
 const { debug, 'debug-file-filter': debugFileFilter } = parsedArgValues;
 const IS_ENABLED = debug ?? false;
 const FILE_FILTER = debugFileFilter;
 const inspectOptions = { maxArrayLength: null, depth: null, colors: true };
+const ctx = (text) => typeof text === 'string' ? chalk.yellow(`[${text}]`) : `${chalk.yellow(`[${text[0]}]`)} ${chalk.cyan(text[1])}`;
 const logArray = (collection) => {
     if (FILE_FILTER) {
         const fileFilter = new RegExp(FILE_FILTER);
@@ -14,21 +16,21 @@ const logArray = (collection) => {
         console.log(util.inspect(collection.sort(), inspectOptions));
     }
 };
-export const debugLog = (message) => {
+export const debugLog = (context, message) => {
     if (!IS_ENABLED)
         return;
-    console.log(`[knip] ${message}`);
+    console.log(`${ctx(context)} ${message}`);
 };
-export const debugLogObject = (name, obj) => {
+export const debugLogObject = (context, name, obj) => {
     if (!IS_ENABLED)
         return;
-    console.log(`[knip] ${name}`);
-    console.log(util.inspect(obj, inspectOptions));
+    console.log(`${ctx(context)} ${name}`);
+    console.log(util.inspect(typeof obj === 'function' ? obj() : obj, inspectOptions));
 };
-export const debugLogArray = (name, sourceFiles) => {
+export const debugLogArray = (context, message, elements) => {
     if (!IS_ENABLED)
         return;
-    const collection = Array.from(sourceFiles);
-    console.debug(`[knip] ${name} (${collection.length})`);
+    const collection = Array.from(elements);
+    console.debug(`${ctx(context)} ${message} (${collection.length})`);
     logArray(collection);
 };

package/dist/util/glob.js

@@ -24,7 +24,7 @@ const glob = async ({ cwd, workingDir = cwd, patterns, ignore = [], gitignore =
     if (globPatterns[0].startsWith('!'))
         return [];
     const ignorePatterns = compact([...ignore, ...GLOBAL_IGNORE_PATTERNS]);
-    debugLogObject(`Globbing (${relativePath || ROOT_WORKSPACE_NAME})`, { cwd, globPatterns, ignorePatterns });
+    debugLogObject(relativePath || ROOT_WORKSPACE_NAME, `Glob options`, { cwd, globPatterns, ignorePatterns });
     return globby(globPatterns, {
         cwd,
         ignore: ignorePatterns,

package/dist/util/path.js

@@ -6,7 +6,7 @@ export const join = path.posix.join;
 export const toPosix = (value) => value.split(path.sep).join(path.posix.sep);
 export const cwd = 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) => path.posix.relative(to ? toPosix(from) : cwd, toPosix(to ?? from));
+export const relative = (from, to) => toPosix(path.relative(to ? from : cwd, to ?? from));
 export const isInNodeModules = (filePath) => filePath.includes('node_modules');
 export const toAbsolute = (id, base) => (isAbsolute(id) ? id : join(base, id));
 export const toRelative = (id) => (isAbsolute(id) ? relative(id) : id);

package/dist/util/plugin.js

@@ -19,7 +19,13 @@ export const normalizePluginConfig = (pluginConfig) => {
     }
     else {
         const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
-        const config = isObject ? arrayify(pluginConfig.config) : pluginConfig ? arrayify(pluginConfig) : null;
+        const config = isObject
+            ? 'config' in pluginConfig
+                ? arrayify(pluginConfig.config)
+                : null
+            : pluginConfig
+                ? arrayify(pluginConfig)
+                : null;
         const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
         const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
         return { config, entry, project };

package/dist/util/require.js

@@ -12,7 +12,7 @@ const tryResolve = (specifier, from) => {
         return resolve(specifier);
     }
     catch {
-        debugLog(`Unable to resolve ${specifier} (from ${from})`);
+        debugLog('*', `Unable to resolve ${specifier} (from ${from})`);
     }
 };
 const resolveSpecifier = (dir, specifier) => {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.33.2";
+export declare const version = "2.33.4";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.33.2';
+export const version = '2.33.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.33.2",
+  "version": "2.33.4",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",