knip 6.36.0 → 6.38.0

package/dist/graph/analyze.js

@@ -70,7 +70,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             return;
         const issueType = isEnumMembers ? 'enumMembers' : 'namespaceMembers';
         const unusedMembers = [];
-        const ignoredMemberIds = [];
+        const ignoredMembers = [];
         for (const member of exportedItem.members) {
             if (findMatch(workspace.ignoreMembers, member.identifier))
                 continue;
@@ -78,8 +78,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 continue;
             if (member.hasRefsInFile)
                 continue;
-            const id = `${identifier}.${member.identifier}`;
-            const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
+            const [isMemberReferenced] = explorer.isReferenced(filePath, `${identifier}.${member.identifier}`, {
                 traverseEntries: true,
                 treatStarAtEntryAsReferenced: true,
             });
@@ -89,10 +88,19 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     unusedMembers.push(member);
             }
             else if (isMemberIgnored) {
-                ignoredMemberIds.push(id);
+                ignoredMembers.push(member);
+            }
+        }
+        return { issueType, unusedMembers, ignoredMembers };
+    };
+    const addMemberTagHints = (members, filePath, identifier) => {
+        for (const member of members) {
+            for (const tagName of member.jsDocTags) {
+                if (options.tags[1].includes(tagName)) {
+                    collector.addTagHint({ type: 'tag', filePath, identifier: `${identifier}.${member.identifier}`, tagName });
+                }
             }
         }
-        return { issueType, unusedMembers, ignoredMemberIds };
     };
     const analyzeGraph = async () => {
         if (options.isReportValues || options.isReportTypes) {
@@ -124,6 +132,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                     const memberIssues = isReferenced
                                         ? getMemberIssues(exportedItem, filePath, identifier, workspace, importsForExport)
                                         : undefined;
+                                    if (memberIssues)
+                                        addMemberTagHints(memberIssues.ignoredMembers, filePath, identifier);
                                     if (!memberIssues || memberIssues.unusedMembers.length === 0) {
                                         for (const tagName of exportedItem.jsDocTags) {
                                             if (options.tags[1].includes(tagName) || (isInternalProd && tagName === INTERNAL_TAG)) {
@@ -160,13 +170,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             fixes: member.fix ? [member.fix] : [],
                                         });
                                     }
-                                    for (const id of memberIssues.ignoredMemberIds) {
-                                        for (const tagName of exportedItem.jsDocTags) {
-                                            if (options.tags[1].includes(tagName)) {
-                                                collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
-                                            }
-                                        }
-                                    }
+                                    addMemberTagHints(memberIssues.ignoredMembers, filePath, identifier);
                                 }
                                 continue;
                             }

package/dist/manifest/index.js

@@ -17,10 +17,8 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
         if (manifest) {
             const defaultBinaryName = packageName.replace(/^@[^/]+\//, '');
             const binaries = typeof manifest.bin === 'string' ? [defaultBinaryName] : Object.keys(manifest.bin ?? {});
-            for (const binaryName of binaries) {
+            for (const binaryName of binaries)
                 addBinary(binaryName, packageName);
-                addBinary(packageName, binaryName);
-            }
             const packagePeerDependencies = Object.keys(manifest.peerDependencies ?? {});
             for (const packagePeerDependency of packagePeerDependencies) {
                 const hostDependency = {

package/dist/plugins/ava/index.js

@@ -23,7 +23,7 @@ const resolveConfig = async (localConfig, options) => {
     const nodeArgs = localConfig.nodeArguments ?? [];
     const requireArgs = (localConfig.require ?? []).map(require => `--require ${require}`);
     const fakeCommand = `node ${nodeArgs.join(' ')} ${requireArgs.join(' ')}`;
-    return files.concat(options.getInputsFromScripts(fakeCommand, { knownBinsOnly: true }));
+    return files.concat(options.getInputsFromScripts(fakeCommand, { optionalBinaries: true }));
 };
 const plugin = {
     title,

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

@@ -1,7 +1,10 @@
 import type { PluginOptions } from '../../types/config.ts';
+import type { Manifest } from '../../util/package-json.ts';
 import { type ConfigInput, type Input } from '../../util/input.ts';
 import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated, Settings } from './types.ts';
 export declare const isFlatConfig: (fileName: string) => boolean;
 export declare const getInputs: (config: ESLintConfigDeprecated | OverrideConfigDeprecated | ESLintConfig, options: PluginOptions) => (Input | ConfigInput)[];
+export type ImportSettingKind = 'resolver' | 'parsers';
+export declare const importSettingKinds: Map<string, ImportSettingKind>;
 export declare const getInputsFromSettings: (settings?: Settings) => Input[];
-export declare const resolveFormatters: (formatters: string | string[]) => Set<Input>;
+export declare const resolveFormatters: (formatters: string | string[], manifest: Manifest) => Set<Input>;

package/dist/plugins/eslint/helpers.js

@@ -79,13 +79,24 @@ const getResolverNames = (value) => {
         return [value];
     if (Array.isArray(value))
         return value.flatMap(getResolverNames);
-    if (value && typeof value === 'object')
+    if (value && typeof value === 'object') {
+        if ('name' in value && 'resolver' in value)
+            return [];
         return Object.keys(value);
+    }
     return [];
 };
+export const importSettingKinds = new Map([
+    ['import/resolver', 'resolver'],
+    ['import-x/resolver', 'resolver'],
+    ['import-x/resolver-legacy', 'resolver'],
+    ['import/parsers', 'parsers'],
+    ['import-x/parsers', 'parsers'],
+]);
 const getDependenciesFromSettings = (settings = {}) => {
     return Object.entries(settings).flatMap(([settingKey, settings]) => {
-        if (settingKey === 'import/resolver') {
+        const kind = importSettingKinds.get(settingKey);
+        if (kind === 'resolver') {
             return getResolverNames(settings)
                 .filter(key => key !== 'node')
                 .map(key => {
@@ -96,7 +107,7 @@ const getDependenciesFromSettings = (settings = {}) => {
                 return `eslint-import-resolver-${key}`;
             });
         }
-        if (settingKey === 'import/parsers') {
+        if (kind === 'parsers') {
             return (typeof settings === 'string' ? [settings] : Object.keys(settings)).map(key => {
                 if (isAbsolute(key))
                     return getPackageNameFromFilePath(key);
@@ -107,15 +118,35 @@ const getDependenciesFromSettings = (settings = {}) => {
 };
 export const getInputsFromSettings = (settings) => compact(getDependenciesFromSettings(settings)).map(id => toDeferResolve(id, { optional: true }));
 const builtinFormatters = new Set(['html', 'json-with-metadata', 'json', 'stylish']);
-export const resolveFormatters = (formatters) => {
+const builtinFormattersUntilV8 = new Set([
+    'checkstyle',
+    'compact',
+    'jslint-xml',
+    'junit',
+    'tap',
+    'unix',
+    'visualstudio',
+]);
+const normalizeFormatterName = (name) => {
+    if (!name.startsWith('@'))
+        return name.startsWith('eslint-formatter-') ? name : `eslint-formatter-${name}`;
+    const [scope, id] = name.split('/');
+    if (!id)
+        return `${scope}/eslint-formatter`;
+    return /^eslint-formatter(-|$)/.test(id) ? name : name.replace('/', '/eslint-formatter-');
+};
+export const resolveFormatters = (formatters, manifest) => {
     const inputs = new Set();
-    for (const formatter of [formatters].flat()) {
-        if (builtinFormatters.has(formatter))
-            continue;
-        else if (isInternal(formatter))
-            inputs.add(toDeferResolve(formatter));
-        else
-            inputs.add(toDependency(`eslint-formatter-${formatter}`));
+    const isBeforeV9 = (manifest.getMajor('eslint') ?? 9) < 9;
+    for (const rawFormatter of [formatters].flat()) {
+        const formatter = rawFormatter.replace(/\\/g, '/');
+        if (!formatter.startsWith('@') && formatter.includes('/')) {
+            inputs.add(toDeferResolve(isInternal(formatter) ? formatter : `./${formatter}`));
+        }
+        else {
+            const isBuiltin = builtinFormatters.has(formatter) || (isBeforeV9 && builtinFormattersUntilV8.has(formatter));
+            inputs.add(toDependency(normalizeFormatterName(formatter), isBuiltin ? { optional: true } : {}));
+        }
     }
     return inputs;
 };

package/dist/plugins/eslint/index.js

@@ -49,12 +49,12 @@ const args = {
     config: true,
     alias: { format: ['f'] },
     boolean: ['inspect-config'],
-    resolveInputs: (parsed) => {
+    resolveInputs: (parsed, { manifest }) => {
         const inputs = [];
         if (parsed['inspect-config'])
             inputs.push(toDependency('@eslint/config-inspector', { optional: true }));
         if (parsed['format'])
-            for (const input of resolveFormatters(parsed['format']))
+            for (const input of resolveFormatters(parsed['format'], manifest))
                 inputs.push(input);
         return inputs;
     },

package/dist/plugins/eslint/resolveFromAST.js

@@ -3,27 +3,30 @@ import { toDeferResolve } from '../../util/input.js';
 import { findProperty, getPropertyKey } from '../../typescript/ast-helpers.js';
 import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isInternal } from '../../util/path.js';
+import { importSettingKinds } from './helpers.js';
 export const getInputsFromSettingsAST = (program) => {
     const inputs = [];
-    const addResolver = (key, resolver) => {
+    const addResolver = (kind, resolver) => {
         if (!resolver || resolver === 'node' || isInternal(resolver))
             return;
-        const dep = key === 'import/resolver' ? `eslint-import-resolver-${resolver}` : resolver;
+        const dep = kind === 'resolver' ? `eslint-import-resolver-${resolver}` : resolver;
         inputs.push(toDeferResolve(dep, { optional: true }));
     };
-    const addResolvers = (key, node) => {
+    const addResolvers = (kind, node) => {
         if (node?.type === 'ArrayExpression') {
             for (const element of node.elements)
-                addResolvers(key, element);
+                addResolvers(kind, element);
         }
         else if (node?.type === 'ObjectExpression') {
+            if (kind === 'resolver' && findProperty(node, 'name') && findProperty(node, 'resolver'))
+                return;
             for (const prop of node.properties) {
                 if (prop.type === 'Property')
-                    addResolver(key, getPropertyKey(prop));
+                    addResolver(kind, getPropertyKey(prop));
             }
         }
         else {
-            addResolver(key, getStringValue(node));
+            addResolver(kind, getStringValue(node));
         }
     };
     const visitor = new Visitor({
@@ -35,8 +38,9 @@ export const getInputsFromSettingsAST = (program) => {
                 if (prop.type !== 'Property')
                     continue;
                 const key = getPropertyKey(prop);
-                if (key === 'import/resolver' || key === 'import/parsers')
-                    addResolvers(key, prop.value);
+                const kind = key && importSettingKinds.get(key);
+                if (kind)
+                    addResolvers(kind, prop.value);
             }
         },
     });

package/dist/plugins/eve/index.js

@@ -3,20 +3,38 @@ const title = 'eve';
 const enablers = ['eve'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const extensions = '{js,jsx,ts,tsx,mjs,cjs,mts,cts}';
-const rootAgentFileNames = '{agent,instructions,instrumentation,sandbox}';
-const subagentFileNames = '{agent,instructions,sandbox}';
+const agentRoots = '{,agent/,agents/*/,agents/*/agent/}';
+const subagentRoots = `${agentRoots}+(subagents/*/|extensions/*/subagents/*/)`;
+const extensionMounts = `{${agentRoots},${subagentRoots}}extensions/*`;
+const rootAgentFileNames = '{agent,instructions,instrumentation,memory,sandbox}';
+const rootAgentDirectories = '{channels,connections,hooks,skills,tools,schedules}';
+const subagentFileNames = '{agent,instructions,memory,sandbox}';
+const subagentDirectories = '{connections,hooks,skills,tools}';
+const entry = ['{evals,agents/*/evals}/evals.config.ts', '{evals,agents/*/evals}/**/*.eval.ts'];
 const production = [
-    `{,agent/}${rootAgentFileNames}.${extensions}`,
-    `{,agent/}sandbox/sandbox.${extensions}`,
-    `{,agent/}{channels,connections,hooks,skills,tools,schedules}/**/*.${extensions}`,
-    `{,agent/}subagents/**/${subagentFileNames}.${extensions}`,
-    `{,agent/}subagents/**/sandbox/sandbox.${extensions}`,
-    `{,agent/}subagents/**/{connections,hooks,skills,tools}/**/*.${extensions}`,
+    `${agentRoots}${rootAgentFileNames}.${extensions}`,
+    `${agentRoots}{instructions,instrumentation,memory}/*.${extensions}`,
+    `${agentRoots}sandbox/sandbox.${extensions}`,
+    `${agentRoots}sandbox/workspace/**/*.${extensions}`,
+    `${agentRoots}${rootAgentDirectories}/**/*.${extensions}`,
+    `${agentRoots}subagents/*.${extensions}`,
+    `${subagentRoots}subagents/*.${extensions}`,
+    `${subagentRoots}${subagentFileNames}.${extensions}`,
+    `${subagentRoots}{instructions,memory}/*.${extensions}`,
+    `${subagentRoots}sandbox/sandbox.${extensions}`,
+    `${subagentRoots}sandbox/workspace/**/*.${extensions}`,
+    `${subagentRoots}${subagentDirectories}/**/*.${extensions}`,
+    `${extensionMounts}.${extensions}`,
+    `${extensionMounts}/{extension,instructions}.${extensions}`,
+    `${extensionMounts}/instructions/*.${extensions}`,
+    `${extensionMounts}/${rootAgentDirectories}/**/*.${extensions}`,
+    `${extensionMounts}/subagents/*.${extensions}`,
 ];
 const plugin = {
     title,
     enablers,
     isEnabled,
+    entry,
     production,
 };
 export default plugin;

package/dist/plugins/github-actions/index.js

@@ -34,7 +34,7 @@ const resolveConfig = async (config, options) => {
                 const manifest = getManifest(dir) ?? options.manifest;
                 const actionPath = relative(dir, configFileDir);
                 const run = step.run.replace(ACTION_PATH_VAR, actionPath ? `./${actionPath}` : '.');
-                for (const input of getInputsFromScripts([run], { knownBinsOnly: true, manifest })) {
+                for (const input of getInputsFromScripts([run], { optionalBinaries: true, manifest })) {
                     if (isDeferResolveEntry(input) && path && !workingDir) {
                         input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
                     }

package/dist/plugins/graphql-codegen/index.js

@@ -1,8 +1,8 @@
 import { toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { get } from '../../util/object.js';
-import { isInternal, join } from '../../util/path.js';
+import { isInternal, join, normalize } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
-import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTypes } from './types.js';
+import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTypes, isNearOperationFilePreset, } from './types.js';
 const title = 'GraphQL Codegen';
 const enablers = [/^@graphql-codegen\//, 'graphql-config'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -24,6 +24,17 @@ const getPluginPackageName = (name) => {
         return name;
     return `@graphql-codegen/${name}`;
 };
+const getOutputPattern = (output, outputConfig) => {
+    if (isConfigurationOutput(outputConfig) && isNearOperationFilePreset(outputConfig.preset)) {
+        const presetConfig = outputConfig.presetConfig ?? {};
+        const { folder = '', extension = '.generated.ts', fileName = '*', filePerOperation = false } = presetConfig;
+        const subfolder = normalize(folder)
+            .split('/')
+            .filter(segment => segment !== '' && segment !== '.' && segment !== '..');
+        return join(output, '**', ...subfolder, `${filePerOperation ? '*' : fileName}${extension}`);
+    }
+    return output.endsWith('/') ? `${output}**` : output;
+};
 const resolveConfig = (config, options) => {
     const codegenConfigs = isGraphqlProjectsConfigTypes(config)
         ? Object.values(config.projects).flatMap(project => project.extensions?.codegen ?? [])
@@ -33,8 +44,8 @@ const resolveConfig = (config, options) => {
     const generateConfigs = codegenConfigs.filter((config) => Boolean(config?.generates));
     const generateSet = generateConfigs.flatMap(config => Object.values(config.generates));
     const outputs = generateConfigs
-        .flatMap(config => Object.keys(config.generates))
-        .map(output => toProductionEntry(join(options.configFileDir, output.endsWith('/') ? `${output}**` : output)));
+        .flatMap(config => Object.entries(config.generates))
+        .map(([output, outputConfig]) => toProductionEntry(join(options.configFileDir, getOutputPattern(output, outputConfig))));
     const configurationOutput = generateSet.filter(isConfigurationOutput);
     const presets = configurationOutput
         .map(configOutput => (configOutput.preset ? configOutput.preset : undefined))

package/dist/plugins/graphql-codegen/types.d.ts

@@ -12,10 +12,20 @@ type OutputPreset = {
     buildGeneratesSection: (options: unknown) => Promise<unknown>;
     prepareDocuments?: (outputFilePath: string, outputSpecificDocuments: unknown) => Promise<unknown>;
 };
+export interface NearOperationFilePresetConfig {
+    baseTypesPath?: string;
+    extension?: string;
+    fileName?: string;
+    filePerOperation?: boolean;
+    folder?: string;
+    [key: string]: unknown;
+}
+export declare const isNearOperationFilePreset: (preset: ConfiguredOutput['preset']) => preset is PresetNames;
 export declare function isConfigurationOutput(config: ConfiguredOutput | ConfiguredPlugin[]): config is ConfiguredOutput;
-interface ConfiguredOutput {
+export interface ConfiguredOutput {
     plugins?: OutputConfig[];
     preset?: PresetNames | OutputPreset;
+    presetConfig?: NearOperationFilePresetConfig;
 }
 export interface GraphqlCodegenTypes {
     generates: {

package/dist/plugins/graphql-codegen/types.js

@@ -1,3 +1,9 @@
+const nearOperationFilePresetNames = new Set([
+    'near-operation-file',
+    'near-operation-file-preset',
+    '@graphql-codegen/near-operation-file-preset',
+]);
+export const isNearOperationFilePreset = (preset) => typeof preset === 'string' && nearOperationFilePresetNames.has(preset);
 export function isConfigurationOutput(config) {
     return 'preset' in config || 'plugins' in config;
 }

package/dist/plugins/husky/index.js

@@ -17,7 +17,7 @@ const resolveConfig = (script, options) => {
             return [toDependency('husky'), ...options.getInputsFromScripts(scripts, { ...options })];
         }
     }
-    return options.getInputsFromScripts(String(script), { knownBinsOnly: true });
+    return options.getInputsFromScripts(String(script), { optionalBinaries: true });
 };
 const plugin = {
     title,

package/dist/plugins/index.d.ts

@@ -157,8 +157,10 @@ export declare const Plugins: {
     tsdown: import("../types/config.ts").Plugin;
     tsup: import("../types/config.ts").Plugin;
     tsx: import("../types/config.ts").Plugin;
+    turbo: import("../types/config.ts").Plugin;
     typedoc: import("../types/config.ts").Plugin;
     typescript: import("../types/config.ts").Plugin;
+    'typescript-content-mapper': import("../types/config.ts").Plugin;
     unbuild: import("../types/config.ts").Plugin;
     unocss: import("../types/config.ts").Plugin;
     'unplugin-auto-import': import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -151,8 +151,10 @@ import { default as tsd } from './tsd/index.js';
 import { default as tsdown } from './tsdown/index.js';
 import { default as tsup } from './tsup/index.js';
 import { default as tsx } from './tsx/index.js';
+import { default as turbo } from './turbo/index.js';
 import { default as typedoc } from './typedoc/index.js';
 import { default as typescript } from './typescript/index.js';
+import { default as typescriptContentMapper } from './typescript-content-mapper/index.js';
 import { default as unbuild } from './unbuild/index.js';
 import { default as unocss } from './unocss/index.js';
 import { default as unpluginAutoImport } from './unplugin-auto-import/index.js';
@@ -337,8 +339,10 @@ export const Plugins = {
     tsdown,
     tsup,
     tsx,
+    turbo,
     typedoc,
     typescript,
+    'typescript-content-mapper': typescriptContentMapper,
     unbuild,
     unocss,
     'unplugin-auto-import': unpluginAutoImport,

package/dist/plugins/lefthook/index.js

@@ -21,7 +21,7 @@ const resolveConfig = async (localConfig, options) => {
     const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(id => toDependency(id)) : [];
     if (extname(configFileName) !== '') {
         const scripts = findByKeyDeep(localConfig, 'run').flatMap(command => {
-            const deps = getInputsFromScripts([command.run], { ...options, knownBinsOnly: true });
+            const deps = getInputsFromScripts([command.run], { ...options, optionalBinaries: true });
             const dir = command.root ?? cwd;
             return deps.flatMap(dependency => ({ ...dependency, dir }));
         });

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

@@ -1,3 +1,6 @@
 import type { Plugin } from '../../types/config.ts';
+import { type Input } from '../../util/input.ts';
+export declare const contentMappers: string[];
+export declare const resolveContentMapperOptions: (options: Record<string, unknown>) => Input[];
 declare const plugin: Plugin;
 export default plugin;

package/dist/plugins/mdx/index.js

@@ -1,25 +1,35 @@
-import { toDependency } from '../../util/input.js';
+import { toDeferResolveProductionEntry, toDependency } from '../../util/input.js';
+import { isInternal } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'MDX';
 const enablers = ['astro', 'mdxlint'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['tsconfig.json'];
-const takeDependencies = (config) => {
+const takeDependencies = (plugins) => {
     const inputs = [];
-    if (Array.isArray(config.plugins)) {
-        for (const plugin of config.plugins) {
+    if (Array.isArray(plugins)) {
+        for (const plugin of plugins) {
             if (typeof plugin === 'string')
                 inputs.push(toDependency(plugin));
-            else if (typeof plugin[0] === 'string')
+            else if (Array.isArray(plugin) && typeof plugin[0] === 'string')
                 inputs.push(toDependency(plugin[0]));
         }
     }
     return inputs;
 };
+export const contentMappers = ['mdx-content-mapper', '@mdx-js/content-mapper'];
+const bundledPlugins = ['remark-mdx-frontmatter'];
+export const resolveContentMapperOptions = (options) => {
+    const inputs = takeDependencies(options.remarkPlugins).filter(input => !bundledPlugins.includes(input.specifier));
+    const provider = options.providerImportSource;
+    if (typeof provider === 'string' && isInternal(provider))
+        inputs.push(toDeferResolveProductionEntry(provider));
+    return inputs;
+};
 const resolveConfig = async (config, options) => {
     const { configFileName } = options;
     if (configFileName === 'tsconfig.json' && 'mdx' in config)
-        return takeDependencies(config.mdx);
+        return takeDependencies(config.mdx.plugins);
     return [];
 };
 const plugin = {

package/dist/plugins/mise/scripts.js

@@ -2,11 +2,11 @@ import { parse } from 'unbash';
 import { getDependenciesFromCommand, getInputsFromNodeOptions } from '../../binaries/command.js';
 import { spawningBinaries } from '../../binaries/fallback.js';
 import { isWrapper } from '../../binaries/plugins.js';
-import KnownResolvers from '../../binaries/resolvers/index.js';
+import { isPackageManager } from '../../binaries/resolvers/index.js';
 import { toScript } from '../../binaries/util.js';
 import { SCRIPT_INTERPOLATION } from '../../constants.js';
 import { isBinary } from '../../util/input.js';
-import { extractBinary } from '../../util/modules.js';
+import { extractBinary, isRelativeNodeModulesBin } from '../../util/modules.js';
 import { walkCommands } from '../../util/scripts.js';
 export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
     const inputs = [];
@@ -62,10 +62,10 @@ export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
                 if (!name || !word || definedFunctions.has(name))
                     continue;
                 const binary = extractBinary(name);
-                const isPackageManager = binary in KnownResolvers && binary !== 'find';
-                const isExplicit = isPackageManager || name.startsWith('./') || /^(?:\.\.?\/)*node_modules\/\.bin\//.test(name);
+                const isPackageCommand = isPackageManager(binary);
+                const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
                 const isLocal = hasLocalBinPath && !command.prefix.some(assignment => assignment.name === 'PATH');
-                const isWrapperCommand = !isPackageManager && isWrapper(binary);
+                const isWrapperCommand = !isPackageCommand && isWrapper(binary);
                 if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
                     continue;
                 let commandInputs;

package/dist/plugins/mocha/index.js

@@ -1,4 +1,4 @@
-import { toDeferResolve, toEntry } from '../../util/input.js';
+import { toDeferResolve, toDeferResolveEntry, toEntry } from '../../util/input.js';
 import { isDirectory } from '../../util/fs.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Mocha';
@@ -9,9 +9,11 @@ const entry = ['**/test/*.{js,cjs,mjs}'];
 const defaultExtensions = ['js', 'cjs', 'mjs'];
 const resolveConfig = localConfig => {
     const entryPatterns = localConfig.spec ? [localConfig.spec].flat() : entry;
+    const files = localConfig.file ? [localConfig.file].flat() : [];
     const require = localConfig.require ? [localConfig.require].flat() : [];
     const inputs = [];
     inputs.push(...entryPatterns.map(id => toEntry(id)));
+    inputs.push(...files.map(id => toDeferResolveEntry(id)));
     inputs.push(...require.map(id => toDeferResolve(id)));
     return inputs;
 };

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

@@ -1,4 +1,5 @@
 export interface MochaConfig {
+    file?: string | string[];
     require?: string | string[];
     spec?: string | string[];
 }

package/dist/plugins/oxlint/index.js

@@ -1,7 +1,7 @@
 import { Visitor } from 'oxc-parser';
 import { findProperty, getPropertyValues } from '../../typescript/ast-helpers.js';
-import { toDependency, toEntry } from '../../util/input.js';
-import { isInternal } from '../../util/path.js';
+import { toConfig, toDependency, toEntry } from '../../util/input.js';
+import { dirname, isInternal, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getInputsFromSettings } from '../eslint/helpers.js';
 import { getInputsFromSettingsAST } from '../eslint/resolveFromAST.js';
@@ -13,28 +13,42 @@ const isViteConfig = (configFileName) => configFileName.startsWith('vite.config.
 const args = {
     config: true,
 };
-const resolveJsPlugins = (jsPlugins) => {
+const resolveJsPlugins = (jsPlugins, configFilePath) => {
     const inputs = [];
+    const dir = dirname(configFilePath);
     for (const plugin of jsPlugins ?? []) {
         const specifier = typeof plugin === 'string' ? plugin : plugin.specifier;
         if (!isInternal(specifier))
             inputs.push(toDependency(specifier));
         else
-            inputs.push(toEntry(specifier));
+            inputs.push(toEntry(toAbsolute(specifier, dir)));
     }
     return inputs;
 };
 const isLoadConfig = ({ configFileName }) => !isViteConfig(configFileName);
-const resolveConfig = config => {
-    const inputs = resolveJsPlugins(config.jsPlugins);
+const resolveExtendedConfig = (config, configFilePath) => {
+    const inputs = [];
+    for (const entry of config.extends ?? []) {
+        if (typeof entry === 'string') {
+            const filePath = toAbsolute(entry, dirname(configFilePath));
+            inputs.push(toConfig('oxlint', filePath, { containingFilePath: configFilePath }));
+        }
+        else {
+            for (const input of resolveExtendedConfig(entry, configFilePath))
+                inputs.push(input);
+        }
+    }
+    for (const input of resolveJsPlugins(config.jsPlugins, configFilePath))
+        inputs.push(input);
     for (const override of config.overrides ?? []) {
-        for (const input of resolveJsPlugins(override.jsPlugins))
+        for (const input of resolveJsPlugins(override.jsPlugins, configFilePath))
             inputs.push(input);
     }
     for (const input of getInputsFromSettings(config.settings))
         inputs.push(input);
     return inputs;
 };
+const resolveConfig = (config, options) => resolveExtendedConfig(config, options.configFilePath);
 const resolveFromAST = (program, options) => {
     if (!isViteConfig(options.configFileName))
         return [];
@@ -55,8 +69,9 @@ const resolveFromAST = (program, options) => {
         },
     });
     visitor.visit(program);
-    return [...resolveJsPlugins([...jsPlugins]), ...getInputsFromSettingsAST(program)];
+    return [...resolveJsPlugins([...jsPlugins], options.configFilePath), ...getInputsFromSettingsAST(program)];
 };
+const isFilterTransitiveDependencies = true;
 const plugin = {
     title,
     enablers,
@@ -65,6 +80,7 @@ const plugin = {
     isLoadConfig,
     resolveConfig,
     resolveFromAST,
+    isFilterTransitiveDependencies,
     args,
 };
 export default plugin;

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

@@ -7,6 +7,7 @@ type Override = {
     jsPlugins?: JsPlugin[];
 };
 export type OxlintConfig = {
+    extends?: (string | OxlintConfig)[];
     jsPlugins?: JsPlugin[];
     overrides?: Override[];
     settings?: Settings;

package/dist/plugins/plop/index.js

@@ -2,11 +2,11 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Plop';
 const enablers = ['plop'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['plopfile.{cjs,mjs,js,ts}'];
+const entry = ['plopfile.{cjs,mjs,js,ts}'];
 const plugin = {
     title,
     enablers,
     isEnabled,
-    config,
+    entry,
 };
 export default plugin;