feat: support type-aware rules, fix #499

Author: antfu

docs/content/1.packages/1.config.md

@@ -133,3 +133,18 @@ export default createConfigForNuxt({
 ```
 
 Learn more about all the available options in the [ESLint Stylistic documentation](https://eslint.style/guide/config-presets#configuration-factory).
+
+## Type Aware Rules
+
+This config also provides type-aware rules for TypeScript and Vue. You can enable them by setting `features.typescript` to an object with `tsconfigPath` the path to your `tsconfig.json` file.
+```js [eslint.config.mjs]
+import { createConfigForNuxt } from '@nuxt/eslint-config'
+
+export default createConfigForNuxt({
+  features: {
+    typescript: {
+      tsconfigPath: './tsconfig.json'
+    }
+  }
+})
+```

eslint.config.js

@@ -8,6 +8,9 @@ export default createConfigForNuxt({
     stylistic: true,
     tooling: true,
     formatters: true,
+    // typescript: {
+    //   tsconfigPath: 'tsconfig.json',
+    // },
   },
   dirs: {
     src: [

packages/eslint-config/src/configs/stylistic.ts

@@ -5,6 +5,6 @@ import type { Linter } from 'eslint'
 export default (options?: StylisticCustomizeOptions): Linter.Config => {
   return {
     name: 'nuxt/stylistic',
-    ...stylistic.configs.customize(options) as Linter.Config,
+    ...stylistic.configs.customize(options) as Linter,
   }
 }

packages/eslint-config/src/configs/typescript.ts

@@ -6,6 +6,15 @@ import { resolveOptions } from '../utils'
 
 export { parserTs, pluginTs }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const getRulesFromConfigs = (config: any) => {
+  const array = Array.isArray(config) ? config : [config]
+  const object = array.reduce((acc, item) => {
+    return { ...acc, ...item.rules }
+  }, {})
+  return object
+}
+
 export default function typescript(options: NuxtESLintConfigOptions): Linter.Config[] {
   const resolved = resolveOptions(options)
 
@@ -14,6 +23,8 @@ export default function typescript(options: NuxtESLintConfigOptions): Linter.Con
   }
 
   const tsOptions = resolved.features.typescript === true ? {} : resolved.features.typescript
+  const strict = tsOptions.strict === false ? false : true
+  const tsconfigPath = tsOptions.tsconfigPath || undefined
 
   return [
     {
@@ -28,14 +39,34 @@ export default function typescript(options: NuxtESLintConfigOptions): Linter.Con
       files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts', '**/*.vue'],
       languageOptions: {
         parser: parserTs,
+        parserOptions: {
+          extraFileExtensions: ['.vue'],
+          sourceType: 'module',
+          ...tsconfigPath
+            ? {
+                projectService: {
+                  allowDefaultProject: ['./*.js'],
+                  defaultProject: tsconfigPath,
+                },
+                tsconfigRootDir: process.cwd(),
+              }
+            : {},
+        },
       },
       rules: {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ...pluginTs.configs['eslint-recommended'].overrides![0].rules as any,
-        ...pluginTs.configs.recommended.rules,
-        ...(tsOptions.strict === false
-          ? {}
-          : pluginTs.configs.strict.rules),
+        ...getRulesFromConfigs(pluginTs.configs['flat/recommended']),
+
+        // Type-aware rules
+        ...(tsconfigPath
+          ? getRulesFromConfigs(pluginTs.configs['flat/recommended-type-checked-only'])
+          : {}),
+
+        // Strict rules
+        ...(strict
+          ? tsconfigPath
+            ? getRulesFromConfigs(pluginTs.configs['flat/strict-type-checked-only'])
+            : getRulesFromConfigs(pluginTs.configs['flat/strict'])
+          : {}),
 
         // Include typescript eslint rules in *.vue files
         // https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/configs/eslint-recommended.ts

packages/eslint-config/src/configs/vue.ts

@@ -80,9 +80,9 @@ export default async function vue(options: NuxtESLintConfigOptions): Promise<Lin
       rules: {
         ...pluginVue.configs.base.rules,
 
-        ...pluginVue.configs['flat/essential'].map(c => c.rules).reduce((acc, c) => ({ ...acc, ...c }), {}) as Linter.Config['rules'],
-        ...pluginVue.configs['flat/strongly-recommended'].map(c => c.rules).reduce((acc, c) => ({ ...acc, ...c }), {}) as Linter.Config['rules'],
-        ...pluginVue.configs['flat/recommended'].map(c => c.rules).reduce((acc, c) => ({ ...acc, ...c }), {}) as Linter.Config['rules'],
+        ...pluginVue.configs['flat/essential'].map(c => c.rules).reduce((acc, c) => ({ ...acc, ...c }), {}),
+        ...pluginVue.configs['flat/strongly-recommended'].map(c => c.rules).reduce((acc, c) => ({ ...acc, ...c }), {}),
+        ...pluginVue.configs['flat/recommended'].map(c => c.rules).reduce((acc, c) => ({ ...acc, ...c }), {}),
 
         // Deprecated in favor of 'vue/block-order'
         'vue/component-tags-order': undefined,

packages/eslint-config/src/index.ts

@@ -1,7 +1,6 @@
 import type { ResolvableFlatConfig, FlatConfigComposer } from 'eslint-flat-config-utils'
 import { composer } from 'eslint-flat-config-utils'
 import gitignore from 'eslint-config-flat-gitignore'
-import type { Linter } from 'eslint'
 import type { NuxtESLintConfigOptions } from './types'
 import disables from './configs/disables'
 import nuxt from './configs/nuxt'
@@ -21,7 +20,7 @@ export { resolveOptions }
  */
 export function defineFlatConfigs(
   ...configs: ResolvableFlatConfig[]
-): FlatConfigComposer<Linter.Config> {
+): FlatConfigComposer {
   return composer(...configs)
 }
 
@@ -35,7 +34,7 @@ export function defineFlatConfigs(
 export function createConfigForNuxt(
   options: NuxtESLintConfigOptions = {},
   ...userConfigs: ResolvableFlatConfig[]
-): FlatConfigComposer<Linter.Config> {
+): FlatConfigComposer {
   const c = composer()
 
   const resolved = resolveOptions(options)

packages/eslint-config/src/types.ts

@@ -84,6 +84,10 @@ export interface NuxtESLintFeaturesOptions {
      * @default true
      */
     strict?: boolean
+    /**
+     * Path to the tsconfig file, when this is provide, type-aware rules will be enabled.
+     */
+    tsconfigPath?: string
   }
 }
 

packages/eslint-config/src/utils.ts

@@ -25,7 +25,7 @@ export const parserPlain = {
 }
 
 export async function ensurePackages(packages: (string | undefined)[]): Promise<void> {
-  if (process.env.CI || process.stdout.isTTY === false)
+  if (process.env.CI || !process.stdout.isTTY)
     return
 
   const nonExistingPackages = packages.filter(i => i && !isPackageExists(i)) as string[]