knip 0.0.0-angular.0

package/dist/plugins/angular/types.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/plugins/ava/index.js

@@ -0,0 +1,20 @@
+import { _getDependenciesFromScripts } from '../../binaries/index.js';
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'Ava';
+export const ENABLERS = ['ava'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['ava.config.{js,cjs,mjs}', 'package.json'];
+export const ENTRY_FILE_PATTERNS = [];
+const findAvaDependencies = async (configFilePath, { cwd, manifest }) => {
+    const config = configFilePath.endsWith('package.json') ? manifest.ava : await load(configFilePath);
+    const requireArgs = (config?.require ?? []).map(require => `--require ${require}`);
+    const otherArgs = config?.nodeArguments ?? [];
+    const cmd = `node ${otherArgs.join(' ')} ${requireArgs.join(' ')}`;
+    return _getDependenciesFromScripts([cmd], {
+        cwd,
+        manifest,
+        knownGlobalsOnly: true,
+    });
+};
+export const findDependencies = timerify(findAvaDependencies);

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

@@ -0,0 +1,4 @@
+export type PluginConfig = {
+    require?: string[];
+    nodeArguments?: string[];
+};

package/dist/plugins/ava/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+export declare const resolvePluginName: (pluginName: string) => string;
+export declare const resolvePresetName: (pluginName: string) => string;
+export declare const api: {
+    assertVersion: () => boolean;
+    cache: {
+        (): undefined;
+        forever(): any;
+        never(): any;
+        using(): any;
+        invalidate(): any;
+    };
+    caller: () => boolean;
+    env: () => boolean;
+    version: string;
+};

package/dist/plugins/babel/helpers.js

@@ -0,0 +1,34 @@
+export const resolvePluginName = (pluginName) => {
+    if (!/babel/.test(pluginName))
+        return `babel-plugin-${pluginName}`;
+    if (pluginName.startsWith('@babel/')) {
+        if (pluginName.startsWith('@babel/plugin'))
+            return pluginName;
+        const [, name] = pluginName.split('/');
+        return `@babel/plugin-${name}`;
+    }
+    return pluginName;
+};
+export const resolvePresetName = (pluginName) => {
+    if (!/babel/.test(pluginName))
+        return `babel-preset-${pluginName}`;
+    if (pluginName.startsWith('@babel/')) {
+        if (pluginName.startsWith('@babel/preset'))
+            return pluginName;
+        const [, name] = pluginName.split('/');
+        return `@babel/preset-${name}`;
+    }
+    return pluginName;
+};
+const cacheFn = () => void 0;
+cacheFn.forever = () => cacheFn;
+cacheFn.never = () => cacheFn;
+cacheFn.using = () => cacheFn;
+cacheFn.invalidate = () => cacheFn;
+export const api = {
+    assertVersion: () => true,
+    cache: cacheFn,
+    caller: () => true,
+    env: () => true,
+    version: '0.0.0',
+};

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

@@ -0,0 +1,8 @@
+import type { BabelConfigObj } from './types.js';
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Babel";
+export declare const ENABLERS: RegExp[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const getDependenciesFromConfig: (config: BabelConfigObj) => string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/babel/index.js

@@ -0,0 +1,30 @@
+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';
+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',
+    '.babelrc',
+    'package.json',
+];
+const getItemName = (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 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) : [];
+};
+export const findDependencies = timerify(findBabelDependencies);

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

@@ -0,0 +1,9 @@
+import { api } from './helpers.js';
+type BabelConfigFn = (options: typeof api) => BabelConfigObj;
+export type BabelConfigObj = {
+    plugins?: (string | [string, unknown])[];
+    presets?: (string | [string, unknown])[];
+    env?: Record<string, BabelConfigObj>;
+};
+export type BabelConfig = BabelConfigObj | BabelConfigFn;
+export {};

package/dist/plugins/babel/types.js

@@ -0,0 +1 @@
+import { api } from './helpers.js';

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

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

package/dist/plugins/capacitor/index.js

@@ -0,0 +1,11 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+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 ?? [];
+};
+export const findDependencies = timerify(findCapacitorDependencies);

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

@@ -0,0 +1,3 @@
+export type CapacitorConfig = {
+    includePlugins?: string[];
+};

package/dist/plugins/capacitor/types.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/plugins/changesets/index.js

@@ -0,0 +1,15 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+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]
+            : [];
+};
+export const findDependencies = timerify(findChangesetsDependencies);

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

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

package/dist/plugins/commitizen/index.js

@@ -0,0 +1,14 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'Commitizen';
+export const ENABLERS = ['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')
+        ? manifest.config?.commitizen
+        : await load(configFilePath);
+    const path = config?.path;
+    return path === undefined ? [] : [path];
+};
+export const findDependencies = timerify(findPluginDependencies);

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

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

package/dist/plugins/commitizen/types.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/plugins/commitlint/index.js

@@ -0,0 +1,18 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'commitlint';
+export const ENABLERS = ['@commitlint/cli'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = [
+    '.commitlintrc',
+    '.commitlintrc.{json,yaml,yml,js,cjs,ts,cts}',
+    'commitlint.config.{js,cjs,ts,cts}',
+    'package.json',
+];
+const findCommitLintDependencies = async (configFilePath, { manifest }) => {
+    const config = configFilePath.endsWith('package.json')
+        ? manifest.commitlint
+        : await load(configFilePath);
+    return config?.extends ? [config.extends].flat() : [];
+};
+export const findDependencies = timerify(findCommitLintDependencies);

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

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

package/dist/plugins/cspell/index.js

@@ -0,0 +1,17 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'cspell';
+export const ENABLERS = ['cspell'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = [
+    'cspell.config.{js,cjs,json,yaml,yml}',
+    'cspell.{json,yaml,yml}',
+    '.c{s,S}pell.json',
+    'cSpell.json',
+];
+const findCspellDependencies = async (configFilePath) => {
+    const config = await load(configFilePath);
+    const imports = config?.import ?? [];
+    return imports;
+};
+export const findDependencies = timerify(findCspellDependencies);

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

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

package/dist/plugins/cspell/types.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/plugins/cypress/index.js

@@ -0,0 +1,10 @@
+import { hasDependency } from '../../util/plugin.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}',
+    'cypress/support/e2e.{js,jsx,ts,tsx}',
+    'cypress/e2e/**/*.cy.{js,jsx,ts,tsx}',
+    'cypress/plugins/index.js',
+];

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

@@ -0,0 +1 @@
+export declare const fallback: (configFilePath: string) => any;

package/dist/plugins/eslint/fallback.js

@@ -0,0 +1,13 @@
+import createJITI from 'jiti';
+import transform from 'jiti/dist/babel.js';
+import { timerify } from '../../util/Performance.js';
+const rushstackMatch = /require\(("|')@rushstack\/(eslint-config\/patch|eslint-patch)\/modern-module-resolution("|')\)/;
+const jiti = createJITI(process.cwd(), {
+    cache: false,
+    transform: (opts) => {
+        opts.source = opts.source.replace(rushstackMatch, '');
+        return transform(opts);
+    },
+});
+const load = (configFilePath) => jiti(configFilePath);
+export const fallback = timerify(load);

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

@@ -0,0 +1,14 @@
+/// <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: {
+    cwd: string;
+    manifest: Manifest;
+}) => 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

@@ -0,0 +1,83 @@
+import { compact } from '../../util/array.js';
+import { isInternal, dirname, toAbsolute } from '../../util/path.js';
+import { load } from '../../util/plugin.js';
+import { _resolve } from '../../util/require.js';
+import { fallback } from './fallback.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 settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
+    const overrides = config.overrides ? [config.overrides].flat().flatMap(getDependencies) : [];
+    return compact([
+        ...extendsSpecifiers,
+        ...plugins,
+        ...extraPlugins,
+        parser,
+        ...extraParsers,
+        ...settings,
+        ...overrides,
+    ]);
+};
+export const getDependenciesDeep = async (configFilePath, dependencies = new Set(), options) => {
+    const addAll = (deps) => deps.forEach(dependency => dependencies.add(dependency));
+    const config = configFilePath.endsWith('package.json')
+        ? options.manifest.eslintConfig
+        : /(\.(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 (isInternal(extend)) {
+                    const filePath = toAbsolute(extend, dirname(configFilePath));
+                    const extendConfigFilePath = _resolve(filePath);
+                    dependencies.add(extendConfigFilePath);
+                    addAll(await getDependenciesDeep(extendConfigFilePath, dependencies, options));
+                }
+            }
+        }
+        addAll(getDependencies(config));
+    }
+    return dependencies;
+};
+const isQualifiedSpecifier = (specifier) => specifier === 'eslint' ||
+    /\/eslint-(config|plugin)$/.test(specifier) ||
+    /.+eslint-(config|plugin)\//.test(specifier) ||
+    /eslint-(config|plugin)-/.test(specifier);
+const resolveSpecifier = (namespace, rawSpecifier) => {
+    const specifier = rawSpecifier.replace(/(^plugin:|:.+$)/, '');
+    if (isQualifiedSpecifier(specifier))
+        return specifier;
+    if (!specifier.startsWith('@'))
+        return `${namespace}-${specifier}`;
+    const [scope, name, ...rest] = specifier.split('/');
+    if (rawSpecifier.startsWith('plugin:') && rest.length === 0)
+        return [scope, namespace, name].join('/');
+    return [scope, name ? `${namespace}-${name}` : namespace, ...rest].join('/');
+};
+export const resolvePluginSpecifier = (specifier) => resolveSpecifier('eslint-plugin', specifier);
+export const resolveExtendSpecifier = (specifier) => {
+    if (isInternal(specifier))
+        return;
+    if (/^next(\/.+)?$/.test(specifier))
+        return specifier;
+    const namespace = specifier.startsWith('plugin:') ? 'eslint-plugin' : 'eslint-config';
+    return resolveSpecifier(namespace, specifier);
+};
+const getDependenciesFromSettings = (settings = {}) => {
+    return compact(Object.entries(settings).flatMap(([settingKey, settings]) => {
+        if (settingKey === 'import/resolver') {
+            return (typeof settings === 'string' ? [settings] : Object.keys(settings))
+                .filter(key => key !== 'node')
+                .map(key => `eslint-import-resolver-${key}`);
+        }
+        if (settingKey === 'import/parsers') {
+            return typeof settings === 'string' ? [settings] : Object.keys(settings);
+        }
+    }));
+};

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

@@ -0,0 +1,7 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "ESLint";
+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/eslint/index.js

@@ -0,0 +1,15 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency } from '../../util/plugin.js';
+import { getDependenciesDeep } from './helpers.js';
+export const NAME = 'ESLint';
+export const ENABLERS = ['eslint'];
+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 });
+    return Array.from(dependencies);
+};
+export const findDependencies = timerify(findESLintDependencies);

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

@@ -0,0 +1,27 @@
+type ParserOptions = {
+    project?: string;
+    babelOptions?: {
+        plugins: string[];
+        presets: string[];
+    };
+};
+type Settings = Record<string, Record<string, unknown> | string>;
+type Rules = Record<string, string | number>;
+type BaseConfig = {
+    extends?: string | string[];
+    parser?: string;
+    parserOptions?: ParserOptions;
+    processor?: string;
+    plugins?: string[];
+    settings?: Settings;
+    rules?: Rules;
+};
+export type OverrideConfig = BaseConfig & {
+    files: string[];
+    overrides: OverrideConfig;
+};
+export type ESLintConfig = BaseConfig & {
+    env?: Record<string, boolean>;
+    overrides?: OverrideConfig[];
+};
+export {};

package/dist/plugins/eslint/types.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/plugins/gatsby/index.js

@@ -0,0 +1,30 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.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 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}',
+];
+const findGatsbyDependencies = async (configFilePath) => {
+    const config = await load(configFilePath);
+    if (/gatsby-config/.test(configFilePath)) {
+        return config.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;
+        if (typeof _config.onCreateBabelConfig === 'function') {
+            _config.onCreateBabelConfig({ actions });
+        }
+        return Array.from(plugins);
+    }
+    return [];
+};
+export const findDependencies = timerify(findGatsbyDependencies);

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

@@ -0,0 +1,15 @@
+export type GatsbyConfig = {
+    plugins: (string | {
+        resolve: string;
+    })[];
+};
+export type GatsbyActions = {
+    actions: {
+        setBabelPlugin: ({ name }: {
+            name: string;
+        }) => void;
+    };
+};
+export type GatsbyNode = {
+    onCreateBabelConfig: (options: GatsbyActions) => void;
+};

package/dist/plugins/gatsby/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +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 isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

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

@@ -0,0 +1,21 @@
+import { _getDependenciesFromScripts } from '../../binaries/index.js';
+import { _firstGlob } from '../../util/glob.js';
+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 }) => {
+    const config = await load(configFilePath);
+    if (!config)
+        return [];
+    const scripts = getValuesByKeyDeep(config, 'run').filter((value) => typeof value === 'string');
+    return _getDependenciesFromScripts(scripts, {
+        cwd,
+        manifest,
+        knownGlobalsOnly: true,
+    });
+};
+export const findDependencies = timerify(findGithubActionsDependencies);

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

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

package/dist/plugins/husky/index.js

@@ -0,0 +1,19 @@
+import { readFileSync } from 'fs';
+import { _getDependenciesFromScripts } from '../../binaries/index.js';
+import { getGitHookPaths } from '../../util/git.js';
+import { timerify } from '../../util/Performance.js';
+import { hasDependency } 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);
+    return _getDependenciesFromScripts(String(script), {
+        cwd,
+        manifest,
+        knownGlobalsOnly: true,
+    });
+};
+export const findDependencies = timerify(findHuskyDependencies);