eslint-plugin-crisp 1.0.20 → 1.0.22

package/index.js

@@ -10,9 +10,11 @@ module.exports = {
     "constructor-variables": require("./rules/constructor-variables"),
     "header-check": require("./rules/header-check"),
     "header-comments-check": require("./rules/header-comments-check"),
+    "jsdoc-align-params": require("./rules/jsdoc-align-params"),
+    "jsdoc-check-indentation": require("./rules/jsdoc-check-indentation"),
+    "jsdoc-check-optional-params": require("./rules/jsdoc-check-optional-params"),
     "jsdoc-enforce-access": require("./rules/jsdoc-enforce-access"),
     "jsdoc-enforce-classdesc": require("./rules/jsdoc-enforce-classdesc"),
-    "jsdoc-check-optional-params": require("./rules/jsdoc-check-optional-params"),
     "methods-naming": require("./rules/methods-naming"),
     "multiline-comment-end-backslash": require("./rules/multiline-comment-end-backslash"),
     "no-async": require("./rules/no-async"),
@@ -24,10 +26,12 @@ module.exports = {
     "regex-in-constructor": require("./rules/regex-in-constructor"),
     "ternary-parenthesis": require("./rules/ternary-parenthesis"),
     "multiline-comment-end-backslash": require("./rules/multiline-comment-end-backslash"),
-    "jsdocs-align-params": require("./rules/jsdocs-align-params"),
     "two-lines-between-class-members": require("./rules/two-lines-between-class-members"),
     "variable-names": require("./rules/variable-names"),
     "align-consecutive-class-assignements": require("./rules/align-consecutive-class-assignements"),
+    "vue-computed-order": require("./rules/vue-computed-order"),
+    "vue-emits-order": require("./rules/vue-emits-order"),
+    "vue-header-check": require("./rules/vue-header-check"),
     "vue-html-quotes": require("./rules/vue-html-quotes"),
     "vue-props-declaration-order": require("./rules/vue-props-declaration-order")
   }

package/package.json

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

package/recommended-vue.js

@@ -34,6 +34,7 @@ module.exports = {
     "no-trailing-spaces": "error",
     "no-tabs": "error",
     "object-curly-spacing": ["error", "always"],
+    "prefer-arrow-callback": "error",
     "semi": ["error", "always"],
     "semi-style": ["error", "last"],
     "semi-spacing": ["error", { "before": false, "after": true }],
@@ -47,6 +48,8 @@ module.exports = {
       { blankLine: "always", prev: "const", next: "*" },
       { blankLine: "any", prev: "const", next: "const" },
       { blankLine: "always", prev: "block-like", next: "*" },
+      { blankLine: "always", prev: "*", next: "break" },
+      { blankLine: "any", prev: "empty", next: "break" },
       { blankLine: "always", prev: "*", next: "block-like" },
       { blankLine: "any", prev: "case", next: "case" },
       { blankLine: "always", prev: "continue", next: "*" },
@@ -59,10 +62,29 @@ module.exports = {
       { "avoidEscape": true, "allowTemplateLiterals": true }
     ],
 
+    // Crisp JS rules
+    "crisp/header-check": "error",
+    "crisp/header-comments-check": "error",
+    "crisp/methods-naming": "error",
+    "crisp/multiline-comment-end-backslash": "error",
+    "crisp/no-async": "error",
+    "crisp/no-var-in-blocks": "error",
+    "crisp/no-useless-template-literals": "error",
+    "crisp/one-space-after-operator": ["error", { "checkColon": false }],
+    "crisp/regex-in-constructor": "error",
+    "crisp/ternary-parenthesis": "error",
+    "crisp/variable-names": "error",
+    "crisp/no-short-parameters": [
+      "error",
+
+      {
+        exceptions: ["_", "$", "x", "y"]
+      }
+    ],
+
     // JSDoc rules
     "jsdoc/require-param-description": "off",
     "jsdoc/newline-after-description": "off",
-    "jsdoc/check-indentation": "error",
     "jsdoc/require-jsdoc": [
       "error",
 
@@ -100,14 +122,17 @@ module.exports = {
     ],
 
     // Crisp JSDoc rules
+    "crisp/jsdoc-align-params": "error",
+    "crisp/jsdoc-check-indentation": "error",
     "crisp/jsdoc-check-optional-params": "error",
     "crisp/jsdoc-enforce-access": "error",
     "crisp/jsdoc-enforce-classdesc": "error",
-    "crisp/jsdocs-align-params": "error",
 
     // General Vue rules
-    "vue/no-v-html": "off",
     "vue/html-quotes": "off",
+    "vue/no-v-html": "off",
+    "vue/prefer-prop-type-boolean-first": "error",
+    "vue/prefer-true-attribute-shorthand": "error",
     "vue/attributes-order": [
       "error",
 
@@ -151,26 +176,10 @@ module.exports = {
       }
     ],
 
-    // Crisp JS rules
-    "crisp/header-check": "error",
-    "crisp/header-comments-check": "error",
-    "crisp/methods-naming": "error",
-    "crisp/multiline-comment-end-backslash": "error",
-    "crisp/no-async": "error",
-    "crisp/no-var-in-blocks": "error",
-    "crisp/no-useless-template-literals": "error",
-    "crisp/one-space-after-operator": ["error", { "checkColon": false }],
-    "crisp/regex-in-constructor": "error",
-    "crisp/variable-names": "error",
-    "crisp/no-short-parameters": [
-      "error",
-
-      {
-        exceptions: ["_", "$", "x", "y"]
-      }
-    ],
-
     // Crisp Vue rules
+    "crisp/vue-computed-order": "error",
+    "crisp/vue-emits-order": "error",
+    "crisp/vue-header-check": "error",
     "crisp/vue-html-quotes": "error",
     "crisp/vue-props-declaration-order": "error"
   },

package/recommended.js

@@ -46,6 +46,8 @@ module.exports = {
       { blankLine: "always", prev: "const", next: "*" },
       { blankLine: "any", prev: "const", next: "const" },
       { blankLine: "always", prev: "block-like", next: "*" },
+      { blankLine: "always", prev: "*", next: "break" },
+      { blankLine: "any", prev: "empty", next: "break" },
       { blankLine: "always", prev: "*", next: "block-like" },
       { blankLine: "any", prev: "case", next: "case" },
       { blankLine: "always", prev: "continue", next: "*" },
@@ -61,7 +63,6 @@ module.exports = {
     // JSDoc rules
     "jsdoc/require-param-description": "off",
     "jsdoc/newline-after-description": "off",
-    "jsdoc/check-indentation": "error",
     "jsdoc/require-jsdoc": [
       "error",
 
@@ -99,8 +100,9 @@ module.exports = {
     ],
 
     // Crisp JSDoc rules
+    "crisp/jsdoc-align-params": "error",
+    "crisp/jsdoc-check-indentation": "error",
     "crisp/jsdoc-enforce-classdesc": "error",
-    "crisp/jsdocs-align-params": "error",
 
     // Crisp JS rules
     "crisp/align-one-var": "error",

package/rules/{jsdocs-align-params.js → jsdoc-align-params.js}

@@ -2,7 +2,7 @@ module.exports = {
   meta: {
     type: 'layout',
     docs: {
-      description: 'enforce alignment for JSDocs',
+      description: 'enforce alignment for JSDoc',
       category: 'Stylistic Issues',
       recommended: false,
     },

package/rules/jsdoc-check-indentation.js

@@ -0,0 +1,95 @@
+// Based on https://github.com/gajus/eslint-plugin-jsdoc/blob/main/src/rules/checkIndentation.js
+
+const { default: iterateJsdoc } = require("eslint-plugin-jsdoc/dist/iterateJsdoc");
+
+/**
+ * @param {string} str
+ * @param {string[]} excludeTags
+ * @returns {string}
+ */
+const maskExcludedContent = (str, excludeTags) => {
+  const regContent = new RegExp(`([ \\t]+\\*)[ \\t]@(?:${excludeTags.join('|')})(?=[ \\n])([\\w|\\W]*?\\n)(?=[ \\t]*\\*(?:[ \\t]*@\\w+\\s|\\/))`, 'gu');
+
+  return str.replace(regContent, (_match, margin, code) => {
+    return (margin + '\n').repeat(code.match(/\n/gu).length);
+  });
+};
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+const maskCodeBlocks = (str) => {
+  const regContent = /([ \t]+\*)[ \t]```[^\n]*?([\w|\W]*?\n)(?=[ \t]*\*(?:[ \t]*(?:```|@\w+\s)|\/))/gu;
+
+  return str.replace(regContent, (_match, margin, code) => {
+    return (margin + '\n').repeat(code.match(/\n/gu).length);
+  });
+};
+
+const maskLineContinuations = (str) => {
+  // Match a line ending with a backslash (first capture group) and the \
+  //   line following it (second capture group)
+  const regContent = /(\*\s.*\\)\n(\s*\*\s+.+)/gu;
+
+  return str.replace(regContent, (_match, lineBeforeContinuation, lineAfterContinuation) => {
+    // Normalize the line after the continuation to remove any extra spaces \
+    //   after the '*'. The goal is to treat the continuation line as a \
+    //   direct extension of the previous line.
+    const normalizedLine = lineAfterContinuation.replace(/(\*\s)(.+)/, "$1$2");
+
+    // Return the combined line (previous line + continuation line)
+    return lineBeforeContinuation + normalizedLine;
+  });
+}
+
+module.exports = iterateJsdoc(({
+  sourceCode,
+  jsdocNode,
+  report,
+  context,
+}) => {
+  const options = context.options[0] || {};
+  const /** @type {{excludeTags: string[]}} */ {
+    excludeTags = [
+      'example',
+    ],
+  } = options;
+
+  const reg = /^(?:\/?\**|[ \t]*)\*[ \t]{2}/gmu;
+
+  const textWithoutCodeBlocks = maskCodeBlocks(sourceCode.getText(jsdocNode));
+  const textWithoutExcluded = excludeTags.length ? maskExcludedContent(textWithoutCodeBlocks, excludeTags) : textWithoutCodeBlocks;
+  const text = maskLineContinuations(textWithoutExcluded);
+
+  if (reg.test(text)) {
+    const lineBreaks = text.slice(0, reg.lastIndex).match(/\n/gu) || [];
+    report('There must be no indentation.', null, {
+      line: lineBreaks.length,
+    });
+  }
+}, {
+  iterateAllJsdocs: true,
+  meta: {
+    docs: {
+      description: 'Reports invalid padding inside JSDoc blocks.',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-indentation.md#repos-sticky-header',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          excludeTags: {
+            items: {
+              pattern: '^\\S+$',
+              type: 'string',
+            },
+            type: 'array',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'layout',
+  },
+});

package/rules/ternary-parenthesis.js

@@ -7,6 +7,7 @@ module.exports = {
       recommended: false,
     },
     schema: [], // no options
+    fixable: "code",
   },
   create(context) {
     return {
@@ -20,6 +21,13 @@ module.exports = {
             context.report({
               node,
               message: "The condition in ternary expressions with an operator should be wrapped in parentheses",
+              fix(fixer) {
+                const conditionText = sourceCode.getText(node.test);
+                return [
+                  fixer.insertTextBefore(node.test, "("),
+                  fixer.insertTextAfter(node.test, ")"),
+                ];
+              },
             });
           }
         }

package/rules/vue-computed-order.js

@@ -0,0 +1,40 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce computed properties alphabetical order",
+      category: "Stylistic Issues",
+      recommended: false
+    },
+    fixable: "code",
+    schema: []  // no options
+  },
+
+  create(context) {
+    return {
+      'ExportDefaultDeclaration Property[key.name="computed"]'(node) {
+        const properties = node.value.properties;
+
+        properties.slice(0, -1).forEach((property, index) => {
+          const nextProperty = properties[index + 1];
+          if (property.key.name > nextProperty.key.name) {
+            context.report({
+              node: nextProperty,
+              message: "Computed properties should be in alphabetical order.",
+              fix(fixer) {
+                const sourceCode = context.getSourceCode();
+                const propertyText = sourceCode.getText(property);
+                const nextPropertyText = sourceCode.getText(nextProperty);
+
+                return [
+                  fixer.replaceText(property, nextPropertyText),
+                  fixer.replaceText(nextProperty, propertyText)
+                ];
+              }
+            });
+          }
+        });
+      }
+    };
+  }
+};

package/rules/vue-emits-order.js

@@ -0,0 +1,40 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce emits alphabetical order",
+      category: "Stylistic Issues",
+      recommended: false
+    },
+    fixable: "code",
+    schema: []  // no options
+  },
+
+  create(context) {
+    return {
+      'ExportDefaultDeclaration Property[key.name="emits"]'(node) {
+        const elements = node.value.elements;
+
+        elements.slice(0, -1).forEach((element, index) => {
+          const nextElement = elements[index + 1];
+          if (element.value > nextElement.value) {
+            context.report({
+              node: nextElement,
+              message: "Emits should be in alphabetical order.",
+              fix(fixer) {
+                const sourceCode = context.getSourceCode();
+                const elementText = sourceCode.getText(element);
+                const nextElementText = sourceCode.getText(nextElement);
+
+                return [
+                  fixer.replaceText(element, nextElementText),
+                  fixer.replaceText(nextElement, elementText)
+                ];
+              }
+            });
+          }
+        });
+      }
+    };
+  }
+};

package/rules/vue-header-check.js

@@ -0,0 +1,48 @@
+const fs = require("fs");
+const path = require("path");
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce Vue section headers",
+      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);
+
+        if (fileExtension === ".vue") {
+          // Define the headers
+          const headers = ["TEMPLATE", "SCRIPT", "STYLE"];
+
+          // Define the Vue tags
+          const vueTags = ["template", "script", "style"];
+
+          // Check each tag individually
+          vueTags.forEach((tag, index) => {
+            const tagRegExp = new RegExp(`<${tag}`);
+            const headerRegExp = new RegExp(`<!--\\s*\\*{73}\\s*\\n\\s*${headers[index]}\\s*\\n\\s*\\*{73}\\s*-->\\s*\\n\\s*<${tag}`);
+
+            // If the tag exists without the corresponding header, report an error
+            if (tagRegExp.test(fileContent) && !headerRegExp.test(fileContent)) {
+              context.report({
+                node,
+                message: `The '<${tag}>' section must be preceded by the '${headers[index]}' header comment.`,
+              });
+            }
+          });
+        }
+      }
+    };
+  }
+};