eslint-plugin-effector 0.12.0 → 0.14.0

package/index.js

@@ -5,6 +5,7 @@ module.exports = {
     "no-getState": require("./rules/no-getState/no-getState"),
     "no-unnecessary-duplication": require("./rules/no-unnecessary-duplication/no-unnecessary-duplication"),
     "prefer-sample-over-forward-with-mapping": require("./rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping"),
+    "no-duplicate-clock-or-source-array-values": require("./rules/no-duplicate-clock-or-source-array-values/no-duplicate-clock-or-source-array-values"),
     "no-useless-methods": require("./rules/no-useless-methods/no-useless-methods"),
     "no-ambiguity-target": require("./rules/no-ambiguity-target/no-ambiguity-target"),
     "no-watch": require("./rules/no-watch/no-watch"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Enforcing best practices for Effector",
   "keywords": [
     "eslint",
@@ -17,10 +17,10 @@
     "access": "public"
   },
   "engines": {
-    "node": "^16 || ^17 || ^18 || ^19 || ^20"
+    "node": "^16 || ^17 || ^18 || ^19 || ^20 || ^21"
   },
   "peerDependencies": {
-    "effector": "*",
+    "effector": "^23",
     "eslint": "7 || 8"
   },
   "dependencies": {

package/rules/enforce-store-naming-convention/enforce-store-naming-convention.js

@@ -94,7 +94,7 @@ module.exports = {
           }
 
           const parentNode = traverseParentByType(node, "VariableDeclarator", {
-            stopOnTypes: ["Program", "BlockStatement"],
+            stopOnTypes: ["Program", "BlockStatement", "Property"],
           });
 
           const resultSavedInVariable =
@@ -153,7 +153,7 @@ module.exports = {
           STORE_IN_DOMAIN_CREATION_METHODS.includes(node.callee?.property?.name)
         ) {
           const parentNode = traverseParentByType(node, "VariableDeclarator", {
-            stopOnTypes: ["Program", "BlockStatement"],
+            stopOnTypes: ["Program", "BlockStatement", "Property"],
           });
 
           const resultSavedInVariable =

package/rules/no-duplicate-clock-or-source-array-values/no-duplicate-clock-or-source-array-values.js

@@ -0,0 +1,120 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
+const {} = require("../../utils/traverse-nested-object-node");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    hasSuggestions: true,
+    docs: {
+      description: "Forbids unit duplicates on `source` and `clock``",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("no-duplicate-clock-or-source-array-values"),
+    },
+    messages: {
+      duplicatesInClock: "Clock contains duplicate units - {{ memberPath }}.",
+      duplicatesInSource: "Source contains duplicate units - {{ memberPath }}.",
+      removeDuplicate: "Remove duplicate {{ memberPath }}.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
+      },
+      CallExpression(node) {
+        if (
+          method.isNot(["sample", "guard"], {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
+
+        const properties = getSourceOrClockProperties(node.arguments[0]);
+
+        properties.forEach(({ key, value }) => {
+          const propType = key.name;
+          const elements = value.elements;
+
+          const usedUnits = new Set();
+
+          for (const node of elements) {
+            const memberPath = createMemberExpressionPath(node);
+
+            if (usedUnits.has(memberPath)) {
+              const messageId = getMessageIdByPropType(propType);
+
+              context.report({
+                node,
+                messageId,
+                data: {
+                  memberPath,
+                },
+                suggest: [
+                  {
+                    messageId: "removeDuplicate",
+                    data: { memberPath },
+                    fix(fixer) {
+                      return fixer.remove(node);
+                    },
+                  },
+                ],
+              });
+
+              return;
+            }
+
+            usedUnits.add(memberPath);
+          }
+        });
+      },
+    };
+  },
+};
+
+function createMemberExpressionPath(node, chain = "") {
+  const compactStrings = (...args) => args.filter(Boolean).join(".");
+
+  if (node.type === "MemberExpression") {
+    const propertyName = node.property.name;
+
+    const updatedChain = compactStrings(propertyName, chain);
+
+    return createMemberExpressionPath(node.object, updatedChain);
+  }
+
+  chain = compactStrings(node.name, chain);
+
+  // remove last dot
+  return chain.slice(0, -1);
+}
+
+function getSourceOrClockProperties(node) {
+  if (node.type !== "ObjectExpression") return [];
+
+  const allowedProps = ["clock", "source"];
+
+  const isClockOrSourceArray = (prop) => {
+    return (
+      allowedProps.includes(prop.key.name) &&
+      prop.value.type === "ArrayExpression"
+    );
+  };
+
+  return node.properties.filter(isClockOrSourceArray);
+}
+
+function getMessageIdByPropType(propType) {
+  return propType === "clock" ? "duplicatesInClock" : "duplicatesInSource";
+}

package/utils/node-type-is.js

@@ -1,4 +1,4 @@
-const { ESLintUtils } = require('@typescript-eslint/utils');
+const { ESLintUtils } = require("@typescript-eslint/utils");
 
 function hasType({ node, possibleTypes, context, from }) {
   try {
@@ -24,13 +24,27 @@ const nodeTypeIs = {
   effect: (opts) =>
     hasType({ ...opts, possibleTypes: ["Effect"], from: "effector" }),
   store: (opts) =>
-    hasType({ ...opts, possibleTypes: ["Store"], from: "effector" }),
+    hasType({
+      ...opts,
+      possibleTypes: ["Store", "StoreWritable"],
+      from: "effector",
+    }),
   event: (opts) =>
-    hasType({ ...opts, possibleTypes: ["Event"], from: "effector" }),
+    hasType({
+      ...opts,
+      possibleTypes: ["Event", "EventCallable"],
+      from: "effector",
+    }),
   unit: (opts) =>
     hasType({
       ...opts,
-      possibleTypes: ["Effect", "Store", "Event"],
+      possibleTypes: [
+        "Effect",
+        "Store",
+        "Event",
+        "EventCallable",
+        "StoreWritable",
+      ],
       from: "effector",
     }),
   gate: (opts) =>
@@ -58,13 +72,27 @@ const nodeTypeIs = {
         from: "effector",
       }),
     store: (opts) =>
-      !hasType({ ...opts, possibleTypes: ["Store"], from: "effector" }),
+      !hasType({
+        ...opts,
+        possibleTypes: ["Store", "StoreWritable"],
+        from: "effector",
+      }),
     event: (opts) =>
-      !hasType({ ...opts, possibleTypes: ["Event"], from: "effector" }),
+      !hasType({
+        ...opts,
+        possibleTypes: ["Event", "EventCallable"],
+        from: "effector",
+      }),
     unit: (opts) =>
       !hasType({
         ...opts,
-        possibleTypes: ["Effect", "Store", "Event"],
+        possibleTypes: [
+          "Effect",
+          "Store",
+          "Event",
+          "EventCallable",
+          "StoreWritable",
+        ],
         from: "effector",
       }),
     gate: (opts) =>