knip 1.12.2 → 1.12.3

package/dist/index.js

@@ -186,16 +186,16 @@ export const main = async (unresolvedConfiguration) => {
             if (report.dependencies || report.unlisted || report.files) {
                 await worker.findDependenciesByPlugins();
                 const { referencedDependencyIssues, peerDependencies, installedBinaries, entryFiles, enabledPlugins } = worker.getFinalDependencies();
+                deputy.addPeerDependencies(name, peerDependencies);
+                deputy.setInstalledBinaries(name, installedBinaries);
+                principal.addEntryPaths(entryFiles);
+                enabledPluginsStore.set(name, enabledPlugins);
                 referencedDependencyIssues.forEach(issue => {
                     const workspace = { name, dir, config, ancestors };
                     const unlistedDependency = deputy.maybeAddListedReferencedDependency(workspace, issue.symbol);
                     if (unlistedDependency)
                         collector.addIssue(issue);
                 });
-                deputy.addPeerDependencies(name, peerDependencies);
-                deputy.setInstalledBinaries(name, installedBinaries);
-                principal.addEntryPaths(entryFiles);
-                enabledPluginsStore.set(name, enabledPlugins);
             }
         }
     }

package/dist/plugins/eslint/fallback.d.ts

@@ -0,0 +1,5 @@
+type Options = {
+    cwd: string;
+};
+export declare const fallback: (configFilePath: string, { cwd }: Options) => Promise<string[]>;
+export {};

package/dist/plugins/eslint/fallback.js

@@ -0,0 +1,20 @@
+import { ESLint } from 'eslint';
+import { compact } from '../../util/array.js';
+import { getPackageName } from '../../util/modules.js';
+import { resolvePluginPackageName, getDependenciesFromSettings } from './helpers.js';
+export const fallback = async (configFilePath, { cwd }) => {
+    const engine = new ESLint({ cwd, overrideConfigFile: configFilePath, useEslintrc: false });
+    const jsConfig = await engine.calculateConfigForFile('__placeholder__.js');
+    const tsConfig = await engine.calculateConfigForFile('__placeholder__.ts');
+    const tsxConfig = await engine.calculateConfigForFile('__placeholder__.tsx');
+    const dependencies = [jsConfig, tsConfig, tsxConfig].map(config => {
+        if (!config)
+            return [];
+        const plugins = config.plugins?.map(resolvePluginPackageName) ?? [];
+        const parsers = config.parser ? [config.parser] : [];
+        const extraParsers = config.parserOptions?.babelOptions?.presets ?? [];
+        const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
+        return [...parsers, ...extraParsers, ...plugins, ...settings].map(getPackageName);
+    });
+    return compact(dependencies.flat());
+};

package/dist/plugins/eslint/helpers.d.ts

@@ -1,4 +1,4 @@
 import type { ESLintConfig } from './types.js';
+export declare const getDependenciesDeep: (configFilePath: string, dependencies?: Set<string>) => Promise<Set<string>>;
 export declare const resolvePluginPackageName: (pluginName: string) => string;
-export declare const customResolvePluginPackageNames: (extend: string) => string | undefined;
 export declare const getDependenciesFromSettings: (settings?: ESLintConfig['settings']) => string[];

package/dist/plugins/eslint/helpers.js

@@ -1,5 +1,35 @@
+import path from 'node:path';
 import { compact } from '../../util/array.js';
+import { _load } from '../../util/loader.js';
 import { getPackageName } from '../../util/modules.js';
+import { require } from '../../util/require.js';
+const getDependencies = (config) => {
+    const extend = config.extends ? [config.extends].flat().map(customResolvePluginPackageNames) : [];
+    if (extend.includes('eslint-plugin-prettier'))
+        extend.push('eslint-config-prettier');
+    const plugins = config.plugins ? config.plugins.map(resolvePluginPackageName) : [];
+    const parser = config.parser;
+    const extraParsers = config.parserOptions?.babelOptions?.presets ?? [];
+    const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
+    return compact([...extend, ...plugins, parser, ...extraParsers, ...settings]).map(getPackageName);
+};
+export const getDependenciesDeep = async (configFilePath, dependencies = new Set()) => {
+    const addAll = (deps) => deps.forEach(dependency => dependencies.add(dependency));
+    const config = await _load(configFilePath);
+    if (config.extends) {
+        for (const extend of [config.extends].flat()) {
+            if (extend.startsWith('.') || (extend.startsWith('/') && !extend.includes('/node_modules/'))) {
+                const extendConfigFilePath = require.resolve(path.join(path.dirname(configFilePath), extend));
+                addAll(await getDependenciesDeep(extendConfigFilePath));
+            }
+        }
+    }
+    if (config.overrides)
+        for (const override of config.overrides)
+            addAll(getDependencies(override));
+    addAll(getDependencies(config));
+    return dependencies;
+};
 const resolvePackageName = (namespace, pluginName) => {
     return pluginName.startsWith('@')
         ? pluginName.includes('/')
@@ -8,7 +38,7 @@ const resolvePackageName = (namespace, pluginName) => {
         : `${namespace}-${pluginName}`;
 };
 export const resolvePluginPackageName = (pluginName) => resolvePackageName('eslint-plugin', pluginName);
-export const customResolvePluginPackageNames = (extend) => {
+const customResolvePluginPackageNames = (extend) => {
     if (extend.includes('/node_modules/'))
         return getPackageName(extend);
     if (extend.startsWith('/') || extend.startsWith('.'))

package/dist/plugins/eslint/index.js

@@ -1,51 +1,29 @@
-import { ESLint } from 'eslint';
-import { compact } from '../../util/array.js';
-import { debugLogFiles, debugLogObject } from '../../util/debug.js';
-import { _firstGlob } from '../../util/glob.js';
 import { _load } from '../../util/loader.js';
-import { getPackageName } from '../../util/modules.js';
 import { timerify } from '../../util/performance.js';
 import { hasDependency } from '../../util/plugin.js';
-import { resolvePluginPackageName, customResolvePluginPackageNames, getDependenciesFromSettings } from './helpers.js';
+import { fallback } from './fallback.js';
+import { getDependenciesDeep } from './helpers.js';
 export const NAME = 'ESLint';
 export const ENABLERS = ['eslint'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['.eslintrc', '.eslintrc.{js,json,cjs}', '.eslintrc.{yml,yaml}', 'package.json'];
 export const ENTRY_FILE_PATTERNS = ['eslint.config.js'];
-const findESLintDependencies = async (configFilePath, { cwd, manifest, workspaceConfig }) => {
-    if (configFilePath.endsWith('package.json') && !manifest.eslintConfig)
-        return [];
+const findESLintDependencies = async (configFilePath, { cwd, manifest }) => {
     let config = undefined;
     try {
         config = configFilePath.endsWith('package.json') ? manifest.eslintConfig : await _load(configFilePath);
     }
     catch (error) {
-        if (error instanceof Error && error.cause instanceof Error && !/Failed to patch ESLint/.test(error.cause.message)) {
+        if (error instanceof Error && error.cause instanceof Error && /Failed to patch ESLint/.test(error.cause.message)) {
+            return fallback(configFilePath, { cwd });
+        }
+        else {
             throw error;
         }
     }
-    const rootExtends = config?.extends ? [config.extends].flat().map(customResolvePluginPackageNames) : [];
-    if (rootExtends.includes('eslint-plugin-prettier'))
-        rootExtends.push('eslint-config-prettier');
-    const patterns = compact([
-        workspaceConfig.entry,
-        ...(config?.overrides?.map(overrides => [overrides.files].flat()) ?? []),
-    ]);
-    debugLogObject('ESLint overrides file patterns', patterns);
-    const samples = await Promise.all(patterns.map(patterns => _firstGlob({ patterns, cwd })));
-    const sampleFilePaths = compact(samples.filter((filePath) => typeof filePath !== 'undefined').map(String));
-    debugLogFiles('ESLint overrides sample files', sampleFilePaths);
-    const engine = new ESLint({ cwd, overrideConfigFile: configFilePath, useEslintrc: false });
-    const calculateConfigForFile = async (sampleFile) => await engine.calculateConfigForFile(sampleFile);
-    const dependencies = await Promise.all(sampleFilePaths.map(calculateConfigForFile)).then(configs => configs.flatMap(config => {
-        if (!config)
-            return [];
-        const plugins = config.plugins?.map(resolvePluginPackageName) ?? [];
-        const parsers = config.parser ? [config.parser] : [];
-        const extraParsers = config.parserOptions?.babelOptions?.presets ?? [];
-        const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
-        return [...parsers, ...extraParsers, ...plugins, ...settings].map(getPackageName);
-    }));
-    return compact([...rootExtends, ...dependencies.flat()]);
+    if (!config)
+        return [];
+    const dependencies = await getDependenciesDeep(configFilePath);
+    return Array.from(dependencies);
 };
 export const findDependencies = timerify(findESLintDependencies);

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

@@ -1,14 +1,25 @@
-export type ESLintConfig = {
+type ParserOptions = {
+    project?: string;
+    babelOptions?: {
+        presets: string[];
+    };
+};
+type Settings = Record<string, Record<string, unknown>>;
+type Rules = Record<string, string | number>;
+type BaseConfig = {
     extends?: string | string[];
     parser?: string;
-    parserOptions?: {
-        babelOptions?: {
-            presets: string[];
-        };
-    };
+    parserOptions?: ParserOptions;
+    processor?: string;
     plugins?: string[];
-    settings?: Record<string, Record<string, unknown>>;
-    overrides?: {
-        files: string[];
-    }[];
+    settings?: Settings;
+    rules?: Rules;
+};
+type OverrideConfig = BaseConfig & {
+    files: string[];
+};
+export type ESLintConfig = BaseConfig & {
+    env?: Record<string, boolean>;
+    overrides?: OverrideConfig[];
 };
+export {};

package/dist/types/plugins.d.ts

@@ -1,4 +1,4 @@
-import { Configuration, PluginConfiguration, WorkspaceConfiguration } from './config.js';
+import type { Configuration, PluginConfiguration, WorkspaceConfiguration } from './config.js';
 import type { PackageJson } from 'type-fest';
 type IsPluginEnabledCallbackOptions = {
     cwd: string;

package/dist/util/binaries/index.d.ts

@@ -1,2 +1,2 @@
-import type { GetBinariesFromScripts } from './types.js';
-export declare const _getReferencesFromScripts: GetBinariesFromScripts;
+import type { GetReferencesFromScripts } from './types.js';
+export declare const _getReferencesFromScripts: GetReferencesFromScripts;

package/dist/util/binaries/types.d.ts

@@ -5,7 +5,7 @@ type Options = {
     ignore?: string[];
     knownGlobalsOnly?: boolean;
 };
-export type GetBinariesFromScripts = (npmScripts: string | string[], options?: Options) => {
+export type GetReferencesFromScripts = (npmScripts: string | string[], options?: Options) => {
     entryFiles: string[];
     binaries: string[];
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.12.2";
+export declare const version = "1.12.3";

package/dist/version.js

@@ -1 +1 @@
-export const version = '1.12.2';
+export const version = '1.12.3';

package/dist/workspace-worker.js

@@ -43,11 +43,10 @@ export default class WorkspaceWorker {
         const dependencies = new Set([Object.keys(manifest?.dependencies ?? {}), Object.keys(manifest?.devDependencies ?? {})].flat());
         const pluginEntries = Object.entries(plugins);
         for (const [pluginName, plugin] of pluginEntries) {
-            const hasIsEnabled = typeof plugin.isEnabled === 'function';
+            const isEnabled = this.config[pluginName] !== false;
+            const isEnabledInAncestor = enabledPluginsInAncestors.includes(pluginName);
             this.enabled[pluginName] =
-                this.config[pluginName] !== false &&
-                    (enabledPluginsInAncestors.includes(pluginName) ||
-                        (hasIsEnabled && (await plugin.isEnabled({ cwd: this.dir, manifest: this.manifest, dependencies }))));
+                isEnabled && (isEnabledInAncestor || (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies })));
         }
         this.enabledPlugins = pluginEntries.filter(([name]) => this.enabled[name]).map(([name]) => name);
         const enabledPluginNames = this.enabledPlugins.map(name => plugins[name].NAME);

package/package.json

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