@foundbyte/eslint-plugin 1.1.5-alpha.0 → 1.1.5-alpha.2

package/README.md

@@ -77,6 +77,13 @@ module.exports = {
       },
     ],
     '@foundbyte/require-json-parse-type': 'error',
+    '@foundbyte/no-restricted-literal-types': [
+      'error',
+      {
+        forbidden: ['null', 'undefined', ''],
+        allowInUnions: true,
+      },
+    ],
   },
 }
 ```
@@ -631,9 +638,15 @@ const a: { s: number } = JSON.parse('{s:1}')
 // ✅ 正确 - 解构赋值带有显式类型注解
 const { s }: { s: number } = JSON.parse('{s:1}')
 
+// ✅ 正确 - 三元表达式中的 JSON.parse 带有显式类型注解
+const qualification: string[] = info.qualification ? JSON.parse(info.qualification) : []
+
 // ❌ 错误 - 缺少类型注解
 const a = JSON.parse('{s:1}')
 
+// ❌ 错误 - 三元表达式中的 JSON.parse 缺少类型注解
+const qualification = info.qualification ? JSON.parse(info.qualification) : []
+
 // ❌ 错误 - 使用 as 断言不算作变量声明类型注解
 const a = JSON.parse('{s:1}') as { s: number }
 ```
@@ -646,6 +659,73 @@ const a = JSON.parse('{s:1}') as { s: number }
 
 **注意：**
 
-- 该规则只检查变量声明的初始化表达式直接是 `JSON.parse(...)` 的情况
+- 该规则检查变量声明的初始化表达式中是否包含 `JSON.parse(...)`，包括三元表达式、逻辑表达式、对象/数组字面量等场景
 - 对于 `const a = JSON.parse('...') as Type` 也会报错，因为它要求类型注解必须声明在变量本身
+- 函数体内部的 `JSON.parse` 不影响外层变量，不会被误判
 - 如希望允许 `as` 类型断言，请搭配 `@foundbyte/no-initial-as-assertion` 规则按需配置
+
+### no-restricted-literal-types
+
+禁止在类型注解中使用指定的无意义字面量类型，例如 `null`、`undefined`、空字符串字面量 `''` 等。
+
+**配置示例：**
+
+```javascript
+// 基本用法 - 禁止 null、undefined 和空字符串字面量类型
+'@foundbyte/no-restricted-literal-types': ['error', {
+  forbidden: ['null', 'undefined', ''],
+}]
+
+// 允许联合类型中的 null / undefined
+'@foundbyte/no-restricted-literal-types': ['error', {
+  forbidden: ['null', 'undefined'],
+  allowInUnions: true,
+}]
+```
+
+**示例：**
+
+```typescript
+// ❌ 错误 - 无意义的 null 类型
+interface OrderItem {
+  seatName: null
+  refundStatus: null
+}
+
+// ❌ 错误 - 无意义的 undefined 类型
+interface Config {
+  value: undefined
+}
+
+// ❌ 错误 - 无意义的空字符串字面量类型
+interface Query {
+  keyword: ''
+}
+
+// ✅ 正确 - 使用具体类型
+interface OrderItem {
+  seatName: string
+  refundStatus: number
+}
+
+// ✅ 正确 - 联合类型中的 null / undefined 是有意义的（当 allowInUnions 为 true 时）
+interface User {
+  phone: string | null
+  email?: string
+}
+```
+
+**配置选项：**
+
+- `forbidden` (array, 必填): 要禁止的字面量类型列表
+  - 支持关键字类型：`'null'`、`'undefined'`、`'void'`、`'never'`、`'any'`、`'unknown'`、`'boolean'`、`'number'`、`'string'`、`'symbol'`、`'bigint'`、`'object'`
+  - 支持字面量值：`''`、`0`、`true`、`false` 等
+
+- `allowInUnions` (boolean, 默认 `false`): 是否允许在联合类型中使用
+  - 为 `true` 时，`string | null` 不会被报错，但独立的 `null` 类型仍然会报错
+  - 为 `false` 时，任何出现 `null` / `undefined` 等的地方都会报错
+
+**注意：**
+
+- 该规则针对类型注解中的字面量，不影响运行时值，例如 `const a = null` 不会触发
+- 建议配合 TypeScript 严格模式使用，逐步替换项目中的无意义类型声明

package/index.js

@@ -9,6 +9,7 @@ const noExcessiveAnyRule = require('./lib/rules/no-excessive-any')
 const noDisabledCommentsRule = require('./lib/rules/no-disabled-comments')
 const noRestrictedComponentsRule = require('./lib/rules/no-restricted-components')
 const requireJsonParseTypeRule = require('./lib/rules/require-json-parse-type')
+const noRestrictedLiteralTypesRule = require('./lib/rules/no-restricted-literal-types')
 
 // 限制属性，同时相当于限制某些组件禁止使用
 const restrictions = [
@@ -44,6 +45,7 @@ module.exports = {
     'no-disabled-comments': noDisabledCommentsRule,
     'no-restricted-components': noRestrictedComponentsRule,
     'require-json-parse-type': requireJsonParseTypeRule,
+    'no-restricted-literal-types': noRestrictedLiteralTypesRule,
   },
   configs: {
     customize: (options) => {

package/lib/rules/hooks-arrow-function-only.js

@@ -1,3 +1,5 @@
+const { getSourceCode } = require('../utils/eslint-compat')
+
 module.exports = {
   meta: {
     type: 'suggestion',
@@ -24,7 +26,7 @@ module.exports = {
             messageId: 'useArrowFunction',
             fix(fixer) {
               // 将 function 声明转换为箭头函数
-              const sourceCode = context.getSourceCode()
+              const sourceCode = getSourceCode(context)
               const functionName = node.id.name
               const params = node.params.map(param => sourceCode.getText(param)).join(', ')
               const body = sourceCode.getText(node.body)
@@ -52,7 +54,7 @@ module.exports = {
             messageId: 'useArrowFunction',
             fix(fixer) {
               // 将函数表达式转换为箭头函数
-              const sourceCode = context.getSourceCode()
+              const sourceCode = getSourceCode(context)
               const params = node.init.params.map(param => sourceCode.getText(param)).join(', ')
               const body = sourceCode.getText(node.init.body)
               

package/lib/rules/hooks-export-limit.js

@@ -1,3 +1,5 @@
+const { getFilename, getSourceCode } = require('../utils/eslint-compat')
+
 module.exports = {
   meta: {
     type: 'problem',
@@ -29,7 +31,7 @@ module.exports = {
     const maxExports = options.maxExports || 20
 
     // 只处理 .vue 文件
-    const filename = context.getFilename()
+    const filename = getFilename(context)
     if (!filename.endsWith('.vue')) {
       return {}
     }
@@ -37,7 +39,7 @@ module.exports = {
     return {
       Program() {
         // 获取整个文件的源代码
-        const sourceCode = context.getSourceCode()
+        const sourceCode = getSourceCode(context)
         const text = sourceCode.getText()
 
         // 使用正则表达式匹配所有 hooks 的解构赋值

package/lib/rules/no-disabled-comments.js

@@ -1,3 +1,5 @@
+const { getFilename, getSourceCode } = require('../utils/eslint-compat')
+
 module.exports = {
   meta: {
     type: 'problem',
@@ -100,7 +102,7 @@ module.exports = {
 
     return {
       Program() {
-        const sourceCode = context.getSourceCode()
+        const sourceCode = getSourceCode(context)
         const comments = sourceCode.getAllComments()
 
         // 检查 JavaScript/TypeScript 注释
@@ -117,7 +119,7 @@ module.exports = {
         })
 
         // 检查 Vue 文件中的 HTML 注释
-        const filename = context.getFilename()
+        const filename = getFilename(context)
         if (filename.endsWith('.vue')) {
           checkVueHtmlComments(context, sourceCode, regexPatterns)
         }

package/lib/rules/no-excessive-any.js

@@ -1,3 +1,5 @@
+const { getSourceCode } = require('../utils/eslint-compat')
+
 module.exports = {
   meta: {
     type: 'problem',
@@ -208,7 +210,7 @@ const anyVariables = new Set()
           // 检查是否有类型参数（通过源代码文本检查）
           // 由于 Vue SFC 文件中的 TypeScript 泛型可能没有被正确解析为 AST 节点，
           // 我们通过检查源代码文本来判断是否有类型参数
-          const sourceCode = context.getSourceCode()
+          const sourceCode = getSourceCode(context)
           const callText = sourceCode.getText(node)
           
           // 检查调用文本中是否包含泛型类型参数（如 <string>）
@@ -325,7 +327,7 @@ const anyVariables = new Set()
      */
     function getImportsForCurrentFile() {
       const imports = []
-      const programNode = context.getSourceCode().ast
+      const programNode = getSourceCode(context).ast
       
       // 遍历所有导入声明
       programNode.body.forEach(node => {
@@ -529,7 +531,7 @@ const anyVariables = new Set()
       
       // 检查函数调用中的类型参数
       if (node.type === 'CallExpression') {
-        const sourceCode = context.getSourceCode()
+        const sourceCode = getSourceCode(context)
         const callText = sourceCode.getText(node)
         
         // 检查类型参数（泛型）

package/lib/rules/no-initial-as-assertion.js

@@ -1,3 +1,5 @@
+const { getSourceCode } = require('../utils/eslint-compat');
+
 module.exports = {
     meta: {
         type: 'suggestion',
@@ -112,7 +114,7 @@ module.exports = {
             }
 
             // 获取类型注解的源代码
-            const sourceCode = context.getSourceCode();
+            const sourceCode = getSourceCode(context);
             const typeAnnotationText = sourceCode.getText(node.typeAnnotation);
 
             // 检查是否匹配任何排除模式

package/lib/rules/no-restricted-components.js

@@ -1,3 +1,5 @@
+const { getFilename, getSourceCode } = require('../utils/eslint-compat');
+
 module.exports = {
     meta: {
         type: 'problem',
@@ -64,7 +66,7 @@ module.exports = {
         });
 
         // 获取文件名，只对 .vue 文件生效
-        const filename = context.getFilename();
+        const filename = getFilename(context);
         if (!filename.endsWith('.vue')) {
             return {};
         }
@@ -72,7 +74,7 @@ module.exports = {
         return {
             Program(node) {
                 // 获取整个文件的源代码
-                const sourceCode = context.getSourceCode();
+                const sourceCode = getSourceCode(context);
                 const text = sourceCode.getText();
                 
                 // 使用正则表达式匹配模板中的标签

package/lib/rules/no-restricted-literal-types.d.ts

@@ -0,0 +1,22 @@
+import { Rule } from 'eslint'
+
+export interface NoRestrictedLiteralTypesOptions {
+  /**
+   * 要禁止的字面量类型列表
+   * @example ['null', 'undefined', '']
+   */
+  forbidden: Array<string | number | boolean>
+
+  /**
+   * 是否允许在联合类型中使用，例如 string | null
+   * @default false
+   */
+  allowInUnions?: boolean
+}
+
+/**
+ * 禁止在类型注解中使用指定的字面量类型
+ */
+declare const rule: Rule.RuleModule
+
+export default rule

package/lib/rules/no-restricted-literal-types.js

@@ -0,0 +1,158 @@
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: '禁止在类型注解中使用指定的字面量类型',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    fixable: null,
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          forbidden: {
+            type: 'array',
+            items: {
+              anyOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+            },
+            description:
+              '要禁止的字面量类型列表，支持 null、undefined、void、never、any、unknown 等关键字，以及空字符串、0、true 等具体字面量',
+          },
+          allowInUnions: {
+            type: 'boolean',
+            default: false,
+            description: '是否允许在联合类型中使用，例如 string | null',
+          },
+        },
+        required: ['forbidden'],
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      noRestrictedLiteralType: '禁止在类型中使用 "{{type}}" 字面量类型',
+    },
+  },
+
+  create(context) {
+    const options = context.options[0] || {}
+    const forbidden = options.forbidden || []
+    const allowInUnions = options.allowInUnions || false
+
+    if (forbidden.length === 0) {
+      return {}
+    }
+
+    const forbiddenStrings = new Set()
+    const forbiddenNumbers = new Set()
+    const forbiddenBooleans = new Set()
+
+    forbidden.forEach((item) => {
+      if (typeof item === 'string') {
+        forbiddenStrings.add(item)
+      } else if (typeof item === 'number') {
+        forbiddenNumbers.add(item)
+      } else if (typeof item === 'boolean') {
+        forbiddenBooleans.add(item)
+      }
+    })
+
+    // 关键字类型映射
+    const keywordTypeMap = {
+      null: 'TSNullKeyword',
+      undefined: 'TSUndefinedKeyword',
+      void: 'TSVoidKeyword',
+      never: 'TSNeverKeyword',
+      any: 'TSAnyKeyword',
+      unknown: 'TSUnknownKeyword',
+      boolean: 'TSBooleanKeyword',
+      number: 'TSNumberKeyword',
+      string: 'TSStringKeyword',
+      symbol: 'TSSymbolKeyword',
+      bigint: 'TSBigIntKeyword',
+      object: 'TSObjectKeyword',
+    }
+
+    /**
+     * 检查类型是否位于联合类型中
+     * @param {Object} node AST 节点
+     * @returns {boolean}
+     */
+    function isInUnion(node) {
+      return node.parent && node.parent.type === 'TSUnionType'
+    }
+
+    /**
+     * 获取匹配到的 forbidden 值
+     * @param {Object} node AST 节点
+     * @returns {string|number|boolean|null}
+     */
+    function getMatchedForbidden(node) {
+      if (allowInUnions && isInUnion(node)) {
+        return null
+      }
+
+      // 关键字类型检查
+      for (const [key, typeName] of Object.entries(keywordTypeMap)) {
+        if (forbiddenStrings.has(key) && node.type === typeName) {
+          return key
+        }
+      }
+
+      // 字面量类型检查
+      if (node.type === 'TSLiteralType' && node.literal) {
+        const literal = node.literal
+
+        if (literal.type === 'Literal') {
+          if (typeof literal.value === 'string' && forbiddenStrings.has(literal.value)) {
+            return literal.value
+          }
+          if (typeof literal.value === 'number' && forbiddenNumbers.has(literal.value)) {
+            return literal.value
+          }
+          if (typeof literal.value === 'boolean' && forbiddenBooleans.has(literal.value)) {
+            return literal.value
+          }
+        }
+      }
+
+      return null
+    }
+
+    const targetTypes = [
+      'TSNullKeyword',
+      'TSUndefinedKeyword',
+      'TSVoidKeyword',
+      'TSNeverKeyword',
+      'TSAnyKeyword',
+      'TSUnknownKeyword',
+      'TSBooleanKeyword',
+      'TSNumberKeyword',
+      'TSStringKeyword',
+      'TSSymbolKeyword',
+      'TSBigIntKeyword',
+      'TSObjectKeyword',
+      'TSLiteralType',
+    ]
+
+    const visitors = {}
+    targetTypes.forEach((type) => {
+      visitors[type] = function (node) {
+        const matched = getMatchedForbidden(node)
+        if (matched === null) {
+          return
+        }
+
+        context.report({
+          node,
+          messageId: 'noRestrictedLiteralType',
+          data: {
+            type: String(matched),
+          },
+        })
+      }
+    })
+
+    return visitors
+  },
+}

package/lib/rules/require-json-parse-type.js

@@ -80,6 +80,43 @@ module.exports = {
       return node
     }
 
+    /**
+     * 递归检查表达式中是否包含 JSON.parse(...) 调用
+     * 用于处理三元表达式、逻辑表达式、对象/数组字面量等场景
+     * @param {Object} node AST 节点
+     * @returns {boolean}
+     */
+    function containsJsonParse(node) {
+      if (!node || typeof node !== 'object') {
+        return false
+      }
+
+      const unwrapped = unwrapExpression(node)
+      if (isJsonParseCall(unwrapped)) {
+        return true
+      }
+
+      // 不进入函数体内部，函数体是独立作用域，不影响外层变量类型
+      if (unwrapped.type === 'ArrowFunctionExpression' || unwrapped.type === 'FunctionExpression') {
+        return false
+      }
+
+      return Object.keys(unwrapped).some((key) => {
+        if (key === 'parent' || key === 'loc' || key === 'range') {
+          return false
+        }
+
+        const value = unwrapped[key]
+        if (Array.isArray(value)) {
+          return value.some((child) => containsJsonParse(child))
+        }
+        if (value && typeof value === 'object' && value.type) {
+          return containsJsonParse(value)
+        }
+        return false
+      })
+    }
+
     /**
      * 检查变量声明是否使用了 JSON.parse 并且缺少显式类型注解
      * @param {Object} node VariableDeclaration 节点
@@ -94,8 +131,7 @@ module.exports = {
           return
         }
 
-        const unwrappedInit = unwrapExpression(declaration.init)
-        if (!isJsonParseCall(unwrappedInit)) {
+        if (!containsJsonParse(declaration.init)) {
           return
         }
 

package/lib/rules/tag-attribute-restriction.js

@@ -1,3 +1,5 @@
+const { getFilename, getSourceCode } = require('../utils/eslint-compat');
+
 module.exports = {
     meta: {
         type: 'problem',
@@ -63,7 +65,7 @@ module.exports = {
         }
 
         // 获取文件名，只对 .vue 文件生效
-        const filename = context.getFilename();
+        const filename = getFilename(context);
         if (!filename.endsWith('.vue')) {
             return {};
         }
@@ -77,7 +79,7 @@ module.exports = {
         return {
             Program(node) {
                 // 获取整个文件的源代码
-                const sourceCode = context.getSourceCode();
+                const sourceCode = getSourceCode(context);
                 const text = sourceCode.getText();
                 
                 // 使用正则表达式匹配模板中的标签和属性

package/lib/rules/type-comment-requirement.js

@@ -1,3 +1,5 @@
+const { getSourceCode } = require('../utils/eslint-compat');
+
 module.exports = {
     meta: {
         type: 'suggestion',
@@ -53,7 +55,7 @@ module.exports = {
          * @returns {boolean} 是否有注释
          */
         function hasComment(node) {
-            const sourceCode = context.getSourceCode();
+            const sourceCode = getSourceCode(context);
             const comments = sourceCode.getCommentsBefore(node);
             
             // 检查是否有任何类型的注释（行注释 // 或块注释 /** */）

package/lib/rules/vue-script-lines-limit.js

@@ -1,3 +1,5 @@
+const { getFilename, getSourceCode } = require('../utils/eslint-compat');
+
 module.exports = {
     meta: {
         type: 'problem',
@@ -29,7 +31,7 @@ module.exports = {
         const maxLines = options.maxLines || 300;
 
         // 只处理 .vue 文件
-        const filename = context.getFilename();
+        const filename = getFilename(context);
         if (!filename.endsWith('.vue')) {
             return {};
         }
@@ -37,7 +39,7 @@ module.exports = {
         return {
             Program(node) {
                 // 获取整个文件的源代码
-                const sourceCode = context.getSourceCode();
+                const sourceCode = getSourceCode(context);
                 const text = sourceCode.getText();
                 
                 // 使用正则表达式匹配 script 标签

package/lib/utils/eslint-compat.js

@@ -0,0 +1,46 @@
+/**
+ * ESLint 8 / 9 / 10 兼容工具
+ *
+ * 背景：
+ * - `context.sourceCode`、`context.filename` 属性自 ESLint v8.40.0 引入
+ * - `context.getSourceCode()`、`context.getFilename()` 方法在 ESLint v9 中废弃，
+ *   并在 ESLint v10.0.0 中被彻底移除
+ *
+ * 因此这里优先读取新属性，不存在时回退到旧方法，
+ * 使规则可以同时运行在 ESLint 8（含 8.0 ~ 8.39）、9、10 三个大版本上。
+ */
+
+/**
+ * 获取 SourceCode 实例（兼容 ESLint 8/9/10）
+ * @param {import('eslint').Rule.RuleContext} context 规则上下文
+ * @returns {import('eslint').SourceCode} SourceCode 实例
+ */
+function getSourceCode(context) {
+  if (context.sourceCode) {
+    return context.sourceCode
+  }
+  if (typeof context.getSourceCode === 'function') {
+    return context.getSourceCode()
+  }
+  throw new Error('[@foundbyte/eslint-plugin] 无法从规则上下文获取 SourceCode')
+}
+
+/**
+ * 获取当前被 lint 文件的文件名（兼容 ESLint 8/9/10）
+ * @param {import('eslint').Rule.RuleContext} context 规则上下文
+ * @returns {string} 文件名
+ */
+function getFilename(context) {
+  if (typeof context.filename === 'string') {
+    return context.filename
+  }
+  if (typeof context.getFilename === 'function') {
+    return context.getFilename()
+  }
+  return '<input>'
+}
+
+module.exports = {
+  getSourceCode,
+  getFilename,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foundbyte/eslint-plugin",
-  "version": "1.1.5-alpha.0",
+  "version": "1.1.5-alpha.2",
   "description": "ESLint plugin for enforcing code style rules including arrow function padding, Vue script lines limit, and TypeScript type comment requirements",
   "author": "",
   "license": "ISC",
@@ -18,13 +18,13 @@
   ],
   "main": "index.js",
   "types": "index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
   "publishConfig": {
     "access": "public"
   },
   "peerDependencies": {
-    "eslint": ">=8.0.0"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "eslint": "^8.0.0 || ^9.0.0 || ^10.0.0"
   }
-}
+}