@lsby/eslint-plugin 0.0.16 → 0.0.18

package/README.md

@@ -1,40 +1,3 @@
 # eslint-plugin
 
-## 概述
-
 一些自己写的eslint插件
-
-## 安装
-
-1. **安装包**
-
-    ```
-    npm i @lsby/eslint-plugin
-    ```
-
-2. **安装 ESLint**
-
-    确保你的项目中已安装 ESLint 和 TypeScript ESLint 解析器。如果尚未安装，可以使用以下命令进行安装：
-
-    ```
-    npm install --save-dev eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin
-    ```
-
-3. **配置 ESLint**
-
-    在你的 ESLint 配置文件中引入并启用规则：
-
-    ```javascript
-    module.exports = {
-      parser: '@typescript-eslint/parser',
-      plugins: ['@typescript-eslint'],
-      extends: [
-        'eslint:recommended',
-        'plugin:@typescript-eslint/recommended'
-      ],
-      rules: {
-        '@lsby/no-broken-link': 'error',
-        '@lsby/prefer-let': 'error',
-      },
-    };
-    ```

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const no_definite_assignment_assertion_1 = __importDefault(require("./lib/rules/no-definite-assignment-assertion"));
+const no_else_on_equality_1 = __importDefault(require("./lib/rules/no-else-on-equality"));
+const no_negation_1 = __importDefault(require("./lib/rules/no-negation"));
+const no_switch_default_1 = __importDefault(require("./lib/rules/no-switch-default"));
+const prefer_let_1 = __importDefault(require("./lib/rules/prefer-let"));
+const prefer_switch_over_multi_if_1 = __importDefault(require("./lib/rules/prefer-switch-over-multi-if"));
+module.exports = {
+    rules: {
+        'prefer-let': prefer_let_1.default,
+        'no-negation': no_negation_1.default,
+        'no-definite-assignment-assertion': no_definite_assignment_assertion_1.default,
+        'no-else-on-equality': no_else_on_equality_1.default,
+        'no-switch-default': no_switch_default_1.default,
+        'prefer-switch-over-multi-if': prefer_switch_over_multi_if_1.default,
+    },
+};

package/dist/lib/rules/no-broken-link.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/lib/rules/no-broken-link.js

@@ -0,0 +1,33 @@
+"use strict";
+// jsdoc的link必须存在
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: { description: '禁止在 JSDoc 注解中使用未定义的 {@link} 引用' },
+        messages: { undefinedLink: '{@link} 中的标识符 "{identifier}" 未定义' },
+        schema: [],
+    },
+    create(context) {
+        return {
+            Program(node) {
+                const sourceCode = context.sourceCode || context.getSourceCode();
+                const comments = sourceCode.getAllComments?.() || [];
+                comments.forEach((comment) => {
+                    const matches = comment.value.match(/\{@link\s+([^\s}]+)\s*\}/g);
+                    if (matches) {
+                        matches.forEach((link) => {
+                            const identifier = link.match(/\{@link\s+([^\s}]+)\s*\}/)[1];
+                            const variables = context.getScope().variables;
+                            const isDefined = variables.some((variable) => variable.name === identifier);
+                            if (!isDefined) {
+                                context.report({ node, messageId: 'undefinedLink', data: { identifier } });
+                            }
+                        });
+                    }
+                });
+            },
+        };
+    },
+};
+exports.default = rule;

package/dist/lib/rules/no-definite-assignment-assertion.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<'noDefiniteAssignment', []>;
+export default rule;

package/dist/lib/rules/no-definite-assignment-assertion.js

@@ -0,0 +1,22 @@
+"use strict";
+// 禁止类属性使用确定赋值断言语法, 否则很容易出现空指针
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: { description: '禁止在类属性上使用明确赋值断言 (!:)' },
+        messages: { noDefiniteAssignment: '类属性不允许使用明确赋值断言 (!:), 应使用初始化或构造函数赋值' },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            PropertyDefinition(node) {
+                if (node.definite === true) {
+                    context.report({ node, messageId: 'noDefiniteAssignment' });
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/dist/lib/rules/no-else-on-equality.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<'noElse', []>;
+export default rule;

package/dist/lib/rules/no-else-on-equality.js

@@ -0,0 +1,40 @@
+"use strict";
+// 禁止 else（当条件是等于或不等于时）
+// 对于等于/不等于的条件判断，else 表示"除当前条件外的所有可能"
+// 当状态集合未来扩展时, 依然会被包含在else分支里, 导致状态遗漏却无任何报错
+// 应当使用提早返回 或 switch + 穷尽检查
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: { description: '当条件是等于或不等于时，禁止使用 else 分支，防止隐含的状态遗漏' },
+        messages: {
+            noElse: '禁止在等于/不等于条件下使用 else 分支。当条件状态扩展时, else 分支可能遗漏新的状态。请改用提前返回(early return)或 switch 语句',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * 检查条件中是否包含等于或不等于操作符
+         */
+        function hasEqualityOperator(node) {
+            if (node.type === 'BinaryExpression') {
+                return ['===', '!==', '==', '!='].includes(node.operator);
+            }
+            if (node.type === 'LogicalExpression') {
+                return hasEqualityOperator(node.left) || hasEqualityOperator(node.right);
+            }
+            return false;
+        }
+        return {
+            IfStatement(node) {
+                // 仅在 if 条件是等于或不等于的情况下，禁止 else
+                if (node.alternate !== null && hasEqualityOperator(node.test)) {
+                    context.report({ node: node.alternate, messageId: 'noElse' });
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/dist/lib/rules/no-negation.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/lib/rules/no-negation.js

@@ -0,0 +1,34 @@
+"use strict";
+// 禁止对非布尔值使用 "!" 运算符, 否则可能导致意外的类型强制转换
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typescript_1 = __importDefault(require("typescript"));
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: { description: '禁止对非布尔值使用逻辑取反操作符 (!)' },
+        messages: { noNegationOnNonBoolean: '禁止对非布尔值使用 "!" 运算符' },
+        schema: [],
+    },
+    create(context) {
+        return {
+            UnaryExpression(node) {
+                if (node.operator !== '!')
+                    return;
+                const parserServices = context.parserServices;
+                if (!parserServices)
+                    return;
+                const typeChecker = parserServices.program.getTypeChecker();
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.argument);
+                const argumentType = typeChecker.getTypeAtLocation(tsNode);
+                const isBoolean = (argumentType.flags & typescript_1.default.TypeFlags.Boolean) !== 0 || (argumentType.flags & typescript_1.default.TypeFlags.BooleanLiteral) !== 0;
+                if (!isBoolean) {
+                    context.report({ node, messageId: 'noNegationOnNonBoolean' });
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/dist/lib/rules/no-switch-default.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/lib/rules/no-switch-default.js

@@ -0,0 +1,27 @@
+"use strict";
+// 禁止 switch 中使用 default 分支
+// default 分支会掩盖新增的 case, 导致代码不可演化
+// 如果未来增加新的 case, default 会让错误悄悄通过编译
+// 通过禁止 default, 可以强制显式列出所有可能的分支
+// 这样 switch 永远保持穷举, 提升类型安全和可维护性
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: { description: '禁止使用 switch 的 default 分支' },
+        messages: { noSwitchDefault: '禁止在 switch 语句中使用 default 分支' },
+        schema: [],
+    },
+    create(context) {
+        return {
+            SwitchStatement(node) {
+                for (const switchCase of node.cases) {
+                    if (switchCase.test === null) {
+                        context.report({ node: switchCase, messageId: 'noSwitchDefault' });
+                    }
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/dist/lib/rules/prefer-let.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<'preferLet', []>;
+export default rule;

package/dist/lib/rules/prefer-let.js

@@ -0,0 +1,56 @@
+"use strict";
+// 永远使用let, 拒绝var和const, 并自动修复
+// 原因:
+// 1 抽象泄漏
+// const只约束原语值和指针不变, 不约束引用值本身不变
+// 使用者要搞懂什么可变什么不可变, 必须理解原语值和引用值的区别, 以及变量在内存上的机制
+// 这种"必须搞懂背后的原理才能正常使用"的情况是显然的抽象泄漏
+// 2 误导
+// 对于新人, 很容易被误解, 导致引用值被意外修改
+// 3 心智成本
+// 实际使用时, 即使是const声明值, 也必须确认其是否为引用类型, 若是则还是需要确认所有可能的修改
+// 这与let无异, 反而增加了心智成本
+// **错误的信息比没有信息更糟糕**
+// 替代:
+// 如果真的需要表达不变, 应该使用类型等级的递归只读, 建模隐藏等方法
+// 这虽然复杂度更高, 但可以真正保证安全
+// 这也迫使程序员思考是否真的有必要这样设计, 而不是"随手一用", 提供一个"虚假的安全感"
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: '禁止使用 const 和 var，仅允许使用 let 声明变量' },
+        fixable: 'code',
+        messages: { preferLet: '使用 let 代替 {kind}' },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            VariableDeclaration(node) {
+                // 跳过 unique symbol
+                if (node.kind === 'const' || node.kind === 'var') {
+                    if (!('declare' in node && node.declare === true)) {
+                        const hasUniqueSymbol = node.declarations.some((decl) => {
+                            const typeAnn = decl.id.typeAnnotation?.typeAnnotation;
+                            return typeAnn?.type === 'TSTypeOperator' && typeAnn.operator === 'unique';
+                        });
+                        if (hasUniqueSymbol)
+                            return;
+                        context.report({
+                            node,
+                            messageId: 'preferLet',
+                            data: { kind: node.kind },
+                            fix(fixer) {
+                                if (!node.range)
+                                    return null;
+                                return fixer.replaceTextRange([node.range[0], node.range[0] + node.kind.length], 'let');
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/dist/lib/rules/prefer-switch-over-multi-if.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<'preferSwitch', []>;
+export default rule;

package/dist/lib/rules/prefer-switch-over-multi-if.js

@@ -0,0 +1,108 @@
+"use strict";
+// 建议使用 switch 替代多个 if 判断同一变量
+// 当有多个连续的 if 语句判断同一个表达式时, 应该使用 switch 来提高代码的可读性
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: '检测多个连续 if 判断同一个表达式，建议使用 switch 提高可读性' },
+        messages: { preferSwitch: '检测到 {{count}} 个连续的 if 判断同一个表达式，可以考虑使用 switch 提高可读性' },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const minIfs = 2;
+        function getText(node) {
+            return sourceCode.getText(node);
+        }
+        function isValidCaseValue(node) {
+            return (node.type === 'Literal' ||
+                node.type === 'TemplateLiteral' ||
+                node.type === 'Identifier' ||
+                node.type === 'MemberExpression');
+        }
+        function getSwitchInfo(test) {
+            if (test.type !== 'BinaryExpression')
+                return null;
+            // 支持所有的二元比较操作符
+            const comparisonOps = ['===', '==', '!==', '!=', '>', '<', '>=', '<='];
+            if (!comparisonOps.includes(test.operator))
+                return null;
+            const left = test.left;
+            const right = test.right;
+            if ((left.type === 'Identifier' || left.type === 'MemberExpression') && isValidCaseValue(right)) {
+                return { variable: getText(left), value: getText(right) };
+            }
+            if ((right.type === 'Identifier' || right.type === 'MemberExpression') && isValidCaseValue(left)) {
+                return { variable: getText(right), value: getText(left) };
+            }
+            return null;
+        }
+        function collectIfChain(node) {
+            const chain = [node];
+            let current = node;
+            // 收集 else-if 链
+            while (current.alternate && current.alternate.type === 'IfStatement') {
+                chain.push(current.alternate);
+                current = current.alternate;
+            }
+            // 如果没有 else-if，尝试收集相邻的 if 语句
+            if (chain.length === 1 && node.parent) {
+                const parent = node.parent;
+                let body = null;
+                if (parent.type === 'BlockStatement') {
+                    body = parent.body;
+                }
+                else if (parent.type === 'Program') {
+                    body = parent.body;
+                }
+                if (body) {
+                    const nodeIndex = body.indexOf(node);
+                    if (nodeIndex !== -1) {
+                        const firstInfo = getSwitchInfo(node.test);
+                        if (firstInfo) {
+                            let nextIndex = nodeIndex + 1;
+                            while (nextIndex < body.length && body[nextIndex].type === 'IfStatement') {
+                                const nextIfStmt = body[nextIndex];
+                                if (nextIfStmt.alternate)
+                                    break; // 如果有 else/else-if，停止
+                                const nextInfo = getSwitchInfo(nextIfStmt.test);
+                                if (!nextInfo || nextInfo.variable !== firstInfo.variable)
+                                    break; // 变量不同，停止
+                                chain.push(nextIfStmt);
+                                nextIndex++;
+                            }
+                        }
+                    }
+                }
+            }
+            return chain;
+        }
+        function allSameVariable(chain) {
+            if (chain.length < minIfs)
+                return null;
+            const firstInfo = getSwitchInfo(chain[0].test);
+            if (!firstInfo)
+                return null;
+            for (const stmt of chain.slice(1)) {
+                const info = getSwitchInfo(stmt.test);
+                if (!info || info.variable !== firstInfo.variable)
+                    return null;
+            }
+            return { variable: firstInfo.variable, count: chain.length };
+        }
+        return {
+            IfStatement(node) {
+                if (node.parent?.type === 'IfStatement' && node.parent.alternate === node)
+                    return;
+                const chain = collectIfChain(node);
+                const info = allSameVariable(chain);
+                if (!info)
+                    return;
+                context.report({ node, messageId: 'preferSwitch', data: { count: info.count } });
+            },
+        };
+    },
+};
+exports.default = rule;

package/package.json

@@ -1,18 +1,34 @@
 {
   "name": "@lsby/eslint-plugin",
-  "version": "0.0.16",
-  "main": "index.js",
+  "version": "0.0.18",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "pub:public": "bumpp && npm publish --access public",
-    "test": "mocha test/**/*.test.js"
+    "build": "rimraf dist && tsc",
+    "check:all": "npm run check:format && npm run check:type",
+    "check:format": "prettier --write .",
+    "check:type": "tsc --noEmit",
+    "dev": "tsc --watch",
+    "pub:public": "npm run build && npm run test && bumpp && npm publish --access public",
+    "test": "npm run build && mocha test/**/*.test.js"
   },
   "devDependencies": {
     "@ianvs/prettier-plugin-sort-imports": "^4.2.1",
+    "@types/eslint": "^8.56.0",
+    "@types/estree": "^1.0.8",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/parser": "^8.50.1",
+    "@typescript-eslint/utils": "^8.50.1",
     "bumpp": "^9.5.1",
     "chai": "^5.1.1",
     "mocha": "^10.7.3",
-    "prettier": "^3.3.3",
-    "prettier-plugin-packagejson": "^2.5.1"
+    "prettier": "^3.7.4",
+    "prettier-plugin-packagejson": "^2.5.20",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.3.0"
   },
   "peerDependencies": {
     "eslint": "^8.56.0"

package/.prettierignore

@@ -1,51 +0,0 @@
-# 忽略 node_modules 目录
-node_modules/
-
-# 忽略所有日志文件
-*.log
-
-# 忽略构建输出目录
-dist/
-build/
-
-# 忽略环境变量文件
-.env
-.env.local
-.env.*.local
-
-# 忽略锁文件
-pnpm-lock.yaml
-yarn.lock
-package-lock.json
-
-# 忽略 IDE 配置文件
-.vscode/
-.idea/
-
-# 忽略临时文件
-*.tmp
-*.temp
-
-# 忽略特定文件类型
-*.min.js
-*.min.css
-
-# 忽略特定文件
-pnpm-lock.yaml
-
-# 忽略图片和其他媒体文件
-*.png
-*.jpg
-*.jpeg
-*.gif
-*.svg
-
-# 忽略压缩文件
-*.zip
-*.tar.gz
-*.rar
-
-# 忽略文档
-*.pdf
-*.docx
-*.xlsx

package/.prettierrc

@@ -1,9 +0,0 @@
-{
-  "printWidth": 120,
-  "trailingComma": "all",
-  "semi": false,
-  "endOfLine": "auto",
-  "singleQuote": true,
-  "plugins": ["prettier-plugin-packagejson", "@ianvs/prettier-plugin-sort-imports"],
-  "importOrder": ["<BUILTIN_MODULES>", "<THIRD_PARTY_MODULES>", "^@([^/]+?)/(.*)$", "^[./]"]
-}

package/index.js

@@ -1,9 +0,0 @@
-module.exports = {
-  rules: {
-    'no-broken-link': require('./lib/rules/no-broken-link'),
-    'prefer-let': require('./lib/rules/prefer-let'),
-    'no-negation': require('./lib/rules/no-negation'),
-    'no-definite-assignment-assertion': require('./lib/rules/no-definite-assignment-assertion'),
-    'no-else': require('./lib/rules/no-else'),
-  },
-}

package/lib/rules/no-broken-link.js

@@ -1,41 +0,0 @@
-// jsdoc的link必须存在
-
-module.exports = {
-  meta: {
-    type: 'problem', // 规则类型，可以是 "problem", "suggestion", 或 "layout"
-    docs: {
-      description: 'Check for broken {@link} references in comments',
-      category: 'Possible Errors',
-      recommended: false,
-    },
-    schema: [], // 规则的选项配置
-  },
-  create: function (context) {
-    return {
-      Program(node) {
-        const sourceCode = context.getSourceCode()
-        const comments = sourceCode.getAllComments()
-
-        comments.forEach((comment) => {
-          const matches = comment.value.match(/\{@link\s+([^\s}]+)\s*\}/g)
-
-          if (matches) {
-            matches.forEach((link) => {
-              const identifier = link.match(/\{@link\s+([^\s}]+)\s*\}/)[1]
-
-              const variables = context.getScope().variables
-              const isDefined = variables.some((variable) => variable.name === identifier)
-
-              if (!isDefined) {
-                context.report({
-                  node: comment,
-                  message: `{@link}中的标识符“${identifier}”没有定义。`,
-                })
-              }
-            })
-          }
-        })
-      },
-    }
-  },
-}

package/lib/rules/no-definite-assignment-assertion.js

@@ -1,35 +0,0 @@
-// 禁止类属性使用确定赋值断言语法
-
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: '禁止类属性使用确定赋值断言 (foo!: T)',
-      recommended: 'error',
-    },
-    messages: {
-      noDefiniteAssignment: '类属性不允许使用确定赋值断言 (!:)',
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      ClassProperty(node) {
-        if (node.definite) {
-          context.report({
-            node,
-            messageId: 'noDefiniteAssignment',
-          })
-        }
-      },
-      PropertyDefinition(node) {
-        if (node.definite) {
-          context.report({
-            node,
-            messageId: 'noDefiniteAssignment',
-          })
-        }
-      },
-    }
-  },
-}

package/lib/rules/no-else.js

@@ -1,30 +0,0 @@
-// 禁止 else
-// else 表示"除当前条件外的所有可能"
-// 当状态集合未来扩展时, 依然会被包含在else分支里, 导致状态遗漏却无任何报错
-// 应当使用提早返回 或 switch + 穷尽检查
-
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: '禁止使用 else, 避免不稳定的否定剩余分支',
-    },
-    messages: {
-      noElse: '禁止使用 else, 请改用 early return 或 switch',
-    },
-    schema: [],
-  },
-
-  create(context) {
-    return {
-      IfStatement(node) {
-        if (node.alternate !== null) {
-          context.report({
-            node: node.alternate,
-            messageId: 'noElse',
-          })
-        }
-      },
-    }
-  },
-}

package/lib/rules/no-negation.js

@@ -1,17 +0,0 @@
-// 禁止对非布尔值使用取反
-// 对于 number | null 的值x, if(!x)在x等于null和0时都会触发, 这可能是非预期的
-
-module.exports = {
-  create(context) {
-    return {
-      UnaryExpression(node) {
-        if (node.operator === '!' && !(node.argument.type === 'Literal' && typeof node.argument.value === 'boolean')) {
-          context.report({
-            node,
-            message: "禁止对非布尔值使用 '!' 运算符。",
-          })
-        }
-      },
-    }
-  },
-}

package/lib/rules/prefer-let.js

@@ -1,43 +0,0 @@
-// 永远使用let, 拒绝var和const, 并自动修复
-// 禁止const是因为它有抽象泄漏
-// 它只对原语值和指针不变, 不对引用值本身不变
-// 要搞懂什么可变什么不可变, 必须理解原语值和引用值的区别, 以及变量在内存上的机制
-// 如果真的需要表达不变, 应该在类型等级写递归只读
-
-module.exports = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Replace const and var with let',
-      category: 'Best Practices',
-      recommended: false,
-    },
-    fixable: 'code',
-    schema: [],
-  },
-
-  create(context) {
-    return {
-      VariableDeclaration(node) {
-        // 跳过 unique symbol
-        if ((node.kind === 'const' || node.kind === 'var') && !node.declare) {
-          let hasUniqueSymbol = node.declarations.some((decl) => {
-            const typeAnn = decl.id.typeAnnotation?.typeAnnotation
-            return typeAnn?.type === 'TSTypeOperator' && typeAnn.operator === 'unique'
-          })
-          if (hasUniqueSymbol) return
-
-          // 使用修复功能将 const 或 var 替换为 let
-          context.report({
-            node,
-            message: '使用let代替const或var',
-            fix(fixer) {
-              const range = node.range
-              return fixer.replaceTextRange([range[0], range[0] + node.kind.length], 'let')
-            },
-          })
-        }
-      },
-    }
-  },
-}