eslint-plugin-effector 0.7.2 → 0.7.5

package/README.md

@@ -72,7 +72,7 @@ This preset is recommended for projects that use [React](https://reactjs.org) wi
 
 #### plugin:effector/future
 
-This preset contains rules wich enforce _future-effector_ code-style.
+This preset contains rules, which enforce _future-effector_ code-style.
 
 - [effector/no-forward](rules/no-forward/no-forward.md)
 - [effector/no-guard](rules/no-guard/no-guard.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.7.2",
+  "version": "0.7.5",
   "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/rules/no-forward/no-forward.js

@@ -16,7 +16,7 @@ module.exports = {
     messages: {
       noForward:
         "Instead of `forward` you can use `sample`, it is more extendable.",
-      replaceWithSample: "Repalce `forward` with `sample`.",
+      replaceWithSample: "Replace `forward` with `sample`.",
     },
     schema: [],
     hasSuggestions: true,

package/rules/no-guard/no-guard.js

@@ -16,7 +16,7 @@ module.exports = {
     messages: {
       noGuard:
         "Instead of `guard` you can use `sample`, it is more extendable.",
-      replaceWithSample: "Repalce `guard` with `sample`.",
+      replaceWithSample: "Replace `guard` with `sample`.",
     },
     schema: [],
     hasSuggestions: true,

package/rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.js

@@ -21,7 +21,7 @@ module.exports = {
         "Instead of `forward` with `{{ eventName }}.map` you can use `sample`",
       overPrepend:
         "Instead of `forward` with `{{ eventName }}.prepend` you can use `sample`",
-      replaceWithSample: "Repalce `forward` with `sample`.",
+      replaceWithSample: "Replace `forward` with `sample`.",
     },
     schema: [],
     hasSuggestions: true,

package/utils/extract-imported-from.js

@@ -1,6 +1,10 @@
 function extractImportedFrom({ importMap, nodeMap, node, packageName }) {
   if (node.source.value === packageName) {
     for (const s of node.specifiers) {
+      if (s.type === "ImportDefaultSpecifier") {
+        continue;
+      }
+
       importMap.set(s.imported.name, s.local.name);
       nodeMap?.set(s.imported.name, s);
     }

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;

package/utils/replace-by-sample.js

@@ -88,7 +88,11 @@ function* replaceBySample(
     })})`
   );
 
-  yield fixer.replaceText(importNodes.get(methodName), "sample");
+  const importNode = importNodes.get(methodName);
+
+  if (!importNodes.has("sample")) {
+    yield fixer.insertTextAfter(importNode, ", sample");
+  }
 }
 
 module.exports = { replaceForwardBySample, replaceGuardBySample };