@vijayhardaha/dev-config 2.2.0 → 2.3.0

package/src/eslint/lib/{ignores.test.js → __tests__/ignores.test.js}

@@ -5,7 +5,7 @@ describe('eslint/lib/ignores.js', () => {
   // Test that the module exports the globalIgnores function.
   it('should export globalIgnores function', async () => {
     // Dynamically import the ignores module to test its exports.
-    const module = await import('./ignores.js');
+    const module = await import('../ignores.js');
 
     // Verify that globalIgnores is a function.
     expect(typeof module.globalIgnores).toBe('function');
@@ -14,7 +14,7 @@ describe('eslint/lib/ignores.js', () => {
   // Test that globalIgnores returns an array (ESLint's expected format for ignores).
   it('should return an array of config objects', async () => {
     // Dynamically import the ignores module to test its function.
-    const module = await import('./ignores.js');
+    const module = await import('../ignores.js');
 
     // Call globalIgnores with no parameters to get default ignores.
     const result = module.globalIgnores();
@@ -26,7 +26,7 @@ describe('eslint/lib/ignores.js', () => {
   // Test that globalIgnores properly merges user-provided ignores with defaults.
   it('should merge user ignores with default ignores', async () => {
     // Dynamically import the ignores module to test its function.
-    const module = await import('./ignores.js');
+    const module = await import('../ignores.js');
 
     // Call globalIgnores with a custom ignore pattern.
     const result = module.globalIgnores(['**/custom-ignore/']);

package/src/eslint/lib/{index.test.js → __tests__/index.test.js}

@@ -5,7 +5,7 @@ describe('eslint/lib/index.js', () => {
   // Test that the module exports a files object with TypeScript and non-TypeScript file arrays.
   it('should export files object', async () => {
     // Dynamically import the index module to test its exports.
-    const module = await import('./index.js');
+    const module = await import('../index.js');
 
     // Verify that files is an object.
     expect(typeof module.files).toBe('object');
@@ -20,7 +20,7 @@ describe('eslint/lib/index.js', () => {
   // Test that the module exports the buildConfig function.
   it('should export buildConfig function', async () => {
     // Dynamically import the index module to test its exports.
-    const module = await import('./index.js');
+    const module = await import('../index.js');
 
     // Verify that buildConfig is a function.
     expect(typeof module.buildConfig).toBe('function');

package/src/eslint/lib/{language-options.test.js → __tests__/language-options.test.js}

@@ -5,7 +5,7 @@ describe('eslint/lib/language-options.js', () => {
   // Test that the module exports the commonLanguageOptions object.
   it('should export commonLanguageOptions object', async () => {
     // Dynamically import the language-options module to test its exports.
-    const module = await import('./language-options.js');
+    const module = await import('../language-options.js');
 
     // Verify that commonLanguageOptions is an object.
     expect(typeof module.commonLanguageOptions).toBe('object');
@@ -14,7 +14,7 @@ describe('eslint/lib/language-options.js', () => {
   // Test that the exported language options have the correct properties.
   it('should have correct language options properties', async () => {
     // Dynamically import the language-options module to test its exports.
-    const module = await import('./language-options.js');
+    const module = await import('../language-options.js');
 
     // Verify that ecmaVersion is set to 'latest' (ESLint's latest ECMAScript version).
     expect(module.commonLanguageOptions.ecmaVersion).toBe('latest');

package/src/eslint/lib/{rules.test.js → __tests__/rules.test.js}

@@ -6,7 +6,7 @@ describe('eslint/lib/rules.js', () => {
 
   // Module-level import before tests to reduce duplication.
   beforeAll(async () => {
-    const module = await import('./rules.js');
+    const module = await import('../rules.js');
     commonRules = module.commonRules;
   });
 

package/src/eslint/lib/{setup.test.js → __tests__/setup.test.js}

@@ -5,7 +5,7 @@ describe('eslint/lib/setup.js', () => {
   // Test that the module exports the commonParser object with a parser property.
   it('should export commonParser object', async () => {
     // Dynamically import the setup module to test its exports.
-    const module = await import('./setup.js');
+    const module = await import('../setup.js');
 
     // Verify that commonParser is an object.
     expect(typeof module.commonParser).toBe('object');

package/src/eslint/lib/build-config.js

@@ -9,6 +9,7 @@ import prettierRecommended from 'eslint-plugin-prettier/recommended';
 
 import { globalIgnores } from './ignores.js';
 import { commonLanguageOptions } from './language-options.js';
+import { getEnabledPlugins, flattenPlugins, fixupPlugins, stripPlugins, stripParser } from './plugin-helpers/index.js';
 import { commonRules } from './rules.js';
 import { commonParser } from './setup.js';
 
@@ -17,122 +18,22 @@ try {
   createTypeScriptImportResolver = (await import('eslint-import-resolver-typescript')).createTypeScriptImportResolver;
 } catch {
   createTypeScriptImportResolver = null;
-}
-
-/**
- * Filters conditional plugins based on user options.
- *
- * @param {object} conditionalPlugins - Plugin map keyed by option name.
- * @param {object} options - User-provided options.
- *
- * @returns {object[]} Flat config objects for enabled plugins.
- */
-const getEnabledPlugins = (conditionalPlugins, options) =>
-  Object.entries(conditionalPlugins)
-    .filter(([key]) => options[key])
-    .flatMap(([, value]) => (Array.isArray(value) ? value : [value]));
-
-/**
- * Flattens a mixed list of config arrays and objects.
- *
- * @param {(Array|object)[]} plugins - Mixed list of flat config arrays and objects.
- *
- * @returns {object[]} Flattened config array.
- */
-const flattenPlugins = (plugins) => {
-  const result = [];
-
-  for (const plugin of plugins) {
-    if (Array.isArray(plugin)) {
-      result.push(...plugin);
-    } else if (typeof plugin === 'object' && plugin !== null) {
-      result.push(plugin);
-    }
+  // Debug logging for optional dependency failure
+  if (process.env.DEBUG?.includes('eslint') || process.env.DEBUG === '*') {
+    console.debug(
+      '[ESLint Config] Optional dependency "eslint-import-resolver-typescript" not found. '
+        + 'TypeScript import resolution will be disabled. '
+        + 'Install it with: npm install --save-dev eslint-import-resolver-typescript'
+    );
   }
-
-  return result;
-};
-
-/**
- * Wraps plugin rules with fixupPluginRules for backward compatibility.
- *
- * @param {object[]} flatConfigs - Flat config array.
- *
- * @returns {object[]} Config array with wrapped plugin rules.
- */
-const fixPlugins = (flatConfigs) =>
-  flatConfigs.map((config) => {
-    if (!config.plugins) return config;
-
-    const fixed = { ...config, plugins: {} };
-
-    for (const [name, plugin] of Object.entries(config.plugins)) {
-      fixed.plugins[name] = fixupPluginRules(plugin);
-    }
-
-    return fixed;
-  });
-
-/**
- * Removes centrally-registered plugins from individual configs to prevent
- * "Cannot redefine plugin" errors.
- *
- * @param {object[]} flatConfigs - Flat config array.
- * @param {string[]} pluginNames - Plugin names to strip from configs.
- *
- * @returns {object[]} Config array with specified plugins removed.
- */
-const stripPlugins = (flatConfigs, pluginNames) => {
-  if (pluginNames.length === 0) return flatConfigs;
-
-  const skip = new Set(pluginNames);
-
-  return flatConfigs.map((config) => {
-    if (!config.plugins) return config;
-
-    const plugins = { ...config.plugins };
-
-    for (const name of skip) {
-      delete plugins[name];
-    }
-
-    if (Object.keys(plugins).length === 0) {
-      const rest = { ...config };
-      delete rest.plugins;
-
-      return rest;
-    }
-
-    return { ...config, plugins };
-  });
-};
-
-/**
- * Removes the parser from individual configs when the main config provides one.
- * Prevents parser conflicts (e.g., eslint-config-next/parser vs `@typescript-eslint/parser`).
- *
- * @param {object[]} flatConfigs - Flat config array.
- *
- * @returns {object[]} Config array with parsers removed.
- */
-const stripParser = (flatConfigs) =>
-  flatConfigs.map((config) => {
-    if (!config.languageOptions?.parser) return config;
-
-    const languageOptions = { ...config.languageOptions };
-    delete languageOptions.parser;
-
-    return Object.keys(languageOptions).length > 0
-      ? { ...config, languageOptions }
-      : { ...config, languageOptions: undefined };
-  });
+}
 
 /**
  * Merges user-provided global ignores with common defaults.
  *
  * @param {string[]|undefined} userGlobalIgnores - User-provided ignore patterns.
  *
- * @returns {object} ESLint ignores config object.
+ * @returns {import('eslint').Linter.Config[]} ESLint global ignores configuration.
  */
 const mergeGlobalIgnores = (userGlobalIgnores) =>
   Array.isArray(userGlobalIgnores) ? globalIgnores(userGlobalIgnores) : globalIgnores();
@@ -240,7 +141,7 @@ export const buildConfig = ({
   ].filter(Boolean);
 
   const flatConfigs = flattenPlugins(mergedPlugins);
-  const wrappedConfigs = fixPlugins(flatConfigs);
+  const wrappedConfigs = fixupPlugins(flatConfigs);
   const strippedConfigs = stripPlugins(wrappedConfigs, Object.keys(centralPlugins));
   const parsedConfigs = typescript ? stripParser(strippedConfigs) : strippedConfigs;
   const mergedGlobalIgnores = mergeGlobalIgnores(opts.globalIgnores);

package/src/eslint/lib/files.js

@@ -1,6 +1,8 @@
+import { ESLINT } from '../../config-constants.js';
+
 /**
  * File patterns for ESLint configuration.
  *
  * @type {{ withTs: string[], withoutTs: string[] }}
  */
-export const files = { withTs: ['**/*.{js,jsx,mjs,cjs,ts,tsx}'], withoutTs: ['**/*.{js,jsx,mjs,cjs}'] };
+export const files = ESLINT.FILE_PATTERNS;

package/src/eslint/lib/plugin-helpers/__tests__/enabled-plugins.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+
+import { getEnabledPlugins } from '../enabled-plugins.js';
+
+describe('getEnabledPlugins', () => {
+  it('should filter plugins by enabled options', () => {
+    const conditionalPlugins = { typescript: { name: 'typescript' }, react: { name: 'react' }, a11y: { name: 'a11y' } };
+
+    const options = { typescript: true, react: false, a11y: true };
+    const result = getEnabledPlugins(conditionalPlugins, options);
+
+    expect(result).toHaveLength(2);
+    expect(result).toContainEqual({ name: 'typescript' });
+    expect(result).toContainEqual({ name: 'a11y' });
+  });
+
+  it('should handle array values', () => {
+    const conditionalPlugins = { react: [{ name: 'react' }, { name: 'react-hooks' }] };
+
+    const options = { react: true };
+    const result = getEnabledPlugins(conditionalPlugins, options);
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({ name: 'react' });
+    expect(result[1]).toEqual({ name: 'react-hooks' });
+  });
+
+  it('should return empty array when no options enabled', () => {
+    const conditionalPlugins = { typescript: { name: 'typescript' }, react: { name: 'react' } };
+
+    const options = { typescript: false, react: false };
+    const result = getEnabledPlugins(conditionalPlugins, options);
+
+    expect(result).toEqual([]);
+  });
+
+  it('should handle mixed single and array values', () => {
+    const conditionalPlugins = {
+      typescript: { name: 'typescript' },
+      react: [{ name: 'react' }, { name: 'react-hooks' }],
+      a11y: { name: 'a11y' },
+    };
+
+    const options = { typescript: true, react: true, a11y: false };
+    const result = getEnabledPlugins(conditionalPlugins, options);
+
+    expect(result).toHaveLength(3);
+  });
+});

package/src/eslint/lib/plugin-helpers/__tests__/fixup.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import { fixupPlugins } from '../fixup.js';
+
+// Mock @eslint/compat
+vi.mock('@eslint/compat', () => ({ fixupPluginRules: (plugin) => ({ ...plugin, _fixed: true }) }));
+
+describe('fixupPlugins', () => {
+  it('should wrap plugin rules with fixupPluginRules', () => {
+    const flatConfigs = [{ plugins: { 'test-plugin': { name: 'test' } } }];
+
+    const result = fixupPlugins(flatConfigs);
+
+    expect(result[0].plugins['test-plugin']._fixed).toBe(true);
+  });
+
+  it('should handle multiple plugins', () => {
+    const flatConfigs = [{ plugins: { 'plugin-1': { name: 'one' }, 'plugin-2': { name: 'two' } } }];
+
+    const result = fixupPlugins(flatConfigs);
+
+    expect(result[0].plugins['plugin-1']._fixed).toBe(true);
+    expect(result[0].plugins['plugin-2']._fixed).toBe(true);
+  });
+
+  it('should skip configs without plugins', () => {
+    const flatConfigs = [{ rules: { 'rule-1': 'error' } }, { plugins: { 'test-plugin': { name: 'test' } } }];
+
+    const result = fixupPlugins(flatConfigs);
+
+    expect(result[0]).toEqual({ rules: { 'rule-1': 'error' } });
+    expect(result[1].plugins['test-plugin']._fixed).toBe(true);
+  });
+
+  it('should not mutate original configs', () => {
+    const flatConfigs = [{ plugins: { 'test-plugin': { name: 'test' } } }];
+
+    const original = JSON.parse(JSON.stringify(flatConfigs));
+    fixupPlugins(flatConfigs);
+
+    expect(flatConfigs).toEqual(original);
+  });
+
+  it('should handle empty configs array', () => {
+    const result = fixupPlugins([]);
+    expect(result).toEqual([]);
+  });
+});

package/src/eslint/lib/plugin-helpers/__tests__/flatten.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+
+import { flattenPlugins } from '../flatten.js';
+
+describe('flattenPlugins', () => {
+  it('should flatten mixed arrays and objects', () => {
+    const plugins = [
+      { rules: { 'rule-1': 'error' } },
+      [{ rules: { 'rule-2': 'error' } }],
+      { rules: { 'rule-3': 'error' } },
+    ];
+
+    const result = flattenPlugins(plugins);
+
+    expect(result).toHaveLength(3);
+    expect(result[0]).toEqual({ rules: { 'rule-1': 'error' } });
+    expect(result[1]).toEqual({ rules: { 'rule-2': 'error' } });
+    expect(result[2]).toEqual({ rules: { 'rule-3': 'error' } });
+  });
+
+  it('should handle nested arrays', () => {
+    const plugins = [[{ config: 'a' }, { config: 'b' }], [{ config: 'c' }]];
+
+    const result = flattenPlugins(plugins);
+
+    expect(result).toHaveLength(3);
+  });
+
+  it('should return empty array for empty input', () => {
+    const result = flattenPlugins([]);
+    expect(result).toEqual([]);
+  });
+
+  it('should filter out null and undefined values', () => {
+    const plugins = [{ config: 'a' }, null, { config: 'b' }, undefined];
+
+    const result = flattenPlugins(plugins);
+
+    expect(result).toHaveLength(2);
+    expect(result).toContainEqual({ config: 'a' });
+    expect(result).toContainEqual({ config: 'b' });
+  });
+
+  it('should handle boolean and false values', () => {
+    const plugins = [{ config: 'a' }, false, { config: 'b' }];
+
+    const result = flattenPlugins(plugins);
+
+    expect(result).toHaveLength(2);
+  });
+});

package/src/eslint/lib/plugin-helpers/__tests__/parser.test.js

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+
+import { stripParser } from '../parser.js';
+
+describe('stripParser', () => {
+  it('should remove parser from languageOptions', () => {
+    const flatConfigs = [{ languageOptions: { parser: 'typescript-parser', sourceType: 'module' } }];
+
+    const result = stripParser(flatConfigs);
+
+    expect(result[0].languageOptions).toEqual({ sourceType: 'module' });
+    expect(result[0].languageOptions.parser).toBeUndefined();
+  });
+
+  it('should remove languageOptions if only parser present', () => {
+    const flatConfigs = [{ languageOptions: { parser: 'typescript-parser' } }];
+
+    const result = stripParser(flatConfigs);
+
+    expect(result[0].languageOptions).toBeUndefined();
+  });
+
+  it('should skip configs without parser', () => {
+    const flatConfigs = [{ languageOptions: { sourceType: 'module' } }];
+
+    const result = stripParser(flatConfigs);
+
+    expect(result[0]).toEqual({ languageOptions: { sourceType: 'module' } });
+  });
+
+  it('should skip configs without languageOptions', () => {
+    const flatConfigs = [{ rules: { 'rule-1': 'error' } }];
+
+    const result = stripParser(flatConfigs);
+
+    expect(result[0]).toEqual({ rules: { 'rule-1': 'error' } });
+  });
+
+  it('should not mutate original configs', () => {
+    const flatConfigs = [{ languageOptions: { parser: 'typescript-parser', sourceType: 'module' } }];
+
+    const original = JSON.parse(JSON.stringify(flatConfigs));
+    stripParser(flatConfigs);
+
+    expect(flatConfigs).toEqual(original);
+  });
+
+  it('should handle multiple configs with different states', () => {
+    const flatConfigs = [
+      { languageOptions: { parser: 'typescript-parser' } },
+      { languageOptions: { sourceType: 'module' } },
+      { rules: { 'rule-1': 'error' } },
+    ];
+
+    const result = stripParser(flatConfigs);
+
+    expect(result[0].languageOptions).toBeUndefined();
+    expect(result[1].languageOptions).toEqual({ sourceType: 'module' });
+    expect(result[2]).toEqual({ rules: { 'rule-1': 'error' } });
+  });
+
+  it('should handle multiple languageOptions properties', () => {
+    const flatConfigs = [
+      {
+        languageOptions: {
+          parser: 'typescript-parser',
+          sourceType: 'module',
+          ecmaVersion: 2021,
+          globals: { global: true },
+        },
+      },
+    ];
+
+    const result = stripParser(flatConfigs);
+
+    expect(result[0].languageOptions).toEqual({ sourceType: 'module', ecmaVersion: 2021, globals: { global: true } });
+  });
+});

package/src/eslint/lib/plugin-helpers/__tests__/strip.test.js

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+
+import { stripPlugins } from '../strip.js';
+
+describe('stripPlugins', () => {
+  it('should remove specified plugins', () => {
+    const flatConfigs = [{ plugins: { prettier: { name: 'prettier' }, eslint: { name: 'eslint' } } }];
+
+    const result = stripPlugins(flatConfigs, ['prettier']);
+
+    expect(result[0].plugins).toEqual({ eslint: { name: 'eslint' } });
+  });
+
+  it('should remove multiple plugins', () => {
+    const flatConfigs = [
+      { plugins: { prettier: { name: 'prettier' }, eslint: { name: 'eslint' }, jsdoc: { name: 'jsdoc' } } },
+    ];
+
+    const result = stripPlugins(flatConfigs, ['prettier', 'eslint']);
+
+    expect(result[0].plugins).toEqual({ jsdoc: { name: 'jsdoc' } });
+  });
+
+  it('should remove plugins object if all plugins are stripped', () => {
+    const flatConfigs = [{ plugins: { prettier: { name: 'prettier' } }, rules: { 'rule-1': 'error' } }];
+
+    const result = stripPlugins(flatConfigs, ['prettier']);
+
+    expect(result[0].plugins).toBeUndefined();
+    expect(result[0].rules).toEqual({ 'rule-1': 'error' });
+  });
+
+  it('should return same array if no plugins to strip', () => {
+    const flatConfigs = [{ plugins: { prettier: { name: 'prettier' } } }];
+
+    const result = stripPlugins(flatConfigs, []);
+
+    expect(result).toBe(flatConfigs);
+  });
+
+  it('should skip configs without plugins', () => {
+    const flatConfigs = [{ rules: { 'rule-1': 'error' } }, { plugins: { prettier: { name: 'prettier' } } }];
+
+    const result = stripPlugins(flatConfigs, ['prettier']);
+
+    expect(result[0]).toEqual({ rules: { 'rule-1': 'error' } });
+    expect(result[1].plugins).toBeUndefined();
+  });
+
+  it('should not mutate original configs', () => {
+    const flatConfigs = [{ plugins: { prettier: { name: 'prettier' }, eslint: { name: 'eslint' } } }];
+
+    const original = JSON.parse(JSON.stringify(flatConfigs));
+    stripPlugins(flatConfigs, ['prettier']);
+
+    expect(flatConfigs).toEqual(original);
+  });
+
+  it('should handle multiple configs', () => {
+    const flatConfigs = [
+      { plugins: { prettier: { name: 'prettier' } } },
+      { plugins: { prettier: { name: 'prettier' }, eslint: { name: 'eslint' } } },
+    ];
+
+    const result = stripPlugins(flatConfigs, ['prettier']);
+
+    expect(result[0].plugins).toBeUndefined();
+    expect(result[1].plugins).toEqual({ eslint: { name: 'eslint' } });
+  });
+});

package/src/eslint/lib/plugin-helpers/enabled-plugins.js

@@ -0,0 +1,26 @@
+/**
+ * Filters conditional plugins based on user options.
+ *
+ * This helper enables/disables plugins based on corresponding options,
+ * supporting both single values and array configurations.
+ *
+ * @param {object} conditionalPlugins - Plugin map keyed by option name.
+ * @param {object} options - User-provided options.
+ *
+ * @returns {Array<object>} Flat config objects for enabled plugins.
+ *
+ * @example
+ * const plugins = getEnabledPlugins(
+ *   {
+ *     typescript: tsPlugin,
+ *     react: [reactPlugin, reactHooksPlugin]
+ *   },
+ *   { typescript: true, react: false }
+ * );
+ * // Returns: [tsPlugin]
+ */
+export function getEnabledPlugins(conditionalPlugins, options) {
+  return Object.entries(conditionalPlugins)
+    .filter(([key]) => options[key])
+    .flatMap(([, value]) => (Array.isArray(value) ? value : [value]));
+}

package/src/eslint/lib/plugin-helpers/fixup.js

@@ -0,0 +1,34 @@
+import { fixupPluginRules } from '@eslint/compat';
+
+/**
+ * Wraps plugin rules with fixupPluginRules for backward compatibility.
+ *
+ * Ensures that plugins from older ESLint versions are properly wrapped
+ * to work with ESLint 10+ flat config format.
+ *
+ * @param {Array<object>} flatConfigs - Flat config array.
+ *
+ * @returns {Array<object>} Config array with wrapped plugin rules.
+ *
+ * @example
+ * const wrapped = fixupPlugins([
+ *   {
+ *     plugins: {
+ *       'legacy-plugin': legacyPluginInstance
+ *     }
+ *   }
+ * ]);
+ */
+export function fixupPlugins(flatConfigs) {
+  return flatConfigs.map((config) => {
+    if (!config.plugins) return config;
+
+    const fixed = { ...config, plugins: {} };
+
+    for (const [name, plugin] of Object.entries(config.plugins)) {
+      fixed.plugins[name] = fixupPluginRules(plugin);
+    }
+
+    return fixed;
+  });
+}

package/src/eslint/lib/plugin-helpers/flatten.js

@@ -0,0 +1,31 @@
+/**
+ * Flattens a mixed list of config arrays and objects into a single array.
+ *
+ * Handles nested arrays from plugin configurations that may contain
+ * both direct config objects and arrays of configs.
+ *
+ * @param {Array<Array | object>} plugins - Mixed list of flat config arrays and objects.
+ *
+ * @returns {Array<object>} Flattened config array.
+ *
+ * @example
+ * const flattened = flattenPlugins([
+ *   { rules: { 'rule-1': 'error' } },
+ *   [{ rules: { 'rule-2': 'error' } }],
+ *   [{ rules: { 'rule-3': 'error' } }, { rules: { 'rule-4': 'error' } }]
+ * ]);
+ * // Returns: [{ rules: {...} }, { rules: {...} }, { rules: {...} }, { rules: {...} }]
+ */
+export function flattenPlugins(plugins) {
+  const result = [];
+
+  for (const plugin of plugins) {
+    if (Array.isArray(plugin)) {
+      result.push(...plugin);
+    } else if (typeof plugin === 'object' && plugin !== null) {
+      result.push(plugin);
+    }
+  }
+
+  return result;
+}

package/src/eslint/lib/plugin-helpers/index.js

@@ -0,0 +1,18 @@
+/**
+ * ESLint Plugin Helpers
+ *
+ * Collection of utility functions for manipulating and processing ESLint
+ * flat config plugins. Each function handles a specific transformation:
+ *
+ * - getEnabledPlugins: Filter plugins by user options
+ * - flattenPlugins: Flatten nested arrays and objects
+ * - fixupPlugins: Wrap plugins for backward compatibility
+ * - stripPlugins: Remove central plugins from nested configs
+ * - stripParser: Remove parsers to prevent conflicts
+ */
+
+export { getEnabledPlugins } from './enabled-plugins.js';
+export { flattenPlugins } from './flatten.js';
+export { fixupPlugins } from './fixup.js';
+export { stripPlugins } from './strip.js';
+export { stripParser } from './parser.js';