eslint-plugin-crisp 1.5.13 → 1.6.1

package/rules/vue-props-declaration-line-break.js

@@ -28,9 +28,14 @@ export default {
             fix(fixer) {
               const typeToken = sourceCode.getLastToken(typeProperty);
               const defaultToken = sourceCode.getFirstToken(defaultProperty);
-              const textBetween = sourceCode.text.slice(typeToken.range[1], defaultToken.range[0]);
-              const newTextBetween = textBetween.replace(/,?\s*/, ",\n\n");
-              return fixer.replaceTextRange([typeToken.range[1], defaultToken.range[0]], newTextBetween);
+              const typeLine = sourceCode.lines[typeProperty.loc.start.line - 1];
+              const leadingText = typeLine.slice(0, typeProperty.loc.start.column);
+              const indent = leadingText.trim() === "" ? leadingText : "";
+
+              return fixer.replaceTextRange(
+                [typeToken.range[1], defaultToken.range[0]],
+                `,\n\n${indent}`
+              );
             }
           });
         }

package/rules/vue-watch-handler.js

@@ -30,6 +30,29 @@ function hasValidSignature(handler) {
   });
 }
 
+function isDefineComponentCall(node) {
+  if (!node || node.type !== "CallExpression") {
+    return false;
+  }
+
+  return (
+    (node.callee.type === "Identifier" && node.callee.name === "defineComponent") ||
+    (
+      node.callee.type === "MemberExpression" &&
+      !node.callee.computed &&
+      node.callee.property.type === "Identifier" &&
+      node.callee.property.name === "defineComponent"
+    )
+  );
+}
+
+function isVueOptionsObject(node) {
+  return (
+    node.parent.type === "ExportDefaultDeclaration" ||
+    isDefineComponentCall(node.parent)
+  );
+}
+
 export default {
   meta: {
     type: "suggestion",
@@ -52,7 +75,17 @@ export default {
 
   create(context) {
     return {
-      'Property[key.name="watch"] > ObjectExpression'(node) {
+      "Property > ObjectExpression"(node) {
+        const watchProperty = node.parent;
+        const optionsObject = watchProperty.parent;
+
+        if (
+          getPropertyName(watchProperty) !== "watch" ||
+          !isVueOptionsObject(optionsObject)
+        ) {
+          return;
+        }
+
         node.properties.forEach((watcher) => {
           if (watcher.type !== "Property") {
             return;

package/tests/fixtures/vue-header-check/missing-script-style/TestComponent.vue

@@ -0,0 +1,19 @@
+
+
+<!-- **********************************************************************
+     TEMPLATE
+     ********************************************************************** -->
+
+<template>
+  <main>Partial headers</main>
+</template>
+
+<script setup>
+const ready = false;
+</script>
+
+<style scoped>
+main {
+  display: block;
+}
+</style>

package/tests/fixtures/vue-header-check/missing-template/TestComponent.vue

@@ -0,0 +1,3 @@
+<template>
+  <main>Missing header</main>
+</template>

package/tests/fixtures/vue-header-check/valid/TestComponent.vue

@@ -0,0 +1,27 @@
+<!-- **********************************************************************
+     TEMPLATE
+     ********************************************************************** -->
+
+<template>
+  <main>Ready</main>
+</template>
+
+
+<!-- **********************************************************************
+     SCRIPT
+     ********************************************************************** -->
+
+<script setup>
+const ready = true;
+</script>
+
+
+<!-- **********************************************************************
+     STYLE
+     ********************************************************************** -->
+
+<style scoped>
+main {
+  display: block;
+}
+</style>

package/tests/rule-tester.js

@@ -0,0 +1,78 @@
+import { RuleTester } from "eslint";
+import { describe, it } from "node:test";
+import vueParser from "vue-eslint-parser";
+
+RuleTester.describe = describe;
+RuleTester.it = it;
+RuleTester.itOnly = it.only;
+
+export default function createRuleTester({
+  languageOptions = {},
+
+  ...options
+} = {}) {
+  return new RuleTester({
+    ...options,
+
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+
+      ...languageOptions
+    }
+  });
+}
+
+export function createVueRuleTester(options = {}) {
+  return createRuleTester({
+    ...options,
+
+    languageOptions: {
+      ...options.languageOptions,
+
+      parser: vueParser
+    }
+  });
+}
+
+export function createPugRuleTester(options = {}) {
+  return createVueRuleTester({
+    ...options,
+
+    languageOptions: {
+      ...options.languageOptions,
+
+      parserOptions: {
+        ...options.languageOptions?.parserOptions,
+
+        templateTokenizer: {
+          pug: "vue-eslint-parser-template-tokenizer-pug"
+        }
+      }
+    }
+  });
+}
+
+export function withoutFixes(rule) {
+  const { fixable, ...meta } = rule.meta || {};
+
+  return {
+    ...rule,
+
+    meta,
+
+    create(context) {
+      const reportOnlyContext = Object.create(context);
+
+      Object.defineProperty(reportOnlyContext, "report", {
+        value(descriptor) {
+          const { fix, ...report } = descriptor;
+
+          context.report(report);
+        }
+      });
+
+      return rule.create(reportOnlyContext);
+    }
+  };
+}

package/tests/rules/align-comments.test.js

@@ -0,0 +1,25 @@
+import rule from "../../rules/align-comments.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("align-comments", rule, {
+  valid: [
+    "// A top-level value\nconst value = 1;",
+    "function example() {\n  // Return the value\n  return true;\n}",
+    "const previous = 1; // Keep this inline\nconst next = 2;",
+    "const callback = () => {\n  // Invoke the callback\n  callback();\n};"
+  ],
+
+  invalid: [
+    {
+      code: "function example() {\n// Misaligned\n  return true;\n}",
+      output: "function example() {\n  // Misaligned\n  return true;\n}",
+      errors: [
+        {
+          message: "Comment should be aligned with the next line."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/align-consecutive-class-assignements.test.js

@@ -0,0 +1,24 @@
+import rule from "../../rules/align-consecutive-class-assignements.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("align-consecutive-class-assignements", rule, {
+  valid: [
+    "class Example {\n  constructor() {\n    this.a    = 1;\n    this.long = 2;\n  }\n}",
+    "class Example {\n  constructor() {\n    this.a = 1;\n\n    this.long = 2;\n  }\n}",
+    "class Example {\n  method() {\n    this.a = 1;\n    this.long = 2;\n  }\n}"
+  ],
+
+  invalid: [
+    {
+      code: "class Example {\n  constructor() {\n    this.a = 1;\n    this.long = 2;\n  }\n}",
+      errors: [
+        {
+          message:
+            "Assignment of 'this.a' at line 3 column 12 should be aligned at column 15"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/align-one-var.test.js

@@ -0,0 +1,31 @@
+import rule from "../../rules/align-one-var.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("align-one-var", rule, {
+  valid: [
+    "const first = 1,\n      next  = 2;",
+    "const first = 1, next = 2;",
+    "let first,\n    next;"
+  ],
+
+  invalid: [
+    {
+      code: "const first = 1,\n       next = 2;",
+      errors: [
+        {
+          message: "Misaligned variable declaration."
+        }
+      ]
+    },
+    {
+      code: "const first = 1,\n      next = 2;",
+      errors: [
+        {
+          message: "Misaligned assignment operator."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/align-requires.test.js

@@ -0,0 +1,27 @@
+import rule from "../../rules/align-requires.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester({
+  languageOptions: {
+    sourceType: "commonjs"
+  }
+});
+
+ruleTester.run("align-requires", rule, {
+  valid: [
+    "const alpha = require(\"alpha\"),\n      beta = require(\"beta\");",
+    "const alpha = require(\"alpha\");\nconst beta = require(\"beta\");",
+    "const alpha = require(\"alpha\"), value = 1,\n        beta = require(\"beta\");"
+  ],
+
+  invalid: [
+    {
+      code: "const alpha = require(\"alpha\"),\n       beta = require(\"beta\");",
+      errors: [
+        {
+          message: "Misaligned require statement."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/arrow-block-newline.test.js

@@ -0,0 +1,23 @@
+import rule from "../../rules/arrow-block-newline.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("arrow-block-newline", rule, {
+  valid: [
+    "const callback = () => {};",
+    "const callback = () => {\n  return true;\n};",
+    "const callback = () => true;"
+  ],
+
+  invalid: [
+    {
+      code: "const callback = () => { return true;\n};",
+      errors: [
+        {
+          messageId: "expectedNewline"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/consecutive-line-comments.test.js

@@ -0,0 +1,27 @@
+import rule from "../../rules/consecutive-line-comments.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+const lines = (...values) => values.join("\n");
+
+ruleTester.run("consecutive-line-comments", rule, {
+  valid: [
+    lines("// First line \\", "//   second line", "const value = 1;"),
+    lines("// First comment", "// Second comment", "const value = 1;"),
+    lines("// eslint-disable-next-line no-console", "console.log(\"value\");"),
+    lines("// Intro \\", "// Important: separate block", "const value = 1;")
+  ],
+
+  invalid: [
+    {
+      code: lines("// First line \\", "// Second line", "const value = 1;"),
+      output: lines("// First line \\", "//   Second line", "const value = 1;"),
+      errors: [
+        {
+          messageId: "format"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/const.test.js

@@ -0,0 +1,52 @@
+import rule from "../../rules/const.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("const", rule, {
+  valid: [
+    "const MAXIMUM = 10;",
+    "const client = createClient();",
+    "const callback = () => true;",
+    "function example() {\n  const __CACHE = 1;\n}",
+    {
+      code: "function example() {\n  const cache = 1;\n}",
+      options: [
+        {
+          exceptions: ["cache"]
+        }
+      ]
+    },
+    "export const publicValue = 1;"
+  ],
+
+  invalid: [
+    {
+      code: "const value = 1;",
+      errors: [
+        {
+          message:
+            "Consts should be uppercase and defined at the top level or be replaced with let _variable (Crisp convention)."
+        }
+      ]
+    },
+    {
+      code: "function example() {\n  const _cache = 1;\n}",
+      output: "function example() {\n  let _cache = 1;\n}",
+      errors: [
+        {
+          message: "Local variables prefixed with \"_\" should use \"let\"."
+        }
+      ]
+    },
+    {
+      code: "function example() {\n  const value = 1;\n}",
+      errors: [
+        {
+          message:
+            "Consts should be uppercase and defined at the top level or be replaced with let _variable (Crisp convention)."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/constructor-variables.test.js

@@ -0,0 +1,52 @@
+import rule from "../../rules/constructor-variables.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("constructor-variables", rule, {
+  valid: [
+    "class Example {\n  constructor() {\n    this._value = 1;\n  }\n}",
+    {
+      code: "class Example {\n  constructor() {\n    this.value = 1;\n  }\n}",
+      options: [
+        {
+          variableExceptions: ["value"]
+        }
+      ]
+    },
+    {
+      code: "class Example {\n  constructor() {\n    this.value = 1;\n  }\n}",
+      filename: "/project/special-file.js",
+      options: [
+        {
+          filenameExceptions: ["special-file.js"]
+        }
+      ]
+    },
+    "class Example {\n  method() {\n    this.value = 1;\n  }\n}",
+    "class Example {\n  constructor() {\n    this[\"_value\"] = 1;\n  }\n}",
+    "class Example {\n  constructor() {\n    this[propertyName] = 1;\n  }\n}"
+  ],
+
+  invalid: [
+    {
+      code: "class Example {\n  constructor() {\n    this.value = 1;\n  }\n}",
+      filename: "/project/example.js",
+      errors: [
+        {
+          message:
+            "Class properties in the constructor should start with '_', except for specified exceptions"
+        }
+      ]
+    },
+    {
+      code: "class Example {\n  constructor() {\n    this[\"value\"] = 1;\n  }\n}",
+      errors: [
+        {
+          message:
+            "Class properties in the constructor should start with '_', except for specified exceptions"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/enforce-optional.test.js

@@ -0,0 +1,24 @@
+import rule from "../../rules/enforce-optional.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("enforce-optional", rule, {
+  valid: [
+    "const result = foo?.bar;",
+    "const result = foo && foo.bar !== null;",
+    "const keys = Object.keys(foo || {});",
+    "const filtered = (foo || []).filter(Boolean);"
+  ],
+
+  invalid: [
+    {
+      code: "const result = foo && foo.bar;",
+      errors: [
+        {
+          message: /Prefer using optional chaining rather than/
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/header-check.test.js

@@ -0,0 +1,69 @@
+import rule from "../../rules/header-check.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("header-check", rule, {
+  valid: [
+    {
+      code:
+        "/*\n * This file is part of Example\n *\n" +
+        " * Copyright (c) 2026 Crisp IM SAS\n" +
+        " * All rights belong to Crisp IM SAS\n */\nconst VALUE = 1;",
+      filename: "/project/example.js"
+    },
+    {
+      code: "/* Custom header */\nconst VALUE = 1;",
+      filename: "/project/example.ts",
+      options: [
+        {
+          patterns: [" Custom header "]
+        }
+      ]
+    },
+    {
+      code: "const VALUE = 1;",
+      filename: "/project/example.txt"
+    }
+  ],
+
+  invalid: [
+    {
+      code: "const VALUE = 1;",
+      filename: "/project/example.js",
+      errors: [
+        {
+          message: "File must start with the proper header."
+        }
+      ]
+    },
+    {
+      code: "/* Wrong header */\nconst VALUE = 1;",
+      filename: "/project/example.ts",
+      options: [
+        {
+          patterns: [" Expected header "]
+        }
+      ],
+      errors: [
+        {
+          message: "File must start with the proper header."
+        }
+      ]
+    },
+    {
+      code: "const VALUE = 1;",
+      filename: "/project/example.js",
+      options: [
+        {
+          patterns: ["["]
+        }
+      ],
+      errors: [
+        {
+          message: "File must start with the proper header."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/header-comments-check.test.js

@@ -0,0 +1,89 @@
+import rule from "../../rules/header-comments-check.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+const header = (name) => [
+  "/**************************************************************************",
+  ` * ${name}`,
+  " ***************************************************************************/"
+].join("\n");
+
+ruleTester.run("header-comments-check", rule, {
+  valid: [
+    {
+      filename: "/project/src/example.js",
+      code: `${header("IMPORTS")}\nimport value from "package";`
+    },
+    {
+      filename: "/project/src/example.ts",
+      code: `${header("CONSTANTS")}\nconst MAX_RETRIES = 3;\n\n${header("INSTANCES")}\nconst pattern = /value/;`
+    },
+    {
+      filename: "/project/src/example.js",
+      code:
+        `${header("TYPES")}\n/** @typedef {string} Identifier */\n\n` +
+        `${header("EXPORTS")}\nexport default {};`
+    },
+    {
+      filename: "/project/src/example.js",
+      code: "export default {};"
+    },
+    {
+      filename: "/project/src/example.js",
+      code: `${header("MIXIN TO MANAGE HANDOFF")}\nexport default {};`
+    },
+    {
+      filename: "/project/src/example.js",
+      code:
+        `${header("IMPORTS")}\nimport first from "first";\n` +
+        "import second from \"second\";"
+    },
+    {
+      filename: "/project/src/example.vue",
+      code: "import value from \"package\";\nconst MAX_RETRIES = 3;"
+    },
+    {
+      filename: "/project/src/example.js",
+      code: "function wrapper() {\n  const LOCAL_CONSTANT = 1;\n}"
+    }
+  ],
+
+  invalid: [
+    {
+      filename: "/project/src/example.js",
+      code: "import value from \"package\";",
+      errors: [
+        {
+          message: "Import group must be preceded by a 'IMPORTS' comment block"
+        }
+      ]
+    },
+    {
+      filename: "/project/src/example.ts",
+      code: "const MAX_RETRIES = 3;",
+      errors: [
+        {
+          message: "Variable group must be preceded by a 'CONSTANTS' comment block"
+        }
+      ]
+    },
+    {
+      filename: "/project/src/example.js",
+      code: "const patterns = [/first/, /second/];",
+      errors: [
+        {
+          message: "Regex group must be preceded by a 'INSTANCES' comment block"
+        }
+      ]
+    },
+    {
+      filename: "/project/src/example.js",
+      code: "/** @typedef {string} Identifier */\nconst value = 1;",
+      errors: [
+        {
+          message: "Type comments group must be preceded by a 'TYPES' comment block"
+        }
+      ]
+    }
+  ]
+});