chore: update deps, migrate tests

packages/eslint-plugin-antfu/src/rules/generic-spacing.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './generic-spacing'
 
 const valids = [
@@ -36,17 +35,15 @@ const invalids = [
 }`],
 ] as const
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      code: i[0],
-      output: i[1].trim(),
-      errors: Array.from({ length: i[2] || 1 }, () => ({ messageId: 'genericSpacingMismatch' })),
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    code: i[0],
+    output: i[1].trim(),
+    errors: Array.from({ length: i[2] || 1 }, () => ({ messageId: 'genericSpacingMismatch' })),
+  })),
 })

packages/eslint-plugin-antfu/src/rules/generic-spacing.ts

@@ -10,7 +10,7 @@ export default createEslintRule<Options, MessageIds>({
     type: 'suggestion',
     docs: {
       description: 'Spaces around generic type parameters',
-      recommended: 'error',
+      recommended: 'stylistic',
     },
     fixable: 'code',
     schema: [],

packages/eslint-plugin-antfu/src/rules/if-newline.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './if-newline'
 
 const valids = [
@@ -14,17 +13,15 @@ const invalids = [
   ['if (true) console.log(\'hello\')', 'if (true) \nconsole.log(\'hello\')'],
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      code: i[0],
-      output: i[1],
-      errors: [{ messageId: 'missingIfNewline' }],
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    code: i[0],
+    output: i[1],
+    errors: [{ messageId: 'missingIfNewline' }],
+  })),
 })

packages/eslint-plugin-antfu/src/rules/if-newline.ts

@@ -10,7 +10,7 @@ export default createEslintRule<Options, MessageIds>({
     type: 'problem',
     docs: {
       description: 'Newline after if',
-      recommended: 'error',
+      recommended: 'stylistic',
     },
     fixable: 'code',
     schema: [],

packages/eslint-plugin-antfu/src/rules/import-dedupe.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './import-dedupe'
 
 const valids = [
@@ -12,17 +11,15 @@ const invalids = [
   ],
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      code: i[0],
-      output: i[1],
-      errors: [{ messageId: 'importDedupe' }, { messageId: 'importDedupe' }, { messageId: 'importDedupe' }],
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    code: i[0],
+    output: i[1],
+    errors: [{ messageId: 'importDedupe' }, { messageId: 'importDedupe' }, { messageId: 'importDedupe' }],
+  })),
 })

packages/eslint-plugin-antfu/src/rules/import-dedupe.ts

@@ -10,7 +10,7 @@ export default createEslintRule<Options, MessageIds>({
     type: 'problem',
     docs: {
       description: 'Fix duplication in imports',
-      recommended: 'error',
+      recommended: 'strict',
     },
     fixable: 'code',
     schema: [],

packages/eslint-plugin-antfu/src/rules/named-tuple-spacing.test.ts

@@ -1,95 +1,98 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './named-tuple-spacing'
 
 const valids = [
   'type T = [i: number]',
   'type T = [i?: number]',
   'type T = [i: number, j: number]',
+  'type T = [i: number, j: () => string]',
   `const emit = defineEmits<{
     change: [id: number]
     update: [value: string]
   }>()`,
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
 
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: [
-      {
-        code: 'type T = [i:number]',
-        output: 'type T = [i: number]',
-        errors: [{ messageId: 'expectedSpaceAfter' }],
-      },
-      {
-        code: 'type T = [i:  number]',
-        output: 'type T = [i: number]',
-        errors: [{ messageId: 'expectedSpaceAfter' }],
-      },
-      {
-        code: 'type T = [i?:number]',
-        output: 'type T = [i?: number]',
-        errors: [{ messageId: 'expectedSpaceAfter' }],
-      },
-      {
-        code: 'type T = [i?   :number]',
-        output: 'type T = [i?: number]',
-        errors: [{ messageId: 'unexpectedSpaceBetween' }, { messageId: 'expectedSpaceAfter' }],
-      },
-      {
-        code: 'type T = [i : number]',
-        output: 'type T = [i: number]',
-        errors: [{ messageId: 'unexpectedSpaceBefore' }],
-      },
-      {
-        code: 'type T = [i  : number]',
-        output: 'type T = [i: number]',
-        errors: [{ messageId: 'unexpectedSpaceBefore' }],
-      },
-      {
-        code: 'type T = [i  ?  : number]',
-        output: 'type T = [i?: number]',
-        errors: [{ messageId: 'unexpectedSpaceBetween' }, { messageId: 'unexpectedSpaceBefore' }],
-      },
-      {
-        code: 'type T = [i:number, j:number]',
-        output: 'type T = [i: number, j: number]',
-        errors: [{ messageId: 'expectedSpaceAfter' }, { messageId: 'expectedSpaceAfter' }],
-      },
-      {
-        code: `
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: [
+    {
+      code: 'type T = [i:number]',
+      output: 'type T = [i: number]',
+      errors: [{ messageId: 'expectedSpaceAfter' }],
+    },
+    {
+      code: 'type T = [i:  number]',
+      output: 'type T = [i: number]',
+      errors: [{ messageId: 'expectedSpaceAfter' }],
+    },
+    {
+      code: 'type T = [i?:number]',
+      output: 'type T = [i?: number]',
+      errors: [{ messageId: 'expectedSpaceAfter' }],
+    },
+    {
+      code: 'type T = [i?   :number]',
+      output: 'type T = [i?: number]',
+      errors: [{ messageId: 'unexpectedSpaceBetween' }, { messageId: 'expectedSpaceAfter' }],
+    },
+    {
+      code: 'type T = [i : number]',
+      output: 'type T = [i: number]',
+      errors: [{ messageId: 'unexpectedSpaceBefore' }],
+    },
+    {
+      code: 'type T = [i  : number]',
+      output: 'type T = [i: number]',
+      errors: [{ messageId: 'unexpectedSpaceBefore' }],
+    },
+    {
+      code: 'type T = [i  ?  : number]',
+      output: 'type T = [i?: number]',
+      errors: [{ messageId: 'unexpectedSpaceBetween' }, { messageId: 'unexpectedSpaceBefore' }],
+    },
+    {
+      code: 'type T = [i:number, j:number]',
+      output: 'type T = [i: number, j: number]',
+      errors: [{ messageId: 'expectedSpaceAfter' }, { messageId: 'expectedSpaceAfter' }],
+    },
+    {
+      code: 'type T = [i:()=>void, j:number]',
+      output: 'type T = [i: ()=>void, j: number]',
+      errors: [{ messageId: 'expectedSpaceAfter' }, { messageId: 'expectedSpaceAfter' }],
+    },
+    {
+      code: `
         const emit = defineEmits<{
           change: [id:number]
           update: [value:string]
         }>()
         `,
-        output: `
+      output: `
         const emit = defineEmits<{
           change: [id: number]
           update: [value: string]
         }>()
         `,
-        errors: [{ messageId: 'expectedSpaceAfter' }, { messageId: 'expectedSpaceAfter' }],
-      },
-      {
-        code: `
+      errors: [{ messageId: 'expectedSpaceAfter' }, { messageId: 'expectedSpaceAfter' }],
+    },
+    {
+      code: `
         const emit = defineEmits<{
           change: [id? :number]
           update: [value:string]
         }>()
         `,
-        output: `
+      output: `
         const emit = defineEmits<{
           change: [id?: number]
           update: [value: string]
         }>()
         `,
-        errors: [{ messageId: 'unexpectedSpaceBetween' }, { messageId: 'expectedSpaceAfter' }, { messageId: 'expectedSpaceAfter' }],
-      },
-    ],
-  })
+      errors: [{ messageId: 'unexpectedSpaceBetween' }, { messageId: 'expectedSpaceAfter' }, { messageId: 'expectedSpaceAfter' }],
+    },
+  ],
 })

packages/eslint-plugin-antfu/src/rules/no-cjs-exports.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './no-cjs-exports'
 
 const valids = [
@@ -13,16 +12,14 @@ const invalids = [
   { code: 'module.exports.a = {}', filename: 'test.ts' },
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      ...i,
-      errors: [{ messageId: 'noCjsExports' }],
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    ...i,
+    errors: [{ messageId: 'noCjsExports' }],
+  })),
 })

packages/eslint-plugin-antfu/src/rules/no-cjs-exports.ts

@@ -10,7 +10,6 @@ export default createEslintRule<Options, MessageIds>({
     type: 'problem',
     docs: {
       description: 'Do not use CJS exports',
-      recommended: false,
     },
     schema: [],
     messages: {

packages/eslint-plugin-antfu/src/rules/no-const-enum.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './no-const-enum'
 
 const valids = [
@@ -10,16 +9,14 @@ const invalids = [
   'const enum E {}',
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      code: i,
-      errors: [{ messageId: 'noConstEnum' }],
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    code: i,
+    errors: [{ messageId: 'noConstEnum' }],
+  })),
 })

packages/eslint-plugin-antfu/src/rules/no-const-enum.ts

@@ -10,7 +10,7 @@ export default createEslintRule<Options, MessageIds>({
     type: 'problem',
     docs: {
       description: 'Disallow using `const enum` expression',
-      recommended: 'error',
+      recommended: 'recommended',
     },
     schema: [],
     messages: {

packages/eslint-plugin-antfu/src/rules/no-import-node-modules-by-path.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './no-import-node-modules-by-path'
 
 const valids = [
@@ -16,16 +15,14 @@ const invalids = [
   'require("../node_modules/d")',
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      code: i,
-      errors: [{ messageId: 'noImportNodeModulesByPath' }],
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    code: i,
+    errors: [{ messageId: 'noImportNodeModulesByPath' }],
+  })),
 })

packages/eslint-plugin-antfu/src/rules/no-import-node-modules-by-path.ts

@@ -10,7 +10,7 @@ export default createEslintRule<Options, MessageIds>({
     type: 'problem',
     docs: {
       description: 'Prevent importing modules in `node_modules` folder by relative or absolute path',
-      recommended: 'error',
+      recommended: 'recommended',
     },
     schema: [],
     messages: {

packages/eslint-plugin-antfu/src/rules/no-ts-export-equal.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './no-ts-export-equal'
 
 const valids = [
@@ -11,16 +10,14 @@ const invalids = [
   { code: 'export = {}', filename: 'test.ts' },
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      ...i,
-      errors: [{ messageId: 'noTsExportEqual' }],
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    ...i,
+    errors: [{ messageId: 'noTsExportEqual' }],
+  })),
 })

packages/eslint-plugin-antfu/src/rules/no-ts-export-equal.ts

@@ -10,7 +10,7 @@ export default createEslintRule<Options, MessageIds>({
     type: 'problem',
     docs: {
       description: 'Do not use `exports =`',
-      recommended: false,
+      recommended: 'recommended',
     },
     schema: [],
     messages: {

packages/eslint-plugin-antfu/src/rules/prefer-inline-type-import.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './prefer-inline-type-import'
 
 const valids = [
@@ -12,17 +11,15 @@ const invalids = [
   ['import type { Foo } from \'foo\'', 'import { type Foo } from \'foo\''],
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      code: i[0],
-      output: i[1].trim(),
-      errors: [{ messageId: 'preferInlineTypeImport' }],
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    code: i[0],
+    output: i[1].trim(),
+    errors: [{ messageId: 'preferInlineTypeImport' }],
+  })),
 })

packages/eslint-plugin-antfu/src/rules/prefer-inline-type-import.ts

@@ -1,7 +1,7 @@
 // Ported from https://github.com/gajus/eslint-plugin-canonical/blob/master/src/rules/preferInlineTypeImport.js
 // by Gajus Kuizinas https://github.com/gajus
 import type { TSESTree } from '@typescript-eslint/utils'
-import type { RuleFixer, SourceCode } from '@typescript-eslint/utils/dist/ts-eslint'
+import type { RuleFixer, SourceCode } from '@typescript-eslint/utils/ts-eslint'
 import { createEslintRule } from '../utils'
 
 export const RULE_NAME = 'prefer-inline-type-import'
@@ -14,7 +14,6 @@ export default createEslintRule<Options, MessageIds>({
     type: 'suggestion',
     docs: {
       description: 'Inline type import',
-      recommended: 'error',
     },
     fixable: 'code',
     schema: [],

packages/eslint-plugin-antfu/src/rules/top-level-function.test.ts

@@ -1,5 +1,4 @@
-import { RuleTester } from '@typescript-eslint/utils/dist/ts-eslint'
-import { it } from 'vitest'
+import { RuleTester } from '@typescript-eslint/rule-tester'
 import rule, { RULE_NAME } from './top-level-function'
 
 const valids = [
@@ -51,17 +50,15 @@ const invalids = [
   ],
 ]
 
-it('runs', () => {
-  const ruleTester: RuleTester = new RuleTester({
-    parser: require.resolve('@typescript-eslint/parser'),
-  })
-
-  ruleTester.run(RULE_NAME, rule, {
-    valid: valids,
-    invalid: invalids.map(i => ({
-      code: i[0],
-      output: i[1],
-      errors: [{ messageId: 'topLevelFunctionDeclaration' }],
-    })),
-  })
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+})
+
+ruleTester.run(RULE_NAME, rule as any, {
+  valid: valids,
+  invalid: invalids.map(i => ({
+    code: i[0],
+    output: i[1],
+    errors: [{ messageId: 'topLevelFunctionDeclaration' }],
+  })),
 })

packages/eslint-plugin-antfu/src/rules/top-level-function.ts

@@ -10,7 +10,7 @@ export default createEslintRule<Options, MessageIds>({
     type: 'problem',
     docs: {
       description: 'Enforce top-level functions to be declared with function keyword',
-      recommended: 'error',
+      recommended: 'stylistic',
     },
     fixable: 'code',
     schema: [],