@santi020k/eslint-config-basic 2.1.1 → 3.1.0

package/dist/index.js

@@ -1,10 +1,12 @@
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   applyDetectionControls,
   applyStrictMode,
   applyStrictProfileDefaults,
   coreConfig,
   createCoreConfig,
+  createGitignoreConfig,
   DEFAULT_IGNORES,
   detectProjectOptions,
   Extension,
@@ -12,10 +14,10 @@ import {
   flattenConfigInputs,
   GENERATED_CODE_IGNORES,
   getStrictMode,
-  gitignore,
   Library,
   mergeFrameworkOption,
   mergeOptionalBucket,
+  mergeProjectOptions,
   NextMode,
   patchImportGroups,
   Preset,
@@ -26,58 +28,42 @@ import {
   Setting,
   Testing
 } from "@santi020k/eslint-config-core";
-import { tailwind as tailwindIntegration } from "@santi020k/eslint-config-integrations";
 import { createTypescriptConfig } from "@santi020k/eslint-config-typescript";
 import { createDetectedFrameworkFlags } from "./frameworks.js";
 import { getIntegrationConfigs, getPrettierConfig } from "./integrations.js";
 import { resolveFramework, resolvePreset } from "./resolvers.js";
-import {
-  AGENT_TARGETS,
-  generateAgentSkills,
-  generateSkillContent
-} from "./agent-skill-generator.js";
+import { buildTailwindSettingsConfig } from "./tailwind.js";
 import {
   angular,
-  angularConfig,
   astro,
   expo,
-  expoConfig,
   hono,
   lit,
   nest,
-  nestConfig,
   next,
-  nextConfig,
   nuxt,
   preact,
-  preactConfig,
   qwik,
   react,
-  reactConfig,
   reactRouter,
-  remix,
   slidev,
   solid,
-  solidConfig,
   svelte,
-  svelteConfig,
   tanstackStart,
   vite,
-  vue,
-  vueConfig
+  vue
 } from "./frameworks.js";
 import {
   coreConfig as coreConfig2,
   createCoreConfig as createCoreConfig2,
+  createGitignoreConfig as createGitignoreConfig2,
   createImportGroups,
   detectProjectOptions as detectProjectOptions2,
   Extension as Extension2,
   Format,
   getGlobalsForRuntime,
-  gitignore as gitignore2,
   groups,
   hasReactConfig,
-  jsConfig,
   Library as Library2,
   NextMode as NextMode2,
   Preset as Preset2,
@@ -87,109 +73,20 @@ import {
   Testing as Testing2,
   Tool
 } from "@santi020k/eslint-config-core";
-import {
-  a11y,
-  aiSdk,
-  autogen,
-  bestPractices,
-  biome,
-  boundaries,
-  command,
-  compat,
-  cspell,
-  css,
-  cypress,
-  deMorgan,
-  depend,
-  docker,
-  drizzle,
-  githubActions,
-  googleGenAi,
-  graphql,
-  html,
-  i18next,
-  jest,
-  jestDom,
-  jsdoc,
-  jsonc,
-  langchain,
-  llamaIndex,
-  markdown,
-  mastra,
-  mcp,
-  mdx,
-  mikroOrm,
-  node,
-  noOnlyTests,
-  nx,
-  openAiAgents,
-  oxlint,
-  packageJson,
-  perfectionist,
-  playwright,
-  pnpm,
-  prettier,
-  prisma,
-  regexp,
-  security,
-  sequelize,
-  sonarjs,
-  stencil,
-  storybook,
-  swagger,
-  tailwind,
-  tanstackQuery,
-  tanstackRouter,
-  testingLibrary,
-  toml,
-  turbo,
-  typeorm,
-  unicorn,
-  vitest,
-  yaml,
-  zod
-} from "@santi020k/eslint-config-integrations";
-import { tsConfig, typescriptConfig } from "@santi020k/eslint-config-typescript";
-const buildTailwindResult = (options, entryPoint) => ({
+import { typescriptConfig } from "@santi020k/eslint-config-typescript";
+const buildTailwindResult = (options, entryPoint, rootDir) => ({
+  cwd: options.cwd ?? rootDir,
   detectComponentClasses: options.detectComponentClasses ?? true,
   ...entryPoint ? { entryPoint } : {},
   ...options.ignore?.length ? { ignore: options.ignore } : {},
   ...options.noUnknownClasses === void 0 ? {} : { noUnknownClasses: options.noUnknownClasses }
 });
-const resolveTailwindOptions = (rootDir, tailwind2) => {
-  if (tailwind2 === false) return void 0;
-  const options = tailwind2 ?? {};
+const resolveTailwindOptions = (rootDir, tailwind) => {
+  if (tailwind === false) return void 0;
+  const options = tailwind ?? {};
   const entryPoint = options.entryPoint ?? findTailwindEntryPoint(rootDir);
-  if (!entryPoint && options.detectComponentClasses === void 0 && !options.ignore?.length && options.noUnknownClasses === void 0) return void 0;
-  return buildTailwindResult(options, entryPoint);
-};
-const createNoUnknownClassesRule = (tailwindOptions, unknownClassOptions, hasUnknownClassOptions) => {
-  if (!hasUnknownClassOptions && tailwindOptions.noUnknownClasses === void 0) return void 0;
-  const severity = tailwindOptions.noUnknownClasses ?? "error";
-  if (severity === false) return "off";
-  return hasUnknownClassOptions ? [severity, unknownClassOptions] : severity;
-};
-const loadTailwindPlugins = async () => {
-  const tailwindConfigs = await tailwindIntegration();
-  const pluginConfig = tailwindConfigs.find((config) => config.plugins?.["better-tailwindcss"]);
-  return pluginConfig?.plugins ?? {};
-};
-const createTailwindSettingsConfig = async (tailwindOptions) => {
-  const { noUnknownClasses: _noUnknownClasses, ...settingsOptions } = tailwindOptions;
-  const unknownClassOptions = {
-    ...tailwindOptions.entryPoint ? { entryPoint: tailwindOptions.entryPoint } : {},
-    ...tailwindOptions.ignore?.length ? { ignore: tailwindOptions.ignore } : {}
-  };
-  const hasUnknownClassOptions = Object.keys(unknownClassOptions).length > 0;
-  const noUnknownClassesRule = createNoUnknownClassesRule(tailwindOptions, unknownClassOptions, hasUnknownClassOptions);
-  return {
-    name: "eslint-config-basic/tailwind-settings",
-    plugins: await loadTailwindPlugins(),
-    ...noUnknownClassesRule === void 0 ? {} : { rules: { "better-tailwindcss/no-unknown-classes": noUnknownClassesRule } },
-    settings: {
-      "better-tailwindcss": settingsOptions
-    }
-  };
+  if (!entryPoint && options.cwd === void 0 && options.detectComponentClasses === void 0 && !options.ignore?.length && options.noUnknownClasses === void 0) return void 0;
+  return buildTailwindResult(options, entryPoint, rootDir);
 };
 const TESTING_CONFIG_NAMES = {
   [Testing.Cypress]: ["integrations/cypress"],
@@ -204,9 +101,7 @@ const applyTestingFileOverrides = (configs, testingFiles) => {
   const entries = Object.entries(testingFiles).filter(([, files]) => files.length > 0);
   if (entries.length === 0) return configs;
   return configs.map((config) => {
-    const match = entries.find(
-      ([testingName]) => (TESTING_CONFIG_NAMES[testingName] ?? []).includes(config.name ?? "")
-    );
+    const match = entries.find(([testingName]) => (TESTING_CONFIG_NAMES[testingName] ?? []).includes(config.name ?? ""));
     if (!match) return config;
     const [, files] = match;
     return {
@@ -215,16 +110,56 @@ const applyTestingFileOverrides = (configs, testingFiles) => {
     };
   });
 };
-const resolveConfigSetup = (options) => ({
-  autoFrameworks: options?.autoFrameworks ?? true,
-  detectRootDir: options?.detectRootDir ?? options?.tsconfigRootDir,
-  optionMergeStrategy: options?.optionMergeStrategy ?? "merge",
-  requestedPreset: options?.preset
-});
-const resolveUniqueLibraries = (libraries, tailwind2) => {
+const ESLINT_CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.cjs",
+  "eslint.config.mjs",
+  "eslint.config.ts",
+  "eslint.config.cts",
+  "eslint.config.mts"
+];
+const findConfigRootFromStack = (stack = new Error().stack) => {
+  if (!stack) return void 0;
+  for (const line of stack.split("\n")) {
+    const configFilename = ESLINT_CONFIG_FILENAMES.find((filename) => line.includes(filename));
+    if (!configFilename) continue;
+    const filenameStart = line.indexOf(configFilename);
+    const fileUrlStart = line.lastIndexOf("file://", filenameStart);
+    const windowsPathStart = line.slice(0, filenameStart).search(/[A-Za-z]:[\\/]/);
+    const absolutePathStart = line.indexOf("/");
+    let configPathStart = absolutePathStart;
+    if (windowsPathStart >= 0) configPathStart = windowsPathStart;
+    if (fileUrlStart >= 0) configPathStart = fileUrlStart;
+    try {
+      if (configPathStart < 0) continue;
+      const configPath = line.slice(configPathStart, filenameStart + configFilename.length);
+      return dirname(configPath.startsWith("file:") ? fileURLToPath(configPath) : configPath);
+    } catch {
+    }
+  }
+  return void 0;
+};
+const resolveConfigSetup = (options) => {
+  const {
+    autoFrameworks = true,
+    detectRootDir,
+    optionMergeStrategy = "merge",
+    preset: requestedPreset,
+    root,
+    tsconfigRootDir
+  } = options ?? {};
+  const implicitRootDir = root ?? detectRootDir ?? tsconfigRootDir ?? findConfigRootFromStack();
+  return {
+    autoFrameworks,
+    detectRootDir: implicitRootDir,
+    optionMergeStrategy,
+    requestedPreset
+  };
+};
+const resolveUniqueLibraries = (libraries, tailwind) => {
   const uniqueLibraries = [...new Set(libraries)];
-  if (tailwind2 === false) return uniqueLibraries.filter((library) => library !== Library.Tailwind);
-  if (!tailwind2) return uniqueLibraries;
+  if (tailwind === false) return uniqueLibraries.filter((library) => library !== Library.Tailwind);
+  if (!tailwind) return uniqueLibraries;
   return [.../* @__PURE__ */ new Set([...uniqueLibraries, Library.Tailwind])];
 };
 const resolvePresetMeta = (requestedPreset, detected, autoFrameworks) => {
@@ -244,12 +179,26 @@ const resolveBucketDefaults = (detected) => ({
   detectedTesting: detected.testing ?? [],
   detectedTools: detected.tools ?? []
 });
+const scopeWorkspaceDetection = (detected, isWorkspace) => isWorkspace ? {
+  ...detected,
+  detectedFrameworks: [],
+  libraries: [],
+  nextMode: void 0,
+  runtime: Runtime.Universal
+} : detected;
+const resolveDetectedOptions = (detectRootDir, detection, requestedPreset) => {
+  const rawDetected = detectProjectOptions(detectRootDir);
+  const shouldDetectProjects = requestedPreset === Preset.Monorepo || rawDetected.preset === Preset.Monorepo;
+  const detected = applyDetectionControls(rawDetected, detection, { projects: shouldDetectProjects });
+  const hasDetectedProjects = Object.keys(detected.projects ?? {}).length > 0;
+  return scopeWorkspaceDetection(detected, hasDetectedProjects);
+};
 const resolveNextModeValue = (options, presetDefaults, detected) => options?.nextMode ?? presetDefaults.nextMode ?? detected.nextMode ?? NextMode.Pages;
 const resolveRuntimeValue = (options, presetDefaults, detected, usePresetRuntime) => options?.runtime ?? (usePresetRuntime ? presetDefaults.runtime : void 0) ?? detected.runtime ?? Runtime.Universal;
 const resolveSettingsValue = (options, detected) => options?.settings ?? detected.settings ?? [];
 const resolveTypescriptValue = (options, presetDefaults, detected) => options?.typescript ?? presetDefaults.typescript ?? detected.typescript ?? false;
 const needsReactAutoAdd = (frameworks) => Boolean(
-  frameworks.next ?? frameworks.expo ?? frameworks.remix ?? frameworks["react-router"] ?? (frameworks["tanstack-start"] && !frameworks.solid)
+  frameworks.next ?? frameworks.expo ?? frameworks["react-router"] ?? (frameworks["tanstack-start"] && !frameworks.solid)
 ) && !frameworks.react;
 const applyFrameworkImpliedDeps = (frameworks) => {
   const result = { ...frameworks };
@@ -258,31 +207,35 @@ const applyFrameworkImpliedDeps = (frameworks) => {
   if (result.nuxt && !result.vue) result.vue = true;
   return result;
 };
-const buildIgnoresConfig = (useDefaultIgnores, useGeneratedCodeIgnores, useGitignore, options) => ({
+const buildIgnoresConfig = (useDefaultIgnores, useGeneratedCodeIgnores, useGitignore, options, rootDir) => ({
   defaultIgnores: useDefaultIgnores ? [{
     ignores: [...DEFAULT_IGNORES, ...useGeneratedCodeIgnores ? GENERATED_CODE_IGNORES : []],
     name: "eslint-config-basic/default-ignores"
   }] : [],
-  gitignoreConfig: useGitignore ? gitignore : [],
+  gitignoreConfig: useGitignore ? createGitignoreConfig(rootDir) : [],
   userIgnores: options?.ignores?.length ? [{
     ignores: options.ignores,
     name: "eslint-config-basic/ignores"
   }] : []
 });
 const FRAMEWORK_EXTRA_OPTS = {
-  astro: (ctx) => ({ hasReact: ctx.hasReact, hasSolid: ctx.hasSolid, hasSvelte: ctx.hasSvelte, hasVue: ctx.hasVue }),
+  astro: (ctx) => ({
+    hasReact: ctx.hasReact,
+    hasSolid: ctx.hasSolid,
+    hasSvelte: ctx.hasSvelte,
+    hasVue: ctx.hasVue,
+    tsconfigRootDir: ctx.tsconfigRootDir
+  }),
   hono: (ctx) => ({ runtime: ctx.runtime }),
   slidev: (ctx) => ({ runtime: ctx.runtime }),
   vite: (ctx) => ({ runtime: ctx.runtime })
 };
 const resolveEnabledFrameworks = async (frameworks, ctx) => {
   const entries = await Promise.all(
-    Object.entries(frameworks).filter((entry) => Boolean(entry[1])).map(
-      ([name, value]) => (
-        // eslint-disable-next-line security/detect-object-injection
-        resolveFramework(name, value, FRAMEWORK_EXTRA_OPTS[name]?.(ctx)).then((config) => [name, config])
-      )
-    )
+    Object.entries(frameworks).filter((entry) => Boolean(entry[1])).map(([name, value]) => (
+      // eslint-disable-next-line security/detect-object-injection
+      resolveFramework(name, value, FRAMEWORK_EXTRA_OPTS[name]?.(ctx)).then((config) => [name, config])
+    ))
   );
   return Object.fromEntries(entries);
 };
@@ -308,7 +261,10 @@ const buildEslintConfigs = async (params) => {
     userIgnores
   } = params;
   const { hasReact, hasSolid, hasSvelte, hasVue } = astroOptions;
-  const fw = await resolveEnabledFrameworks(resolvedFrameworks, { hasReact, hasSolid, hasSvelte, hasVue, runtime });
+  const fw = await resolveEnabledFrameworks(
+    resolvedFrameworks,
+    { hasReact, hasSolid, hasSvelte, hasVue, runtime, tsconfigRootDir }
+  );
   const get = (name) => fw[name] ?? [];
   return [
     ...defaultIgnores,
@@ -343,7 +299,6 @@ const buildEslintConfigs = async (params) => {
     ...get("solid"),
     ...get("angular"),
     ...get("qwik"),
-    ...get("remix"),
     ...get("react-router"),
     ...get("tanstack-start"),
     ...get("nuxt"),
@@ -373,7 +328,7 @@ const buildEslintConfigs = async (params) => {
         ...uniqueExtensions.includes(Extension.Security) ? { "security/detect-non-literal-fs-filename": "off" } : {}
       }
     },
-    ...tailwindOptions ? [await createTailwindSettingsConfig(tailwindOptions)] : [],
+    ...tailwindOptions ? [buildTailwindSettingsConfig(tailwindOptions)] : [],
     ...await getPrettierConfig(uniqueTools)
   ];
 };
@@ -412,13 +367,53 @@ const logEslintDebug = ({
   }, null, 2)}
 `);
 };
-const emitBasicWarnings = (options) => {
-  if (options?.frameworks && "remix" in options.frameworks) {
-    process.emitWarning('[eslint-config-basic] Warning: `frameworks.remix` is deprecated and will be removed in the next major. Please use `frameworks["react-router"]` instead.');
-  }
+const emitAstroDoctorWarning = (extensions, frameworks) => {
+  if (!extensions.includes(Extension.AstroDoctor) || frameworks.astro) return;
+  process.emitWarning(
+    "[eslint-config-basic] Warning: Astro Doctor is enabled without the Astro framework config. Enable `frameworks: { astro: true }` or remove the `astro-doctor` feature."
+  );
+};
+const resolveProjectConfigs = async (configuredProjects, projectDefaults, detectRootDir, autoFrameworks) => Promise.all(
+  Object.entries(configuredProjects).map(async ([projectPath, projectOptions]) => {
+    const projectRoot = join(detectRootDir ?? process.cwd(), projectPath);
+    const inheritedOptions = mergeProjectOptions(projectDefaults ?? {}, projectOptions);
+    const scopedConfigs = await defineConfig({
+      autoFrameworks,
+      ...inheritedOptions,
+      projectDefaults: void 0,
+      projects: void 0,
+      root: inheritedOptions.root ?? inheritedOptions.detectRootDir ?? projectRoot
+    });
+    return scopedConfigs.map((config) => config.name === "eslint-config/gitignore" ? config : scopeConfigToProject(config, projectPath));
+  })
+);
+const getConfigsParams = (options, rootDir, runtime, uniqueLibraries, uniqueSettings, resolvedFrameworks) => {
+  const hasReact = !!resolvedFrameworks.react;
+  const hasVue = !!resolvedFrameworks.vue;
+  const hasSvelte = !!resolvedFrameworks.svelte;
+  const hasSolid = !!resolvedFrameworks.solid;
+  const useGitignore = !uniqueSettings.includes(Setting.NoGitignore);
+  const useDefaultIgnores = !uniqueSettings.includes(Setting.NoDefaultIgnores);
+  const useGeneratedCodeIgnores = !uniqueSettings.includes(Setting.NoGeneratedCodeIgnores);
+  const tailwindOptions = uniqueLibraries.includes(Library.Tailwind) ? resolveTailwindOptions(rootDir, options?.tailwind) : void 0;
+  const runtimeCoreConfig = runtime === Runtime.Universal ? coreConfig : createCoreConfig(runtime);
+  const { defaultIgnores, gitignoreConfig, userIgnores } = buildIgnoresConfig(
+    useDefaultIgnores,
+    useGeneratedCodeIgnores,
+    useGitignore,
+    options,
+    rootDir
+  );
+  return {
+    astroOptions: { hasReact, hasSolid, hasSvelte, hasVue },
+    defaultIgnores,
+    gitignoreConfig,
+    runtimeCoreConfig,
+    tailwindOptions,
+    userIgnores
+  };
 };
-const eslintConfig = async (options, ...extraConfigs) => {
-  emitBasicWarnings(options);
+const defineConfig = async (options, ...extraConfigs) => {
   const {
     detection,
     extensions: optExtensions,
@@ -432,12 +427,7 @@ const eslintConfig = async (options, ...extraConfigs) => {
     workspacePrefixes
   } = options ?? {};
   const { autoFrameworks, detectRootDir, optionMergeStrategy, requestedPreset } = resolveConfigSetup(options);
-  const shouldDefaultProjectDetection = requestedPreset === Preset.Monorepo;
-  const detected = applyDetectionControls(
-    detectProjectOptions(detectRootDir),
-    detection,
-    { projects: shouldDefaultProjectDetection }
-  );
+  const detected = resolveDetectedOptions(detectRootDir, detection, requestedPreset);
   const { frameworkDefaults, preset, presetDefaults } = resolvePresetMeta(requestedPreset, detected, autoFrameworks);
   const configuredProjects = resolveConfiguredProjects(detected, options);
   const { detectedExtensions, detectedFormats, detectedLibraries, detectedTesting, detectedTools } = resolveBucketDefaults(detected);
@@ -498,27 +488,19 @@ const eslintConfig = async (options, ...extraConfigs) => {
   const uniqueTools = [...new Set(tools)];
   const uniqueExtensions = [...new Set(extensions)];
   const uniqueSettings = [...new Set(settings)];
-  const hasReact = !!resolvedFrameworks.react;
-  const hasVue = !!resolvedFrameworks.vue;
-  const hasSvelte = !!resolvedFrameworks.svelte;
-  const hasSolid = !!resolvedFrameworks.solid;
-  const useGitignore = !uniqueSettings.includes(Setting.NoGitignore);
-  const useDefaultIgnores = !uniqueSettings.includes(Setting.NoDefaultIgnores);
-  const useGeneratedCodeIgnores = !uniqueSettings.includes(Setting.NoGeneratedCodeIgnores);
-  const tailwindOptions = uniqueLibraries.includes(Library.Tailwind) ? resolveTailwindOptions(rootDir, options?.tailwind) : void 0;
-  const runtimeCoreConfig = runtime === Runtime.Universal ? coreConfig : createCoreConfig(runtime);
-  const { defaultIgnores, gitignoreConfig, userIgnores } = buildIgnoresConfig(useDefaultIgnores, useGeneratedCodeIgnores, useGitignore, options);
+  emitAstroDoctorWarning(uniqueExtensions, resolvedFrameworks);
+  const params = getConfigsParams(options, rootDir, runtime, uniqueLibraries, uniqueSettings, resolvedFrameworks);
   const configs = await buildEslintConfigs({
-    astroOptions: { hasReact, hasSolid, hasSvelte, hasVue },
-    defaultIgnores,
-    gitignoreConfig,
+    astroOptions: params.astroOptions,
+    defaultIgnores: params.defaultIgnores,
+    gitignoreConfig: params.gitignoreConfig,
     nextMode,
     resolvedFrameworks,
     resolvedTypescript,
     rootDir,
     runtime,
-    runtimeCoreConfig,
-    tailwindOptions,
+    runtimeCoreConfig: params.runtimeCoreConfig,
+    tailwindOptions: params.tailwindOptions,
     testingFiles: options?.testingFiles,
     tsconfigRootDir,
     uniqueExtensions,
@@ -526,7 +508,7 @@ const eslintConfig = async (options, ...extraConfigs) => {
     uniqueLibraries,
     uniqueTesting,
     uniqueTools,
-    userIgnores
+    userIgnores: params.userIgnores
   });
   logEslintDebug({
     autoFrameworks,
@@ -544,26 +526,17 @@ const eslintConfig = async (options, ...extraConfigs) => {
     uniqueTesting,
     uniqueTools
   });
-  const projectConfigs = await Promise.all(
-    Object.entries(configuredProjects).map(async ([projectPath, projectOptions]) => {
-      const projectRoot = join(detectRootDir ?? process.cwd(), projectPath);
-      const scopedConfigs = await eslintConfig({
-        autoFrameworks: options?.autoFrameworks,
-        ...projectOptions,
-        detectRootDir: projectOptions.detectRootDir ?? projectRoot,
-        projects: void 0,
-        tsconfigRootDir: projectOptions.tsconfigRootDir ?? projectRoot
-      });
-      return scopedConfigs.map((config) => scopeConfigToProject(config, projectPath));
-    })
+  const projectConfigs = await resolveProjectConfigs(
+    configuredProjects,
+    options?.projectDefaults,
+    detectRootDir,
+    options?.autoFrameworks
   );
   const allConfigs = [...configs, ...projectConfigs.flat(), ...flattenConfigInputs(extraConfigs)];
   const patchedConfigs = workspacePrefixes?.length ? patchImportGroups(allConfigs, workspacePrefixes) : allConfigs;
   return applyStrictMode(patchedConfigs, strict);
 };
-const defineConfig = eslintConfig;
 export {
-  AGENT_TARGETS,
   Extension2 as Extension,
   Format,
   Library2 as Library,
@@ -574,107 +547,32 @@ export {
   Setting2 as Setting,
   Testing2 as Testing,
   Tool,
-  a11y,
-  aiSdk,
   angular,
-  angularConfig,
   astro,
-  autogen,
-  bestPractices,
-  biome,
-  boundaries,
-  command,
-  compat,
   coreConfig2 as coreConfig,
   createCoreConfig2 as createCoreConfig,
+  createGitignoreConfig2 as createGitignoreConfig,
   createImportGroups,
-  cspell,
-  css,
-  cypress,
-  deMorgan,
   defineConfig,
-  depend,
   detectProjectOptions2 as detectProjectOptions,
-  docker,
-  drizzle,
-  eslintConfig,
   expo,
-  expoConfig,
-  generateAgentSkills,
-  generateSkillContent,
   getGlobalsForRuntime,
-  githubActions,
-  gitignore2 as gitignore,
-  googleGenAi,
-  graphql,
   groups,
   hasReactConfig,
   hono,
-  html,
-  i18next,
-  jest,
-  jestDom,
-  jsConfig,
-  jsdoc,
-  jsonc,
-  langchain,
   lit,
-  llamaIndex,
-  markdown,
-  mastra,
-  mcp,
-  mdx,
-  mikroOrm,
   nest,
-  nestConfig,
   next,
-  nextConfig,
-  noOnlyTests,
-  node,
   nuxt,
-  nx,
-  openAiAgents,
-  oxlint,
-  packageJson,
-  perfectionist,
-  playwright,
-  pnpm,
   preact,
-  preactConfig,
-  prettier,
-  prisma,
   qwik,
   react,
-  reactConfig,
   reactRouter,
-  regexp,
-  remix,
-  security,
-  sequelize,
   slidev,
   solid,
-  solidConfig,
-  sonarjs,
-  stencil,
-  storybook,
   svelte,
-  svelteConfig,
-  swagger,
-  tailwind,
-  tanstackQuery,
-  tanstackRouter,
   tanstackStart,
-  testingLibrary,
-  toml,
-  tsConfig,
-  turbo,
-  typeorm,
   typescriptConfig,
-  unicorn,
   vite,
-  vitest,
-  vue,
-  vueConfig,
-  yaml,
-  zod
+  vue
 };

package/dist/integrations.d.ts

@@ -1 +1,6 @@
-export { getIntegrationConfigs, getPrettierConfig } from '@santi020k/eslint-config-integrations';
+import { Library, Tool, Testing, Format, Extension, FlatConfigArray } from '@santi020k/eslint-config-core';
+
+declare const getIntegrationConfigs: (libraries: Library[], tools: Tool[], testing: Testing[], formats: Format[], extensions: Extension[]) => Promise<FlatConfigArray>;
+declare const getPrettierConfig: (tools: Tool[]) => Promise<FlatConfigArray>;
+
+export { getIntegrationConfigs, getPrettierConfig };

package/dist/integrations.js

@@ -1,4 +1,47 @@
-import { getIntegrationConfigs, getPrettierConfig } from "@santi020k/eslint-config-integrations";
+import {
+  createModuleLoader,
+  resolveConfigFeatures
+} from "@santi020k/eslint-config-core";
+const loadModule = createModuleLoader((specifier) => import.meta.resolve(specifier, import.meta.url));
+const packCache = /* @__PURE__ */ new Map();
+const loadFeaturePack = async (specifier) => {
+  let pending = packCache.get(specifier);
+  if (!pending) {
+    pending = loadModule(specifier);
+    packCache.set(specifier, pending);
+  }
+  try {
+    const module = await pending;
+    if (!module.features) {
+      throw new Error(`Installed package "${specifier}" does not export a feature registry.`);
+    }
+    return module.features;
+  } catch (error) {
+    packCache.delete(specifier);
+    throw new Error(
+      `Unable to load optional feature pack "${specifier}". Install it for the selected options, or remove those options from defineConfig().`,
+      { cause: error }
+    );
+  }
+};
+const loadSelectedPacks = async (libraries, tools, testing, formats, extensions) => (await Promise.all([
+  extensions.length > 0 ? loadFeaturePack("@santi020k/eslint-config-extensions/registry") : [],
+  formats.length > 0 ? loadFeaturePack("@santi020k/eslint-config-formats/registry") : [],
+  libraries.length > 0 ? loadFeaturePack("@santi020k/eslint-config-libraries/registry") : [],
+  testing.length > 0 ? loadFeaturePack("@santi020k/eslint-config-testing/registry") : [],
+  tools.length > 0 ? loadFeaturePack("@santi020k/eslint-config-tools/registry") : []
+])).flat();
+const getIntegrationConfigs = async (libraries, tools, testing, formats, extensions) => {
+  const selected = [...libraries, ...tools, ...testing, ...formats, ...extensions];
+  if (selected.length === 0) return [];
+  const features = await loadSelectedPacks(libraries, tools, testing, formats, extensions);
+  return resolveConfigFeatures(features, selected);
+};
+const getPrettierConfig = async (tools) => {
+  if (tools.length === 0) return [];
+  const features = await loadFeaturePack("@santi020k/eslint-config-tools/registry");
+  return resolveConfigFeatures(features, tools, "finalizer");
+};
 export {
   getIntegrationConfigs,
   getPrettierConfig