eslint-plugin-effector 0.7.1 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "description": "Enforcing best practices for Effector",
   "keywords": [
     "eslint",

package/rules/mandatory-useEvent/mandatory-useEvent.js

@@ -2,6 +2,7 @@ const { createLinkToRule } = require("../../utils/create-link-to-rule");
 const { isInsideReactComponent } = require("../../utils/react");
 const { nodeTypeIs } = require("../../utils/node-type-is");
 const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
+const { nodeIsType } = require("../../utils/node-is-type");
 
 module.exports = {
   meta: {
@@ -23,34 +24,44 @@ module.exports = {
     const parserServices = context.parserServices;
 
     // TypeScript-only rule, since units can be imported from anywhere
-    if (parserServices.hasFullTypeInformation) {
-      return {
-        Identifier(node) {
-          if (isInsideReactComponent(node)) {
-            if (
-              nodeTypeIs.effect({ node, context }) ||
-              nodeTypeIs.event({ node, context })
-            ) {
-              if (!isInsideUseEventCall({ node, context })) {
-                context.report({
-                  node,
-                  messageId: "useEventNeeded",
-                  data: {
-                    unitName: node.name,
-                  },
-                });
-              }
-            }
-          }
-        },
-      };
+    if (!parserServices.hasFullTypeInformation) {
+      return {};
     }
 
-    return {};
+    return {
+      Identifier(node) {
+        if (!isInsideReactComponent(node)) {
+          return;
+        }
+
+        if (nodeIsType({ node })) {
+          return;
+        }
+
+        if (
+          nodeTypeIs.not.effect({ node, context }) &&
+          nodeTypeIs.not.event({ node, context })
+        ) {
+          return;
+        }
+
+        if (isInsideEffectorHook({ node, context })) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "useEventNeeded",
+          data: {
+            unitName: node.name,
+          },
+        });
+      },
+    };
   },
 };
 
-function isInsideUseEventCall({ node, context }) {
+function isInsideEffectorHook({ node, context }) {
   const calleeParentNode = traverseParentByType(node.parent, "CallExpression");
 
   if (!calleeParentNode?.callee) return false;
@@ -58,6 +69,6 @@ function isInsideUseEventCall({ node, context }) {
   return nodeTypeIs.effectorReactHook({
     node: calleeParentNode.callee,
     context,
-    hook: ["useEvent", "useUnit"],
+    hook: ["useEvent", "useUnit", "useStore"],
   });
 }

package/utils/extract-config.js

@@ -1,13 +1,26 @@
 function extractConfig(fields, { node }) {
   const config = {};
 
-  fields.forEach((field) => {
-    config[field] = node.arguments?.[0]?.properties.find(
-      (n) => n.key?.name === field
-    );
-  });
+  if (isObject(node.arguments?.[0])) {
+    extractConfigFromObject(config, fields, node.arguments?.[0]);
+  } else if (isObject(node.arguments?.[1])) {
+    extractConfigFromObject(config, fields, node.arguments?.[1]);
+    if (fields.includes("clock")) {
+      config.clock = { value: node.arguments?.[0] };
+    }
+  }
 
   return config;
 }
 
+function isObject(node) {
+  return Boolean(node?.properties);
+}
+
+function extractConfigFromObject(config, fields, node) {
+  fields.forEach((field) => {
+    config[field] = node?.properties?.find((n) => n.key?.name === field);
+  });
+}
+
 module.exports = { extractConfig };

package/utils/node-is-type.js

@@ -0,0 +1,5 @@
+function nodeIsType({ node }) {
+  return node?.parent?.type === "TSTypeReference";
+}
+
+module.exports = { nodeIsType };

package/utils/react.js

@@ -90,11 +90,41 @@ function isInsideReactComponent(node) {
     if (isForwardRefCallback(node) || isMemoCallback(node)) {
       return true;
     }
+
+    if (isClass(node) && !isClassComponent(node)) {
+      return false;
+    }
+
+    if (isClassComponent(node)) {
+      return true;
+    }
+
     node = node.parent;
   }
   return false;
 }
 
+function isClass(node) {
+  return node?.type === "ClassDeclaration";
+}
+
+function isClassComponent(node) {
+  if (!node?.superClass) {
+    return false;
+  }
+  if (node?.superClass?.type === "MemberExpression") {
+    return (
+      node?.superClass?.object?.name === "React" &&
+      /^(Pure)?Component$/.test(node?.superClass?.property?.name)
+    );
+  }
+  if (node?.superClass?.type === "Identifier") {
+    return /^(Pure)?Component$/.test(node?.superClass?.name);
+  }
+
+  return false;
+}
+
 function isInsideReactHook(node) {
   while (node) {
     const functionName = getFunctionName(node);

package/utils/read-example.js

@@ -7,8 +7,8 @@ function readExample(dirname, exampleName) {
 }
 
 function getCorrectExamples(dirname, config = {}) {
-  const { ext = "js", namesOnly = true } = config;
-  const pattern = `correct-*.${ext}`;
+  const { ext, namesOnly = true } = config;
+  const pattern = `correct-*.${resolveExtension(ext)}`;
   const correct = glob.sync(join(dirname, "examples", pattern));
 
   let result = correct;
@@ -24,9 +24,27 @@ function getCorrectExamples(dirname, config = {}) {
   return result;
 }
 
+function resolveExtension(ext) {
+  const DEFAULT_EXT = "js";
+
+  if (Array.isArray(ext)) {
+    if (ext.length === 0) {
+      return DEFAULT_EXT;
+    }
+
+    if (ext.length === 1) {
+      return ext[0];
+    }
+
+    return `{${ext.join(",")}}`;
+  }
+
+  return ext ?? DEFAULT_EXT;
+}
+
 function getIncorrectExamples(dirname, config = {}) {
-  const { ext = "js", namesOnly = true } = config;
-  const pattern = `incorrect-*.${ext}`;
+  const { ext, namesOnly = true } = config;
+  const pattern = `incorrect-*.${resolveExtension(ext)}`;
   const incorrect = glob.sync(join(dirname, "examples", pattern));
 
   let result = incorrect;