knip 0.0.0-graph.3 → 0.0.0-node-types.0

package/dist/plugins/babel/index.js

@@ -1,30 +1,33 @@
 import { compact } from '../../util/array.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
-import { resolvePresetName, resolvePluginName, api } from './helpers.js';
+import { resolveName, api } from './helpers.js';
 export const NAME = 'Babel';
 export const ENABLERS = [/^@babel\//];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = [
-    'babel.config.json',
-    'babel.config.js',
-    '.babelrc.json',
-    '.babelrc.js',
+    'babel.config.{json,js,cjs,mjs,cts}',
+    '.babelrc.{json,js,cjs,mjs,cts}',
     '.babelrc',
     'package.json',
 ];
-const getItemName = (value) => typeof value === 'string' ? [value] : Array.isArray(value) ? [value[0]] : [];
+const getName = (value) => typeof value === 'string' ? [value] : Array.isArray(value) ? [value[0]] : [];
 export const getDependenciesFromConfig = (config) => {
-    const presets = config.presets?.flatMap(getItemName).map(resolvePresetName) ?? [];
-    const plugins = config.plugins?.flatMap(getItemName).map(resolvePluginName) ?? [];
+    const presets = config.presets?.flatMap(getName).map(name => resolveName(name, 'preset')) ?? [];
+    const plugins = config.plugins?.flatMap(getName).map(name => resolveName(name, 'plugin')) ?? [];
     const nested = config.env ? Object.values(config.env).flatMap(getDependenciesFromConfig) : [];
     return compact([...presets, ...plugins, ...nested]);
 };
-const findBabelDependencies = async (configFilePath, { manifest }) => {
-    let config = configFilePath.endsWith('package.json') ? manifest.babel : await load(configFilePath);
-    if (typeof config === 'function') {
-        config = config(api);
-    }
-    return config ? getDependenciesFromConfig(config) : [];
+const findBabelDependencies = async (configFilePath, { manifest, isProduction }) => {
+    if (isProduction)
+        return [];
+    let localConfig = configFilePath.endsWith('package.json')
+        ? manifest.babel
+        : await load(configFilePath);
+    if (typeof localConfig === 'function')
+        localConfig = localConfig(api);
+    if (!localConfig)
+        return [];
+    return getDependenciesFromConfig(localConfig);
 };
 export const findDependencies = timerify(findBabelDependencies);

package/dist/plugins/capacitor/index.js

@@ -4,8 +4,12 @@ export const NAME = 'Capacitor';
 export const ENABLERS = [/^@capacitor\//];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['capacitor.config.ts'];
-const findCapacitorDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    return config.includePlugins ?? [];
+const findCapacitorDependencies = async (configFilePath, { isProduction }) => {
+    if (isProduction)
+        return [];
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    return localConfig.includePlugins ?? [];
 };
 export const findDependencies = timerify(findCapacitorDependencies);

package/dist/plugins/changesets/index.js

@@ -4,12 +4,16 @@ export const NAME = 'Changesets';
 export const ENABLERS = ['@changesets/cli'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['.changeset/config.json'];
-const findChangesetsDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    return Array.isArray(config.changelog)
-        ? [config.changelog[0]]
-        : typeof config.changelog === 'string'
-            ? [config.changelog]
+const findChangesetsDependencies = async (configFilePath, { isProduction }) => {
+    if (isProduction)
+        return [];
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    return Array.isArray(localConfig.changelog)
+        ? [localConfig.changelog[0]]
+        : typeof localConfig.changelog === 'string'
+            ? [localConfig.changelog]
             : [];
 };
 export const findDependencies = timerify(findChangesetsDependencies);

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

@@ -1,6 +1,7 @@
 import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
 export declare const NAME = "Commitizen";
 export declare const ENABLERS: string[];
+export declare const PACKAGE_JSON_PATH = "config.commitizen";
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/commitizen/index.js

@@ -2,13 +2,17 @@ import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 export const NAME = 'Commitizen';
 export const ENABLERS = ['commitizen'];
+export const PACKAGE_JSON_PATH = 'config.commitizen';
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['.czrc', '.cz.json', 'package.json'];
-const findPluginDependencies = async (configFilePath, { manifest }) => {
-    const config = configFilePath.endsWith('package.json')
+const findPluginDependencies = async (configFilePath, { manifest, isProduction }) => {
+    if (isProduction)
+        return [];
+    const localConfig = configFilePath.endsWith('package.json')
         ? manifest.config?.commitizen
         : await load(configFilePath);
-    const path = config?.path;
-    return path === undefined ? [] : [path];
+    if (!localConfig)
+        return [];
+    return localConfig.path ? [localConfig.path] : [];
 };
 export const findDependencies = timerify(findPluginDependencies);

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

@@ -1,3 +1,3 @@
-export type PluginConfig = {
+export type CommitizenConfig = {
     path?: string;
 };

package/dist/plugins/commitlint/index.js

@@ -9,10 +9,14 @@ export const CONFIG_FILE_PATTERNS = [
     'commitlint.config.{js,cjs,ts,cts}',
     'package.json',
 ];
-const findCommitLintDependencies = async (configFilePath, { manifest }) => {
-    const config = configFilePath.endsWith('package.json')
+const findCommitLintDependencies = async (configFilePath, { manifest, isProduction }) => {
+    if (isProduction)
+        return [];
+    const localConfig = configFilePath.endsWith('package.json')
         ? manifest.commitlint
         : await load(configFilePath);
-    return config?.extends ? [config.extends].flat() : [];
+    if (!localConfig)
+        return [];
+    return localConfig.extends ? [localConfig.extends].flat() : [];
 };
 export const findDependencies = timerify(findCommitLintDependencies);

package/dist/plugins/cspell/index.js

@@ -9,9 +9,13 @@ export const CONFIG_FILE_PATTERNS = [
     '.c{s,S}pell.json',
     'cSpell.json',
 ];
-const findCspellDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    const imports = config?.import ?? [];
+const findCspellDependencies = async (configFilePath, { isProduction }) => {
+    if (isProduction)
+        return [];
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    const imports = localConfig.import ?? [];
     return imports;
 };
 export const findDependencies = timerify(findCspellDependencies);

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

@@ -1,3 +1,3 @@
-export type PluginConfig = {
+export type CSpellConfig = {
     import?: string[];
 };

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

@@ -1,5 +1,7 @@
-import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+import type { GenericPluginCallback, IsPluginEnabledCallback } from '../../types/plugins.js';
 export declare const NAME = "Cypress";
 export declare const ENABLERS: string[];
 export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
 export declare const ENTRY_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/cypress/index.js

@@ -1,10 +1,23 @@
-import { hasDependency } from '../../util/plugin.js';
+import { load, hasDependency } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Cypress';
 export const ENABLERS = ['cypress'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const ENTRY_FILE_PATTERNS = [
-    'cypress.config.{js,ts,mjs,cjs}',
+export const CONFIG_FILE_PATTERNS = ['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/e2e/**/*.cy.{js,jsx,ts,tsx}',
     'cypress/plugins/index.js',
 ];
+export const ENTRY_FILE_PATTERNS = [...TEST_FILE_PATTERNS, ...SUPPORT_FILE_PATTERNS];
+export 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)];
+};

package/dist/plugins/drizzle/index.js

@@ -1,16 +1,14 @@
-import { _glob } from '../../util/glob.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
+import { toProductionEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Drizzle';
 export const ENABLERS = ['drizzle-kit'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['drizzle.config.{ts,js,json}'];
-const findDrizzleDependencies = async (configFilePath, { cwd }) => {
-    const config = await load(configFilePath);
-    if (!config || !config.schema)
+const findDrizzleDependencies = async (configFilePath) => {
+    const localConfig = await load(configFilePath);
+    if (!localConfig?.schema)
         return [];
-    const patterns = Array.isArray(config.schema) ? config.schema : [config.schema];
-    const paths = await _glob({ cwd, patterns });
-    return paths;
+    return [localConfig.schema].flat().map(toProductionEntryPattern);
 };
 export const findDependencies = timerify(findDrizzleDependencies);

package/dist/plugins/eslint/fallback.js

@@ -1,5 +1,6 @@
 import createJITI from 'jiti';
 import transform from 'jiti/dist/babel.js';
+import { FAKE_PATH } from '../../util/loader.js';
 import { timerify } from '../../util/Performance.js';
 const rushstackMatch = /require\(("|')@rushstack\/(eslint-config\/patch|eslint-patch)\/modern-module-resolution("|')\)/;
 const jiti = createJITI(process.cwd(), {
@@ -9,5 +10,9 @@ const jiti = createJITI(process.cwd(), {
         return transform(opts);
     },
 });
-const load = (configFilePath) => jiti(configFilePath);
+const load = (configFilePath) => {
+    if (configFilePath === FAKE_PATH)
+        return;
+    return jiti(configFilePath);
+};
 export const fallback = timerify(load);

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

@@ -1,14 +1,7 @@
-/// <reference types="npmcli__package-json" />
-import type { ESLintConfig } from './types.js';
-import type { PackageJson } from '@npmcli/package-json';
-type Manifest = PackageJson & {
-    eslintConfig?: ESLintConfig;
-};
-type GetDependenciesDeep = (configFilePath: string, dependencies: Set<string>, options: {
+import type { PackageJsonWithPlugins } from '../../types/package-json.js';
+type GetDependenciesDeep = (configFilePath: string, options: {
     cwd: string;
-    manifest: Manifest;
-}) => Promise<Set<string>>;
+    manifest: PackageJsonWithPlugins;
+}, dependencies?: Set<string>) => Promise<Set<string>>;
 export declare const getDependenciesDeep: GetDependenciesDeep;
-export declare const resolvePluginSpecifier: (specifier: string) => string;
-export declare const resolveExtendSpecifier: (specifier: string) => string | undefined;
 export {};

package/dist/plugins/eslint/helpers.js

@@ -1,47 +1,43 @@
 import { compact } from '../../util/array.js';
+import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
 import { isInternal, dirname, toAbsolute } from '../../util/path.js';
 import { load } from '../../util/plugin.js';
 import { _resolve } from '../../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')))
         extendsSpecifiers.push('eslint-config-prettier');
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
     const parser = config.parser;
-    const extraPlugins = config.parserOptions?.babelOptions?.plugins ?? [];
-    const extraParsers = config.parserOptions?.babelOptions?.presets ?? [];
+    const babelDependencies = config.parserOptions?.babelOptions
+        ? getDependenciesFromConfig(config.parserOptions.babelOptions)
+        : [];
     const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
     const overrides = config.overrides ? [config.overrides].flat().flatMap(getDependencies) : [];
-    return compact([
-        ...extendsSpecifiers,
-        ...plugins,
-        ...extraPlugins,
-        parser,
-        ...extraParsers,
-        ...settings,
-        ...overrides,
-    ]);
+    return compact([...extendsSpecifiers, ...plugins, parser, ...babelDependencies, ...settings, ...overrides]);
 };
-export const getDependenciesDeep = async (configFilePath, dependencies = new Set(), options) => {
+export const getDependenciesDeep = async (configFilePath, options, dependencies = new Set()) => {
     const addAll = (deps) => deps.forEach(dependency => dependencies.add(dependency));
-    const config = configFilePath.endsWith('package.json')
-        ? options.manifest.eslintConfig
+    const localConfig = configFilePath.endsWith('package.json')
+        ? options.manifest[PACKAGE_JSON_PATH]
         : /(\.(jsonc?|ya?ml)|rc)$/.test(configFilePath)
             ? await load(configFilePath)
             : await fallback(configFilePath);
-    if (config) {
-        if (config.extends) {
-            for (const extend of [config.extends].flat()) {
+    if (localConfig) {
+        if (localConfig.extends) {
+            for (const extend of [localConfig.extends].flat()) {
                 if (isInternal(extend)) {
                     const filePath = toAbsolute(extend, dirname(configFilePath));
                     const extendConfigFilePath = _resolve(filePath);
                     dependencies.add(extendConfigFilePath);
-                    addAll(await getDependenciesDeep(extendConfigFilePath, dependencies, options));
+                    addAll(await getDependenciesDeep(extendConfigFilePath, options, dependencies));
                 }
             }
         }
-        addAll(getDependencies(config));
+        addAll(getDependencies(localConfig));
     }
     return dependencies;
 };
@@ -53,15 +49,17 @@ const resolveSpecifier = (namespace, rawSpecifier) => {
     const specifier = rawSpecifier.replace(/(^plugin:|:.+$)/, '');
     if (isQualifiedSpecifier(specifier))
         return specifier;
-    if (!specifier.startsWith('@'))
-        return `${namespace}-${specifier}`;
+    if (!specifier.startsWith('@')) {
+        const id = rawSpecifier.startsWith('plugin:') ? getPackageNameFromModuleSpecifier(specifier) : specifier;
+        return `${namespace}-${id}`;
+    }
     const [scope, name, ...rest] = specifier.split('/');
     if (rawSpecifier.startsWith('plugin:') && rest.length === 0)
-        return [scope, namespace, name].join('/');
+        return [scope, namespace].join('/');
     return [scope, name ? `${namespace}-${name}` : namespace, ...rest].join('/');
 };
-export const resolvePluginSpecifier = (specifier) => resolveSpecifier('eslint-plugin', specifier);
-export const resolveExtendSpecifier = (specifier) => {
+const resolvePluginSpecifier = (specifier) => resolveSpecifier('eslint-plugin', specifier);
+const resolveExtendSpecifier = (specifier) => {
     if (isInternal(specifier))
         return;
     if (/^next(\/.+)?$/.test(specifier))
@@ -70,7 +68,7 @@ export const resolveExtendSpecifier = (specifier) => {
     return resolveSpecifier(namespace, specifier);
 };
 const getDependenciesFromSettings = (settings = {}) => {
-    return compact(Object.entries(settings).flatMap(([settingKey, settings]) => {
+    return Object.entries(settings).flatMap(([settingKey, settings]) => {
         if (settingKey === 'import/resolver') {
             return (typeof settings === 'string' ? [settings] : Object.keys(settings))
                 .filter(key => key !== 'node')
@@ -79,5 +77,5 @@ const getDependenciesFromSettings = (settings = {}) => {
         if (settingKey === 'import/parsers') {
             return typeof settings === 'string' ? [settings] : Object.keys(settings);
         }
-    }));
+    });
 };

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

@@ -1,7 +1,7 @@
 import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
 export declare const NAME = "ESLint";
 export declare const ENABLERS: string[];
+export declare const PACKAGE_JSON_PATH = "eslintConfig";
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
-export declare const ENTRY_FILE_PATTERNS: string[];
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/eslint/index.js

@@ -3,13 +3,23 @@ import { hasDependency } from '../../util/plugin.js';
 import { getDependenciesDeep } from './helpers.js';
 export const NAME = 'ESLint';
 export const ENABLERS = ['eslint'];
+export const PACKAGE_JSON_PATH = 'eslintConfig';
 export const isEnabled = ({ dependencies, manifest, config }) => hasDependency(dependencies, ENABLERS) ||
     'eslint' in config ||
     Boolean(manifest.name && /(^eslint-config|\/eslint-config)/.test(manifest.name));
-export const CONFIG_FILE_PATTERNS = ['.eslintrc', '.eslintrc.{js,json,cjs}', '.eslintrc.{yml,yaml}', 'package.json'];
-export const ENTRY_FILE_PATTERNS = ['eslint.config.js'];
-const findESLintDependencies = async (configFilePath, { cwd, manifest }) => {
-    const dependencies = await getDependenciesDeep(configFilePath, new Set(), { cwd, manifest });
+export const CONFIG_FILE_PATTERNS = [
+    'eslint.config.js',
+    '.eslintrc',
+    '.eslintrc.{js,json,cjs}',
+    '.eslintrc.{yml,yaml}',
+    'package.json',
+];
+const findESLintDependencies = async (configFilePath, { cwd, manifest, isProduction }) => {
+    if (isProduction)
+        return [];
+    if (configFilePath.endsWith('eslint.config.js'))
+        return [];
+    const dependencies = await getDependenciesDeep(configFilePath, { cwd, manifest });
     return Array.from(dependencies);
 };
 export const findDependencies = timerify(findESLintDependencies);

package/dist/plugins/gatsby/index.js

@@ -1,25 +1,31 @@
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
+import { toProductionEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Gatsby';
 export const ENABLERS = ['gatsby', 'gatsby-cli'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = ['gatsby-{config,node}.{js,jsx,ts,tsx}'];
+export const CONFIG_FILE_PATTERNS = ['gatsby-{config,node}.{js,jsx,ts,tsx}', 'plugins/**/gatsby-node.{js,jsx,ts,tsx}'];
 export const PRODUCTION_ENTRY_FILE_PATTERNS = [
     'gatsby-{browser,ssr}.{js,jsx,ts,tsx}',
     'src/api/**/*.{js,ts}',
     'src/pages/**/*.{js,jsx,ts,tsx}',
     'src/templates/**/*.{js,jsx,ts,tsx}',
     'src/html.{js,jsx,ts,tsx}',
+    'plugins/**/gatsby-{browser,ssr}.{js,jsx,ts,tsx}',
 ];
-const findGatsbyDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
+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)) {
-        return config.plugins.map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve));
+        return localConfig.plugins.map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve));
     }
     if (/gatsby-node/.test(configFilePath)) {
         const plugins = new Set();
         const actions = { setBabelPlugin: plugin => plugins.add(plugin.name) };
-        const _config = config;
+        const _config = localConfig;
         if (typeof _config.onCreateBabelConfig === 'function') {
             _config.onCreateBabelConfig({ actions });
         }

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

@@ -1,6 +1,6 @@
 import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
 export declare const NAME = "GitHub Actions";
-export declare const ENABLERS = "This plugin is enabled when a `.yml` file is found in the `.github/workflows` folder.";
+export declare const ENABLERS = "This plugin is enabled when a `.yml` or `.yaml` file is found in the `.github/workflows` folder.";
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
 export declare const findDependencies: GenericPluginCallback;

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

@@ -4,10 +4,13 @@ import { getValuesByKeyDeep } from '../../util/object.js';
 import { timerify } from '../../util/Performance.js';
 import { load } from '../../util/plugin.js';
 export const NAME = 'GitHub Actions';
-export const ENABLERS = 'This plugin is enabled when a `.yml` file is found in the `.github/workflows` folder.';
-export const isEnabled = async ({ cwd }) => Boolean(await _firstGlob({ cwd, patterns: ['.github/workflows/*.yml'] }));
-export const CONFIG_FILE_PATTERNS = ['.github/workflows/*.yml', '.github/**/action.{yml,yaml}'];
-const findGithubActionsDependencies = async (configFilePath, { cwd, manifest }) => {
+export const ENABLERS = 'This plugin is enabled when a `.yml` or `.yaml` file is found in the `.github/workflows` folder.';
+export const isEnabled = async ({ cwd }) => Boolean(await _firstGlob({ cwd, patterns: ['.github/workflows/*.{yml,yaml}'] }));
+export const CONFIG_FILE_PATTERNS = ['.github/workflows/*.{yml,yaml}', '.github/**/action.{yml,yaml}'];
+const findGithubActionsDependencies = async (configFilePath, options) => {
+    const { cwd, manifest, isProduction } = options;
+    if (isProduction)
+        return [];
     const config = await load(configFilePath);
     if (!config)
         return [];

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

@@ -0,0 +1,7 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "GraphQL Codegen";
+export declare const ENABLERS: RegExp[];
+export declare const PACKAGE_JSON_PATH = "codegen";
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

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

@@ -0,0 +1,46 @@
+import { 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 { isConfigurationOutput } from './types.js';
+export const NAME = 'GraphQL Codegen';
+export const ENABLERS = [/^@graphql-codegen\//];
+export const PACKAGE_JSON_PATH = 'codegen';
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = [
+    '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 = configFilePath.endsWith('package.json')
+        ? manifest[PACKAGE_JSON_PATH]
+        : await load(configFilePath);
+    if (!localConfig)
+        return [];
+    const generateSet = Object.values(localConfig.generates);
+    const configurationOutput = generateSet.filter(isConfigurationOutput);
+    const presets = configurationOutput
+        .map(configOutput => (configOutput.preset ? configOutput.preset : undefined))
+        .filter((preset) => typeof preset === 'string')
+        .map(presetName => `@graphql-codegen/${presetName}${presetName.endsWith('-preset') ? '' : '-preset'}`);
+    const flatPlugins = generateSet
+        .filter((config) => !isConfigurationOutput(config))
+        .flatMap(item => Object.keys(item))
+        .map(plugin => `@graphql-codegen/${plugin}`);
+    const nestedPlugins = configurationOutput
+        .flatMap(configOutput => (configOutput.plugins ? configOutput.plugins : []))
+        .flatMap(plugin => {
+        if (typeof plugin !== 'string')
+            return [];
+        if (isInternal(plugin))
+            return [toEntryPattern(plugin)];
+        return [`@graphql-codegen/${plugin}`];
+    });
+    return [...presets, ...flatPlugins, ...nestedPlugins];
+};
+export const findDependencies = timerify(findPluginDependencies);

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

@@ -0,0 +1,25 @@
+type PluginConfig<T = unknown> = {
+    [key: string]: T;
+};
+export interface ConfiguredPlugin {
+    [name: string]: PluginConfig;
+}
+type NamedPlugin = string;
+type OutputConfig = NamedPlugin | ConfiguredPlugin;
+type PresetNamesBase = 'client' | 'near-operation-file' | 'gql-tag-operations' | 'graphql-modules' | 'import-types';
+export type PresetNames = `${PresetNamesBase}-preset` | PresetNamesBase;
+type OutputPreset = {
+    buildGeneratesSection: (options: unknown) => Promise<unknown>;
+    prepareDocuments?: (outputFilePath: string, outputSpecificDocuments: unknown) => Promise<unknown>;
+};
+export declare function isConfigurationOutput(config: ConfiguredOutput | ConfiguredPlugin[]): config is ConfiguredOutput;
+interface ConfiguredOutput {
+    plugins?: OutputConfig[];
+    preset?: PresetNames | OutputPreset;
+}
+export interface GraphqlCodegenTypes {
+    generates: {
+        [outputPath: string]: ConfiguredOutput | ConfiguredPlugin[];
+    };
+}
+export {};

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

@@ -0,0 +1,3 @@
+export function isConfigurationOutput(config) {
+    return 'preset' in config || 'plugins' in config;
+}

package/dist/plugins/husky/index.js

@@ -1,15 +1,20 @@
-import { readFileSync } from 'fs';
 import { _getDependenciesFromScripts } from '../../binaries/index.js';
 import { getGitHookPaths } from '../../util/git.js';
+import { FAKE_PATH } from '../../util/loader.js';
 import { timerify } from '../../util/Performance.js';
-import { hasDependency } from '../../util/plugin.js';
+import { hasDependency, loadFile } from '../../util/plugin.js';
 export const NAME = 'husky';
 export const ENABLERS = ['husky'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 const gitHookPaths = getGitHookPaths('.husky');
 export const CONFIG_FILE_PATTERNS = [...gitHookPaths];
-const findHuskyDependencies = async (configFilePath, { cwd, manifest }) => {
-    const script = readFileSync(configFilePath);
+const findHuskyDependencies = async (configFilePath, options) => {
+    const { cwd, manifest, isProduction } = options;
+    if (isProduction || configFilePath === FAKE_PATH)
+        return [];
+    const script = await loadFile(configFilePath);
+    if (!script)
+        return [];
     return _getDependenciesFromScripts(String(script), {
         cwd,
         manifest,

package/dist/plugins/index.d.ts

@@ -1,4 +1,5 @@
 export * as angular from './angular/index.js';
+export * as astro from './astro/index.js';
 export * as ava from './ava/index.js';
 export * as babel from './babel/index.js';
 export * as capacitor from './capacitor/index.js';
@@ -11,6 +12,7 @@ export * as drizzle from './drizzle/index.js';
 export * as eslint from './eslint/index.js';
 export * as gatsby from './gatsby/index.js';
 export * as githubActions from './github-actions/index.js';
+export * as graphqlCodegen from './graphql-codegen/index.js';
 export * as husky from './husky/index.js';
 export * as jest from './jest/index.js';
 export * as lefthook from './lefthook/index.js';
@@ -18,6 +20,7 @@ export * as lintStaged from './lint-staged/index.js';
 export * as markdownlint from './markdownlint/index.js';
 export * as mocha from './mocha/index.js';
 export * as next from './next/index.js';
+export * as nodeTestRunner from './node-test-runner/index.js';
 export * as npmPackageJsonLint from './npm-package-json-lint/index.js';
 export * as nx from './nx/index.js';
 export * as nyc from './nyc/index.js';
@@ -36,6 +39,7 @@ export * as stryker from './stryker/index.js';
 export * as stylelint from './stylelint/index.js';
 export * as svelte from './svelte/index.js';
 export * as tailwind from './tailwind/index.js';
+export * as tsup from './tsup/index.js';
 export * as typedoc from './typedoc/index.js';
 export * as typescript from './typescript/index.js';
 export * as vite from './vite/index.js';