eslint-plugin-crisp 1.5.12 → 1.6.0

package/rules/vue-pinia-action-single-parameter.js

@@ -0,0 +1,158 @@
+const MESSAGE_ID = "singlePayloadArgument";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require Pinia actions to accept at most one payload argument",
+      category: "Possible Errors",
+      recommended: true
+    },
+    schema: [],
+    messages: {
+      [MESSAGE_ID]: "Pinia actions must accept at most one payload argument. Wrap multiple values in an object."
+    }
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+    const defineStoreImports = collectDefineStoreImports(sourceCode.ast);
+
+    return {
+      CallExpression(node) {
+        if (!isImportedDefineStoreCall(node, sourceCode, defineStoreImports)) {
+          return;
+        }
+
+        const options = node.arguments[1];
+
+        if (!options || options.type !== "ObjectExpression") {
+          return;
+        }
+
+        const actions = findObjectProperty(options, "actions");
+
+        if (!actions || actions.value.type !== "ObjectExpression") {
+          return;
+        }
+
+        for (const property of actions.value.properties) {
+          const action = getActionFunction(property);
+
+          if (
+            action &&
+            (
+              action.params.length > 1 ||
+              action.params.some((parameter) => parameter.type === "RestElement")
+            )
+          ) {
+            context.report({
+              node: action,
+              messageId: MESSAGE_ID
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// Collects local bindings for named defineStore imports from Pinia
+function collectDefineStoreImports(program) {
+  const imports = new Map();
+
+  for (const node of program.body) {
+    if (node.type !== "ImportDeclaration" || node.source.value !== "pinia") {
+      continue;
+    }
+
+    for (const specifier of node.specifiers) {
+      if (
+        specifier.type === "ImportSpecifier" &&
+        getImportedName(specifier) === "defineStore"
+      ) {
+        imports.set(specifier.local.name, specifier);
+      }
+    }
+  }
+
+  return imports;
+}
+
+// Returns the imported name for JavaScript and TypeScript ESTree nodes
+function getImportedName(specifier) {
+  return specifier.imported.name || specifier.imported.value;
+}
+
+// Checks that a call resolves to the collected Pinia import, rather than a shadow
+function isImportedDefineStoreCall(node, sourceCode, defineStoreImports) {
+  if (
+    node.callee.type !== "Identifier" ||
+    !defineStoreImports.has(node.callee.name)
+  ) {
+    return false;
+  }
+
+  const expectedSpecifier = defineStoreImports.get(node.callee.name);
+  let scope = sourceCode.getScope(node);
+
+  while (scope) {
+    const variable = scope.variables.find(({ name }) => name === node.callee.name);
+
+    if (variable) {
+      return variable.defs.some((definition) => {
+        return (
+          definition.type === "ImportBinding" &&
+          definition.node === expectedSpecifier
+        );
+      });
+    }
+
+    scope = scope.upper;
+  }
+
+  return false;
+}
+
+// Finds a direct, statically named property in an object expression
+function findObjectProperty(object, name) {
+  return object.properties.find((property) => {
+    return (
+      property.type === "Property" &&
+      property.kind === "init" &&
+      getStaticPropertyName(property) === name
+    );
+  });
+}
+
+// Returns a property's static name, including quoted property names
+function getStaticPropertyName(property) {
+  if (!property.computed && property.key.type === "Identifier") {
+    return property.key.name;
+  }
+
+  if (property.key.type === "Literal") {
+    return property.key.value;
+  }
+
+  return null;
+}
+
+// Returns a directly declared action function
+function getActionFunction(property) {
+  if (
+    property.type !== "Property" ||
+    property.kind !== "init"
+  ) {
+    return null;
+  }
+
+  if (
+    property.value.type === "FunctionExpression" ||
+    property.value.type === "ArrowFunctionExpression"
+  ) {
+    return property.value;
+  }
+
+  return null;
+}

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/
+        }
+      ]
+    }
+  ]
+});