Merge branch 'main' of https://github.com/vbenjs/vue-vben-admin into antdv-next

internal/lint-configs/eslint-config/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vben/eslint-config",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "private": true,
   "homepage": "https://github.com/vbenjs/vue-vben-admin",
   "bugs": "https://github.com/vbenjs/vue-vben-admin/issues",
@@ -27,32 +27,22 @@
     }
   },
   "dependencies": {
-    "eslint-config-turbo": "catalog:",
-    "eslint-plugin-command": "catalog:",
-    "eslint-plugin-import-x": "catalog:"
+    "@vben/oxlint-config": "workspace:*"
   },
   "devDependencies": {
     "@eslint/js": "catalog:",
-    "@types/eslint": "catalog:",
     "@typescript-eslint/eslint-plugin": "catalog:",
     "@typescript-eslint/parser": "catalog:",
     "eslint": "catalog:",
-    "eslint-plugin-eslint-comments": "catalog:",
-    "eslint-plugin-jsdoc": "catalog:",
     "eslint-plugin-jsonc": "catalog:",
     "eslint-plugin-n": "catalog:",
-    "eslint-plugin-no-only-tests": "catalog:",
     "eslint-plugin-perfectionist": "catalog:",
     "eslint-plugin-pnpm": "catalog:",
-    "eslint-plugin-prettier": "catalog:",
-    "eslint-plugin-regexp": "catalog:",
     "eslint-plugin-unicorn": "catalog:",
     "eslint-plugin-unused-imports": "catalog:",
-    "eslint-plugin-vitest": "catalog:",
     "eslint-plugin-vue": "catalog:",
     "eslint-plugin-yml": "catalog:",
     "globals": "catalog:",
-    "jsonc-eslint-parser": "catalog:",
     "vue-eslint-parser": "catalog:",
     "yaml-eslint-parser": "catalog:"
   }

internal/lint-configs/eslint-config/src/configs/command.ts

@@ -1,9 +0,0 @@
-import createCommand from 'eslint-plugin-command/config';
-
-export async function command() {
-  return [
-    {
-      ...createCommand(),
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/comments.ts

@@ -1,24 +0,0 @@
-import type { Linter } from 'eslint';
-
-import { interopDefault } from '../util';
-
-export async function comments(): Promise<Linter.Config[]> {
-  const [pluginComments] = await Promise.all([
-    // @ts-expect-error - no types
-    interopDefault(import('eslint-plugin-eslint-comments')),
-  ] as const);
-
-  return [
-    {
-      plugins: {
-        'eslint-comments': pluginComments,
-      },
-      rules: {
-        'eslint-comments/no-aggregating-enable': 'error',
-        'eslint-comments/no-duplicate-disable': 'error',
-        'eslint-comments/no-unlimited-disable': 'error',
-        'eslint-comments/no-unused-enable': 'error',
-      },
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/disableds.ts

@@ -1,28 +0,0 @@
-import type { Linter } from 'eslint';
-
-export async function disableds(): Promise<Linter.Config[]> {
-  return [
-    {
-      files: ['**/__tests__/**/*.?([cm])[jt]s?(x)'],
-      name: 'disables/test',
-      rules: {
-        '@typescript-eslint/ban-ts-comment': 'off',
-        'no-console': 'off',
-      },
-    },
-    {
-      files: ['**/*.d.ts'],
-      name: 'disables/dts',
-      rules: {
-        '@typescript-eslint/triple-slash-reference': 'off',
-      },
-    },
-    {
-      files: ['**/*.js', '**/*.mjs', '**/*.cjs'],
-      name: 'disables/js',
-      rules: {
-        '@typescript-eslint/explicit-module-boundary-types': 'off',
-      },
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/ignores.ts

@@ -48,6 +48,12 @@ export async function ignores(): Promise<Linter.Config[]> {
         '**/*.woff',
         '**/.github',
         '**/lefthook.yml',
+
+        '**/.agent/**',
+        '**/.agents/**',
+        '**/.codex/**',
+        '**/.claude/**',
+        '**/.cursor/**',
       ],
     },
   ];

internal/lint-configs/eslint-config/src/configs/import.ts

@@ -1,25 +0,0 @@
-import type { Linter } from 'eslint';
-
-import * as pluginImport from 'eslint-plugin-import-x';
-
-export async function importPluginConfig(): Promise<Linter.Config[]> {
-  return [
-    {
-      plugins: {
-        // @ts-expect-error - This is a dynamic import
-        import: pluginImport,
-      },
-      rules: {
-        'import/consistent-type-specifier-style': ['error', 'prefer-top-level'],
-        'import/first': 'error',
-        'import/newline-after-import': 'error',
-        'import/no-duplicates': 'error',
-        'import/no-mutable-exports': 'error',
-        'import/no-named-default': 'error',
-        'import/no-self-import': 'error',
-        'import/no-unresolved': 'off',
-        'import/no-webpack-loader-syntax': 'error',
-      },
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/index.ts

@@ -1,18 +1,9 @@
-export * from './command';
-export * from './comments';
-export * from './disableds';
 export * from './ignores';
-export * from './import';
 export * from './javascript';
-export * from './jsdoc';
 export * from './jsonc';
 export * from './node';
 export * from './perfectionist';
 export * from './pnpm';
-export * from './prettier';
-export * from './regexp';
-export * from './test';
-export * from './turbo';
 export * from './typescript';
 export * from './unicorn';
 export * from './vue';

internal/lint-configs/eslint-config/src/configs/javascript.ts

@@ -4,7 +4,73 @@ import js from '@eslint/js';
 import pluginUnusedImports from 'eslint-plugin-unused-imports';
 import globals from 'globals';
 
+const rulesCoveredByOxlint = new Set([
+  'constructor-super',
+  'for-direction',
+  'getter-return',
+  'no-async-promise-executor',
+  'no-case-declarations',
+  'no-class-assign',
+  'no-compare-neg-zero',
+  'no-cond-assign',
+  'no-const-assign',
+  'no-constant-binary-expression',
+  'no-constant-condition',
+  'no-debugger',
+  'no-delete-var',
+  'no-dupe-args',
+  'no-dupe-class-members',
+  'no-dupe-else-if',
+  'no-dupe-keys',
+  'no-duplicate-case',
+  'no-empty',
+  'no-empty-character-class',
+  'no-empty-pattern',
+  'no-empty-static-block',
+  'no-ex-assign',
+  'no-extra-boolean-cast',
+  'no-fallthrough',
+  'no-func-assign',
+  'no-global-assign',
+  'no-import-assign',
+  'no-invalid-regexp',
+  'no-irregular-whitespace',
+  'no-loss-of-precision',
+  'no-misleading-character-class',
+  'no-new-native-nonconstructor',
+  'no-nonoctal-decimal-escape',
+  'no-obj-calls',
+  'no-prototype-builtins',
+  'no-redeclare',
+  'no-regex-spaces',
+  'no-self-assign',
+  'no-setter-return',
+  'no-shadow-restricted-names',
+  'no-sparse-arrays',
+  'no-this-before-super',
+  'no-unreachable',
+  'no-unsafe-finally',
+  'no-unsafe-negation',
+  'no-unsafe-optional-chaining',
+  'no-unused-labels',
+  'no-unused-private-class-members',
+  'no-unused-vars',
+  'no-useless-backreference',
+  'no-useless-catch',
+  'no-useless-escape',
+  'no-with',
+  'require-yield',
+  'use-isnan',
+  'valid-typeof',
+]);
+
 export async function javascript(): Promise<Linter.Config[]> {
+  const recommendedRules = Object.fromEntries(
+    Object.entries(js.configs.recommended.rules).filter(
+      ([ruleName]) => !rulesCoveredByOxlint.has(ruleName),
+    ),
+  );
+
   return [
     {
       languageOptions: {
@@ -33,79 +99,11 @@ export async function javascript(): Promise<Linter.Config[]> {
         'unused-imports': pluginUnusedImports,
       },
       rules: {
-        ...js.configs.recommended.rules,
-        'accessor-pairs': [
-          'error',
-          { enforceForClassMembers: true, setWithoutGet: true },
-        ],
-        'array-callback-return': 'error',
-        'block-scoped-var': 'error',
-        'constructor-super': 'error',
-        'default-case-last': 'error',
+        ...recommendedRules,
         'dot-notation': ['error', { allowKeywords: true }],
-        eqeqeq: ['error', 'always'],
         'keyword-spacing': 'off',
-
-        'new-cap': [
-          'error',
-          { capIsNew: false, newIsCap: true, properties: true },
-        ],
-        'no-alert': 'error',
-        'no-array-constructor': 'error',
-        'no-async-promise-executor': 'error',
-        'no-caller': 'error',
-        'no-case-declarations': 'error',
-        'no-class-assign': 'error',
-        'no-compare-neg-zero': 'error',
-        'no-cond-assign': ['error', 'always'],
-        'no-console': ['error', { allow: ['warn', 'error'] }],
-        'no-const-assign': 'error',
         'no-control-regex': 'error',
-        'no-debugger': 'error',
-        'no-delete-var': 'error',
-        'no-dupe-args': 'error',
-        'no-dupe-class-members': 'error',
-        'no-dupe-keys': 'error',
-        'no-duplicate-case': 'error',
-        'no-empty': ['error', { allowEmptyCatch: true }],
-        'no-empty-character-class': 'error',
         'no-empty-function': 'off',
-        'no-empty-pattern': 'error',
-        'no-eval': 'error',
-        'no-ex-assign': 'error',
-        'no-extend-native': 'error',
-        'no-extra-bind': 'error',
-        'no-extra-boolean-cast': 'error',
-        'no-fallthrough': 'error',
-        'no-func-assign': 'error',
-        'no-global-assign': 'error',
-        'no-implied-eval': 'error',
-        'no-import-assign': 'error',
-        'no-invalid-regexp': 'error',
-        'no-irregular-whitespace': 'error',
-        'no-iterator': 'error',
-        'no-labels': ['error', { allowLoop: false, allowSwitch: false }],
-        'no-lone-blocks': 'error',
-        'no-loss-of-precision': 'error',
-        'no-misleading-character-class': 'error',
-        'no-multi-str': 'error',
-        'no-new': 'error',
-        'no-new-func': 'error',
-        'no-new-object': 'error',
-        'no-new-symbol': 'error',
-        'no-new-wrappers': 'error',
-        'no-obj-calls': 'error',
-        'no-octal': 'error',
-        'no-octal-escape': 'error',
-        'no-proto': 'error',
-        'no-prototype-builtins': 'error',
-        'no-redeclare': ['error', { builtinGlobals: false }],
-        'no-regex-spaces': 'error',
-        'no-restricted-globals': [
-          'error',
-          { message: 'Use `globalThis` instead.', name: 'global' },
-          { message: 'Use `globalThis` instead.', name: 'self' },
-        ],
         'no-restricted-properties': [
           'error',
           {
@@ -138,84 +136,9 @@ export async function javascript(): Promise<Linter.Config[]> {
           'TSEnumDeclaration[const=true]',
           'TSExportAssignment',
         ],
-        'no-self-assign': ['error', { props: true }],
-        'no-self-compare': 'error',
-        'no-sequences': 'error',
-        'no-shadow-restricted-names': 'error',
-        'no-sparse-arrays': 'error',
-        'no-template-curly-in-string': 'error',
-        'no-this-before-super': 'error',
-        'no-throw-literal': 'error',
         'no-undef': 'off',
-        'no-undef-init': 'error',
-        'no-unexpected-multiline': 'error',
-        'no-unmodified-loop-condition': 'error',
-        'no-unneeded-ternary': ['error', { defaultAssignment: false }],
-        'no-unreachable': 'error',
         'no-unreachable-loop': 'error',
-        'no-unsafe-finally': 'error',
-        'no-unsafe-negation': 'error',
-        'no-unused-expressions': [
-          'error',
-          {
-            allowShortCircuit: true,
-            allowTaggedTemplates: true,
-            allowTernary: true,
-          },
-        ],
-        'no-unused-vars': [
-          'error',
-          {
-            args: 'none',
-            caughtErrors: 'none',
-            ignoreRestSiblings: true,
-            vars: 'all',
-          },
-        ],
-        'no-use-before-define': [
-          'error',
-          { classes: false, functions: false, variables: false },
-        ],
-        'no-useless-backreference': 'error',
-        'no-useless-call': 'error',
-        'no-useless-catch': 'error',
-        'no-useless-computed-key': 'error',
-        'no-useless-constructor': 'error',
-        'no-useless-rename': 'error',
-        'no-useless-return': 'error',
-        'no-var': 'error',
-        'no-with': 'error',
-        'object-shorthand': [
-          'error',
-          'always',
-          { avoidQuotes: true, ignoreConstructors: false },
-        ],
-        'one-var': ['error', { initialized: 'never' }],
-        'prefer-arrow-callback': [
-          'error',
-          {
-            allowNamedFunctions: false,
-            allowUnboundThis: true,
-          },
-        ],
-        'prefer-const': [
-          'error',
-          {
-            destructuring: 'all',
-            ignoreReadBeforeAssign: true,
-          },
-        ],
-        'prefer-exponentiation-operator': 'error',
-
-        'prefer-promise-reject-errors': 'error',
-        'prefer-regex-literals': ['error', { disallowRedundantWrapping: true }],
-        'prefer-rest-params': 'error',
-        'prefer-spread': 'error',
-        'prefer-template': 'error',
         'space-before-function-paren': 'off',
-        'spaced-comment': 'error',
-        'symbol-description': 'error',
-        'unicode-bom': ['error', 'never'],
 
         'unused-imports/no-unused-imports': 'error',
         'unused-imports/no-unused-vars': [
@@ -227,14 +150,6 @@ export async function javascript(): Promise<Linter.Config[]> {
             varsIgnorePattern: '^_',
           },
         ],
-        'use-isnan': [
-          'error',
-          { enforceForIndexOf: true, enforceForSwitchCase: true },
-        ],
-        'valid-typeof': ['error', { requireStringLiterals: true }],
-
-        'vars-on-top': 'error',
-        yoda: ['error', 'never'],
       },
     },
   ];

internal/lint-configs/eslint-config/src/configs/jsdoc.ts

@@ -1,34 +0,0 @@
-import type { Linter } from 'eslint';
-
-import { interopDefault } from '../util';
-
-export async function jsdoc(): Promise<Linter.Config[]> {
-  const [pluginJsdoc] = await Promise.all([
-    interopDefault(import('eslint-plugin-jsdoc')),
-  ] as const);
-
-  return [
-    {
-      plugins: {
-        jsdoc: pluginJsdoc,
-      },
-      rules: {
-        'jsdoc/check-access': 'warn',
-        'jsdoc/check-param-names': 'warn',
-        'jsdoc/check-property-names': 'warn',
-        'jsdoc/check-types': 'warn',
-        'jsdoc/empty-tags': 'warn',
-        'jsdoc/implements-on-classes': 'warn',
-        'jsdoc/no-defaults': 'warn',
-        'jsdoc/no-multi-asterisks': 'warn',
-        'jsdoc/require-param-name': 'warn',
-        'jsdoc/require-property': 'warn',
-        'jsdoc/require-property-description': 'warn',
-        'jsdoc/require-property-name': 'warn',
-        'jsdoc/require-returns-check': 'warn',
-        'jsdoc/require-returns-description': 'warn',
-        'jsdoc/require-yields-check': 'warn',
-      },
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/jsonc.ts

@@ -3,17 +3,12 @@ import type { Linter } from 'eslint';
 import { interopDefault } from '../util';
 
 export async function jsonc(): Promise<Linter.Config[]> {
-  const [pluginJsonc, parserJsonc] = await Promise.all([
-    interopDefault(import('eslint-plugin-jsonc')),
-    interopDefault(import('jsonc-eslint-parser')),
-  ] as const);
+  const pluginJsonc = await interopDefault(import('eslint-plugin-jsonc'));
 
   return [
     {
       files: ['**/*.json', '**/*.json5', '**/*.jsonc', '*.code-workspace'],
-      languageOptions: {
-        parser: parserJsonc as any,
-      },
+      language: 'jsonc/x',
       plugins: {
         jsonc: pluginJsonc as any,
       },

internal/lint-configs/eslint-config/src/configs/node.ts

@@ -13,7 +13,6 @@ export async function node(): Promise<Linter.Config[]> {
       rules: {
         'n/handle-callback-err': ['error', '^(err|error)$'],
         'n/no-deprecated-api': 'error',
-        'n/no-exports-assign': 'error',
         'n/no-extraneous-import': [
           'error',
           {
@@ -23,13 +22,10 @@ export async function node(): Promise<Linter.Config[]> {
               'vitest',
               'vite',
               '@vue/test-utils',
-              '@vben/tailwind-config',
               '@playwright/test',
             ],
           },
         ],
-        'n/no-new-require': 'error',
-        'n/no-path-concat': 'error',
         // 'n/no-unpublished-import': 'off',
         'n/no-unsupported-features/es-syntax': [
           'error',
@@ -44,6 +40,33 @@ export async function node(): Promise<Linter.Config[]> {
         'n/process-exit-as-throw': 'error',
       },
     },
+    {
+      files: [
+        '**/__tests__/**/*.?([cm])[jt]s?(x)',
+        '**/*.spec.?([cm])[jt]s?(x)',
+        '**/*.test.?([cm])[jt]s?(x)',
+        '**/*.bench.?([cm])[jt]s?(x)',
+        '**/*.benchmark.?([cm])[jt]s?(x)',
+      ],
+      rules: {
+        'n/prefer-global/process': 'off',
+      },
+    },
+    {
+      files: ['apps/backend-mock/**/**', 'docs/**/**'],
+      rules: {
+        'n/no-extraneous-import': 'off',
+        'n/prefer-global/buffer': 'off',
+        'n/prefer-global/process': 'off',
+      },
+    },
+    {
+      files: ['**/**/playwright.config.ts'],
+      rules: {
+        'n/prefer-global/buffer': 'off',
+        'n/prefer-global/process': 'off',
+      },
+    },
     {
       files: [
         'scripts/**/*.?([cm])[jt]s?(x)',

internal/lint-configs/eslint-config/src/configs/perfectionist.ts

@@ -21,41 +21,58 @@ export async function perfectionist(): Promise<Linter.Config[]> {
         'perfectionist/sort-imports': [
           'error',
           {
-            customGroups: {
-              type: {
-                'vben-core-type': ['^@vben-core/.+'],
-                'vben-type': ['^@vben/.+'],
-                'vue-type': ['^vue$', '^vue-.+', '^@vue/.+'],
+            customGroups: [
+              {
+                selector: 'type',
+                groupName: 'vben-core-type',
+                elementNamePattern: '^@vben-core/.+',
               },
-              value: {
-                vben: ['^@vben/.+'],
-                'vben-core': ['^@vben-core/.+'],
-                vue: ['^vue$', '^vue-.+', '^@vue/.+'],
+              {
+                selector: 'type',
+                groupName: 'vben-type',
+                elementNamePattern: '^@vben/.+',
               },
-            },
+              {
+                selector: 'type',
+                groupName: 'vue-type',
+                elementNamePattern: ['^vue$', '^vue-.+', '^@vue/.+'],
+              },
+              {
+                groupName: 'vben',
+                elementNamePattern: '^@vben/.+',
+              },
+              {
+                groupName: 'vben-core',
+                elementNamePattern: '^@vben-core/.+',
+              },
+              {
+                groupName: 'vue',
+                elementNamePattern: ['^vue$', '^vue-.+', '^@vue/.+'],
+              },
+            ],
             environment: 'node',
             groups: [
-              ['external-type', 'builtin-type', 'type'],
+              ['type-external', 'type-builtin', 'type-import'],
               'vue-type',
               'vben-type',
               'vben-core-type',
-              ['parent-type', 'sibling-type', 'index-type'],
-              ['internal-type'],
-              'builtin',
+              ['type-parent', 'type-sibling', 'type-index'],
+              ['type-internal'],
+              'value-builtin',
               'vue',
               'vben',
               'vben-core',
-              'external',
-              'internal',
-              ['parent', 'sibling', 'index'],
+              'value-external',
+              'value-internal',
+              ['value-parent', 'value-sibling', 'value-index'],
               'side-effect',
               'side-effect-style',
               'style',
-              'object',
+              'ts-equals-import',
               'unknown',
             ],
             internalPattern: ['^#/.+'],
-            newlinesBetween: 'always',
+            newlinesBetween: 1,
             order: 'asc',
             type: 'natural',
           },

internal/lint-configs/eslint-config/src/configs/pnpm.ts

@@ -3,18 +3,15 @@ import type { Linter } from 'eslint';
 import { interopDefault } from '../util';
 
 export async function pnpm(): Promise<Linter.Config[]> {
-  const [pluginPnpm, parserPnpm, parserJsonc] = await Promise.all([
+  const [pluginPnpm, parserPnpm] = await Promise.all([
     interopDefault(import('eslint-plugin-pnpm')),
     interopDefault(import('yaml-eslint-parser')),
-    interopDefault(import('jsonc-eslint-parser')),
   ] as const);
 
   return [
     {
       files: ['package.json', '**/package.json'],
-      languageOptions: {
-        parser: parserJsonc,
-      },
+      language: 'jsonc/x',
       plugins: {
         pnpm: pluginPnpm,
       },

internal/lint-configs/eslint-config/src/configs/prettier.ts

@@ -1,19 +0,0 @@
-import type { Linter } from 'eslint';
-
-import { interopDefault } from '../util';
-
-export async function prettier(): Promise<Linter.Config[]> {
-  const [pluginPrettier] = await Promise.all([
-    interopDefault(import('eslint-plugin-prettier')),
-  ] as const);
-  return [
-    {
-      plugins: {
-        prettier: pluginPrettier,
-      },
-      rules: {
-        'prettier/prettier': 'error',
-      },
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/regexp.ts

@@ -1,20 +0,0 @@
-import type { Linter } from 'eslint';
-
-import { interopDefault } from '../util';
-
-export async function regexp(): Promise<Linter.Config[]> {
-  const [pluginRegexp] = await Promise.all([
-    interopDefault(import('eslint-plugin-regexp')),
-  ] as const);
-
-  return [
-    {
-      plugins: {
-        regexp: pluginRegexp,
-      },
-      rules: {
-        ...pluginRegexp.configs.recommended.rules,
-      },
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/test.ts

@@ -1,45 +0,0 @@
-import type { Linter } from 'eslint';
-
-import { interopDefault } from '../util';
-
-export async function test(): Promise<Linter.Config[]> {
-  const [pluginTest, pluginNoOnlyTests] = await Promise.all([
-    interopDefault(import('eslint-plugin-vitest')),
-    // @ts-expect-error - no types
-    interopDefault(import('eslint-plugin-no-only-tests')),
-  ] as const);
-
-  return [
-    {
-      files: [
-        `**/__tests__/**/*.?([cm])[jt]s?(x)`,
-        `**/*.spec.?([cm])[jt]s?(x)`,
-        `**/*.test.?([cm])[jt]s?(x)`,
-        `**/*.bench.?([cm])[jt]s?(x)`,
-        `**/*.benchmark.?([cm])[jt]s?(x)`,
-      ],
-      plugins: {
-        test: {
-          ...pluginTest,
-          rules: {
-            ...pluginTest.rules,
-            ...pluginNoOnlyTests.rules,
-          },
-        },
-      },
-      rules: {
-        'no-console': 'off',
-        'node/prefer-global/process': 'off',
-        'test/consistent-test-it': [
-          'error',
-          { fn: 'it', withinDescribe: 'it' },
-        ],
-        'test/no-identical-title': 'error',
-        'test/no-import-node-test': 'error',
-        'test/no-only-tests': 'error',
-        'test/prefer-hooks-in-order': 'error',
-        'test/prefer-lowercase-title': 'error',
-      },
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/turbo.ts

@@ -1,17 +0,0 @@
-import type { Linter } from 'eslint';
-
-import { interopDefault } from '../util';
-
-export async function turbo(): Promise<Linter.Config[]> {
-  const [pluginTurbo] = await Promise.all([
-    interopDefault(import('eslint-config-turbo')),
-  ] as const);
-
-  return [
-    {
-      plugins: {
-        turbo: pluginTurbo,
-      },
-    },
-  ];
-}

internal/lint-configs/eslint-config/src/configs/typescript.ts

@@ -2,11 +2,24 @@ import type { Linter } from 'eslint';
 
 import { interopDefault } from '../util';
 
+const rulesCoveredByOxlint = new Set([
+  '@typescript-eslint/ban-ts-comment',
+  '@typescript-eslint/no-non-null-assertion',
+  '@typescript-eslint/no-unused-expressions',
+  '@typescript-eslint/no-unused-vars',
+  '@typescript-eslint/triple-slash-reference',
+]);
+
 export async function typescript(): Promise<Linter.Config[]> {
   const [pluginTs, parserTs] = await Promise.all([
     interopDefault(import('@typescript-eslint/eslint-plugin')),
     interopDefault(import('@typescript-eslint/parser')),
   ] as const);
+  const strictRules = Object.fromEntries(
+    Object.entries(pluginTs.configs.strict?.rules ?? {}).filter(
+      ([ruleName]) => !rulesCoveredByOxlint.has(ruleName),
+    ),
+  );
 
   return [
     {
@@ -30,40 +43,14 @@ export async function typescript(): Promise<Linter.Config[]> {
       },
       rules: {
         ...pluginTs.configs['eslint-recommended']?.overrides?.[0]?.rules,
-        ...pluginTs.configs.strict?.rules,
-        '@typescript-eslint/ban-ts-comment': [
-          'error',
-          {
-            'ts-check': false,
-            'ts-expect-error': 'allow-with-description',
-            'ts-ignore': 'allow-with-description',
-            'ts-nocheck': 'allow-with-description',
-          },
-        ],
-
+        ...strictRules,
         // '@typescript-eslint/consistent-type-definitions': ['warn', 'interface'],
         '@typescript-eslint/consistent-type-definitions': 'off',
         '@typescript-eslint/explicit-function-return-type': 'off',
         '@typescript-eslint/explicit-module-boundary-types': 'off',
-        '@typescript-eslint/no-empty-function': [
-          'error',
-          {
-            allow: ['arrowFunctions', 'functions', 'methods'],
-          },
-        ],
         '@typescript-eslint/no-explicit-any': 'off',
         '@typescript-eslint/no-namespace': 'off',
-        '@typescript-eslint/no-non-null-assertion': 'error',
-        '@typescript-eslint/no-unused-expressions': 'off',
-        '@typescript-eslint/no-unused-vars': [
-          'error',
-          {
-            argsIgnorePattern: '^_',
-            varsIgnorePattern: '^_',
-          },
-        ],
         '@typescript-eslint/no-use-before-define': 'off',
-        '@typescript-eslint/no-var-requires': 'error',
         'unused-imports/no-unused-vars': 'off',
       },
     },

internal/lint-configs/eslint-config/src/configs/unicorn.ts

@@ -2,10 +2,20 @@ import type { Linter } from 'eslint';
 
 import { interopDefault } from '../util';
 
+const rulesCoveredByOxlint = new Set([
+  'unicorn/consistent-function-scoping',
+  'unicorn/no-process-exit',
+  'unicorn/prefer-global-this',
+  'unicorn/prefer-module',
+]);
+
 export async function unicorn(): Promise<Linter.Config[]> {
-  const [pluginUnicorn] = await Promise.all([
-    interopDefault(import('eslint-plugin-unicorn')),
-  ] as const);
+  const pluginUnicorn = await interopDefault(import('eslint-plugin-unicorn'));
+  const recommendedRules = Object.fromEntries(
+    Object.entries(pluginUnicorn.configs.recommended.rules ?? {}).filter(
+      ([ruleName]) => !rulesCoveredByOxlint.has(ruleName),
+    ),
+  );
 
   return [
     {
@@ -13,11 +23,10 @@ export async function unicorn(): Promise<Linter.Config[]> {
         unicorn: pluginUnicorn,
       },
       rules: {
-        ...pluginUnicorn.configs.recommended.rules,
+        ...recommendedRules,
 
         'unicorn/better-regex': 'off',
         'unicorn/consistent-destructuring': 'off',
-        'unicorn/consistent-function-scoping': 'off',
         'unicorn/expiring-todo-comments': 'off',
         'unicorn/filename-case': 'off',
         'unicorn/import-style': 'off',
@@ -27,19 +36,9 @@ export async function unicorn(): Promise<Linter.Config[]> {
         'unicorn/prefer-at': 'off',
         'unicorn/prefer-dom-node-text-content': 'off',
         'unicorn/prefer-export-from': ['error', { ignoreUsedVariables: true }],
-        'unicorn/prefer-global-this': 'off',
         'unicorn/prefer-top-level-await': 'off',
         'unicorn/prevent-abbreviations': 'off',
       },
     },
-    {
-      files: [
-        'scripts/**/*.?([cm])[jt]s?(x)',
-        'internal/**/*.?([cm])[jt]s?(x)',
-      ],
-      rules: {
-        'unicorn/no-process-exit': 'off',
-      },
-    },
   ];
 }

internal/lint-configs/eslint-config/src/configs/vue.ts

@@ -128,7 +128,6 @@ export async function vue(): Promise<Linter.Config[]> {
           },
         ],
         'vue/one-component-per-file': 'error',
-        'vue/prefer-import-from-vue': 'error',
         'vue/prefer-separate-static-class': 'error',
         'vue/prefer-template': 'error',
         'vue/prop-name-casing': ['error', 'camelCase'],

internal/lint-configs/eslint-config/src/configs/yaml.ts

@@ -12,7 +12,7 @@ export async function yaml(): Promise<Linter.Config[]> {
     {
       files: ['**/*.y?(a)ml'],
       plugins: {
-        yaml: pluginYaml as any,
+        yaml: pluginYaml,
       },
       languageOptions: {
         parser: parserYaml,

internal/lint-configs/eslint-config/src/custom-config.ts

@@ -1,10 +1,6 @@
 import type { Linter } from 'eslint';
 
-const restrictedImportIgnores = [
-  '**/vite.config.mts',
-  '**/tailwind.config.mjs',
-  '**/postcss.config.mjs',
-];
+const restrictedImportIgnores = ['**/vite.config.mts'];
 
 const customConfig: Linter.Config[] = [
   // shadcn-ui 内部组件是自动生成的，不做太多限制
@@ -25,14 +21,6 @@ const customConfig: Linter.Config[] = [
     ignores: restrictedImportIgnores,
     rules: {
       'perfectionist/sort-interfaces': 'off',
-      'perfectionist/sort-objects': 'off',
-    },
-  },
-  {
-    files: ['**/**.vue'],
-    ignores: restrictedImportIgnores,
-    rules: {
-      'perfectionist/sort-objects': 'off',
     },
   },
   {
@@ -71,7 +59,6 @@ const customConfig: Linter.Config[] = [
           ],
         },
       ],
-      'perfectionist/sort-interfaces': 'off',
     },
   },
   {
@@ -145,19 +132,12 @@ const customConfig: Linter.Config[] = [
   {
     files: ['apps/backend-mock/**/**', 'docs/**/**'],
     rules: {
-      '@typescript-eslint/no-extraneous-class': 'off',
-      'n/no-extraneous-import': 'off',
-      'n/prefer-global/buffer': 'off',
-      'n/prefer-global/process': 'off',
       'no-console': 'off',
-      'unicorn/prefer-module': 'off',
     },
   },
   {
     files: ['**/**/playwright.config.ts'],
     rules: {
-      'n/prefer-global/buffer': 'off',
-      'n/prefer-global/process': 'off',
       'no-console': 'off',
     },
   },
@@ -167,6 +147,12 @@ const customConfig: Linter.Config[] = [
       'no-console': 'off',
     },
   },
+  {
+    files: ['packages/@core/base/shared/src/utils/inference.ts'],
+    rules: {
+      'vue/prefer-import-from-vue': 'off',
+    },
+  },
 ];
 
 export { customConfig };

internal/lint-configs/eslint-config/src/index.ts

@@ -1,21 +1,12 @@
 import type { Linter } from 'eslint';
 
 import {
-  command,
-  comments,
-  disableds,
   ignores,
-  importPluginConfig,
   javascript,
-  jsdoc,
   jsonc,
   node,
   perfectionist,
   pnpm,
-  prettier,
-  regexp,
-  test,
-  turbo,
   typescript,
   unicorn,
   vue,
@@ -36,20 +27,11 @@ async function defineConfig(config: FlatConfig[] = []) {
     vue(),
     javascript(),
     ignores(),
-    prettier(),
     typescript(),
     jsonc(),
-    disableds(),
-    importPluginConfig(),
     node(),
     perfectionist(),
-    comments(),
-    jsdoc(),
     unicorn(),
-    test(),
-    regexp(),
-    command(),
-    turbo(),
     yaml(),
     pnpm(),
     ...customConfig,