knip 5.1.2 → 5.1.3

package/dist/plugins/cypress/index.js

@@ -1,32 +1,24 @@
-import { load, hasDependency } from '../../util/plugin.js';
+import { hasDependency } from '#p/util/plugin.js';
 import { toEntryPattern } from '../../util/protocols.js';
-const NAME = 'Cypress';
-const ENABLERS = ['cypress'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['cypress.config.{js,ts,mjs,cjs}'];
+const title = 'Cypress';
+const enablers = ['cypress'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['cypress.config.{js,ts,mjs,cjs}'];
 const TEST_FILE_PATTERNS = ['cypress/e2e/**/*.cy.{js,jsx,ts,tsx}'];
 const SUPPORT_FILE_PATTERNS = [
     'cypress/support/e2e.{js,jsx,ts,tsx}',
     'cypress/support/commands.{js,ts}',
     'cypress/plugins/index.js',
 ];
-const ENTRY_FILE_PATTERNS = [...TEST_FILE_PATTERNS, ...SUPPORT_FILE_PATTERNS];
-const findDependencies = async (configFilePath, options) => {
-    const { config } = options;
-    const localConfig = await load(configFilePath);
-    if (!localConfig)
-        return [];
-    if (config.entry)
-        return config.entry.map(toEntryPattern);
-    const patterns = [localConfig.e2e?.specPattern ?? [], localConfig.component?.specPattern ?? []].flat();
-    const entryPatterns = (patterns.length > 0 ? patterns : TEST_FILE_PATTERNS).map(toEntryPattern);
-    return [...entryPatterns, ...SUPPORT_FILE_PATTERNS.map(toEntryPattern)];
+const entry = [...TEST_FILE_PATTERNS, ...SUPPORT_FILE_PATTERNS];
+const resolveEntryPaths = async (localConfig) => {
+    return [localConfig.e2e?.specPattern ?? [], localConfig.component?.specPattern ?? []].flat().map(toEntryPattern);
 };
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    ENTRY_FILE_PATTERNS,
-    findDependencies,
+    config,
+    entry,
+    resolveEntryPaths,
 };

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

@@ -1,9 +1,10 @@
-import type { GenericPluginCallback, IsPluginEnabledCallback } from '../../types/plugins.js';
+import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { DrizzleConfig } from './types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "Drizzle";
+    readonly enablers: string[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<DrizzleConfig>;
 };
 export default _default;

package/dist/plugins/drizzle/index.js

@@ -1,21 +1,18 @@
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { toProductionEntryPattern } from '../../util/protocols.js';
-const NAME = 'Drizzle';
-const ENABLERS = ['drizzle-kit'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['drizzle.config.{ts,js,json}'];
-const findDrizzleDependencies = async (configFilePath) => {
-    const localConfig = await load(configFilePath);
-    if (!localConfig?.schema)
+import { hasDependency } from '#p/util/plugin.js';
+import { toProductionEntryPattern } from '#p/util/protocols.js';
+const title = 'Drizzle';
+const enablers = ['drizzle-kit'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['drizzle.config.{ts,js,json}'];
+const resolveConfig = config => {
+    if (!config.schema)
         return [];
-    return [localConfig.schema].flat().map(toProductionEntryPattern);
+    return [config.schema].flat().map(toProductionEntryPattern);
 };
-const findDependencies = timerify(findDrizzleDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    resolveConfig,
 };

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

@@ -1,12 +1,14 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import { DummyEleventyConfig } from './helpers.js';
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { EleventyConfig } from './types.js';
+type T = Partial<EleventyConfig> | ((arg: DummyEleventyConfig) => Promise<Partial<EleventyConfig>>);
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    ENTRY_FILE_PATTERNS: string[];
-    PRODUCTION_ENTRY_FILE_PATTERNS: string[];
-    PROJECT_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    production: string[];
+    resolveEntryPaths: ResolveEntryPaths<T>;
+    resolveConfig: ResolveConfig<T>;
 };
 export default _default;

package/dist/plugins/eleventy/index.js

@@ -1,24 +1,16 @@
+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 { dirname, isInNodeModules, join } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { toProductionEntryPattern } from '../../util/protocols.js';
 import { DummyEleventyConfig, defaultEleventyConfig } from './helpers.js';
-const NAME = 'Eleventy';
-const ENABLERS = ['@11ty/eleventy'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['.eleventy.js', 'eleventy.config.{js,cjs,mjs}'];
-const ENTRY_FILE_PATTERNS = [];
-const PRODUCTION_ENTRY_FILE_PATTERNS = ['posts/**/*.11tydata.js', '_data/**/*.{js,cjs,mjs}'];
-const PROJECT_FILE_PATTERNS = [];
-const findEleventyDependencies = async (configFilePath, options) => {
-    const { config } = options;
-    let localConfig = (await load(configFilePath));
-    if (!localConfig)
-        return config.entry
-            ? config.entry.map(toProductionEntryPattern)
-            : PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern);
+const title = 'Eleventy';
+const enablers = ['@11ty/eleventy'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.eleventy.js', 'eleventy.config.{js,cjs,mjs}'];
+const production = ['posts/**/*.11tydata.js', '_data/**/*.{js,cjs,mjs}'];
+const resolveEntryPaths = async (localConfig, options) => {
+    const { configFileDir } = options;
     const dummyUserConfig = new DummyEleventyConfig();
     if (typeof localConfig === 'function')
         localConfig = await localConfig(dummyUserConfig);
@@ -26,38 +18,40 @@ const findEleventyDependencies = async (configFilePath, options) => {
     const dataDir = localConfig?.dir?.data || defaultEleventyConfig.dir.data;
     const templateFormats = localConfig.templateFormats || defaultEleventyConfig.templateFormats;
     const exts = DEFAULT_EXTENSIONS.map(extname => extname.slice(1)).join(',');
-    const copiedPackages = new Set();
     const copiedEntries = new Set();
     for (const path of Object.keys(dummyUserConfig.passthroughCopies)) {
-        const isDir = !path.includes('*') && isDirectory(join(dirname(configFilePath), path));
+        const isDir = !path.includes('*') && isDirectory(join(configFileDir, path));
         if (isDir) {
             copiedEntries.add(join(path, `**/*.{${exts}}`));
         }
-        else if (isInNodeModules(path)) {
-            copiedPackages.add(path);
-        }
-        else {
+        else if (!isInNodeModules(path)) {
             copiedEntries.add(path);
         }
     }
     return [
-        ...(config?.entry ?? [
-            join(inputDir, dataDir, '**/*.js'),
-            join(inputDir, `**/*.{${typeof templateFormats === 'string' ? templateFormats : templateFormats.join(',')}}`),
-            join(inputDir, '**/*.11tydata.js'),
-            ...copiedEntries,
-        ]).map(toProductionEntryPattern),
-        ...copiedPackages,
-    ];
+        join(inputDir, dataDir, '**/*.{js,cjs,mjs}'),
+        join(inputDir, `**/*.{${typeof templateFormats === 'string' ? templateFormats : templateFormats.join(',')}}`),
+        join(inputDir, '**/*.11tydata.js'),
+        ...copiedEntries,
+    ].map(toProductionEntryPattern);
+};
+const resolveConfig = async (localConfig) => {
+    const dummyUserConfig = new DummyEleventyConfig();
+    if (typeof localConfig === 'function')
+        localConfig = await localConfig(dummyUserConfig);
+    const copiedPackages = new Set();
+    for (const path of Object.keys(dummyUserConfig.passthroughCopies)) {
+        if (isInNodeModules(path))
+            copiedPackages.add(path);
+    }
+    return [...copiedPackages];
 };
-const findDependencies = timerify(findEleventyDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    ENTRY_FILE_PATTERNS,
-    PRODUCTION_ENTRY_FILE_PATTERNS,
-    PROJECT_FILE_PATTERNS,
-    findDependencies,
+    config,
+    production,
+    resolveEntryPaths,
+    resolveConfig,
 };

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

@@ -1,7 +1,5 @@
-import type { PackageJson } from '../../types/package-json.js';
-type GetDependenciesDeep = (configFilePath: string, options: {
-    cwd: string;
-    manifest: PackageJson;
-}, dependencies?: Set<string>) => Promise<Set<string>>;
+import type { ESLintConfig } from './types.js';
+import type { PluginOptions } from '../../types/plugins.js';
+type GetDependenciesDeep = (localConfig: ESLintConfig, options: PluginOptions, dependencies?: Set<string>) => Promise<Set<string>>;
 export declare const getDependenciesDeep: GetDependenciesDeep;
 export {};

package/dist/plugins/eslint/helpers.js

@@ -1,11 +1,9 @@
-import { compact } from '../../util/array.js';
-import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-import { basename, isInternal, dirname, toAbsolute, isAbsolute } from '../../util/path.js';
-import { load } from '../../util/plugin.js';
-import { _resolve } from '../../util/require.js';
+import { compact } from '#p/util/array.js';
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '#p/util/modules.js';
+import { isInternal, toAbsolute, isAbsolute } from '#p/util/path.js';
+import { load } from '#p/util/plugin.js';
+import { _resolve } from '#p/util/require.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
-import { fallback } from './fallback.js';
-import { PACKAGE_JSON_PATH } from './index.js';
 const getDependencies = (config) => {
     const extendsSpecifiers = config.extends ? [config.extends].flat().map(resolveExtendSpecifier) : [];
     if (extendsSpecifiers.some(specifier => specifier?.startsWith('eslint-plugin-prettier')))
@@ -19,21 +17,18 @@ const getDependencies = (config) => {
     const overrides = config.overrides ? [config.overrides].flat().flatMap(getDependencies) : [];
     return compact([...extendsSpecifiers, ...plugins, parser, ...babelDependencies, ...settings, ...overrides]);
 };
-export const getDependenciesDeep = async (configFilePath, options, dependencies = new Set()) => {
+export const getDependenciesDeep = async (localConfig, options, dependencies = new Set()) => {
+    const { configFileDir } = options;
     const addAll = (deps) => deps.forEach(dependency => dependencies.add(dependency));
-    const localConfig = basename(configFilePath) === 'package.json'
-        ? options.manifest[PACKAGE_JSON_PATH]
-        : /(\.(jsonc?|ya?ml)|rc)$/.test(configFilePath)
-            ? await load(configFilePath)
-            : await fallback(configFilePath);
     if (localConfig) {
         if (localConfig.extends) {
             for (const extend of [localConfig.extends].flat()) {
                 if (isInternal(extend)) {
-                    const filePath = toAbsolute(extend, dirname(configFilePath));
+                    const filePath = toAbsolute(extend, configFileDir);
                     const extendConfigFilePath = _resolve(filePath);
                     dependencies.add(extendConfigFilePath);
-                    addAll(await getDependenciesDeep(extendConfigFilePath, options, dependencies));
+                    const localConfig = await load(extendConfigFilePath);
+                    addAll(await getDependenciesDeep(localConfig, options, dependencies));
                 }
             }
         }

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

@@ -1,11 +1,13 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
-export declare const PACKAGE_JSON_PATH = "eslintConfig";
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { ESLintConfig } from './types.js';
+export declare const packageJsonPath = "eslintConfig";
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    PACKAGE_JSON_PATH: string;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "ESLint";
+    readonly enablers: string[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly packageJsonPath: "eslintConfig";
+    readonly entry: string[];
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<ESLintConfig>;
 };
 export default _default;

package/dist/plugins/eslint/index.js

@@ -1,37 +1,23 @@
-import { basename } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { hasDependency } from '../../util/plugin.js';
+import { hasDependency } from '#p/util/plugin.js';
 import { getDependenciesDeep } from './helpers.js';
-const NAME = 'ESLint';
-const ENABLERS = ['eslint'];
-const isEnabled = ({ dependencies, manifest, config }) => hasDependency(dependencies, ENABLERS) ||
+const title = 'ESLint';
+const enablers = ['eslint'];
+const isEnabled = ({ dependencies, manifest, config }) => hasDependency(dependencies, enablers) ||
     'eslint' in config ||
     Boolean(manifest.name && /(^eslint-config|\/eslint-config)/.test(manifest.name));
-export const PACKAGE_JSON_PATH = 'eslintConfig';
-const CONFIG_FILE_PATTERNS = [
-    'eslint.config.{js,cjs,mjs}',
-    '.eslintrc',
-    '.eslintrc.{js,json,cjs}',
-    '.eslintrc.{yml,yaml}',
-    'package.json',
-];
-const findESLintDependencies = async (configFilePath, { cwd, manifest, isProduction }) => {
-    if (isProduction)
-        return [];
-    const baseFilePath = basename(configFilePath);
-    if (baseFilePath === 'eslint.config.js' ||
-        baseFilePath === 'eslint.config.cjs' ||
-        baseFilePath === 'eslint.config.mjs')
-        return [];
-    const dependencies = await getDependenciesDeep(configFilePath, { cwd, manifest });
+export 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 findDependencies = timerify(findESLintDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    PACKAGE_JSON_PATH,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    packageJsonPath,
+    entry,
+    config,
+    resolveConfig,
 };

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

@@ -1,10 +1,11 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { GatsbyConfig, GatsbyNode } from './types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    PRODUCTION_ENTRY_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    production: string[];
+    resolveConfig: ResolveConfig<GatsbyConfig | GatsbyNode>;
 };
 export default _default;

package/dist/plugins/gatsby/index.js

@@ -1,11 +1,9 @@
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { toProductionEntryPattern } from '../../util/protocols.js';
-const NAME = 'Gatsby';
-const ENABLERS = ['gatsby', 'gatsby-cli'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['gatsby-{config,node}.{js,jsx,ts,tsx}', 'plugins/**/gatsby-node.{js,jsx,ts,tsx}'];
-const PRODUCTION_ENTRY_FILE_PATTERNS = [
+import { hasDependency } from '#p/util/plugin.js';
+const title = 'Gatsby';
+const enablers = ['gatsby', 'gatsby-cli'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['gatsby-{config,node}.{js,jsx,ts,tsx}', 'plugins/**/gatsby-node.{js,jsx,ts,tsx}'];
+const production = [
     'gatsby-{browser,ssr}.{js,jsx,ts,tsx}',
     'src/api/**/*.{js,ts}',
     'src/pages/**/*.{js,jsx,ts,tsx}',
@@ -13,16 +11,12 @@ const PRODUCTION_ENTRY_FILE_PATTERNS = [
     'src/html.{js,jsx,ts,tsx}',
     'plugins/**/gatsby-{browser,ssr}.{js,jsx,ts,tsx}',
 ];
-const findGatsbyDependencies = async (configFilePath, options) => {
-    const { isProduction, config } = options;
-    const localConfig = await load(configFilePath);
-    const entryPatterns = (config.entry ?? PRODUCTION_ENTRY_FILE_PATTERNS).map(toProductionEntryPattern);
-    if (isProduction || !localConfig)
-        return entryPatterns;
-    if (/gatsby-config/.test(configFilePath)) {
+const resolveConfig = async (localConfig, options) => {
+    const { configFileName } = options;
+    if (/gatsby-config/.test(configFileName)) {
         return localConfig.plugins.map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve));
     }
-    if (/gatsby-node/.test(configFilePath)) {
+    if (/gatsby-node/.test(configFileName)) {
         const plugins = new Set();
         const actions = { setBabelPlugin: plugin => plugins.add(plugin.name) };
         const _config = localConfig;
@@ -33,12 +27,11 @@ const findGatsbyDependencies = async (configFilePath, options) => {
     }
     return [];
 };
-const findDependencies = timerify(findGatsbyDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    PRODUCTION_ENTRY_FILE_PATTERNS,
-    findDependencies,
+    config,
+    production,
+    resolveConfig,
 };

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

@@ -1,9 +1,9 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string;
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string;
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    resolveConfig: ResolveConfig;
 };
 export default _default;

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

@@ -1,38 +1,28 @@
-import { _firstGlob } from '../../util/glob.js';
-import { getValuesByKeyDeep } from '../../util/object.js';
-import { basename, dirname, join } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { getDependenciesFromScripts, load } from '../../util/plugin.js';
-function isString(value) {
-    return typeof value === 'string';
-}
-const NAME = 'GitHub Actions';
-const ENABLERS = 'This plugin is enabled when a `.yml` or `.yaml` file is found in the `.github/workflows` folder.';
+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';
+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_FILE_PATTERNS = ['.github/workflows/*.{yml,yaml}', '.github/**/action.{yml,yaml}'];
-const findGithubActionsDependencies = async (configFilePath, options) => {
-    const { isProduction } = options;
-    const configFileName = basename(configFilePath);
-    if (isProduction)
-        return [];
-    const config = await load(configFilePath);
-    if (!config)
-        return [];
+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 getActionDependencies = () => {
         const isActionManifest = configFileName === 'action.yml' || configFileName === 'action.yaml';
         if (!isActionManifest || !config?.runs?.using?.startsWith('node'))
             return [];
         const scripts = [config.runs.pre, config.runs.main, config.runs.post].filter(isString);
-        return scripts.map(script => join(dirname(configFilePath), script));
+        return scripts.map(script => join(configFileDir, script));
     };
     return [...getActionDependencies(), ...getDependenciesFromScripts(scripts, { ...options, knownGlobalsOnly: true })];
 };
-const findDependencies = timerify(findGithubActionsDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    resolveConfig,
 };

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

@@ -1,10 +1,11 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { GraphqlCodegenTypes } from './types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: RegExp[];
-    isEnabled: IsPluginEnabledCallback;
-    PACKAGE_JSON_PATH: string;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "GraphQL Codegen";
+    readonly enablers: RegExp[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly packageJsonPath: "codegen";
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<GraphqlCodegenTypes>;
 };
 export default _default;

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

@@ -1,26 +1,19 @@
-import { basename, isInternal } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
+import { isInternal } from '#p/util/path.js';
+import { hasDependency } from '#p/util/plugin.js';
+import { toEntryPattern } from '#p/util/protocols.js';
 import { isConfigurationOutput } from './types.js';
-const NAME = 'GraphQL Codegen';
-const ENABLERS = [/^@graphql-codegen\//];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const PACKAGE_JSON_PATH = 'codegen';
-const CONFIG_FILE_PATTERNS = [
+const title = 'GraphQL Codegen';
+const enablers = [/^@graphql-codegen\//];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const packageJsonPath = 'codegen';
+const config = [
     'codegen.{json,yml,yaml,js,ts,mjs,cts}',
     '.codegenrc.{json,yml,yaml,js,ts}',
     'codegen.config.js',
     'package.json',
 ];
-const findPluginDependencies = async (configFilePath, options) => {
-    const { manifest, isProduction } = options;
-    if (isProduction)
-        return [];
-    const localConfig = basename(configFilePath) === 'package.json' ? manifest[PACKAGE_JSON_PATH] : await load(configFilePath);
-    if (!localConfig)
-        return [];
-    const generateSet = localConfig.generates ? Object.values(localConfig.generates) : [];
+const resolveConfig = config => {
+    const generateSet = config.generates ? Object.values(config.generates) : [];
     const configurationOutput = generateSet.filter(isConfigurationOutput);
     const presets = configurationOutput
         .map(configOutput => (configOutput.preset ? configOutput.preset : undefined))
@@ -41,12 +34,11 @@ const findPluginDependencies = async (configFilePath, options) => {
     });
     return [...presets, ...flatPlugins, ...nestedPlugins];
 };
-const findDependencies = timerify(findPluginDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    PACKAGE_JSON_PATH,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    packageJsonPath,
+    config,
+    resolveConfig,
 };

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

@@ -1,9 +1,9 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/plugins.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    resolveConfig: ResolveConfig<string>;
 };
 export default _default;

package/dist/plugins/husky/index.js

@@ -1,25 +1,19 @@
 import { getGitHookPaths } from '../../util/git.js';
-import { timerify } from '../../util/Performance.js';
-import { getDependenciesFromScripts, hasDependency, loadFile } from '../../util/plugin.js';
-const NAME = 'husky';
-const ENABLERS = ['husky'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+import { getDependenciesFromScripts, hasDependency } from '../../util/plugin.js';
+const title = 'husky';
+const enablers = ['husky'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const gitHookPaths = getGitHookPaths('.husky', false);
-const CONFIG_FILE_PATTERNS = [...gitHookPaths];
-const findHuskyDependencies = async (configFilePath, options) => {
-    const { isProduction } = options;
-    if (isProduction)
-        return [];
-    const script = await loadFile(configFilePath);
+const config = [...gitHookPaths];
+const resolveConfig = async (script, options) => {
     if (!script)
         return [];
     return getDependenciesFromScripts(String(script), { ...options, knownGlobalsOnly: true });
 };
-const findDependencies = timerify(findHuskyDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    resolveConfig,
 };