@foundbyte/eslint-plugin 1.0.0 → 1.0.2

package/index.js

@@ -1,7 +1,11 @@
 const arrowFunctionPaddingRule = require('./lib/rules/arrow-function-padding');
+const vueScriptLinesLimitRule = require('./lib/rules/vue-script-lines-limit');
+const typeCommentRequirementRule = require('./lib/rules/type-comment-requirement');
 
 module.exports = {
     rules: {
         'arrow-function-padding': arrowFunctionPaddingRule,
+        'vue-script-lines-limit': vueScriptLinesLimitRule,
+        'type-comment-requirement': typeCommentRequirementRule,
     },
 };

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

@@ -0,0 +1,152 @@
+module.exports = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '要求 TypeScript interface 和 type 定义中每 groupSize 个字段至少有 minCommentsPerGroup 个字段必须加注释',
+            category: 'Best Practices',
+            recommended: false,
+        },
+        fixable: null,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    groupSize: {
+                        type: 'number',
+                        minimum: 1,
+                        description: '每多少个字段为一组进行检查',
+                    },
+                    minCommentsPerGroup: {
+                        type: 'number',
+                        minimum: 0,
+                        description: '每组中至少有多少个字段必须加注释',
+                    },
+                    includeTypes: {
+                        type: 'boolean',
+                        description: '是否检查 type 定义',
+                        default: true,
+                    },
+                    includeInterfaces: {
+                        type: 'boolean',
+                        description: '是否检查 interface 定义',
+                        default: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            missingComments: '{{typeName}} 中的字段组（{{groupStart}} 到 {{groupEnd}}）需要至少 {{requiredCount}} 个字段有注释，当前只有 {{currentCount}} 个字段有注释',
+        },
+    },
+
+    create(context) {
+        const options = context.options[0] || {};
+        const groupSize = options.groupSize || 5; // 默认每5个字段为一组
+        const minCommentsPerGroup = options.minCommentsPerGroup || 1; // 默认每组至少1个字段有注释
+        const includeTypes = options.includeTypes !== false;
+        const includeInterfaces = options.includeInterfaces !== false;
+
+        /**
+         * 检查字段是否有注释
+         * @param {Object} node AST节点
+         * @returns {boolean} 是否有注释
+         */
+        function hasComment(node) {
+            const sourceCode = context.getSourceCode();
+            const comments = sourceCode.getCommentsBefore(node);
+            
+            // 检查是否有任何类型的注释（行注释 // 或块注释 /** */）
+            return comments.length > 0;
+        }
+
+        /**
+         * 检查字段组中的注释要求
+         * @param {Array} properties 字段数组
+         * @param {string} typeName 类型名称
+         * @param {string} parentPath 父级路径，用于嵌套类型
+         */
+        function checkCommentRequirement(properties, typeName, parentPath = '') {
+            if (properties.length === 0) return;
+
+            // 如果字段数量少于 groupSize，则不要求必须有注释
+            if (properties.length < groupSize) {
+                return;
+            }
+
+            // 计算总共有多少个字段组
+            const totalGroups = Math.ceil(properties.length / groupSize);
+            
+            // 计算总共需要多少个有注释的字段
+            const totalRequiredComments = totalGroups * minCommentsPerGroup;
+            
+            // 计算当前有注释的字段数量
+            const commentedFields = properties.filter(field => hasComment(field));
+            const currentCommentCount = commentedFields.length;
+            
+            // 如果当前有注释的字段数量不足
+            if (currentCommentCount < totalRequiredComments) {
+                const fullTypeName = parentPath ? `${typeName}${parentPath}` : typeName;
+                context.report({
+                    node: properties[0],
+                    messageId: 'missingComments',
+                    data: {
+                        typeName: fullTypeName,
+                        groupStart: 1,
+                        groupEnd: properties.length,
+                        requiredCount: totalRequiredComments,
+                        currentCount: currentCommentCount,
+                    },
+                });
+            }
+
+            // 递归检查嵌套的对象类型
+            properties.forEach((property, index) => {
+                // 检查是否是属性签名
+                if (property.type === 'TSPropertySignature' && property.typeAnnotation) {
+                    let typeAnnotation = property.typeAnnotation;
+                    
+                    // 处理 typeAnnotation 可能是 TSTypeAnnotation 的情况
+                    if (typeAnnotation.type === 'TSTypeAnnotation') {
+                        typeAnnotation = typeAnnotation.typeAnnotation;
+                    }
+                    
+                    // 检查是否是嵌套的对象类型
+                    if (typeAnnotation && typeAnnotation.type === 'TSTypeLiteral') {
+                        const nestedProperties = typeAnnotation.members || [];
+                        const propertyName = property.key.name || `[${index}]`;
+                        const nestedPath = parentPath ? `${parentPath}.${propertyName}` : `.${propertyName}`;
+                        
+                        checkCommentRequirement(nestedProperties, typeName, nestedPath);
+                    }
+                }
+            });
+        }
+
+        const visitors = {};
+
+        // 检查 TypeScript interface 定义
+        if (includeInterfaces) {
+            visitors.TSInterfaceDeclaration = function(node) {
+                const typeName = node.id.name;
+                const properties = node.body.body || [];
+                checkCommentRequirement(properties, `interface ${typeName}`);
+            };
+        }
+
+        // 检查 TypeScript type 定义
+        if (includeTypes) {
+            visitors.TSTypeAliasDeclaration = function(node) {
+                const typeName = node.id.name;
+                
+                // 检查是否是对象类型
+                if (node.typeAnnotation && node.typeAnnotation.type === 'TSTypeLiteral') {
+                    const properties = node.typeAnnotation.members || [];
+                    checkCommentRequirement(properties, `type ${typeName}`);
+                }
+            };
+        }
+
+        return visitors;
+    },
+};

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

@@ -0,0 +1,76 @@
+module.exports = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: '限制 Vue 文件 script 标签内的行数',
+            category: 'Best Practices',
+            recommended: false,
+        },
+        fixable: null,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    maxLines: {
+                        type: 'number',
+                        minimum: 1,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            exceedMaxLines: 'Vue 文件 script 标签内的代码行数不能超过 {{maxLines}} 行，当前有 {{currentLines}} 行',
+        },
+    },
+
+    create(context) {
+        const options = context.options[0] || {};
+        const maxLines = options.maxLines || 300;
+
+        // 只处理 .vue 文件
+        const filename = context.getFilename();
+        if (!filename.endsWith('.vue')) {
+            return {};
+        }
+
+        return {
+            Program(node) {
+                // 获取整个文件的源代码
+                const sourceCode = context.getSourceCode();
+                const text = sourceCode.getText();
+                
+                // 使用正则表达式匹配 script 标签
+                const scriptRegex = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+                let match;
+                
+                while ((match = scriptRegex.exec(text)) !== null) {
+                    const scriptContent = match[1];
+                    
+                    // 计算 script 内容中的行数
+                    const lines = scriptContent.split('\n').filter(line => line.trim() !== '');
+                    const lineCount = lines.length;
+                    
+                    if (lineCount > maxLines) {
+                        // 找到 script 标签在 AST 中的位置
+                        const scriptStartIndex = match.index;
+                        const scriptEndIndex = scriptStartIndex + match[0].length;
+                        
+                        // 在 script 标签的位置报告错误
+                        context.report({
+                            loc: {
+                                start: sourceCode.getLocFromIndex(scriptStartIndex),
+                                end: sourceCode.getLocFromIndex(scriptEndIndex),
+                            },
+                            messageId: 'exceedMaxLines',
+                            data: {
+                                maxLines,
+                                currentLines: lineCount,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@foundbyte/eslint-plugin",
-    "version": "1.0.0",
-    "description": "ESLint plugin for enforcing padding between arrow function declarations",
+    "version": "1.0.2",
+    "description": "ESLint plugin for enforcing code style rules including arrow function padding, Vue script lines limit, and TypeScript type comment requirements",
     "main": "index.js",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1"
@@ -10,7 +10,13 @@
         "eslint",
         "eslintplugin",
         "arrow-function",
-        "padding"
+        "padding",
+        "vue",
+        "script",
+        "lines-limit",
+        "typescript",
+        "type-comment",
+        "comment-requirement"
     ],
     "author": "",
     "license": "ISC",