@santi020k/eslint-config-basic 1.6.0 → 2.0.0-beta.1

package/dist/index.js

@@ -1,57 +1,126 @@
-import { applyStrictMode } from "./compose.js";
-import { getOptionalConfigs, getPrettierConfig } from "./optionals.js";
-import { resolveFramework, resolvePreset } from "./resolvers.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import {
   coreConfig,
   createCoreConfig,
   detectProjectOptions,
+  Extension,
+  Format,
   gitignore,
+  Library,
   NextMode,
+  Preset,
   Runtime,
-  Setting
+  Setting,
+  Testing,
+  Tool
 } from "@santi020k/eslint-config-core";
 import { createTypescriptConfig } from "@santi020k/eslint-config-typescript";
+import { applyStrictMode } from "./compose.js";
+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 {
+  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
+} from "./frameworks.js";
 import {
   coreConfig as coreConfig2,
   createCoreConfig as createCoreConfig2,
+  createImportGroups,
   detectProjectOptions as detectProjectOptions2,
-  Extension,
-  Format,
+  Extension as Extension2,
+  Format as Format2,
   getGlobalsForRuntime,
   gitignore as gitignore2,
+  groups,
   hasReactConfig,
   jsConfig,
-  Library,
+  Library as Library2,
   NextMode as NextMode2,
-  Preset,
+  Preset as Preset2,
   ReactConfigKeys,
   Runtime as Runtime2,
   Setting as Setting2,
-  Testing,
-  Tool
+  Testing as Testing2,
+  Tool as Tool2
 } from "@santi020k/eslint-config-core";
-import { tsConfig, typescriptConfig } from "@santi020k/eslint-config-typescript";
 import {
+  a11y,
+  aiSdk,
+  autogen,
   bestPractices,
+  biome,
+  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,
@@ -61,77 +130,435 @@ import {
   tanstackRouter,
   testingLibrary,
   toml,
+  turbo,
+  typeorm,
   unicorn,
   vitest,
-  yaml
-} from "@santi020k/eslint-config-optionals";
-const eslintConfig = (options) => {
-  const detected = detectProjectOptions();
-  const preset = options?.preset ?? detected.preset;
-  const presetDefaults = preset ? resolvePreset(preset) : {};
-  const {
-    typescript = presetDefaults.typescript ?? detected.typescript ?? false,
-    libraries = presetDefaults.libraries ?? detected.libraries ?? [],
-    testing = presetDefaults.testing ?? detected.testing ?? [],
-    formats = presetDefaults.formats ?? detected.formats ?? [],
-    tools = presetDefaults.tools ?? detected.tools ?? [],
-    extensions = presetDefaults.extensions ?? detected.extensions ?? [],
-    settings = options?.settings ?? detected.settings ?? [],
-    strict = options?.strict ?? false,
-    runtime = presetDefaults.runtime ?? detected.runtime ?? Runtime.Universal,
-    tsconfigRootDir = options?.tsconfigRootDir,
-    nextMode = presetDefaults.nextMode ?? detected.nextMode ?? NextMode.Pages,
-    frameworks = { ...presetDefaults.frameworks, ...options?.frameworks }
-  } = options ?? {};
-  const uniqueLibraries = [...new Set(libraries)];
-  const uniqueTesting = [...new Set(testing)];
-  const uniqueFormats = [...new Set(formats)];
-  const uniqueTools = [...new Set(tools)];
-  const uniqueExtensions = [...new Set(extensions)];
-  const uniqueSettings = [...new Set(settings)];
-  if ((frameworks.next || frameworks.expo) && !frameworks.react) {
-    throw new TypeError(
-      "Next and Expo configurations require frameworks.react. Import @santi020k/eslint-config-react and pass it via frameworks.react."
+  yaml,
+  zod
+} from "@santi020k/eslint-config-integrations";
+import { tsConfig, typescriptConfig } from "@santi020k/eslint-config-typescript";
+const toUniqueArray = (values) => [...new Set(values)];
+const DEFAULT_IGNORES = [
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/.turbo/**",
+  "**/.next/**",
+  "**/.open-next/**",
+  "**/.astro/**",
+  "**/.svelte-kit/**",
+  "**/.vercel/**",
+  "**/.wrangler/**",
+  "**/playwright-report/**",
+  "**/test-results/**",
+  "**/node_modules/**",
+  "**/tsconfig.tsbuildinfo",
+  // Package manager lock files (machine-generated, slow to lint)
+  "**/pnpm-lock.yaml",
+  "**/yarn.lock",
+  "**/package-lock.json",
+  "**/bun.lock",
+  "**/bun.lockb",
+  // AI coding-assistant artifacts (rule/skill folders managed by tools, not source code)
+  "**/.agent/**",
+  "**/.agents/**",
+  "**/.aider*",
+  "**/.aider*/**",
+  "**/.claude/**",
+  "**/.clinerules/**",
+  "**/.codex/**",
+  "**/.copilot/**",
+  "**/.cursor/**",
+  "**/.gemini/**",
+  "**/.kiro/**",
+  "**/.opencode/**",
+  "**/.roo/**",
+  "**/.windsurf/**"
+];
+const GENERATED_CODE_IGNORES = [
+  "**/__generated__/**",
+  "**/generated/**",
+  "**/codegen/**",
+  "**/*.generated.*",
+  "**/*.gen.*",
+  "**/graphql.ts",
+  "**/graphql.tsx",
+  "**/gql/**",
+  "**/.prisma/**"
+];
+const TAILWIND_ENTRYPOINT_CANDIDATES = [
+  "src/styles/global.css",
+  "src/app/globals.css",
+  "src/globals.css",
+  "src/index.css",
+  "app/globals.css",
+  "styles/global.css"
+];
+const OPTIONAL_BUCKETS = {
+  extensions: Object.values(Extension),
+  formats: Object.values(Format),
+  libraries: Object.values(Library),
+  testing: Object.values(Testing),
+  tools: Object.values(Tool)
+};
+const flattenConfigInputs = (configs) => configs.flatMap((config) => {
+  if (!config) return [];
+  return Array.isArray(config) ? config : [config];
+});
+const mergeArrayOption = (detectedValues, presetValues, explicitValues, strategy) => {
+  if (strategy === "replace") {
+    if (explicitValues) return toUniqueArray(explicitValues);
+    if (presetValues) return toUniqueArray(presetValues);
+    return toUniqueArray(detectedValues);
+  }
+  return toUniqueArray([
+    ...detectedValues,
+    ...presetValues ?? [],
+    ...explicitValues ?? []
+  ]);
+};
+const isOptionalBucketValue = (bucket, value) => OPTIONAL_BUCKETS[bucket].includes(value);
+const getFeatureEntries = (options, bucket, enabled) => [
+  ...Object.entries(options?.features ?? {}),
+  ...Object.entries(options?.integrations ?? {})
+].filter(([name, value]) => value === enabled && isOptionalBucketValue(bucket, name)).map(([name]) => name);
+const applyFeatureDisables = (values, options, bucket) => {
+  const disabled = new Set(getFeatureEntries(options, bucket, false));
+  return values.filter((value) => !disabled.has(value));
+};
+const mergeOptionalBucket = (bucket, detectedValues, presetValues, explicitValues, options, strategy) => {
+  const featureEntries = getFeatureEntries(options, bucket, true);
+  const combined = explicitValues !== void 0 || featureEntries.length > 0 ? [...explicitValues ?? [], ...featureEntries] : void 0;
+  return applyFeatureDisables(
+    mergeArrayOption(detectedValues, presetValues, combined, strategy),
+    options,
+    bucket
+  );
+};
+const mergeFrameworkOption = (detectedFrameworks, presetFrameworks, explicitFrameworks, strategy) => {
+  if (strategy === "replace") {
+    if (explicitFrameworks) return { ...explicitFrameworks };
+    if (presetFrameworks) return { ...presetFrameworks };
+    return { ...detectedFrameworks };
+  }
+  return {
+    ...detectedFrameworks,
+    ...presetFrameworks ?? {},
+    ...explicitFrameworks ?? {}
+  };
+};
+const resolveDetectionOptions = (detection, defaults = {}) => {
+  const defaultControls = {
+    extensions: true,
+    formats: true,
+    frameworks: true,
+    libraries: true,
+    nextMode: true,
+    projects: false,
+    runtime: true,
+    testing: true,
+    tools: true,
+    typescript: true,
+    ...defaults
+  };
+  if (detection === false) {
+    return Object.fromEntries(
+      Object.keys(defaultControls).map((key) => [key, false])
     );
   }
-  const hasReact = !!frameworks.react;
-  const hasVue = !!frameworks.vue;
-  const hasSvelte = !!frameworks.svelte;
-  const hasSolid = !!frameworks.solid;
-  const useGitignore = !uniqueSettings.includes(Setting.NoGitignore);
-  const reactParam = resolveFramework("react", frameworks.react);
-  const nextParam = resolveFramework("next", frameworks.next);
-  const astroParam = resolveFramework("astro", frameworks.astro, {
-    hasReact,
-    hasVue,
-    hasSvelte,
-    hasSolid
+  if (detection === true || detection === void 0) {
+    return defaultControls;
+  }
+  return {
+    ...defaultControls,
+    ...detection
+  };
+};
+const applyArrayControls = (controls, detected) => ({
+  detectedFrameworks: controls.frameworks ? detected.detectedFrameworks : [],
+  extensions: controls.extensions ? detected.extensions : [],
+  formats: controls.formats ? detected.formats : [],
+  libraries: controls.libraries ? detected.libraries : [],
+  testing: controls.testing ? detected.testing : [],
+  tools: controls.tools ? detected.tools : []
+});
+const applyScalarControls = (controls, detected) => ({
+  nextMode: controls.nextMode ? detected.nextMode : void 0,
+  preset: controls.typescript && controls.runtime ? detected.preset : void 0,
+  projects: controls.projects ? detected.projects : void 0,
+  runtime: controls.runtime ? detected.runtime : void 0,
+  typescript: controls.typescript ? detected.typescript : false
+});
+const applyDetectionControls = (detected, detection, defaults) => {
+  const controls = resolveDetectionOptions(detection, defaults);
+  return { ...detected, ...applyArrayControls(controls, detected), ...applyScalarControls(controls, detected) };
+};
+const getStrictMode = (explicitStrict, presetStrict) => explicitStrict ?? presetStrict ?? false;
+const applyStrictProfileDefaults = (extensions, strict) => {
+  if (strict !== "pedantic") return extensions;
+  return toUniqueArray([...extensions, Extension.BestPractices]);
+};
+const hasTsconfig = (rootDir) => [
+  "tsconfig.eslint.json",
+  "tsconfig.json",
+  "tsconfig.base.json",
+  "tsconfig.app.json",
+  "tsconfig.node.json"
+].some((fileName) => existsSync(join(rootDir, fileName)));
+const resolveTypescriptOptions = (typescript) => {
+  if (!typescript || typescript === "off") return false;
+  if (typescript === true) return { mode: "type-aware" };
+  if (typeof typescript === "string") return { mode: typescript };
+  if (typescript.mode === "off") return false;
+  return {
+    ...typescript,
+    mode: typescript.mode ?? "type-aware"
+  };
+};
+const resolveTsconfigRootDir = (rootDir, typescript, explicitRootDir) => {
+  if (explicitRootDir) return explicitRootDir;
+  return resolveTypescriptOptions(typescript) && hasTsconfig(rootDir) ? rootDir : void 0;
+};
+const findTailwindEntryPoint = (rootDir) => TAILWIND_ENTRYPOINT_CANDIDATES.find(
+  (candidate) => existsSync(join(rootDir, candidate))
+);
+const buildTailwindResult = (options, entryPoint) => ({
+  detectComponentClasses: options.detectComponentClasses ?? true,
+  ...entryPoint ? { entryPoint } : {},
+  ...options.ignore?.length ? { ignore: options.ignore } : {}
+});
+const resolveTailwindOptions = (rootDir, tailwind2) => {
+  if (tailwind2 === false) return void 0;
+  const options = tailwind2 ?? {};
+  const entryPoint = options.entryPoint ?? findTailwindEntryPoint(rootDir);
+  if (!entryPoint && options.detectComponentClasses === void 0 && !options.ignore?.length) return void 0;
+  return buildTailwindResult(options, entryPoint);
+};
+const createTailwindSettingsConfig = (tailwindOptions) => {
+  const unknownClassOptions = {
+    ...tailwindOptions.entryPoint ? { entryPoint: tailwindOptions.entryPoint } : {},
+    ...tailwindOptions.ignore?.length ? { ignore: tailwindOptions.ignore } : {}
+  };
+  const hasUnknownClassOptions = Object.keys(unknownClassOptions).length > 0;
+  return {
+    name: "eslint-config-basic/tailwind-settings",
+    ...hasUnknownClassOptions ? { rules: { "better-tailwindcss/no-unknown-classes": ["error", unknownClassOptions] } } : {},
+    settings: {
+      "better-tailwindcss": tailwindOptions
+    }
+  };
+};
+const scopeFilePattern = (projectPath, pattern) => {
+  if (typeof pattern === "string") {
+    const isNegated = pattern.startsWith("!");
+    const basePattern = (isNegated ? pattern.slice(1) : pattern).replace(/^\.\//, "");
+    const scoped = `${projectPath.replace(/\/$/, "")}/${basePattern}`;
+    return isNegated ? `!${scoped}` : scoped;
+  }
+  if (Array.isArray(pattern)) {
+    return pattern.map((item) => scopeFilePattern(projectPath, item));
+  }
+  return pattern;
+};
+const scopeConfigToProject = (config, projectPath) => {
+  if ("ignores" in config && !config.files) {
+    return {
+      ...config,
+      ignores: config.ignores?.map((pattern) => scopeFilePattern(projectPath, pattern))
+    };
+  }
+  return {
+    ...config,
+    files: Array.isArray(config.files) ? config.files.map((pattern) => scopeFilePattern(projectPath, pattern)) : [`${projectPath.replace(/\/$/, "")}/**/*`]
+  };
+};
+const patchImportGroupsConfig = (config, workspacePatterns) => {
+  const rule = config.rules?.["simple-import-sort/imports"];
+  if (!Array.isArray(rule) || !rule[1]) return config;
+  const ruleOpts = rule[1];
+  const existingGroups = ruleOpts.groups ?? [];
+  if (existingGroups.length === 0) return config;
+  const externalIdx = existingGroups.findIndex((g) => g.some((p) => p.includes("^@?\\w")));
+  const insertAt = externalIdx >= 0 ? externalIdx : existingGroups.length;
+  return {
+    ...config,
+    rules: {
+      ...config.rules,
+      "simple-import-sort/imports": [
+        rule[0],
+        { ...ruleOpts, groups: [...existingGroups.slice(0, insertAt), workspacePatterns, ...existingGroups.slice(insertAt)] }
+      ]
+    }
+  };
+};
+const patchImportGroups = (allConfigs, workspacePrefixes) => {
+  const workspacePatterns = workspacePrefixes.map(
+    (p) => `^${p.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")}(/.*|$)`
+  );
+  return allConfigs.map(
+    (item) => Array.isArray(item) ? item : patchImportGroupsConfig(item, workspacePatterns)
+  );
+};
+const TESTING_CONFIG_NAMES = {
+  [Testing.Playwright]: ["integrations/playwright"]
+};
+const applyTestingFileOverrides = (configs, testingFiles) => {
+  if (!testingFiles) return configs;
+  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 ?? "")
+    );
+    if (!match) return config;
+    const [, files] = match;
+    return {
+      ...config,
+      files
+    };
   });
-  const expoParam = resolveFramework("expo", frameworks.expo);
-  const nestParam = resolveFramework("nest", frameworks.nest);
-  const honoParam = resolveFramework("hono", frameworks.hono, { runtime });
-  const vueParam = resolveFramework("vue", frameworks.vue);
-  const svelteParam = resolveFramework("svelte", frameworks.svelte);
-  const solidParam = resolveFramework("solid", frameworks.solid);
-  const angularParam = resolveFramework("angular", frameworks.angular);
-  const qwikParam = resolveFramework("qwik", frameworks.qwik);
-  const remixParam = resolveFramework("remix", frameworks.remix);
-  const runtimeCoreConfig = runtime !== Runtime.Universal ? createCoreConfig(runtime) : coreConfig;
-  const configs = [
-    // Settings
-    ...useGitignore ? gitignore : [],
-    // Global TSConfig Root Dir fix
+};
+const resolveConfigSetup = (options) => ({
+  autoFrameworks: options?.autoFrameworks ?? true,
+  detectRootDir: options?.detectRootDir ?? options?.tsconfigRootDir,
+  optionMergeStrategy: options?.optionMergeStrategy ?? "merge",
+  requestedPreset: options?.preset
+});
+const resolveUniqueLibraries = (libraries, tailwind2) => {
+  const uniqueLibraries = [...new Set(libraries)];
+  if (tailwind2 === false) return uniqueLibraries.filter((library) => library !== Library.Tailwind);
+  if (!tailwind2) return uniqueLibraries;
+  return [.../* @__PURE__ */ new Set([...uniqueLibraries, Library.Tailwind])];
+};
+const resolvePresetMeta = (requestedPreset, detected, autoFrameworks) => {
+  const preset = requestedPreset ?? detected.preset;
+  const presetDefaults = preset ? resolvePreset(preset) : {};
+  const frameworkDefaults = autoFrameworks ? createDetectedFrameworkFlags(detected.detectedFrameworks) : {};
+  return { frameworkDefaults, preset, presetDefaults };
+};
+const resolveConfiguredProjects = (detected, options) => ({
+  ...detected.projects ?? {},
+  ...options?.projects ?? {}
+});
+const resolveBucketDefaults = (detected) => ({
+  detectedExtensions: detected.extensions ?? [],
+  detectedFormats: detected.formats ?? [],
+  detectedLibraries: detected.libraries ?? [],
+  detectedTesting: detected.testing ?? [],
+  detectedTools: detected.tools ?? []
+});
+const resolveNextModeValue = (options, presetDefaults, detected) => options?.nextMode ?? presetDefaults.nextMode ?? detected.nextMode ?? NextMode.Pages;
+const resolveRuntimeValue = (options, presetDefaults, detected) => options?.runtime ?? presetDefaults.runtime ?? 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.react;
+const applyFrameworkImpliedDeps = (frameworks) => {
+  const result = { ...frameworks };
+  if (needsReactAutoAdd(result)) result.react = true;
+  if (result.slidev && !result.vue) result.vue = true;
+  if (result.nuxt && !result.vue) result.vue = true;
+  return result;
+};
+const buildIgnoresConfig = (useDefaultIgnores, useGeneratedCodeIgnores, useGitignore, options) => ({
+  defaultIgnores: useDefaultIgnores ? [{
+    ignores: [...DEFAULT_IGNORES, ...useGeneratedCodeIgnores ? GENERATED_CODE_IGNORES : []],
+    name: "eslint-config-basic/default-ignores"
+  }] : [],
+  gitignoreConfig: useGitignore ? gitignore : [],
+  userIgnores: options?.ignores?.length ? [{
+    ignores: options.ignores,
+    name: "eslint-config-basic/ignores"
+  }] : []
+});
+const buildEslintConfigs = async (params) => {
+  const {
+    astroOptions,
+    defaultIgnores,
+    gitignoreConfig,
+    nextMode,
+    resolvedFrameworks,
+    resolvedTypescript,
+    rootDir: _rootDir,
+    runtime,
+    runtimeCoreConfig,
+    tailwindOptions,
+    testingFiles,
+    tsconfigRootDir,
+    uniqueExtensions,
+    uniqueFormats,
+    uniqueLibraries,
+    uniqueTesting,
+    uniqueTools,
+    userIgnores
+  } = params;
+  const { hasReact, hasSolid, hasSvelte, hasVue } = astroOptions;
+  const [
+    reactParam,
+    nextParam,
+    astroParam,
+    expoParam,
+    nestParam,
+    honoParam,
+    vueParam,
+    svelteParam,
+    solidParam,
+    angularParam,
+    qwikParam,
+    remixParam,
+    reactRouterParam,
+    tanstackStartParam,
+    nuxtParam,
+    preactParam,
+    litParam,
+    slidevParam,
+    viteParam
+  ] = await Promise.all([
+    resolveFramework("react", resolvedFrameworks.react),
+    resolveFramework("next", resolvedFrameworks.next),
+    resolveFramework("astro", resolvedFrameworks.astro, { hasReact, hasSolid, hasSvelte, hasVue }),
+    resolveFramework("expo", resolvedFrameworks.expo),
+    resolveFramework("nest", resolvedFrameworks.nest),
+    resolveFramework("hono", resolvedFrameworks.hono, { runtime }),
+    resolveFramework("vue", resolvedFrameworks.vue),
+    resolveFramework("svelte", resolvedFrameworks.svelte),
+    resolveFramework("solid", resolvedFrameworks.solid),
+    resolveFramework("angular", resolvedFrameworks.angular),
+    resolveFramework("qwik", resolvedFrameworks.qwik),
+    resolveFramework("remix", resolvedFrameworks.remix),
+    resolveFramework("react-router", resolvedFrameworks["react-router"]),
+    resolveFramework("tanstack-start", resolvedFrameworks["tanstack-start"]),
+    resolveFramework("nuxt", resolvedFrameworks.nuxt),
+    resolveFramework("preact", resolvedFrameworks.preact),
+    resolveFramework("lit", resolvedFrameworks.lit),
+    resolveFramework("slidev", resolvedFrameworks.slidev, { runtime }),
+    resolveFramework("vite", resolvedFrameworks.vite, { runtime })
+  ]);
+  return [
+    ...defaultIgnores,
+    ...userIgnores,
+    ...gitignoreConfig,
     ...tsconfigRootDir ? [{
-      name: "eslint-config-basic/tsconfig-root-dir",
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir
-        }
-      }
+      languageOptions: { parserOptions: { tsconfigRootDir } },
+      name: "eslint-config-basic/tsconfig-root-dir"
     }] : [],
-    // Core JS config with runtime-aware globals
+    {
+      files: ["**/*.cjs", "**/*.cts"],
+      languageOptions: {
+        globals: {
+          __dirname: "readonly",
+          __filename: "readonly",
+          exports: "readonly",
+          module: "readonly",
+          require: "readonly"
+        },
+        sourceType: "commonjs"
+      },
+      name: "eslint-config-basic/commonjs"
+    },
     ...runtimeCoreConfig,
-    // React config (included if any React-based framework is used/passed)
     ...hasReact ? reactParam : [],
     ...nextParam,
     ...expoParam,
@@ -143,82 +570,306 @@ const eslintConfig = (options) => {
     ...angularParam,
     ...qwikParam,
     ...remixParam,
-    ...typescript ? createTypescriptConfig({ tsconfigRootDir }) : [],
-    // Astro needs to run after generic TypeScript so its parser and false-positive
-    // workarounds win for .astro files and embedded expressions.
+    ...reactRouterParam,
+    ...tanstackStartParam,
+    ...nuxtParam,
+    ...preactParam,
+    ...litParam,
+    ...slidevParam,
+    ...viteParam,
+    ...resolvedTypescript ? createTypescriptConfig({
+      ...resolvedTypescript,
+      tsconfigRootDir: resolvedTypescript.tsconfigRootDir ?? tsconfigRootDir
+    }) : [],
     ...astroParam,
-    // Next.js App Router overrides (#12)
-    ...frameworks.next && nextMode === NextMode.AppRouter ? [
-      {
-        name: "eslint-config-next/app-router-overrides",
-        files: ["app/**/*.{ts,tsx}"],
-        rules: {
-          "@next/next/no-html-link-for-pages": "off"
-        }
-      }
-    ] : [],
-    // Optionals
-    ...getOptionalConfigs(
-      uniqueLibraries,
-      uniqueTools,
-      uniqueTesting,
-      uniqueFormats,
-      uniqueExtensions
+    ...resolvedFrameworks.next && nextMode === NextMode.AppRouter ? [{
+      files: ["app/**/*.{ts,tsx}", "src/**/*.{ts,tsx}"],
+      name: "eslint-config-next/app-router-overrides",
+      rules: { "@next/next/no-html-link-for-pages": "off" }
+    }] : [],
+    ...applyTestingFileOverrides(
+      await getIntegrationConfigs(uniqueLibraries, uniqueTools, uniqueTesting, uniqueFormats, uniqueExtensions),
+      testingFiles
     ),
-    // Prettier always last
-    ...getPrettierConfig(uniqueTools)
+    ...tailwindOptions ? [createTailwindSettingsConfig(tailwindOptions)] : [],
+    ...await getPrettierConfig(uniqueTools)
   ];
-  return applyStrictMode(configs, strict);
 };
+const logEslintDebug = (autoFrameworks, detectRootDir, nextMode, optionMergeStrategy, preset, resolvedFrameworks, resolvedTypescript, runtime, tsconfigRootDir, uniqueExtensions, uniqueFormats, uniqueLibraries, uniqueTesting, uniqueTools) => {
+  if (!process.env.ESLINT_BASIC_DEBUG) return;
+  process.stdout.write(`[ESLint Basic] Resolved options: ${JSON.stringify({
+    autoFrameworks,
+    detectRootDir: detectRootDir ?? process.cwd(),
+    extensions: uniqueExtensions,
+    formats: uniqueFormats,
+    frameworks: Object.entries(resolvedFrameworks).filter(([, value]) => Boolean(value)).map(([key]) => key),
+    libraries: uniqueLibraries,
+    nextMode,
+    optionMergeStrategy,
+    preset,
+    runtime,
+    testing: uniqueTesting,
+    tools: uniqueTools,
+    tsconfigRootDir,
+    typescript: resolvedTypescript ? resolvedTypescript.mode : false
+  }, null, 2)}
+`);
+};
+const eslintConfig = async (options, ...extraConfigs) => {
+  const {
+    detection,
+    extensions: optExtensions,
+    formats: optFormats,
+    frameworks: optFrameworks,
+    libraries: optLibraries,
+    strict: optStrict,
+    testing: optTesting,
+    tools: optTools,
+    tsconfigRootDir: optTsconfigRootDir,
+    workspacePrefixes
+  } = options ?? {};
+  const { autoFrameworks, detectRootDir, optionMergeStrategy, requestedPreset } = resolveConfigSetup(options);
+  const shouldDefaultProjectDetection = requestedPreset === Preset.Monorepo;
+  const detected = applyDetectionControls(
+    detectProjectOptions(detectRootDir),
+    detection,
+    { projects: shouldDefaultProjectDetection }
+  );
+  const { frameworkDefaults, preset, presetDefaults } = resolvePresetMeta(requestedPreset, detected, autoFrameworks);
+  const configuredProjects = resolveConfiguredProjects(detected, options);
+  const { detectedExtensions, detectedFormats, detectedLibraries, detectedTesting, detectedTools } = resolveBucketDefaults(detected);
+  const configuredExtensions = mergeOptionalBucket(
+    "extensions",
+    detectedExtensions,
+    presetDefaults.extensions,
+    optExtensions,
+    options,
+    optionMergeStrategy
+  );
+  const formats = mergeOptionalBucket(
+    "formats",
+    detectedFormats,
+    presetDefaults.formats,
+    optFormats,
+    options,
+    optionMergeStrategy
+  );
+  const frameworks = mergeFrameworkOption(frameworkDefaults, presetDefaults.frameworks, optFrameworks, optionMergeStrategy);
+  const libraries = mergeOptionalBucket(
+    "libraries",
+    detectedLibraries,
+    presetDefaults.libraries,
+    optLibraries,
+    options,
+    optionMergeStrategy
+  );
+  const nextMode = resolveNextModeValue(options, presetDefaults, detected);
+  const runtime = resolveRuntimeValue(options, presetDefaults, detected);
+  const settings = resolveSettingsValue(options, detected);
+  const strict = getStrictMode(optStrict, presetDefaults.strict);
+  const testing = mergeOptionalBucket(
+    "testing",
+    detectedTesting,
+    presetDefaults.testing,
+    optTesting,
+    options,
+    optionMergeStrategy
+  );
+  const tools = mergeOptionalBucket(
+    "tools",
+    detectedTools,
+    presetDefaults.tools,
+    optTools,
+    options,
+    optionMergeStrategy
+  );
+  const typescript = resolveTypescriptValue(options, presetDefaults, detected);
+  const resolvedTypescript = resolveTypescriptOptions(typescript);
+  const rootDir = detectRootDir ?? process.cwd();
+  const tsconfigRootDir = resolveTsconfigRootDir(rootDir, typescript, optTsconfigRootDir);
+  const extensions = applyStrictProfileDefaults(configuredExtensions, strict);
+  const resolvedFrameworks = applyFrameworkImpliedDeps({ ...frameworks });
+  const uniqueLibraries = resolveUniqueLibraries(libraries, options?.tailwind);
+  const uniqueTesting = [...new Set(testing)];
+  const uniqueFormats = [...new Set(formats)];
+  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);
+  const configs = await buildEslintConfigs({
+    astroOptions: { hasReact, hasSolid, hasSvelte, hasVue },
+    defaultIgnores,
+    gitignoreConfig,
+    nextMode,
+    resolvedFrameworks,
+    resolvedTypescript,
+    rootDir,
+    runtime,
+    runtimeCoreConfig,
+    tailwindOptions,
+    testingFiles: options?.testingFiles,
+    tsconfigRootDir,
+    uniqueExtensions,
+    uniqueFormats,
+    uniqueLibraries,
+    uniqueTesting,
+    uniqueTools,
+    userIgnores
+  });
+  logEslintDebug(
+    autoFrameworks,
+    detectRootDir,
+    nextMode,
+    optionMergeStrategy,
+    preset,
+    resolvedFrameworks,
+    resolvedTypescript,
+    runtime,
+    tsconfigRootDir,
+    uniqueExtensions,
+    uniqueFormats,
+    uniqueLibraries,
+    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({
+        ...projectOptions,
+        detectRootDir: projectOptions.detectRootDir ?? projectRoot,
+        projects: void 0,
+        tsconfigRootDir: projectOptions.tsconfigRootDir ?? projectRoot
+      });
+      return scopedConfigs.map((config) => scopeConfigToProject(config, projectPath));
+    })
+  );
+  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,
-  Extension,
-  Format,
-  Library,
+  Extension2 as Extension,
+  Format2 as Format,
+  Library2 as Library,
   NextMode2 as NextMode,
-  Preset,
+  Preset2 as Preset,
   ReactConfigKeys,
   Runtime2 as Runtime,
   Setting2 as Setting,
-  Testing,
-  Tool,
+  Testing2 as Testing,
+  Tool2 as Tool,
+  a11y,
+  aiSdk,
+  angular,
+  angularConfig,
+  astro,
+  autogen,
   bestPractices,
+  biome,
+  command,
+  compat,
   coreConfig2 as coreConfig,
   createCoreConfig2 as createCoreConfig,
+  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,
-  yaml
+  vue,
+  vueConfig,
+  yaml,
+  zod
 };