knip 5.33.3 → 5.34.0

package/dist/plugins/cypress/helpers.js

@@ -1,9 +1,8 @@
-import { isInternal, toAbsolute } from '#p/util/path.js';
-import { load, resolveEntry } from '#p/util/plugin.js';
+import { isInternal, toAbsolute } from '../../util/path.js';
+import { load } from '../../util/plugin.js';
 export const resolveDependencies = async (config, options) => {
     const { reporter } = config;
     const { configFileDir } = options;
-    const resolve = (specifier) => resolveEntry(options, specifier);
     const reporters = reporter ? new Set([reporter]) : new Set();
     if (reporter === 'cypress-multi-reporters' && config.reporterOptions?.configFile) {
         const { configFile } = config.reporterOptions;
@@ -14,7 +13,7 @@ export const resolveDependencies = async (config, options) => {
                 const { reporterEnabled: reporterConcatenatedNames } = reporterConfig;
                 const reporterNames = reporterConcatenatedNames.split(',');
                 for (const reporterName of reporterNames) {
-                    reporters.add(resolve(reporterName.trim()));
+                    reporters.add(reporterName.trim());
                 }
             }
         }

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
 import type { CypressConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/cypress/index.js

@@ -1,5 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
+import { toDeferResolve, toEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 import { resolveDependencies } from './helpers.js';
 const title = 'Cypress';
 const enablers = ['cypress'];
@@ -18,10 +18,11 @@ const resolveEntryPaths = async (localConfig) => {
     return [
         ...(specPatterns.length > 0 ? specPatterns : TEST_FILE_PATTERNS),
         ...(supportFiles.length > 0 ? supportFiles : SUPPORT_FILE_PATTERNS),
-    ].map(toEntryPattern);
+    ].map(toEntry);
 };
-const resolveConfig = (config, options) => {
-    return resolveDependencies(config, options);
+const resolveConfig = async (config, options) => {
+    const inputs = await resolveDependencies(config, options);
+    return inputs.map(toDeferResolve);
 };
 export default {
     title,

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

@@ -0,0 +1,8 @@
+import type { ParsedArgs } from 'minimist';
+declare const _default: {
+    title: string;
+    args: {
+        fromArgs: (parsed: ParsedArgs, args: string[]) => string[];
+    };
+};
+export default _default;

package/dist/plugins/dotenv/index.js

@@ -0,0 +1,9 @@
+import { argsFrom } from '../../binaries/util.js';
+const title = 'dotenv';
+const args = {
+    fromArgs: (parsed, args) => argsFrom(args, parsed._[0]),
+};
+export default {
+    title,
+    args,
+};

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { DrizzleConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/drizzle/index.js

@@ -1,5 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
-import { toProductionEntryPattern } from '#p/util/protocols.js';
+import { toProductionEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Drizzle';
 const enablers = ['drizzle-kit'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -7,7 +7,7 @@ const config = ['drizzle.config.{ts,js,json}'];
 const resolveConfig = config => {
     if (!config.schema)
         return [];
-    return [config.schema].flat().map(toProductionEntryPattern);
+    return [config.schema].flat().map(id => toProductionEntry(id));
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
 import { DummyEleventyConfig } from './helpers.js';
 import type { EleventyConfig } from './types.js';
 type T = Partial<EleventyConfig> | ((arg: DummyEleventyConfig) => Promise<Partial<EleventyConfig>>);

package/dist/plugins/eleventy/index.js

@@ -1,8 +1,8 @@
-import { isDirectory } from '#p/util/fs.js';
-import { isInNodeModules, join } from '#p/util/path.js';
-import { hasDependency } from '#p/util/plugin.js';
-import { toProductionEntryPattern } from '#p/util/protocols.js';
 import { DEFAULT_EXTENSIONS } from '../../constants.js';
+import { isDirectory } from '../../util/fs.js';
+import { toDeferResolve, toProductionEntry } from '../../util/input.js';
+import { isInNodeModules, join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
 import { DummyEleventyConfig, defaultEleventyConfig } from './helpers.js';
 const title = 'Eleventy';
 const enablers = ['@11ty/eleventy'];
@@ -33,7 +33,7 @@ const resolveEntryPaths = async (localConfig, options) => {
         join(inputDir, `**/*.{${typeof templateFormats === 'string' ? templateFormats : templateFormats.join(',')}}`),
         join(inputDir, '**/*.11tydata.js'),
         ...copiedEntries,
-    ].map(toProductionEntryPattern);
+    ].map(id => toProductionEntry(id));
 };
 const resolveConfig = async (localConfig) => {
     const dummyUserConfig = new DummyEleventyConfig();
@@ -44,7 +44,7 @@ const resolveConfig = async (localConfig) => {
         if (isInNodeModules(path))
             copiedPackages.add(path);
     }
-    return [...copiedPackages];
+    return [...copiedPackages].map(id => toDeferResolve(id));
 };
 export default {
     title,

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

@@ -1,5 +1,4 @@
-import type { PluginOptions } from '../../types/plugins.js';
-import type { ESLintConfig } from './types.js';
-type GetDependenciesDeep = (localConfig: ESLintConfig, options: PluginOptions, dependencies?: Set<string>) => Promise<Set<string>>;
-export declare const getDependenciesDeep: GetDependenciesDeep;
-export {};
+import type { PluginOptions } from '../../types/config.js';
+import { type ConfigInput, type Input } from '../../util/input.js';
+import type { ESLintConfig, OverrideConfig } from './types.js';
+export declare const getDependencies: (config: ESLintConfig | OverrideConfig, options: PluginOptions) => (Input | ConfigInput)[];

package/dist/plugins/eslint/helpers.js

@@ -1,12 +1,13 @@
-import { compact } from '#p/util/array.js';
-import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '#p/util/modules.js';
-import { basename, dirname, isAbsolute, isInternal, toAbsolute } from '#p/util/path.js';
-import { load, resolve } from '#p/util/plugin.js';
+import { compact } from '../../util/array.js';
+import { toConfig, toDeferResolve } from '../../util/input.js';
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../../util/modules.js';
+import { isAbsolute, isInternal } from '../../util/path.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
-const getDependencies = (config) => {
-    const extendsSpecifiers = config.extends ? [config.extends].flat().map(resolveExtendSpecifier) : [];
+export const getDependencies = (config, options) => {
+    const extendsSpecifiers = config.extends ? compact([config.extends].flat().map(resolveExtendSpecifier)) : [];
     if (extendsSpecifiers.some(specifier => specifier?.startsWith('eslint-plugin-prettier')))
         extendsSpecifiers.push('eslint-config-prettier');
+    const extendConfigs = extendsSpecifiers.map(specifier => toConfig('eslint', specifier, options.configFilePath));
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
     const parser = config.parser ?? config.parserOptions?.parser;
     const babelDependencies = config.parserOptions?.babelOptions
@@ -14,32 +15,9 @@ const getDependencies = (config) => {
         : [];
     const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
     const rules = getDependenciesFromRules({});
-    const overrides = config.overrides ? [config.overrides].flat().flatMap(getDependencies) : [];
-    return compact([...extendsSpecifiers, ...plugins, parser, ...babelDependencies, ...settings, ...rules, ...overrides]);
-};
-export const getDependenciesDeep = async (localConfig, options, dependencies = new Set()) => {
-    const { configFileDir } = options;
-    const addAll = (deps) => {
-        for (const dependency of deps)
-            dependencies.add(dependency);
-    };
-    if (localConfig) {
-        if (localConfig.extends) {
-            for (const extend of [localConfig.extends].flat()) {
-                if (isInternal(extend)) {
-                    const filePath = resolve(toAbsolute(extend, configFileDir), configFileDir);
-                    if (filePath) {
-                        dependencies.add(filePath);
-                        const localConfig = await load(filePath);
-                        const opts = { ...options, configFileDir: dirname(filePath), configFileName: basename(filePath) };
-                        addAll(await getDependenciesDeep(localConfig, opts, dependencies));
-                    }
-                }
-            }
-        }
-        addAll(getDependencies(localConfig));
-    }
-    return dependencies;
+    const overrides = config.overrides ? [config.overrides].flat().flatMap(d => getDependencies(d, options)) : [];
+    const x = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(toDeferResolve);
+    return [...extendConfigs, ...x, ...babelDependencies, ...overrides];
 };
 const isQualifiedSpecifier = (specifier) => specifier === 'eslint' ||
     /\/eslint-(config|plugin)$/.test(specifier) ||

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { ESLintConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/eslint/index.js

@@ -1,5 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
-import { getDependenciesDeep } from './helpers.js';
+import { hasDependency } from '../../util/plugin.js';
+import { getDependencies } from './helpers.js';
 const title = 'ESLint';
 const enablers = ['eslint', '@eslint/js'];
 const isEnabled = ({ dependencies, manifest, config }) => hasDependency(dependencies, enablers) ||
@@ -8,10 +8,7 @@ const isEnabled = ({ dependencies, manifest, config }) => hasDependency(dependen
 const packageJsonPath = 'eslintConfig';
 const entry = ['eslint.config.{js,cjs,mjs}'];
 const config = ['.eslintrc', '.eslintrc.{js,json,cjs}', '.eslintrc.{yml,yaml}', 'package.json'];
-const resolveConfig = async (localConfig, options) => {
-    const dependencies = await getDependenciesDeep(localConfig, options);
-    return Array.from(dependencies);
-};
+const resolveConfig = (localConfig, options) => getDependencies(localConfig, options);
 export default {
     title,
     enablers,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { GatsbyConfig, GatsbyNode } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/gatsby/index.js

@@ -1,4 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toDeferResolve, toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Gatsby';
 const enablers = ['gatsby', 'gatsby-cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -14,7 +15,9 @@ const production = [
 const resolveConfig = async (localConfig, options) => {
     const { configFileName } = options;
     if (/gatsby-config/.test(configFileName)) {
-        return localConfig.plugins.map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve));
+        return localConfig.plugins
+            .map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve))
+            .map(toDeferResolve);
     }
     if (/gatsby-node/.test(configFileName)) {
         const plugins = new Set();
@@ -23,7 +26,7 @@ const resolveConfig = async (localConfig, options) => {
         if (typeof _config.onCreateBabelConfig === 'function') {
             _config.onCreateBabelConfig({ actions });
         }
-        return Array.from(plugins);
+        return Array.from(plugins).map(toDependency);
     }
     return [];
 };

package/dist/plugins/github-actions/index.d.ts

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 declare const _default: {
     title: string;
     enablers: string;

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

@@ -1,15 +1,31 @@
-import { _firstGlob } from '#p/util/glob.js';
-import { getValuesByKeyDeep } from '#p/util/object.js';
-import { join } from '#p/util/path.js';
-import { getDependenciesFromScripts } from '#p/util/plugin.js';
+import { _firstGlob } from '../../util/glob.js';
+import { isDeferResolveEntry, toEntry } from '../../util/input.js';
+import { findByKeyDeep } from '../../util/object.js';
+import { join, relative } from '../../util/path.js';
 const title = 'GitHub Actions';
 const enablers = 'This plugin is enabled when a `.yml` or `.yaml` file is found in the `.github/workflows` folder.';
 const isEnabled = async ({ cwd }) => Boolean(await _firstGlob({ cwd, patterns: ['.github/workflows/*.{yml,yaml}'] }));
 const config = ['.github/workflows/*.{yml,yaml}', '.github/**/action.{yml,yaml}'];
 const isString = (value) => typeof value === 'string';
 const resolveConfig = async (config, options) => {
-    const { configFileDir, configFileName } = options;
-    const scripts = getValuesByKeyDeep(config, 'run').filter(isString);
+    const { configFileDir, configFileName, rootCwd, getInputsFromScripts } = options;
+    const inputs = new Set();
+    const jobs = findByKeyDeep(config, 'steps');
+    for (const steps of jobs) {
+        const action = steps.steps.find(step => step.uses?.startsWith('actions/checkout@') && typeof step.with?.path === 'string' && !step.with.repository);
+        const path = action?.with?.path;
+        for (const step of steps.steps) {
+            const workingDir = step['working-directory'];
+            const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
+            if (step.run) {
+                for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true })) {
+                    if (isDeferResolveEntry(input) && path && !workingDir)
+                        input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
+                    inputs.add({ ...input, dir });
+                }
+            }
+        }
+    }
     const getActionDependencies = () => {
         const isActionManifest = configFileName === 'action.yml' || configFileName === 'action.yaml';
         if (!(isActionManifest && config?.runs?.using?.startsWith('node')))
@@ -17,7 +33,7 @@ const resolveConfig = async (config, options) => {
         const scripts = [config.runs.pre, config.runs.main, config.runs.post].filter(isString);
         return scripts.map(script => join(configFileDir, script));
     };
-    return [...getActionDependencies(), ...getDependenciesFromScripts(scripts, { ...options, knownGlobalsOnly: true })];
+    return [...getActionDependencies().map(toEntry), ...inputs];
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { GraphqlCodegenTypes, GraphqlConfigTypes, GraphqlProjectsConfigTypes } from './types.js';
 declare const _default: {
     title: string;

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

@@ -1,7 +1,7 @@
-import { get } from '#p/util/object.js';
-import { isInternal } from '#p/util/path.js';
-import { hasDependency } from '#p/util/plugin.js';
-import { toEntryPattern } from '#p/util/protocols.js';
+import { toDependency, toEntry } from '../../util/input.js';
+import { get } from '../../util/object.js';
+import { isInternal } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
 import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTypes } from './types.js';
 const title = 'GraphQL Codegen';
 const enablers = [/^@graphql-codegen\//, 'graphql-config'];
@@ -47,10 +47,10 @@ const resolveConfig = config => {
         if (typeof plugin !== 'string')
             return [];
         if (isInternal(plugin))
-            return [toEntryPattern(plugin)];
-        return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`];
+            return [toEntry(plugin)];
+        return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`].map(toDependency);
     });
-    return [...presets, ...flatPlugins, ...nestedPlugins];
+    return [...presets, ...flatPlugins, ...nestedPlugins].map(id => (typeof id === 'string' ? toDependency(id) : id));
 };
 export default {
     title,

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

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

package/dist/plugins/husky/index.js

@@ -1,5 +1,6 @@
 import { getGitHookPaths } from '../../util/git.js';
-import { getDependenciesFromScripts, hasDependency } from '../../util/plugin.js';
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'husky';
 const enablers = ['husky'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -12,10 +13,10 @@ const resolveConfig = (script, options) => {
         const hooks = script.hooks;
         if (hooks) {
             const scripts = Object.values(hooks);
-            return ['husky', ...getDependenciesFromScripts(scripts, { ...options })];
+            return [toDependency('husky'), ...options.getInputsFromScripts(scripts, { ...options })];
         }
     }
-    return getDependenciesFromScripts(String(script), { ...options, knownGlobalsOnly: true });
+    return options.getInputsFromScripts(String(script), { knownBinsOnly: true });
 };
 export default {
     title,