eslint-plugin-crisp 1.4.3 → 1.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-crisp",
-  "version": "1.4.3",
+  "version": "1.4.6",
   "description": "Custom ESLint Rules for Crisp",
   "author": "Crisp IM SAS",
   "main": "index.js",

package/rules/header-comments-check.js

@@ -1,3 +1,60 @@
+const COMMENT_HEADER_FORMAT = (section) => {
+  return `/**************************************************************************\n * ${section.toUpperCase()}\n ***************************************************************************/`;
+};
+
+function isTypeComment(comment) {
+  if (comment.type !== "Block" || !comment.value.startsWith("*")) {
+    return false;
+  }
+
+  const content = comment.value;
+
+  return content.includes("@import") || content.includes("@typedef");
+}
+
+function isUppercaseConstant(declaration) {
+  return (
+    declaration &&
+    declaration.id &&
+    declaration.id.name &&
+    declaration.id.name === declaration.id.name.toUpperCase()
+  );
+}
+
+function isRegex(node) {
+  if (node.type !== "VariableDeclaration") {
+    return false;
+  }
+
+  for (const declaration of node.declarations) {
+    if (declaration.init.type === "Literal" && declaration.init.regex != null) {
+      return true;
+    }
+
+    if (
+      declaration.init.type === "NewExpression" &&
+      declaration.init.callee.name === "RegExp"
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Checks if a variable declaration is an import or require
+function isImportOrRequire(declaration) {
+  return (
+    declaration.init &&
+    declaration.init.type === "CallExpression" &&
+    (
+      (declaration.init.callee.name && declaration.init.callee.name === "require") ||
+      (declaration.init.callee.type && declaration.init.callee.type === "Import") ||
+      (declaration.init.callee.object && (declaration.init.callee.object || {}).type === "MetaProperty" && declaration.init.callee.object.meta.type === "Identifier" && declaration.init.callee.object.meta.name === "import")
+    )
+  );
+}
+
 export default {
   meta: {
     type: "suggestion",
@@ -6,13 +63,12 @@ export default {
       category: "Best Practices",
       recommended: false,
     },
-    fixable: null,  // This rule is not auto-fixable
+    fixable: null,
   },
 
   create(context) {
     const filename = context.getFilename();
 
-    // Only apply this rule to .js and .ts files
     if (!filename.endsWith(".js") && !filename.endsWith(".ts")) {
       return {};
     }
@@ -20,63 +76,37 @@ export default {
     let lastNode = null;
     let groupStart = null;
 
-    // Cache all block comments once at start (sorted by position for fast lookup)
     const sourceCode = context.sourceCode || context.getSourceCode();
     const allBlockComments = sourceCode.getAllComments()
       .filter(c => c.type === "Block")
       .sort((a, b) => a.range[0] - b.range[0]);
 
-    // This function formats the section string into a comment block header
-    const COMMENT_HEADER_FORMAT = (section) => {
-      return `/**************************************************************************\n * ${section.toUpperCase()}\n ***************************************************************************/`;
-    };
+    const typeComments = allBlockComments.filter(c => isTypeComment(c));
 
-    function isUppercaseConstant(declaration) {
-      return (
-        declaration &&
-        declaration.id &&
-        declaration.id.name &&
-        declaration.id.name === declaration.id.name.toUpperCase()
-      );
-    }
+    function checkTypeCommentsGroup() {
+      if (typeComments.length === 0) {
+        return;
+      }
 
-    function isRegex(node) {
-      // Check if the node is a variable declaration
-      if (node.type !== "VariableDeclaration") {
-        return false;
-      };
-
-      // For each of the declarations in the variable declaration
-      for (const declaration of node.declarations) {
-        // If the initializer is a regex literal, return true
-        if (declaration.init.type === "Literal" && declaration.init.regex != null) {
-          return true;
-        }
+      const firstTypeComment = typeComments[0];
+      const typeCommentStart = firstTypeComment.range[0];
+
+      let comment = null;
 
-        // If the initializer is a new RegExp expression, return true
-        if (
-          declaration.init.type === "NewExpression" &&
-          declaration.init.callee.name === "RegExp"
-        ) {
-          return true;
+      for (let i = allBlockComments.length - 1; i >= 0; i--) {
+        if (allBlockComments[i].range[1] < typeCommentStart) {
+          comment = allBlockComments[i];
+
+          break;
         }
       }
 
-      // If none of the declarations are regexes, return false
-      return false;
-    }
-
-    // Checks if a variable declaration is an import or require
-    function isImportOrRequire(declaration) {
-      return (
-        declaration.init &&
-        declaration.init.type === "CallExpression" &&
-        (
-          (declaration.init.callee.name && declaration.init.callee.name === "require") ||
-          (declaration.init.callee.type && declaration.init.callee.type === "Import") ||
-          (declaration.init.callee.object && (declaration.init.callee.object || {}).type === "MetaProperty" && declaration.init.callee.object.meta.type === "Identifier" && declaration.init.callee.object.meta.name === "import")
-        )
-      );
+      if (!comment || `/*${comment.value.trim()}*/` !== COMMENT_HEADER_FORMAT("TYPES")) {
+        context.report({
+          loc: firstTypeComment.loc,
+          message: "Type comments group must be preceded by a 'TYPES' comment block",
+        });
+      }
     }
 
     function checkGroup(nodeType, startNode) {
@@ -180,6 +210,9 @@ export default {
         if (groupStart) {
           checkGroup(lastNode.type, groupStart);
         }
+
+        // Check type comments group
+        checkTypeCommentsGroup();
       }
     };
   }

package/rules/import-group-comment.js

@@ -1,3 +1,51 @@
+function isTypeComment(comment) {
+  return (
+    comment.type === "Block" &&
+    comment.value.startsWith("*") &&
+    (comment.value.includes("@import") || comment.value.includes("@typedef"))
+  );
+}
+
+function isTypesGroupComment(comment) {
+  return comment.type === "Line" && comment.value.trim() === "TYPES";
+}
+
+function isGroupComment(comment) {
+  return (
+    comment.type === "Line" &&
+    (
+      comment.value.trim().startsWith("PROJECT:") ||
+      comment.value.trim().startsWith("NPM") ||
+      comment.value.trim().startsWith("TYPES")
+    )
+  );
+}
+
+function isIgnoreComment(comment) {
+  return (
+    comment.type === "Line" &&
+    comment.value.trim().startsWith("@ts-ignore")
+  );
+}
+
+function getDirectoryName(filePath) {
+  const pathParts = filePath.split("/");
+
+  return pathParts[pathParts.length - 2].toUpperCase();
+}
+
+function generateExpectedComment(group) {
+  if (group === "NPM") {
+    return group;
+  }
+
+  if (group === "SRC") {
+    group = "MAIN";
+  }
+
+  return `PROJECT: ${group}`;
+}
+
 export default {
   meta: {
     type: "suggestion",
@@ -21,18 +69,12 @@ export default {
     const customGroups = context.options[0] || {};  // Get custom groups from options
 
     // Pre-compile custom regexes once instead of on every import
-    const compiledCustomGroups = Object.entries(customGroups).map(
-      ([regexStr, group]) => [new RegExp(regexStr), group]
-    );
+    const compiledCustomGroups = Object.entries(customGroups).map(([regexStr, group]) => {
+      return [new RegExp(regexStr), group];
+    });
 
     let currentGroupComment = null;
 
-    // Extract the directory name from the file path
-    function getDirectoryName(filePath) {
-      const pathParts = filePath.split("/");
-      return pathParts[pathParts.length - 2].toUpperCase(); // Directory name
-    }
-
     function extractGroupFromPath(path, filePath) {
       // Check custom regexes first (using pre-compiled patterns)
       for (const [regex, group] of compiledCustomGroups) {
@@ -60,36 +102,6 @@ export default {
       return "NPM";
     }
 
-    function generateExpectedComment(group) {
-      if (group === "NPM") {
-        return group;
-      }
-
-      if (group === "SRC") {
-        group = "MAIN";
-      }
-
-      return `PROJECT: ${group}`;
-    }
-
-    function isGroupComment(comment) {
-      return (
-        comment.type === "Line" &&
-        (
-          comment.value.trim().startsWith("PROJECT:") ||
-          comment.value.trim().startsWith("NPM")
-        )
-      );
-    }
-
-    function isIgnoreComment(comment) {
-      // Skip some comments
-      return (
-        comment.type === "Line" &&
-        comment.value.trim().startsWith("@ts-ignore")
-      );
-    }
-
     function updateCurrentGroupComment(node) {
       const comments = context.getSourceCode().getCommentsBefore(node);
 
@@ -127,8 +139,49 @@ export default {
       }
     }
 
+    const sourceCode = context.sourceCode || context.getSourceCode();
+    const allComments = sourceCode.getAllComments();
+    const typeComments = allComments.filter(c => isTypeComment(c));
+
+    function checkTypeCommentsGroup() {
+      const filename = context.getFilename();
+
+      // Only check for // TYPES in .vue files (block header is checked by header-comments-check rule for .js/.ts)
+      if (!filename.endsWith(".vue")) {
+        return;
+      }
+
+      if (typeComments.length === 0) {
+        return;
+      }
+
+      const firstTypeComment = typeComments[0];
+      const typeCommentStart = firstTypeComment.range[0];
+
+      let comment = null;
+
+      for (let i = allComments.length - 1; i >= 0; i--) {
+        if (allComments[i].range[1] < typeCommentStart) {
+          comment = allComments[i];
+
+          break;
+        }
+      }
+
+      if (!comment || !isTypesGroupComment(comment)) {
+        context.report({
+          loc: firstTypeComment.loc,
+          message: "Type comments group must be preceded by a '// TYPES' comment",
+        });
+      }
+    }
+
     return {
       ImportDeclaration: checkImportGroup,
+
+      "Program:exit": () => {
+        checkTypeCommentsGroup();
+      }
     };
   }
 };