knip 5.33.2 → 5.34.0

package/dist/plugins/typescript/index.js

@@ -1,48 +1,32 @@
-import { compact } from '#p/util/array.js';
-import { dirname, isInternal, join, toAbsolute } from '#p/util/path.js';
-import { hasDependency, loadJSON } from '#p/util/plugin.js';
-import { loadTSConfig } from '#p/util/tsconfig-loader.js';
+import { compact } from '../../util/array.js';
+import { toConfig, toDeferResolve, toProductionDependency } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'TypeScript';
 const enablers = ['typescript'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['tsconfig.json', 'tsconfig.*.json'];
+const config = ['tsconfig.json'];
 const production = [];
-const getExtends = async (configFilePath, internalExtends = new Set()) => {
-    const filePath = configFilePath.replace(/(\.json)?$/, '.json');
-    const localConfig = await loadJSON(filePath);
-    if (!localConfig)
-        return internalExtends;
-    const extends_ = localConfig.extends ? [localConfig.extends].flat() : [];
-    for (const extend of extends_) {
-        if (isInternal(extend)) {
-            const presetConfigPath = toAbsolute(extend, dirname(configFilePath));
-            await getExtends(presetConfigPath, internalExtends);
-        }
-    }
-    for (const extend of extends_) {
-        if (isInternal(extend))
-            internalExtends.add(toAbsolute(extend, dirname(configFilePath)));
-        else
-            internalExtends.add(extend);
-    }
-    return internalExtends;
-};
 const resolveConfig = async (localConfig, options) => {
-    const { isProduction, configFileDir, configFileName } = options;
-    const configFilePath = join(configFileDir, configFileName);
-    const { compilerOptions } = await loadTSConfig(configFilePath);
-    const extend = await getExtends(configFilePath);
+    const { compilerOptions } = localConfig;
+    const extend = localConfig.extends
+        ? [localConfig.extends].flat().map(specifier => toConfig('typescript', specifier, options.configFilePath))
+        : [];
     if (!(compilerOptions && localConfig))
-        return [];
-    const jsx = compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : [];
-    if (isProduction)
-        return [...jsx];
+        return extend;
+    const jsx = (compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : []).map(toProductionDependency);
     const types = compilerOptions.types ?? [];
     const plugins = Array.isArray(compilerOptions?.plugins)
         ? compilerOptions.plugins.map(plugin => (typeof plugin === 'object' && 'name' in plugin ? plugin.name : ''))
         : [];
     const importHelpers = compilerOptions?.importHelpers ? ['tslib'] : [];
-    return compact([...extend, ...types, ...plugins, ...importHelpers, ...jsx]);
+    return compact([...extend, ...[...types, ...plugins, ...importHelpers].map(toDeferResolve), ...jsx]);
+};
+const args = {
+    binaries: ['tsc'],
+    string: ['project'],
+    alias: { project: ['p'] },
+    config: [['project', (p) => (p.endsWith('.json') ? p : join(p, 'tsconfig.json'))]],
 };
 export default {
     title,
@@ -51,4 +35,5 @@ export default {
     config,
     production,
     resolveConfig,
+    args,
 };

package/dist/plugins/unbuild/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 { UnbuildConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/unbuild/index.js

@@ -1,5 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
-import { toEntryPattern } from '#p/util/protocols.js';
+import { toEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'unbuild';
 const enablers = ['unbuild'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -9,7 +9,7 @@ const resolveConfig = config => {
         .flat()
         .map(obj => obj.entries)
         .flatMap(entries => entries?.map(entry => (typeof entry === 'string' ? entry : entry.input)) ?? [])
-        .map(toEntryPattern);
+        .map(toEntry);
 };
 export default {
     title,

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

@@ -1,7 +1,7 @@
-import type { IsPluginEnabled } from '#p/types/plugins.js';
+import type { IsPluginEnabled } from '../../types/config.js';
 declare const _default: {
     title: string;
-    enablers: import("#p/types/config.js").IgnorePatterns;
+    enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
 };

package/dist/plugins/unocss/index.js

@@ -1,4 +1,5 @@
-import { hasDependency, toUnconfig } from '#p/util/plugin.js';
+import { toUnconfig } from '../../util/plugin-config.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'UnoCSS';
 const enablers = ['unocss'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);

package/dist/plugins/vercel-og/index.d.ts

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

package/dist/plugins/vercel-og/index.js

@@ -1,4 +1,4 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Vercel OG';
 const enablers = ['next', '@vercel/og'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);

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

@@ -1,7 +1,7 @@
-import type { IsPluginEnabled } from '#p/types/plugins.js';
+import type { IsPluginEnabled } from '../../types/config.js';
 declare const _default: {
     title: string;
-    enablers: import("#p/types/config.js").IgnorePatterns;
+    enablers: string[];
     isEnabled: IsPluginEnabled;
     production: string[];
 };

package/dist/plugins/vike/index.js

@@ -1,4 +1,4 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Vike';
 const enablers = ['vike'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled } from '#p/types/plugins.js';
+import type { IsPluginEnabled } from '../../types/config.js';
 export declare const config: string[];
 declare const _default: {
     title: string;
@@ -6,7 +6,7 @@ declare const _default: {
     isEnabled: IsPluginEnabled;
     config: string[];
     production: string[];
-    resolveEntryPaths: import("#p/types/plugins.js").ResolveEntryPaths<import("../vitest/types.js").ViteConfigOrFn | import("../vitest/types.js").VitestWorkspaceConfig>;
-    resolveConfig: import("#p/types/plugins.js").ResolveConfig<import("../vitest/types.js").ViteConfigOrFn | import("../vitest/types.js").VitestWorkspaceConfig>;
+    resolveEntryPaths: import("../../types/config.js").ResolveEntryPaths<import("../vitest/types.js").ViteConfigOrFn | import("../vitest/types.js").VitestWorkspaceConfig>;
+    resolveConfig: import("../../types/config.js").ResolveConfig<import("../vitest/types.js").ViteConfigOrFn | import("../vitest/types.js").VitestWorkspaceConfig>;
 };
 export default _default;

package/dist/plugins/vite/index.js

@@ -1,9 +1,9 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { hasDependency } from '../../util/plugin.js';
 import { resolveConfig, resolveEntryPaths } from '../vitest/index.js';
 const title = 'Vite';
 const enablers = ['vite', 'vitest'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-export const config = ['vite*.config.{js,mjs,ts,cjs,mts,cts}'];
+export const config = ['vite.config.{js,mjs,ts,cjs,mts,cts}'];
 const production = [];
 export default {
     title,

package/dist/plugins/vitest/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 { ViteConfigOrFn, VitestWorkspaceConfig } from './types.js';
 export declare const resolveEntryPaths: ResolveEntryPaths<ViteConfigOrFn | VitestWorkspaceConfig>;
 export declare const resolveConfig: ResolveConfig<ViteConfigOrFn | VitestWorkspaceConfig>;
@@ -10,5 +10,8 @@ declare const _default: {
     entry: string[];
     resolveEntryPaths: ResolveEntryPaths<ViteConfigOrFn | VitestWorkspaceConfig>;
     resolveConfig: ResolveConfig<ViteConfigOrFn | VitestWorkspaceConfig>;
+    args: {
+        config: boolean;
+    };
 };
 export default _default;

package/dist/plugins/vitest/index.js

@@ -1,11 +1,11 @@
-import { join } from '#p/util/path.js';
-import { hasDependency, resolveEntry } from '#p/util/plugin.js';
-import { toEntryPattern } from '#p/util/protocols.js';
+import { toDeferResolve, toDependency, toEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
 import { getEnvPackageName, getExternalReporters } from './helpers.js';
 const title = 'Vitest';
 const enablers = ['vitest'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['vitest*.config.{js,mjs,ts,cjs,mts,cts}', 'vitest.{workspace,projects}.{js,mjs,ts,cjs,mts,cts,json}'];
+const config = ['vitest.config.{js,mjs,ts,cjs,mts,cts}', 'vitest.{workspace,projects}.{js,mjs,ts,cjs,mts,cts,json}'];
 const entry = ['**/*.{bench,test,test-d,spec}.?(c|m)[jt]s?(x)'];
 const isVitestCoverageCommand = /vitest(.+)--coverage(?:\.enabled(?:=true)?)?/;
 const hasScriptWithCoverage = (scripts) => scripts
@@ -14,7 +14,7 @@ const hasScriptWithCoverage = (scripts) => scripts
     })
     : false;
 const findConfigDependencies = (localConfig, options) => {
-    const { manifest } = options;
+    const { manifest, configFileDir } = options;
     const testConfig = localConfig.test;
     if (!testConfig)
         return [];
@@ -22,10 +22,14 @@ const findConfigDependencies = (localConfig, options) => {
     const reporters = getExternalReporters(testConfig.reporters);
     const hasCoverageEnabled = (testConfig.coverage && testConfig.coverage.enabled !== false) || hasScriptWithCoverage(manifest.scripts);
     const coverage = hasCoverageEnabled ? [`@vitest/coverage-${testConfig.coverage?.provider ?? 'v8'}`] : [];
-    const rootDir = testConfig.root ?? '.';
-    const setupFiles = [testConfig.setupFiles ?? []].flat().map(specifier => resolveEntry(options, specifier, rootDir));
-    const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => resolveEntry(options, specifier, rootDir));
-    return [...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup];
+    const dir = join(configFileDir, testConfig.root ?? '.');
+    const setupFiles = [testConfig.setupFiles ?? []].flat().map(specifier => {
+        return { ...toDeferResolve(specifier), dir };
+    });
+    const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => {
+        return { ...toDeferResolve(specifier), dir };
+    });
+    return [...[...environments, ...reporters, ...coverage].map(toDependency), ...setupFiles, ...globalSetup];
 };
 const getConfigs = async (localConfig) => {
     const configs = [];
@@ -47,34 +51,40 @@ const getConfigs = async (localConfig) => {
     return configs;
 };
 export const resolveEntryPaths = async (localConfig, options) => {
-    const dependencies = new Set(['src/vite-env.d.ts']);
+    const inputs = new Set();
+    inputs.add(toEntry(join(options.cwd, 'src/vite-env.d.ts')));
     const configs = await getConfigs(localConfig);
     for (const cfg of configs) {
-        const rootDir = cfg.test?.root ?? '.';
+        const dir = join(options.configFileDir, cfg.test?.root ?? '.');
         if (cfg.test?.include) {
             for (const dependency of cfg.test.include)
-                dependencies.add(join(rootDir, dependency));
+                inputs.add(toEntry(join(dir, dependency)));
         }
         else {
             for (const dependency of options.config.entry ?? entry)
-                dependencies.add(join(rootDir, dependency));
+                inputs.add(toEntry(join(dir, dependency)));
         }
     }
-    return Array.from(dependencies).map(toEntryPattern);
+    return Array.from(inputs);
 };
 export const resolveConfig = async (localConfig, options) => {
-    const dependencies = new Set();
+    const inputs = new Set();
     const configs = await getConfigs(localConfig);
     for (const cfg of configs) {
         for (const dependency of findConfigDependencies(cfg, options))
-            dependencies.add(dependency);
+            inputs.add(dependency);
         const entry = cfg.build?.lib?.entry ?? [];
-        const rootDir = cfg.test?.root ?? '.';
-        const deps = (typeof entry === 'string' ? [entry] : Object.values(entry)).map(specifier => resolveEntry(options, specifier, rootDir));
+        const dir = join(options.configFileDir, cfg.test?.root ?? '.');
+        const deps = (typeof entry === 'string' ? [entry] : Object.values(entry))
+            .map(specifier => join(dir, specifier))
+            .map(toEntry);
         for (const dependency of deps)
-            dependencies.add(dependency);
+            inputs.add(dependency);
     }
-    return Array.from(dependencies);
+    return Array.from(inputs);
+};
+const args = {
+    config: true,
 };
 export default {
     title,
@@ -84,4 +94,5 @@ export default {
     entry,
     resolveEntryPaths,
     resolveConfig,
+    args,
 };

package/dist/plugins/vue/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 { VueConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/vue/index.js

@@ -1,12 +1,13 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toDevDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
 const title = 'Vue';
 const enablers = ['vue'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['vue.config.{js,ts}'];
 const resolveConfig = async (config, options) => {
-    const { cwd, isProduction, manifest } = options;
-    const deps = [];
+    const { cwd, manifest } = options;
+    const inputs = [];
     if (config.configureWebpack) {
         const baseConfig = {
             mode: 'development',
@@ -16,19 +17,18 @@ const resolveConfig = async (config, options) => {
             module: { rules: [] },
         };
         const modifiedConfig = typeof config.configureWebpack === 'function' ? config.configureWebpack(baseConfig) : config.configureWebpack;
-        const { dependencies } = await findWebpackDependenciesFromConfig({
+        const inputsFromConfig = await findWebpackDependenciesFromConfig({
             config: modifiedConfig ?? baseConfig,
             cwd,
         });
-        for (const dependency of dependencies)
-            deps.push(dependency);
+        for (const input of inputsFromConfig)
+            inputs.push(input);
     }
-    if (!isProduction &&
-        manifest.scripts &&
+    if (manifest.scripts &&
         Object.values(manifest.scripts).some(script => /(?<=^|\s)vue-cli-service(\s|\s.+\s)lint(?=\s|$)/.test(script))) {
-        deps.push('@vue/cli-plugin-eslint');
+        inputs.push(toDevDependency('@vue/cli-plugin-eslint'));
     }
-    return deps;
+    return inputs;
 };
 export default {
     title,

package/dist/plugins/webdriver-io/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 { WebdriverIOConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/webdriver-io/index.js

@@ -1,4 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'WebdriverIO';
 const enablers = ['@wdio/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -22,7 +23,7 @@ const resolveConfig = async (config) => {
         })
             .map(reporter => `@wdio/${reporter}-reporter`)
         : [];
-    return [...frameworks, ...runners, ...reporters];
+    return [...frameworks, ...runners, ...reporters].map(toDependency);
 };
 export default {
     title,

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

@@ -1,12 +1,10 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+import { type Input } from '../../util/input.js';
 import type { WebpackConfig } from './types.js';
 export declare const findWebpackDependenciesFromConfig: ({ config, cwd }: {
     config: WebpackConfig;
     cwd: string;
-}) => Promise<{
-    dependencies: Set<string>;
-    entryPatterns: Set<string>;
-}>;
+}) => Promise<Set<Input>>;
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/webpack/index.js

@@ -1,12 +1,12 @@
-import { compact } from '#p/util/array.js';
-import { isAbsolute, isInternal, join, relative } from '#p/util/path.js';
-import { hasDependency } from '#p/util/plugin.js';
-import { toEntryPattern, toProductionEntryPattern } from '#p/util/protocols.js';
+import { compact } from '../../util/array.js';
+import { toDeferResolve, toDependency, toDevDependency, toEntry, toProductionEntry, } from '../../util/input.js';
+import { isAbsolute, isInternal, join, relative } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 const title = 'Webpack';
 const enablers = ['webpack', 'webpack-cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['webpack.config*.{js,ts,mjs,cjs,mts,cts}'];
+const config = ['webpack.config.{js,ts,mjs,cjs,mts,cts}'];
 const production = [];
 const hasBabelOptions = (use) => Boolean(use) &&
     typeof use !== 'string' &&
@@ -24,13 +24,15 @@ const resolveRuleSetDependencies = (rule) => {
     if (typeof useItem === 'function')
         useItem = useItem(info);
     if (typeof useItem === 'string' && hasBabelOptions(rule)) {
-        return [useItem, ...getDependenciesFromConfig(rule.options)];
+        const d = getDependenciesFromConfig(rule.options).map(d => d.specifier);
+        return [useItem, ...d];
     }
     return [useItem].flat().flatMap((item) => {
         if (!item)
             return [];
         if (hasBabelOptions(item)) {
-            return [...resolveUseItem(item), ...getDependenciesFromConfig(item.options)];
+            const d = getDependenciesFromConfig(item.options).map(d => d.specifier);
+            return [...resolveUseItem(item), ...d];
         }
         if (typeof item !== 'string' && 'oneOf' in item)
             return item.oneOf?.flatMap(resolveRuleSetDependencies) ?? [];
@@ -48,8 +50,7 @@ const resolveUseItem = (use) => {
 };
 export const findWebpackDependenciesFromConfig = async ({ config, cwd }) => {
     const passes = typeof config === 'function' ? [false, true] : [false];
-    const dependencies = new Set();
-    const entryPatterns = new Set();
+    const inputs = new Set();
     for (const isProduction of passes) {
         const env = { production: isProduction };
         const argv = { mode: isProduction ? 'production' : 'development' };
@@ -57,7 +58,7 @@ export const findWebpackDependenciesFromConfig = async ({ config, cwd }) => {
         for (const options of [resolvedConfig].flat()) {
             const entries = [];
             for (const loader of options.module?.rules?.flatMap(resolveRuleSetDependencies) ?? []) {
-                dependencies.add(loader.replace(/\?.*/, ''));
+                inputs.add(toDeferResolve(loader.replace(/\?.*/, '')));
             }
             if (typeof options.entry === 'string')
                 entries.push(options.entry);
@@ -77,28 +78,26 @@ export const findWebpackDependenciesFromConfig = async ({ config, cwd }) => {
             }
             for (const entry of entries) {
                 if (!isInternal(entry)) {
-                    dependencies.add(entry);
+                    inputs.add(toDependency(entry));
                 }
                 else {
                     const absoluteEntry = isAbsolute(entry) ? entry : join(options.context ? options.context : cwd, entry);
                     const item = relative(cwd, absoluteEntry);
-                    const value = options.mode === 'development' ? toEntryPattern(item) : toProductionEntryPattern(item);
-                    entryPatterns.add(value);
+                    const value = options.mode === 'development' ? toEntry(item) : toProductionEntry(item);
+                    inputs.add(value);
                 }
             }
         }
     }
-    return { dependencies, entryPatterns };
+    return inputs;
 };
 const resolveConfig = async (localConfig, options) => {
-    const { cwd, isProduction, manifest } = options;
-    const { entryPatterns, dependencies } = await findWebpackDependenciesFromConfig({ config: localConfig, cwd });
-    if (isProduction)
-        return [...entryPatterns];
+    const { cwd, manifest } = options;
+    const inputs = await findWebpackDependenciesFromConfig({ config: localConfig, cwd });
     const scripts = Object.values(manifest.scripts ?? {});
     const webpackCLI = scripts.some(script => script && /(?<=^|\s)webpack(?=\s|$)/.test(script)) ? ['webpack-cli'] : [];
     const webpackDevServer = scripts.some(script => script?.includes('webpack serve')) ? ['webpack-dev-server'] : [];
-    return compact([...entryPatterns, ...dependencies, ...webpackCLI, ...webpackDevServer]);
+    return compact([...inputs, [...webpackCLI, ...webpackDevServer].map(toDevDependency)].flat());
 };
 export default {
     title,

package/dist/plugins/wireit/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 { WireitConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/wireit/index.js

@@ -1,4 +1,4 @@
-import { getDependenciesFromScripts, hasDependency } from '#p/util/plugin.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Wireit';
 const enablers = ['wireit'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -6,7 +6,7 @@ const packageJsonPath = 'wireit';
 const config = ['package.json'];
 const resolveConfig = (localConfig, options) => {
     const scripts = Object.values(localConfig).flatMap(({ command: script }) => (script ? [script] : []));
-    const scriptDependencies = getDependenciesFromScripts(scripts, options);
+    const scriptDependencies = options.getInputsFromScripts(scripts);
     return scriptDependencies;
 };
 export default {

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

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

package/dist/plugins/wrangler/index.js

@@ -1,10 +1,11 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toProductionEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Wrangler';
 const enablers = ['wrangler'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['wrangler.{json,toml}'];
 const resolveEntryPaths = async (config) => {
-    return config.main ? [config.main] : [];
+    return (config.main ? [config.main] : []).map(id => toProductionEntry(id));
 };
 export default {
     title,

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

@@ -1,8 +1,8 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { XOConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: import("#p/types/config.js").IgnorePatterns;
+    enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     entry: string[];

package/dist/plugins/xo/index.js

@@ -1,5 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
-import { getDependenciesDeep } from '../eslint/helpers.js';
+import { hasDependency } from '../../util/plugin.js';
+import { getDependencies } from '../eslint/helpers.js';
 const title = 'xo';
 const enablers = ['xo'];
 const isEnabled = ({ dependencies, config }) => hasDependency(dependencies, enablers) || 'xo' in config;
@@ -7,8 +7,8 @@ const packageJsonPath = 'xo';
 const config = ['package.json', '.xo-config', '.xo-config.{js,cjs,json}', 'xo.config.{js,cjs}'];
 const entry = ['.xo-config.{js,cjs}', 'xo.config.{js,cjs}'];
 const resolveConfig = async (config, options) => {
-    const dependencies = await getDependenciesDeep(config, options);
-    return [...dependencies];
+    const inputs = getDependencies(config, options);
+    return [...inputs];
 };
 export default {
     title,

package/dist/plugins/yorkie/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 { LintStagedConfig } from '../lint-staged/types.js';
 declare const _default: {
     title: string;

package/dist/plugins/yorkie/index.js

@@ -1,17 +1,18 @@
-import { getDependenciesFromScripts, hasDependency } from '#p/util/plugin.js';
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'yorkie';
 const enablers = ['yorkie'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'gitHooks';
 const config = ['package.json'];
 const resolveConfig = (config, options) => {
-    const dependencies = new Set();
+    const inputs = new Set();
     for (const script of Object.values(config).flat()) {
         const scripts = [script].flat();
-        for (const identifier of getDependenciesFromScripts(scripts, options))
-            dependencies.add(identifier);
+        for (const identifier of options.getInputsFromScripts(scripts))
+            inputs.add(identifier);
     }
-    return ['yorkie', ...dependencies];
+    return [toDependency('yorkie'), ...inputs];
 };
 export default {
     title,

package/dist/plugins.d.ts

@@ -1,4 +1,7 @@
-import type { PluginName } from './types/config.js';
-import type { Plugin } from './types/plugins.js';
-declare const plugins: Record<PluginName, Plugin>;
-export { plugins };
+import type { PluginName } from './types/PluginNames.js';
+import type { Args } from './types/args.js';
+import type { Entries, PluginMap } from './types/config.js';
+declare const PMap: PluginMap;
+declare const PluginEntries: Entries;
+declare const pluginArgsMap: Map<string, [PluginName, Args]>;
+export { PMap as Plugins, PluginEntries, pluginArgsMap };