eslint-plugin-crisp 1.0.2 → 1.0.3

package/index.js

@@ -1,22 +1,29 @@
 module.exports = {
   configs: {
-    recommended: require('./recommended'),
+    recommended: require("./recommended"),
+    "recommended-vue": require("./recommended-vue")
   },
   rules: {
-    "jsdoc-match-params": require("./rules/jsdoc-match-params"),
     "align-one-var": require("./rules/align-one-var"),
-    "no-trailing-spaces": require("./rules/no-trailing-spaces"),
-    "new-line-after-block": require("./rules/new-line-after-block"),
+    "align-requires": require("./rules/align-requires"),
+    "const": require("./rules/const"),
     "constructor-variables": require("./rules/constructor-variables"),
+    "header-check": require("./rules/header-check"),
+    "header-comments-check": require("./rules/header-comments-check"),
+    "jsdoc-enforce-classdesc": require("./rules/jsdoc-enforce-classdesc"),
     "methods-naming": require("./rules/methods-naming"),
-    "regex-in-constructor": require("./rules/regex-in-constructor"),
-    "one-space-after-operator": require("./rules/one-space-after-operator"),
+    "multiline-comment-end-backslash": require("./rules/multiline-comment-end-backslash"),
+    "new-line-after-block": require("./rules/new-line-after-block"),
     "no-async": require("./rules/no-async"),
-    "const": require("./rules/const"),
-    "two-lines-between-class-members": require("./rules/two-lines-between-class-members"),
-    "align-requires": require("./rules/align-requires"),
+    "no-trailing-spaces": require("./rules/no-trailing-spaces"),
+    "no-var-in-blocks": require("./rules/no-var-in-blocks"),
+    "no-space-in-optional-arguments": require("./rules/no-space-in-optional-arguments"),
+    "one-space-after-operator": require("./rules/one-space-after-operator"),
+    "regex-in-constructor": require("./rules/regex-in-constructor"),
     "ternary-parenthesis": require("./rules/ternary-parenthesis"),
-    "variable-names": require("./rules/variable-names"),
-    "multiline-comment-end-backslash": require("./rules/multiline-comment-end-backslash")
+    "multiline-comment-end-backslash": require("./rules/multiline-comment-end-backslash"),
+    "align-jsdocs-params": require("./rules/align-jsdocs-params"),
+    "two-lines-between-class-members": require("./rules/two-lines-between-class-members"),
+    "variable-names": require("./rules/variable-names")
   }
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-crisp",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Custom EsLint Rules for Crisp",
   "main": "index.js",
   "author": "Crisp IM SAS",
@@ -8,6 +8,6 @@
   "dependencies": {
     "doctrine": "3.0.0",
     "eslint": "8.45.0",
-    "eslint-plugin-jsdoc": "40.3.0"
+    "eslint-plugin-jsdoc": "43.0.7"
   }
 }

package/recommended-vue.js

@@ -0,0 +1,92 @@
+module.exports = {
+  env: {
+    es6: true,
+    node: true
+  },
+
+  plugins: [
+    "eslint-plugin-jsdoc"
+  ],
+
+  extends: [
+    "plugin:jsdoc/recommended"
+  ],
+
+  rules: {
+    // General JS rules
+    "no-eval": "error",
+    "no-console": "warn",
+    "no-debugger": "warn",
+    "no-unused-vars": "warn",
+
+    // JSDoc rules
+    "jsdoc/require-param-description": "off",
+    "jsdoc/check-indentation": "error",
+    "jsdoc/require-jsdoc": [
+      "error",
+
+      {
+        require: {
+          FunctionDeclaration: true,
+          MethodDefinition: true,
+          ClassDeclaration: true,
+          ArrowFunctionExpression: false,
+          FunctionExpression: false
+        }
+      }
+    ],
+    "jsdoc/sort-tags": [
+      "error",
+
+      {
+        tagSequence: [
+          {
+            tags: [
+              "private",
+              "protected",
+              "public",
+
+              "class",
+
+              "classdesc",
+
+              "param",
+              "return"
+            ]
+          }
+        ]
+      }
+    ],
+
+    // Crisp JSDoc rules
+    "crisp/jsdoc-enforce-classdesc": "error",
+    "crisp/align-jsdocs-params": "error",
+
+
+    // Crisp JS rules
+    "crisp/header-check": "error",
+    "crisp/header-comments-check": "error",
+    "crisp/methods-naming": "error",
+    "crisp/multiline-comment-end-backslash": "error",
+    "crisp/new-line-after-block": "error",
+    "crisp/no-async": "error",
+    "crisp/no-trailing-spaces": "error",
+    "crisp/one-space-after-operator": "error",
+    "crisp/regex-in-constructor": "error",
+    "crisp/variable-names": "error",
+
+    // Crisp Vue rules
+  },
+
+  settings: {
+    jsdoc: {
+      tagNamePreference: {
+        returns: "return"
+      },
+
+      preferredTypes: {
+        Function: "function"
+      }
+    }
+  }
+}

package/recommended.js

@@ -1,12 +1,35 @@
 module.exports = {
-  "env": {
-    "es6": true,
-    "node": true
+  env: {
+    es6: true,
+    node: true
   },
-  "plugins": [
-    "eslint-plugin-jsdoc"
+
+  settings: {
+    jsdoc: {
+      tagNamePreference: {
+        returns: "return"
+      },
+
+      preferredTypes: {
+        Function: "function"
+      }
+    }
+  },
+
+  plugins: [
+    "eslint-plugin-jsdoc",
+  ],
+
+  extends: [
+    "plugin:jsdoc/recommended"
   ],
-  "rules": {
+
+  rules: {
+    // General JS rules
+    "no-eval": "error",
+    "no-console": "warn",
+    "no-debugger": "warn",
+    "no-unused-vars": ["warn", { "argsIgnorePattern": "^request" }],
     "indent": "off",
     "linebreak-style": ["error", "unix"],
     "quotes": ["error", "double", { "avoidEscape": true, "allowTemplateLiterals": true }],
@@ -14,13 +37,38 @@ module.exports = {
     "max-len": ["error", 80],
     "comma-dangle": ["error", "never"],
     "arrow-parens": ["error", "always"],
-    "crisp/align-one-var": ["error"],
+
+    // Crisp JSDoc rules
+    "crisp/jsdoc-enforce-classdesc": "error",
+    "crisp/align-jsdocs-params": "error",
+
+    // JSDoc rules
+    "jsdoc/require-param-description": "off",
+    "jsdoc/newline-after-description": "off",
+    "jsdoc/require-jsdoc": [
+      "error",
+
+      {
+        require: {
+          "FunctionDeclaration": true,
+          "MethodDefinition": true,
+          "ClassDeclaration": true,
+          "ArrowFunctionExpression": false,
+          "FunctionExpression": false
+        }
+      }
+    ],
+
+    // Crisp rules
+    "crisp/align-one-var": "error",
     "crisp/multiline-comment-end-backslash": "error",
     "crisp/const": "error",
-    "crisp/regex-in-constructor": ["error"],
+    "crisp/regex-in-constructor": "error",
     "crisp/align-requires": "error",
     "crisp/two-lines-between-class-members": "error",
     "crisp/no-async": "error",
+    "crisp/no-var-in-blocks": "error",
+    "crisp/no-space-in-optional-arguments": "error",
     "crisp/methods-naming": "error",
     "crisp/new-line-after-block": "error",
     "crisp/one-space-after-operator": "error",
@@ -29,20 +77,9 @@ module.exports = {
     "crisp/variable-names": ["error", {
       "variableExceptions": ["fn"]
     }],
-    "crisp/jsdoc-match-params": ["error", { "exceptions": ["constructor"] }],
-
     "crisp/constructor-variables": ["error", {
       "filenameExceptions": ["app.js"],
       "variableExceptions": ["client"]
-    }],
-    "jsdoc/require-jsdoc": ["error", {
-      "require": {
-        "FunctionDeclaration": true,
-        "MethodDefinition": true,
-        "ClassDeclaration": true,
-        "ArrowFunctionExpression": false,
-        "FunctionExpression": false
-      }
     }]
   }
 }

package/rules/align-jsdocs-params.js

@@ -0,0 +1,78 @@
+module.exports = {
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'enforce alignment for JSDocs',
+      category: 'Stylistic Issues',
+      recommended: false,
+    },
+    fixable: 'whitespace',
+  },
+  create: function(context) {
+    return {
+      Program: function(node) {
+        const comments = context.getSourceCode().getAllComments(node);
+
+        comments
+          .filter(comment => comment.type === 'Block' && comment.value.startsWith('*'))
+          .forEach(jsdocComment => {
+            const lines = jsdocComment.value.split('\n');
+            let bracePos = -1, descPos = -1;
+            let lineNum = jsdocComment.loc.start.line;
+
+            for (const line of lines) {
+              lineNum++;
+              const paramMatch = line.match(/@param\s*{(\S*)}[\s\t]+(\S+)\s*(.*)/);
+              const returnMatch = line.match(/@return\s*{(\S*)}\s*(.*)/);
+
+              let match = null;
+
+              if (paramMatch) {
+                match = paramMatch;
+              } else if (returnMatch) {
+                match = returnMatch;
+              }
+
+              if (match) {
+                const newBracePos = match.index + match[0].indexOf('{');
+                let descStart = match[0].substring(match[0].lastIndexOf('}') + 1).search(/\S/);
+
+                // If description is undefined, skip the description alignment check
+                if (match[match.length - 1] === 'undefined') {
+                  descStart = -1;
+                }
+
+                if (descStart !== -1) {
+                  const newDescPos = match.index + match[0].lastIndexOf('}') + 1 + descStart + 1; // +1 for ESLint column index
+
+                  if (descPos === -1) {
+                    descPos = newDescPos;
+                  } else if (descPos !== newDescPos) {
+                    context.report({
+                      node: jsdocComment,
+                      message: `In JSDoc at line ${lineNum}, the description is misaligned. Found at column ${newDescPos}, but expected column ${descPos}.`,
+                      loc: {
+                        start: { line: lineNum, column: newDescPos },
+                      },
+                    });
+                  }
+                }
+
+                if (bracePos === -1) {
+                  bracePos = newBracePos;
+                } else if (bracePos !== newBracePos) {
+                  context.report({
+                    node: jsdocComment,
+                    message: `In JSDoc at line ${lineNum}, the type brace is misaligned. Found at column ${newBracePos + 1}, but expected column ${bracePos + 1}.`,
+                    loc: {
+                      start: { line: lineNum, column: newBracePos + 1 },
+                    },
+                  });
+                }
+              }
+            }
+          });
+      },
+    };
+  },
+};

package/rules/header-check.js

@@ -0,0 +1,51 @@
+const fs = require("fs");
+const path = require("path");
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce file header",
+      category: "Best Practices",
+      recommended: false,
+    },
+    fixable: null,  // This rule is not auto-fixable
+  },
+
+  create(context) {
+    return {
+      Program(node) {
+        const fileName = context.getFilename();
+        const fileContent = fs.readFileSync(path.resolve(fileName), "utf8");
+
+        // Determine the file extension
+        const fileExtension = path.extname(fileName);
+
+        // Base header comment pattern
+        let basePattern = "\n \\* This file is part of .+\\n \\*\\n \\* Copyright \\(c\\) \\d{4} Crisp IM SAS\\n \\* All rights belong to Crisp IM SAS\\n ";
+
+        let headerStart, headerEnd;
+
+        // Set the headerFormat RegExp according to the file type
+        if (fileExtension === ".vue") {
+          headerStart = "<!--";
+          headerEnd = "-->";
+        } else if (fileExtension === ".js") {
+          headerStart = "\/\\*";
+          headerEnd = "\\*\/";
+        }
+
+        // Construct the final headerFormat RegExp
+        const headerFormat = headerStart && headerEnd ? new RegExp("^" + headerStart + basePattern + headerEnd) : null;
+
+        // Only check the header format if it's a .vue or .js file
+        if (headerFormat && !headerFormat.test(fileContent)) {
+          context.report({
+            node,
+            message: "File must start with the proper header.",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/header-comments-check.js

@@ -0,0 +1,117 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce file header comments",
+      category: "Best Practices",
+      recommended: false,
+    },
+    fixable: null,  // This rule is not auto-fixable
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Only apply this rule to .js files
+    if (!filename.endsWith(".js")) {
+      return {};
+    }
+
+    let lastNodeType = null;
+    let groupStart = null;
+
+    // This function formats the section string into a comment block header
+    const COMMENT_HEADER_FORMAT = (section) => {
+      return `/**************************************************************************\n * ${section.toUpperCase()}\n ***************************************************************************/`;
+    };
+
+    function checkGroup(nodeType, startNode) {
+      // If a variable is not declared at the top level, don't enforce the comment
+      if (nodeType === "VariableDeclaration" && startNode.parent.type !== "Program") {
+        return;
+      }
+
+      // Find the nearest Block Comment before the startNode
+      const tokens = context.getSourceCode().getTokensBefore(startNode, {includeComments: true});
+      const comment = tokens.reverse().find(token => token.type === "Block");
+
+      // Different types of nodes require different comment blocks
+      switch (nodeType) {
+        case "ImportDeclaration": {
+          if (!comment || `/*${comment.value.trim()}*/` !== COMMENT_HEADER_FORMAT("IMPORTS")) {
+            context.report({
+              node: startNode,
+              message: "Import group must be preceded by a 'IMPORTS' comment block",
+            });
+          }
+
+          break;
+        }
+
+        case "VariableDeclaration": {
+          if (!comment || `/*${comment.value.trim()}*/` !== COMMENT_HEADER_FORMAT("CONSTANTS")) {
+            context.report({
+              node: startNode,
+              message: "Variable group must be preceded by a 'CONSTANTS' comment block",
+            });
+          }
+
+          if (startNode.declarations.some(d => d.init && d.init.regex)) {
+            if (!comment || `/*${comment.value.trim()}*/` !== COMMENT_HEADER_FORMAT("INSTANCES")) {
+              context.report({
+                node: startNode,
+                message: "Regex group must be preceded by a 'INSTANCES' comment block",
+              });
+            }
+          }
+
+          break;
+        }
+
+        case "NewExpression": {
+          if (!comment || `/*${comment.value.trim()}*/` !== COMMENT_HEADER_FORMAT("INSTANCES")) {
+            context.report({
+              node: startNode,
+              message: "Regex group must be preceded by a 'INSTANCES' comment block",
+            });
+          }
+
+          break;
+        }
+
+        case "ExportDefaultDeclaration": {
+          // Only enforce the 'EXPORTS' comment block if it's the last statement in the file
+          if (startNode !== context.getSourceCode().ast.body.slice(-1)[0] && (!comment || `/*${comment.value.trim()}*/` !== COMMENT_HEADER_FORMAT("EXPORTS"))) {
+            context.report({
+              node: startNode,
+              message: "Export group must be preceded by a 'EXPORTS' comment block",
+            });
+          }
+
+          break;
+        }
+      }
+    }
+
+    return {
+      ":statement": (node) => {
+        const nodeType = node.type;
+        // If the type of node has changed since last time, check the group starting with the last node
+        if (nodeType !== lastNodeType) {
+          if (groupStart) {
+            checkGroup(lastNodeType, groupStart);
+          }
+          groupStart = node;
+        }
+        lastNodeType = nodeType;
+      },
+
+      "Program:exit": () => {
+        // When the program exits, check the group starting with the last node
+        if (groupStart) {
+          checkGroup(lastNodeType, groupStart);
+        }
+      }
+    };
+  }
+};

package/rules/jsdoc-enforce-classdesc.js

@@ -0,0 +1,36 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce @classdesc in JSDoc class headers",
+      category: "Best Practices",
+      recommended: true,
+    }
+  },
+
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        const jsdoc = context.getSourceCode().getJSDocComment(node);
+
+        if (jsdoc) {
+          const hasClassdesc = /@classdesc/.test(jsdoc.value);
+          if (!hasClassdesc) {
+            context.report({
+              node,
+              message: "JSDoc class header should include @classdesc"
+            });
+          } else {
+            const hasNonEmptyDescription = /@classdesc\s+[^*\s]/.test(jsdoc.value);
+            if (!hasNonEmptyDescription) {
+              context.report({
+                node,
+                message: "The @classdesc tag in JSDoc class header should have a non-empty description",
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};

package/rules/methods-naming.js

@@ -1,5 +1,3 @@
-// File: eslint-plugin-custom/private-public-methods.js
-
 module.exports = {
   meta: {
     type: "problem",
@@ -16,7 +14,7 @@ module.exports = {
       MethodDefinition: function(node) {
         const commentsBefore = context.getCommentsBefore(node);
 
-        const jsDocComment = commentsBefore.find(comment => 
+        const jsDocComment = commentsBefore.find(comment =>
           comment.type === "Block" && comment.value.startsWith("*")
         );
 

package/rules/multiline-comment-end-backslash.js

@@ -1,4 +1,3 @@
-// file: eslint-plugin-crisp/lib/rules/multiline-comment-end-backslash.js
 module.exports = {
   meta: {
     type: "layout",

package/rules/no-space-in-optional-arguments.js

@@ -0,0 +1,21 @@
+module.exports = {
+  create: function(context) {
+    return {
+      'FunctionDeclaration, FunctionExpression, ArrowFunctionExpression, MethodDefinition': function(node) {
+        (node.params || []).forEach(param => {
+          if (param.type === 'AssignmentPattern') {
+            const sourceCode = context.getSourceCode();
+            const operatorToken = sourceCode.getFirstTokenBetween(param.left, param.right, token => token.value === '=');
+
+            if (sourceCode.getTokenBefore(operatorToken).end !== operatorToken.start || sourceCode.getTokenAfter(operatorToken).start !== operatorToken.end) {
+              context.report({
+                node,
+                message: 'There should be no space before or after = in optional parameters'
+              });
+            }
+          }
+        });
+      }
+    };
+  }
+};

package/rules/no-trailing-spaces.js

@@ -1,4 +1,3 @@
-// file: eslint-plugin-crisp/lib/rules/no-trailing-spaces.js
 module.exports = {
   meta: {
     type: "layout",

package/rules/no-var-in-blocks.js

@@ -0,0 +1,25 @@
+module.exports = {
+  create: function (context) {
+    return {
+      'FunctionDeclaration VariableDeclaration[kind="var"], FunctionExpression VariableDeclaration[kind="var"], ArrowFunctionExpression VariableDeclaration[kind="var"], MethodDefinition VariableDeclaration[kind="var"], ClassDeclaration VariableDeclaration[kind="var"]': function (node) {
+        var isRequire = node.declarations.some(function (declaration) {
+          if (declaration.init) {
+            if (declaration.init.type === 'CallExpression' && declaration.init.callee.name === 'require') {
+              return true;
+            }
+            if (declaration.init.type === 'MemberExpression') {
+              return declaration.init.object.type === 'CallExpression' && declaration.init.object.callee.name === 'require';
+            }
+          }
+          return false;
+        });
+        if (!isRequire) {
+          context.report({
+            node: node,
+            message: "Unexpected 'var' declaration inside function, method, or class block."
+          });
+        }
+      }
+    }
+  }
+}

package/rules/regex-in-constructor.js

@@ -1,4 +1,3 @@
-// file: eslint-plugin-crisp/lib/rules/regex-in-constructor.js
 module.exports = {
   meta: {
     type: "suggestion",
@@ -24,5 +23,3 @@ module.exports = {
     };
   },
 };
-
-

package/rules/two-lines-between-class-members.js

@@ -1,4 +1,3 @@
-// file: eslint-plugin-crisp/lib/rules/two-lines-between-class-members.js
 module.exports = {
   meta: {
     type: "layout",

package/rules/variable-names.js

@@ -4,53 +4,132 @@ module.exports = {
     docs: {
       description: "enforce that variables defined within a method start with '_', except for parameters",
       category: "Stylistic Issues",
-      recommended: false,
+      recommended: false
     },
+
     schema: [{
       type: "object",
       properties: {
         variableExceptions: {
           type: "array",
           items: { type: "string" },
-          uniqueItems: true,
+          uniqueItems: true
         }
       },
-      additionalProperties: false,
-    }], // options schema updated
+      additionalProperties: false
+    }]
   },
+
   create(context) {
     const options = context.options[0] || {};
     const variableExceptions = options.variableExceptions || [];
 
-    function checkDeclaration(node, body) {
-      body.body.forEach((statement) => {
-        if (statement.type === "VariableDeclaration") {
-          statement.declarations.forEach((declaration) => {
+    function checkDeclaration(node) {
+      if (!node) {
+        return;
+      }
+
+      switch(node.type) {
+        // In case of a variable declaration, it checks if the variable name \
+        //   starts with "_" or is an exception
+        case "VariableDeclaration": {
+          node.declarations.forEach((declaration) => {
             if (declaration.id.name && !declaration.id.name.startsWith("_") && !variableExceptions.includes(declaration.id.name)) {
               context.report({
                 node: declaration,
-                message: `Variables defined within a method should start with '_' ({${declaration.id.name}})`,
+                message: `Variables defined within a method should start with "_" ({${declaration.id.name}})`,
               });
             }
           });
+
+          break;
+        }
+
+        // BlockStatement and Program nodes contain lists of statements \
+        //   (node.body), so we check each statement
+        case "BlockStatement":
+        case "Program": {
+          node.body.forEach(checkDeclaration);
+
+          break;
+        }
+
+        // IfStatement nodes have a consequent (then), and an \
+        //   optional alternate (else) to be checked
+        case "IfStatement": {
+          checkDeclaration(node.consequent);
+
+          if (node.alternate) {
+            checkDeclaration(node.alternate);
+          }
+
+          break;
+        }
+
+        // Loops nodes contain a body with statements to be checked
+        case "ForStatement":
+        case "WhileStatement":
+        case "DoWhileStatement":
+        case "ForInStatement":
+        case "ForOfStatement": {
+          if (node.body) {
+            checkDeclaration(node.body);
+          }
+
+          // Check the loop condition itself
+          checkDeclaration(node.left);
+
+          break;
         }
-      });
+
+        // SwitchStatement nodes contain an array of SwitchCase nodes that \
+        //   represent each case in the switch statement
+        case "SwitchStatement": {
+          node.cases.forEach(checkDeclaration);
+
+          break;
+        }
+
+        // SwitchCase nodes contain a consequent which is an array of \
+        //   Statements to be checked
+        case "SwitchCase": {
+          node.consequent.forEach(checkDeclaration);
+
+          break;
+        }
+
+        default: {
+          break;
+        }
+      }
     }
 
     return {
+      // For each property in an object, if it's a function / arrow function, \
+      //   check its body (usefull for Vue.js components, in which methods and \
+      //   computed are defined as properties of a parent object)
+      Property(node) {
+        if (node.value.type === "FunctionExpression" ||
+            node.value.type === "ArrowFunctionExpression") {
+          checkDeclaration(node);
+        }
+      },
+
       MethodDefinition(node) {
-        checkDeclaration(node, node.value.body);
+        checkDeclaration(node.value.body);
       },
+
       ArrowFunctionExpression(node) {
         if (node.body.type === "BlockStatement") {
-          checkDeclaration(node, node.body);
+          checkDeclaration(node.body);
         }
       },
+
       FunctionExpression(node) {
         if (node.body.type === "BlockStatement") {
-          checkDeclaration(node, node.body);
+          checkDeclaration(node.body);
         }
-      },
+      }
     };
-  },
+  }
 };

package/rules/jsdoc-match-params.js

@@ -1,56 +0,0 @@
-const doctrine = require("doctrine");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "enforce JSDoc and function parameter names match",
-      category: "Possible Errors",
-      recommended: true,
-    },
-  },
-
-  create(context) {
-    const sourceCode = context.getSourceCode();
-
-    function getJSDocComment(node) {
-      const commentsBefore = sourceCode.getCommentsBefore(node);
-
-      const jsDocComment = commentsBefore.find(comment =>
-        comment.type === "Block" && comment.value.startsWith("*")
-      );
-
-      if (jsDocComment) {
-        const parsed = doctrine.parse(jsDocComment.value, { unwrap: true });
-        const jsDocParams = parsed.tags.filter(tag => tag.title === "param").map(tag => tag.name);
-        return jsDocParams;
-      }
-
-      return null;
-    }
-
-    function checkParameters(node) {
-      const jsDocParams = getJSDocComment(node);
-
-      if (!jsDocParams) {
-        return;
-      }
-
-      const funcParams = node.value.params.map(param => param.type === "Identifier" ? param.name : param.left.name);
-
-      for (let i = 0; i < jsDocParams.length; i++) {
-        if (jsDocParams[i] !== funcParams[i]) {
-          context.report({
-            node: node,
-            message: `JSDoc @param name does not match function parameter name. Expected '${funcParams[i]}' but got '${jsDocParams[i]}'`
-          });
-        }
-      }
-    }
-
-    return {
-      FunctionDeclaration: checkParameters,
-      MethodDefinition: checkParameters,
-    };
-  },
-};