fix: .dts generation + better types (#538)

closes #537

<details>
<summary>`dist/index.dts`</summary>

```
declare const _default: {
    configs: {
        readonly 'flat/pedantic': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/pedantic";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/style': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/style";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/suspicious': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/suspicious";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/restriction': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/restriction";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/correctness': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/correctness";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/perf': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/perf";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/eslint': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/eslint";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/import': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/import";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/jest': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/jest";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/jsdoc': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/jsdoc";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/jsx-a11y': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/jsx-a11y";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/nextjs': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/nextjs";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/node': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/node";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/promise': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/promise";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/react': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/react";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/react-hooks': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/react-hooks";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/react-perf': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/react-perf";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/typescript': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/typescript";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/unicorn': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/unicorn";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/vitest': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/vitest";
            readonly rules: Record<string, "off">;
        }>;
        readonly 'flat/vue': import('./config-helper.js').SplittedFlatConfig<{
            readonly name: "oxlint/vue";
            readonly rules: Record<string, "off">;
        }>;
        readonly recommended: {
            plugins: string[];
            rules: Record<string, "off">;
        };
        readonly all: {
            plugins: string[];
            rules: Record<string, "off">;
        };
        readonly 'flat/all': import('./config-helper.js').SplittedFlatConfig<{
            name: string;
            rules: Record<string, "off">;
        }>;
        readonly 'flat/recommended': import('./config-helper.js').SplittedFlatConfig<{
            name: string;
            rules: Record<string, "off">;
        }>;
    };
    buildFromOxlintConfig: (config: import('./build-from-oxlint-config/types.js').OxlintConfig) => import('./build-from-oxlint-config/types.js').EslintPluginOxlintConfig[];
    buildFromOxlintConfigFile: (oxlintConfigFile: string) => import('./build-from-oxlint-config/types.js').EslintPluginOxlintConfig[];
};
export default _default;
```

</details>

Author: Sysix

scripts/config-generator.ts

@@ -59,7 +59,7 @@ export class ConfigGenerator {
 
       code += `  name: 'oxlint/${kebabCase(grouping)}',\n`;
       code += `  rules: rules.${camelCase(grouping)}Rules,`;
-      code += '\n};\n\n';
+      code += '\n} as const;\n\n';
     }
 
     code += `const configBy${exportName} =  {\n`;

src/config-helper.ts

@@ -1,10 +1,27 @@
 import { rulesDisabledForVueAndSvelteFiles } from './constants.js';
-import type { Linter } from 'eslint';
+
+// Some type helpers for better type inference
+type LegacyConfig = {
+  rules?: Record<string, 'off'>;
+  overrides?: {
+    files: string[];
+    excludedFiles?: string[];
+    rules?: Record<string, 'off'>;
+  }[];
+};
+
+type FlatConfig = {
+  name?: string;
+  rules?: Record<string, 'off'>;
+  ignores?: string[];
+};
 
 // for eslint legacy configuration
-export const overrideDisabledRulesForVueAndSvelteFiles = (
-  config: Linter.LegacyConfig<Record<string, 'off'>>
-): Linter.LegacyConfig<Record<string, 'off'>> => {
+export const overrideDisabledRulesForVueAndSvelteFiles = <
+  C extends LegacyConfig,
+>(
+  config: C
+): C => {
   const foundRules = Object.keys(config.rules!).filter((rule) =>
     rulesDisabledForVueAndSvelteFiles.includes(rule)
   );
@@ -32,10 +49,12 @@ export const overrideDisabledRulesForVueAndSvelteFiles = (
   return newConfig;
 };
 
+export type SplittedFlatConfig<C extends FlatConfig> = [C] | [C, FlatConfig];
+
 // for eslint flat configuration
-export const splitDisabledRulesForVueAndSvelteFiles = (
-  config: Linter.Config
-): Linter.Config[] => {
+export const splitDisabledRulesForVueAndSvelteFiles = <C extends FlatConfig>(
+  config: C
+): SplittedFlatConfig<C> => {
   const foundRules = Object.keys(config.rules!).filter((rule) =>
     rulesDisabledForVueAndSvelteFiles.includes(rule)
   );
@@ -46,7 +65,7 @@ export const splitDisabledRulesForVueAndSvelteFiles = (
 
   const oldConfig = structuredClone(config);
 
-  const newConfig: Linter.Config = {
+  const newConfig: FlatConfig = {
     // flat configs use minimatch syntax
     name: 'oxlint/vue-svelte-exceptions',
     ignores: ['**/*.vue', '**/*.svelte'],
@@ -60,3 +79,17 @@ export const splitDisabledRulesForVueAndSvelteFiles = (
 
   return [oldConfig, newConfig];
 };
+
+export const splitDisabledRulesForVueAndSvelteFilesDeep = <
+  T extends Record<string, FlatConfig>,
+>(
+  config: T
+): { [K in keyof T]: SplittedFlatConfig<T[K]> } => {
+  const result = {} as { [K in keyof T]: SplittedFlatConfig<T[K]> };
+
+  for (const name in config) {
+    result[name] = splitDisabledRulesForVueAndSvelteFiles(config[name]);
+  }
+
+  return result;
+};

src/configs.ts

@@ -5,8 +5,8 @@ import configByCategory from './generated/configs-by-category.js';
 import {
   overrideDisabledRulesForVueAndSvelteFiles,
   splitDisabledRulesForVueAndSvelteFiles,
+  splitDisabledRulesForVueAndSvelteFilesDeep,
 } from './config-helper.js';
-import type { Linter } from 'eslint';
 
 type UnionToIntersection<U> = (
   U extends unknown ? (x: U) => void : never
@@ -22,16 +22,6 @@ const allRules: UnionToIntersection<AllRules> = Object.assign(
   ...Object.values(ruleMapsByScope)
 );
 
-const splitDisabledRulesForVueAndSvelteFilesDeep = <T extends string>(
-  config: Record<T, Linter.Config>
-): Record<T, Linter.Config[]> => {
-  const entries = Object.entries<Linter.Config>(config).map(
-    ([name, config]) => [name, splitDisabledRulesForVueAndSvelteFiles(config)]
-  );
-
-  return Object.fromEntries(entries);
-};
-
 export default {
   recommended: overrideDisabledRulesForVueAndSvelteFiles({
     plugins: ['oxlint'],
@@ -51,4 +41,4 @@ export default {
   }),
   ...splitDisabledRulesForVueAndSvelteFilesDeep(configByScope),
   ...splitDisabledRulesForVueAndSvelteFilesDeep(configByCategory),
-};
+} as const;

src/generated/configs-by-category.ts

@@ -5,32 +5,32 @@ import * as rules from './rules-by-category.js';
 const pedanticConfig = {
   name: 'oxlint/pedantic',
   rules: rules.pedanticRules,
-};
+} as const;
 
 const styleConfig = {
   name: 'oxlint/style',
   rules: rules.styleRules,
-};
+} as const;
 
 const suspiciousConfig = {
   name: 'oxlint/suspicious',
   rules: rules.suspiciousRules,
-};
+} as const;
 
 const restrictionConfig = {
   name: 'oxlint/restriction',
   rules: rules.restrictionRules,
-};
+} as const;
 
 const correctnessConfig = {
   name: 'oxlint/correctness',
   rules: rules.correctnessRules,
-};
+} as const;
 
 const perfConfig = {
   name: 'oxlint/perf',
   rules: rules.perfRules,
-};
+} as const;
 
 const configByCategory = {
   'flat/pedantic': pedanticConfig,

src/generated/configs-by-scope.ts

@@ -5,77 +5,77 @@ import * as rules from './rules-by-scope.js';
 const eslintConfig = {
   name: 'oxlint/eslint',
   rules: rules.eslintRules,
-};
+} as const;
 
 const importConfig = {
   name: 'oxlint/import',
   rules: rules.importRules,
-};
+} as const;
 
 const jestConfig = {
   name: 'oxlint/jest',
   rules: rules.jestRules,
-};
+} as const;
 
 const jsdocConfig = {
   name: 'oxlint/jsdoc',
   rules: rules.jsdocRules,
-};
+} as const;
 
 const jsxA11yConfig = {
   name: 'oxlint/jsx-a11y',
   rules: rules.jsxA11yRules,
-};
+} as const;
 
 const nextjsConfig = {
   name: 'oxlint/nextjs',
   rules: rules.nextjsRules,
-};
+} as const;
 
 const nodeConfig = {
   name: 'oxlint/node',
   rules: rules.nodeRules,
-};
+} as const;
 
 const promiseConfig = {
   name: 'oxlint/promise',
   rules: rules.promiseRules,
-};
+} as const;
 
 const reactConfig = {
   name: 'oxlint/react',
   rules: rules.reactRules,
-};
+} as const;
 
 const reactHooksConfig = {
   name: 'oxlint/react-hooks',
   rules: rules.reactHooksRules,
-};
+} as const;
 
 const reactPerfConfig = {
   name: 'oxlint/react-perf',
   rules: rules.reactPerfRules,
-};
+} as const;
 
 const typescriptConfig = {
   name: 'oxlint/typescript',
   rules: rules.typescriptRules,
-};
+} as const;
 
 const unicornConfig = {
   name: 'oxlint/unicorn',
   rules: rules.unicornRules,
-};
+} as const;
 
 const vitestConfig = {
   name: 'oxlint/vitest',
   rules: rules.vitestRules,
-};
+} as const;
 
 const vueConfig = {
   name: 'oxlint/vue',
   rules: rules.vueRules,
-};
+} as const;
 
 const configByScope = {
   'flat/eslint': eslintConfig,