@santi020k/eslint-config-lite 2.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,742 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import {
+  coreConfig,
+  createCoreConfig,
+  detectProjectOptions,
+  Extension,
+  Format,
+  gitignore,
+  Library,
+  NextMode,
+  Preset,
+  Runtime,
+  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 {
+  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 as Extension2,
+  Format as Format2,
+  getGlobalsForRuntime,
+  gitignore as gitignore2,
+  hasReactConfig,
+  jsConfig,
+  Library as Library2,
+  NextMode as NextMode2,
+  Preset as Preset2,
+  ReactConfigKeys,
+  Runtime as Runtime2,
+  Setting as Setting2,
+  Testing as Testing2,
+  Tool as Tool2
+} from "@santi020k/eslint-config-core";
+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 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 hasExplicitInput = explicitValues !== void 0 || featureEntries.length > 0;
+  const mergedExplicit = hasExplicitInput ? [...explicitValues ?? [], ...featureEntries] : void 0;
+  return applyFeatureDisables(
+    mergeArrayOption(detectedValues, presetValues, mergedExplicit, 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])
+    );
+  }
+  if (detection === true || detection === void 0) {
+    return defaultControls;
+  }
+  return {
+    ...defaultControls,
+    ...detection
+  };
+};
+const applyArrayDetectionControls = (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 applyScalarDetectionControls = (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,
+    ...applyArrayDetectionControls(controls, detected),
+    ...applyScalarDetectionControls(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"
+  // eslint-disable-next-line security/detect-non-literal-fs-filename -- config root is user-selected project context
+].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(
+  // eslint-disable-next-line security/detect-non-literal-fs-filename -- probes known stylesheet candidates under project root
+  (candidate) => existsSync(join(rootDir, candidate))
+);
+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 resolveLiteSetup = (options) => ({
+  autoFrameworks: options?.autoFrameworks ?? true,
+  detectRootDir: options?.detectRootDir ?? options?.tsconfigRootDir,
+  optionMergeStrategy: options?.optionMergeStrategy ?? "merge",
+  requestedPreset: options?.preset
+});
+const resolveLitePresetMeta = (requestedPreset, detected, autoFrameworks, optProjects) => {
+  const preset = requestedPreset ?? detected.preset;
+  const presetDefaults = preset ? resolvePreset(preset) : {};
+  const frameworkDefaults = autoFrameworks ? createDetectedFrameworkFlags(detected.detectedFrameworks ?? []) : {};
+  const configuredProjects = { ...detected.projects ?? {}, ...optProjects ?? {} };
+  return { configuredProjects, frameworkDefaults, preset, presetDefaults };
+};
+const resolveLiteBucketDefaults = (detected) => ({
+  detectedExtensions: detected.extensions ?? [],
+  detectedFormats: detected.formats ?? [],
+  detectedLibraries: detected.libraries ?? [],
+  detectedTesting: detected.testing ?? [],
+  detectedTools: detected.tools ?? []
+});
+const resolveLiteNextMode = (optNextMode, presetNextMode, detectedNextMode) => optNextMode ?? presetNextMode ?? detectedNextMode ?? NextMode.Pages;
+const resolveLiteRuntime = (optRuntime, presetRuntime, detectedRuntime) => optRuntime ?? presetRuntime ?? detectedRuntime ?? Runtime.Universal;
+const resolveLiteTypescript = (optTypescript, presetTypescript, detectedTypescript) => optTypescript ?? presetTypescript ?? detectedTypescript ?? false;
+const resolveLiteScalars = (opts, presetDefaults, detected) => ({
+  nextMode: resolveLiteNextMode(opts.nextMode, presetDefaults.nextMode, detected.nextMode),
+  runtime: resolveLiteRuntime(opts.runtime, presetDefaults.runtime, detected.runtime),
+  settings: opts.settings ?? detected.settings ?? [],
+  strict: getStrictMode(opts.strict, presetDefaults.strict),
+  typescript: resolveLiteTypescript(opts.typescript, presetDefaults.typescript, detected.typescript)
+});
+const hasReactImplyingFramework = (result) => Boolean(
+  result.next ?? result.expo ?? result.remix ?? result["react-router"] ?? (result["tanstack-start"] && !result.solid)
+);
+const applyLiteFrameworkImpliedDeps = (frameworks) => {
+  const result = { ...frameworks };
+  if (hasReactImplyingFramework(result) && !result.react) result.react = true;
+  if (result.slidev && !result.vue) result.vue = true;
+  if (result.nuxt && !result.vue) result.vue = true;
+  return result;
+};
+const buildLiteIgnoresConfig = (useDefaultIgnores, useGeneratedCodeIgnores, useGitignore, optIgnores) => ({
+  defaultIgnores: useDefaultIgnores ? [{
+    ignores: [...DEFAULT_IGNORES, ...useGeneratedCodeIgnores ? GENERATED_CODE_IGNORES : []],
+    name: "eslint-config-lite/default-ignores"
+  }] : [],
+  gitignoreConfig: useGitignore ? gitignore : [],
+  userIgnores: optIgnores?.length ? [{
+    ignores: optIgnores,
+    name: "eslint-config-lite/ignores"
+  }] : []
+});
+const logLiteDebug = (autoFrameworks, detectRootDir, nextMode, optionMergeStrategy, preset, resolvedFrameworks, resolvedTypescript, runtime, tsconfigRootDir, uniqueExtensions, uniqueFormats, uniqueLibraries, uniqueTesting, uniqueTools) => {
+  if (!process.env.ESLINT_CONFIG_LITE_DEBUG && !process.env.ESLINT_BASIC_DEBUG) return;
+  process.stdout.write(`[ESLint Config Lite] 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 buildLiteEslintConfigs = async (params) => {
+  const {
+    angularParam,
+    astroOptions,
+    astroParam,
+    defaultIgnores,
+    expoParam,
+    gitignoreConfig,
+    honoParam,
+    litParam,
+    nestParam,
+    nextMode,
+    nextParam,
+    nuxtParam,
+    preactParam,
+    qwikParam,
+    reactParam,
+    reactRouterParam,
+    remixParam,
+    resolvedFrameworks,
+    resolvedTypescript,
+    runtimeCoreConfig,
+    slidevParam,
+    solidParam,
+    svelteParam,
+    tailwindEntryPoint,
+    tanstackStartParam,
+    tsconfigRootDir,
+    uniqueExtensions,
+    uniqueFormats,
+    uniqueLibraries,
+    uniqueTesting,
+    uniqueTools,
+    userIgnores,
+    viteParam,
+    vueParam
+  } = params;
+  const { hasReact } = astroOptions;
+  return [
+    ...defaultIgnores,
+    ...userIgnores,
+    // Settings
+    ...gitignoreConfig,
+    // Global TSConfig Root Dir fix
+    ...tsconfigRootDir ? [{
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir
+        }
+      },
+      name: "eslint-config-lite/tsconfig-root-dir"
+    }] : [],
+    {
+      files: ["**/*.cjs", "**/*.cts"],
+      languageOptions: {
+        globals: {
+          __dirname: "readonly",
+          __filename: "readonly",
+          exports: "readonly",
+          module: "readonly",
+          require: "readonly"
+        },
+        sourceType: "commonjs"
+      },
+      name: "eslint-config-lite/commonjs"
+    },
+    // Core JS config with runtime-aware globals
+    ...runtimeCoreConfig,
+    // React config (included if any React-based framework is used/passed)
+    ...hasReact ? reactParam : [],
+    ...nextParam,
+    ...expoParam,
+    ...nestParam,
+    ...honoParam,
+    ...vueParam,
+    ...svelteParam,
+    ...solidParam,
+    ...angularParam,
+    ...qwikParam,
+    ...remixParam,
+    ...reactRouterParam,
+    ...tanstackStartParam,
+    ...nuxtParam,
+    ...preactParam,
+    ...litParam,
+    ...slidevParam,
+    ...viteParam,
+    ...resolvedTypescript ? createTypescriptConfig({
+      ...resolvedTypescript,
+      tsconfigRootDir: resolvedTypescript.tsconfigRootDir ?? tsconfigRootDir
+    }) : [],
+    // Astro needs to run after generic TypeScript so its parser and false-positive
+    // workarounds win for .astro files and embedded expressions.
+    ...astroParam,
+    // Next.js App Router overrides (#12)
+    ...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"
+        }
+      }
+    ] : [],
+    // Integrations
+    ...await getIntegrationConfigs(
+      uniqueLibraries,
+      uniqueTools,
+      uniqueTesting,
+      uniqueFormats,
+      uniqueExtensions
+    ),
+    ...tailwindEntryPoint ? [{
+      name: "eslint-config-lite/tailwind-settings",
+      settings: {
+        "better-tailwindcss": {
+          detectComponentClasses: true,
+          entryPoint: tailwindEntryPoint
+        }
+      }
+    }] : [],
+    // Prettier always last
+    ...await getPrettierConfig(uniqueTools)
+  ];
+};
+const eslintConfig = async (options) => {
+  const {
+    detection,
+    extensions: optExtensions,
+    formats: optFormats,
+    frameworks: optFrameworks,
+    ignores: optIgnores,
+    libraries: optLibraries,
+    nextMode: optNextMode,
+    projects: optProjects,
+    runtime: optRuntime,
+    settings: optSettings,
+    strict: optStrict,
+    testing: optTesting,
+    tools: optTools,
+    tsconfigRootDir: optTsconfigRootDir,
+    typescript: optTypescript,
+    workspacePrefixes
+  } = options ?? {};
+  const { autoFrameworks, detectRootDir, optionMergeStrategy, requestedPreset } = resolveLiteSetup(options);
+  const shouldDefaultProjectDetection = requestedPreset === Preset.Monorepo;
+  const detected = applyDetectionControls(
+    detectProjectOptions(detectRootDir),
+    detection,
+    { projects: shouldDefaultProjectDetection }
+  );
+  const { configuredProjects, frameworkDefaults, preset, presetDefaults } = resolveLitePresetMeta(
+    requestedPreset,
+    detected,
+    autoFrameworks,
+    optProjects
+  );
+  const { detectedExtensions, detectedFormats, detectedLibraries, detectedTesting, detectedTools } = resolveLiteBucketDefaults(detected);
+  const { nextMode, runtime, settings, strict, typescript } = resolveLiteScalars(
+    { nextMode: optNextMode, runtime: optRuntime, settings: optSettings, strict: optStrict, typescript: optTypescript },
+    presetDefaults,
+    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 testing = mergeOptionalBucket("testing", detectedTesting, presetDefaults.testing, optTesting, options, optionMergeStrategy);
+  const tools = mergeOptionalBucket("tools", detectedTools, presetDefaults.tools, optTools, options, optionMergeStrategy);
+  const resolvedTypescript = resolveTypescriptOptions(typescript);
+  const rootDir = detectRootDir ?? process.cwd();
+  const tsconfigRootDir = resolveTsconfigRootDir(rootDir, typescript, optTsconfigRootDir);
+  const extensions = applyStrictProfileDefaults(configuredExtensions, strict);
+  const resolvedFrameworks = applyLiteFrameworkImpliedDeps({ ...frameworks });
+  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)];
+  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 tailwindEntryPoint = uniqueLibraries.includes(Library.Tailwind) ? findTailwindEntryPoint(rootDir) : void 0;
+  const runtimeCoreConfig = runtime === Runtime.Universal ? coreConfig : createCoreConfig(runtime);
+  const { defaultIgnores, gitignoreConfig, userIgnores } = buildLiteIgnoresConfig(
+    useDefaultIgnores,
+    useGeneratedCodeIgnores,
+    useGitignore,
+    optIgnores
+  );
+  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 })
+  ]);
+  const configs = await buildLiteEslintConfigs({
+    angularParam,
+    astroOptions: { hasReact, hasSolid, hasSvelte, hasVue },
+    astroParam,
+    defaultIgnores,
+    expoParam,
+    gitignoreConfig,
+    honoParam,
+    litParam,
+    nestParam,
+    nextMode,
+    nextParam,
+    nuxtParam,
+    preactParam,
+    qwikParam,
+    reactParam,
+    reactRouterParam,
+    remixParam,
+    resolvedFrameworks,
+    resolvedTypescript,
+    rootDir,
+    runtime,
+    runtimeCoreConfig,
+    slidevParam,
+    solidParam,
+    svelteParam,
+    tailwindEntryPoint,
+    tanstackStartParam,
+    tsconfigRootDir,
+    uniqueExtensions,
+    uniqueFormats,
+    uniqueLibraries,
+    uniqueTesting,
+    uniqueTools,
+    userIgnores,
+    viteParam,
+    vueParam
+  });
+  logLiteDebug(
+    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()];
+  const patchedConfigs = workspacePrefixes?.length ? patchImportGroups(allConfigs, workspacePrefixes) : allConfigs;
+  return applyStrictMode(patchedConfigs, strict);
+};
+const defineConfig = eslintConfig;
+export {
+  Extension2 as Extension,
+  Format2 as Format,
+  Library2 as Library,
+  NextMode2 as NextMode,
+  Preset2 as Preset,
+  ReactConfigKeys,
+  Runtime2 as Runtime,
+  Setting2 as Setting,
+  Testing2 as Testing,
+  Tool2 as Tool,
+  angular,
+  angularConfig,
+  astro,
+  coreConfig2 as coreConfig,
+  createCoreConfig2 as createCoreConfig,
+  createImportGroups,
+  defineConfig,
+  detectProjectOptions2 as detectProjectOptions,
+  eslintConfig,
+  expo,
+  expoConfig,
+  getGlobalsForRuntime,
+  gitignore2 as gitignore,
+  hasReactConfig,
+  hono,
+  jsConfig,
+  lit,
+  nest,
+  nestConfig,
+  next,
+  nextConfig,
+  nuxt,
+  preact,
+  preactConfig,
+  qwik,
+  react,
+  reactConfig,
+  reactRouter,
+  remix,
+  slidev,
+  solid,
+  solidConfig,
+  svelte,
+  svelteConfig,
+  tanstackStart,
+  tsConfig,
+  typescriptConfig,
+  vite,
+  vue,
+  vueConfig
+};