eslint-plugin-effector 0.5.2 → 0.6.0

package/README.md

@@ -57,16 +57,18 @@ This preset is recommended for projects that use [React](https://reactjs.org) wi
 
 - [effector/enforce-store-naming-convention](rules/enforce-store-naming-convention/enforce-store-naming-convention.md)
 - [effector/enforce-effect-naming-convention](rules/enforce-effect-naming-convention/enforce-effect-naming-convention.md)
-- [effector/no-getState](rules/no-getState/no-getState.md)
+- [effector/enforce-gate-naming-convention](rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md)
 - [effector/no-unnecessary-duplication](rules/no-unnecessary-duplication/no-unnecessary-duplication.md)
+- [effector/no-unnecessary-combination](rules/no-unnecessary-combination/no-unnecessary-combination.md)
 - [effector/no-useless-methods](rules/no-useless-methods/no-useless-methods.md)
+- [effector/no-forward](rules/no-forward/no-forward.md)
 - [effector/no-ambiguity-target](rules/no-ambiguity-target/no-ambiguity-target.md)
-- [effector/prefer-sample-over-forward-with-mapping](rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md)
-- [effector/no-watch](rules/no-watch/no-watch.md)
-- [effector/no-unnecessary-combination](rules/no-unnecessary-combination/no-unnecessary-combination.md)
 - [effector/no-duplicate-on](rules/no-duplicate-on/no-duplicate-on.md)
+- [effector/no-getState](rules/no-getState/no-getState.md)
+- [effector/no-watch](rules/no-watch/no-watch.md)
+- [effector/prefer-sample-over-forward-with-mapping](rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md)
 - [effector/strict-effect-handlers](rules/strict-effect-handlers/strict-effect-handlers.md)
-- [effector/enforce-gate-naming-convention](rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md)
+- [effector/keep-options-order](rules/keep-options-order/keep-options-order.md)
 
 ## Maintenance
 

package/config/recommended.js

@@ -10,5 +10,6 @@ module.exports = {
     "effector/no-watch": "warn",
     "effector/no-unnecessary-combination": "warn",
     "effector/no-duplicate-on": "error",
+    "effector/keep-options-order": "warn",
   },
 };

package/index.js

@@ -12,6 +12,8 @@ module.exports = {
     "no-duplicate-on": require("./rules/no-duplicate-on/no-duplicate-on"),
     "strict-effect-handlers": require("./rules/strict-effect-handlers/strict-effect-handlers"),
     "enforce-gate-naming-convention": require("./rules/enforce-gate-naming-convention/enforce-gate-naming-convention"),
+    "keep-options-order": require("./rules/keep-options-order/keep-options-order"),
+    "no-forward": require("./rules/no-forward/no-forward"),
   },
   configs: {
     recommended: require("./config/recommended"),

package/package.json

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

package/rules/keep-options-order/config.js

@@ -0,0 +1,3 @@
+const correctOrder = ["clock", "source", "filter", "fn", "target"];
+
+module.exports = { correctOrder };

package/rules/keep-options-order/keep-options-order.js

@@ -0,0 +1,107 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { buildObjectInText } = require("../../utils/builders");
+
+const { correctOrder } = require("./config");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce options order for Effector methods",
+      category: "Style",
+      recommended: true,
+      url: createLinkToRule("keep-options-order"),
+    },
+    messages: {
+      invalidOrder: `Order of options should be ${makeTag(
+        correctOrder
+      )}, but found {{ incorrectOrderTag }}`,
+      changeOrder: "Sort options",
+    },
+    schema: [],
+    hasSuggestions: true,
+  },
+  create(context) {
+    const importedFromEffector = new Map();
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
+      },
+      CallExpression(node) {
+        // Effect creation with method
+        const OPTIONS_METHODS = ["sample", "guard"];
+        for (const method of OPTIONS_METHODS) {
+          const localMethod = importedFromEffector.get(method);
+          if (!localMethod) {
+            continue;
+          }
+
+          const isEffectorMethods = node.callee.name === localMethod;
+          if (!isEffectorMethods) {
+            continue;
+          }
+
+          const configNode = node?.arguments?.[0];
+          const optionsNodes = configNode?.properties;
+
+          const optionsOrder = optionsNodes?.map((prop) => prop?.key.name);
+
+          const idealOrder = filteredCorrectOrder(optionsOrder);
+
+          if (isCorrectOrder(optionsOrder, idealOrder)) {
+            continue;
+          }
+
+          context.report({
+            node,
+            messageId: "invalidOrder",
+            data: {
+              incorrectOrderTag: makeTag(optionsOrder),
+            },
+            suggest: [
+              {
+                messageId: "changeOrder",
+                fix(fixer) {
+                  const newConfig = buildObjectInText.fromArrayOfNodes({
+                    properties: sortNodesByName(optionsNodes, idealOrder),
+                    context,
+                  });
+
+                  return fixer.replaceText(configNode, newConfig);
+                },
+              },
+            ],
+          });
+        }
+      },
+    };
+  },
+};
+
+function makeTag(order) {
+  return order.join("->");
+}
+
+function isCorrectOrder(checkOrder, idealOrder) {
+  return idealOrder.every((refItem, index) => checkOrder?.[index] === refItem);
+}
+
+function filteredCorrectOrder(checkOrder) {
+  return correctOrder.filter((item) => checkOrder?.includes(item));
+}
+
+function sortNodesByName(nodes, nameOrder) {
+  const newNodes = [];
+
+  for (const name of nameOrder) {
+    const node = nodes.find((node) => node?.key.name === name);
+    newNodes.push(node);
+  }
+
+  return newNodes;
+}

package/rules/no-ambiguity-target/no-ambiguity-target.js

@@ -1,6 +1,7 @@
 const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -29,46 +30,42 @@ module.exports = {
         });
       },
       CallExpression(node) {
-        const POSSIBLE_USELESS_METHODS = ["sample", "guard"];
-        for (const method of POSSIBLE_USELESS_METHODS) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
+        if (
+          method.isNot(["sample", "guard"], {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
+        const configHasTarget = node?.arguments?.[0]?.properties?.some(
+          (prop) => prop?.key.name === "target"
+        );
+        if (!configHasTarget) {
+          return;
+        }
 
-          const configHasTarget = node?.arguments?.[0]?.properties?.some(
-            (prop) => prop?.key.name === "target"
-          );
-          if (!configHasTarget) {
-            continue;
-          }
+        const resultAssignedInVariable = traverseParentByType(
+          node,
+          "VariableDeclarator",
+          { stopOnTypes: ["BlockStatement"] }
+        );
+        const resultPartOfChain = traverseParentByType(
+          node,
+          "ObjectExpression"
+        );
 
-          const resultAssignedInVariable = traverseParentByType(
-            node,
-            "VariableDeclarator",
-            { stopOnTypes: ["BlockStatement"] }
-          );
-          const resultPartOfChain = traverseParentByType(
+        if (resultAssignedInVariable || resultPartOfChain) {
+          context.report({
             node,
-            "ObjectExpression"
-          );
-
-          if (resultAssignedInVariable || resultPartOfChain) {
-            context.report({
-              node,
-              messageId: "ambiguityTarget",
-              data: {
-                methodName: node?.callee?.name,
-              },
-            });
+            messageId: "ambiguityTarget",
+            data: {
+              methodName: node?.callee?.name,
+            },
+          });
 
-            continue;
-          }
+          return;
         }
       },
     };

package/rules/no-duplicate-on/no-duplicate-on.js

@@ -1,5 +1,8 @@
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
 const { getNestedObjectName } = require("../../utils/get-nested-object-name");
+const {
+  traverseNestedObjectNode,
+} = require("../../utils/traverse-nested-object-node");
 const { is } = require("../../utils/is");
 
 module.exports = {
@@ -56,7 +59,9 @@ module.exports = {
 
     return {
       'CallExpression[callee.property.name="on"]'(node) {
-        const storeObject = getNestedCallee(node) ?? getAssignedVariable(node);
+        const storeObject = traverseNestedObjectNode(
+          getNestedCallee(node) ?? getAssignedVariable(node)
+        );
         const storeName = getStoreName(storeObject);
 
         if (!is.store({ context, node: storeObject })) {
@@ -96,6 +101,10 @@ module.exports = {
 };
 
 function normalizePossibleArrayNode(node) {
+  if (!node) {
+    return [];
+  }
+
   if (node.type === "ArrayExpression") {
     return node.elements;
   }

package/rules/no-forward/no-forward.js

@@ -0,0 +1,77 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
+const { replaceForwardBySample } = require("../../utils/replace-by-sample");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer `sample` over `forward`",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("no-forward"),
+    },
+    messages: {
+      noForward:
+        "Instead of `forward` you can use `sample`, it is more extendable.",
+      replaceWithSample: "Repalce `forward` with `sample`.",
+    },
+    schema: [],
+    hasSuggestions: true,
+  },
+  create(context) {
+    const importNodes = new Map();
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          nodeMap: importNodes,
+          node,
+          packageName: "effector",
+        });
+      },
+      CallExpression(node) {
+        if (
+          method.isNot("forward", {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
+
+        const forwardConfig = {
+          from: node.arguments?.[0]?.properties.find(
+            (n) => n.key?.name === "from"
+          ),
+          to: node.arguments?.[0]?.properties.find((n) => n.key?.name === "to"),
+        };
+
+        if (!forwardConfig.from || !forwardConfig.to) {
+          return;
+        }
+
+        context.report({
+          messageId: "noForward",
+          node,
+          suggest: [
+            {
+              messageId: "replaceWithSample",
+              *fix(fixer) {
+                yield* replaceForwardBySample(forwardConfig, {
+                  fixer,
+                  node,
+                  context,
+                  importNodes,
+                });
+              },
+            },
+          ],
+        });
+      },
+    };
+  },
+};

package/rules/no-unnecessary-combination/no-unnecessary-combination.js

@@ -1,5 +1,6 @@
 const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -29,16 +30,10 @@ module.exports = {
         });
       },
       CallExpression(node) {
-        const METHODS_WITH_POSSIBLE_UNNECESSARY_COMBINATION = [
-          "sample",
-          "guard",
-          "forward",
-        ];
-
         const CONFIG_ARG_PROPERTIES = ["source", "clock", "from"];
 
-        function toLocalMethod(method) {
-          return importedFromEffector.get(method);
+        function toLocalMethod(methodName) {
+          return importedFromEffector.get(methodName);
         }
 
         const UNNECESSARY_METHODS = {
@@ -47,48 +42,45 @@ module.exports = {
           from: ["merge"].map(toLocalMethod).filter(Boolean),
         };
 
-        for (const method of METHODS_WITH_POSSIBLE_UNNECESSARY_COMBINATION) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
+        if (
+          method.isNot(["sample", "guard", "forward"], {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
+        const candidates =
+          node?.arguments?.[0]?.properties?.filter((n) =>
+            CONFIG_ARG_PROPERTIES.includes(n.key.name)
+          ) ?? [];
 
-          const candidates =
-            node?.arguments?.[0]?.properties?.filter((n) =>
-              CONFIG_ARG_PROPERTIES.includes(n.key.name)
-            ) ?? [];
+        if (candidates.length === 0) {
+          return;
+        }
 
-          if (candidates.length === 0) {
+        for (const candidate of candidates) {
+          const candidateName = candidate?.value?.callee?.name;
+          const argProp = candidate?.key?.name;
+          if (!candidateName || !argProp) {
             continue;
           }
 
-          for (const candidate of candidates) {
-            const candidateName = candidate?.value?.callee?.name;
-            const argProp = candidate?.key?.name;
-            if (!candidateName || !argProp) {
-              continue;
-            }
-
-            const localUnnecessaryMethods = UNNECESSARY_METHODS[argProp];
-
-            const UnnecessaryMethodIsEffectorMethod =
-              localUnnecessaryMethods.some((m) => m === candidateName);
+          const localUnnecessaryMethods = UNNECESSARY_METHODS[argProp];
 
-            if (!UnnecessaryMethodIsEffectorMethod) {
-              continue;
-            }
+          const UnnecessaryMethodIsEffectorMethod =
+            localUnnecessaryMethods.some((m) => m === candidateName);
 
-            context.report({
-              node: candidate?.value,
-              messageId: "unnecessaryCombination",
-              data: { methodName: candidateName },
-            });
+          if (!UnnecessaryMethodIsEffectorMethod) {
+            continue;
           }
+
+          context.report({
+            node: candidate?.value,
+            messageId: "unnecessaryCombination",
+            data: { methodName: candidateName },
+          });
         }
       },
     };

package/rules/no-unnecessary-duplication/no-unnecessary-duplication.js

@@ -1,6 +1,8 @@
 const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { areNodesSameInText } = require("../../utils/are-nodes-same-in-text");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { buildObjectInText } = require("../../utils/builders");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -32,45 +34,41 @@ module.exports = {
         });
       },
       CallExpression(node) {
-        const METHODS_WITH_POSSIBLE_DUPLCATION = ["sample", "guard"];
-        for (const method of METHODS_WITH_POSSIBLE_DUPLCATION) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
-
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
-
-          const params = {
-            source: node?.arguments?.[0]?.properties?.find(
-              (n) => n.key.name === "source"
-            ),
-            clock: node?.arguments?.[0]?.properties?.find(
-              (n) => n.key.name === "clock"
-            ),
-          };
-          if (!params.source || !params.clock) {
-            return;
-          }
+        if (
+          method.isNot(["sample", "guard"], {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const sameSourceAndClock = areNodesSameInText({
-            context,
-            nodes: [params.source?.value, params.clock?.value],
-          });
-          if (!sameSourceAndClock) {
-            return;
-          }
+        const params = {
+          source: node?.arguments?.[0]?.properties?.find(
+            (n) => n.key.name === "source"
+          ),
+          clock: node?.arguments?.[0]?.properties?.find(
+            (n) => n.key.name === "clock"
+          ),
+        };
+        if (!params.source || !params.clock) {
+          return;
+        }
 
-          reportUnnecessaryDuplication({
-            context,
-            node,
-            params,
-            firstArgument: node?.arguments?.[0],
-          });
+        const sameSourceAndClock = areNodesSameInText({
+          context,
+          nodes: [params.source?.value, params.clock?.value],
+        });
+        if (!sameSourceAndClock) {
+          return;
         }
+
+        reportUnnecessaryDuplication({
+          context,
+          node,
+          params,
+          firstArgument: node?.arguments?.[0],
+        });
       },
     };
   },
@@ -86,11 +84,8 @@ function reportUnnecessaryDuplication({
     const properties = objectNode?.properties?.filter?.(
       (p) => p !== paramToExcludeNode
     );
-    const newPropertiesText = properties
-      .map((p) => context.getSourceCode().getText(p))
-      .join(", ");
 
-    return `{ ${newPropertiesText} }`;
+    return buildObjectInText.fromArrayOfNodes({ properties, context });
   }
 
   context.report({

package/rules/no-useless-methods/no-useless-methods.js

@@ -1,6 +1,7 @@
 const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -29,67 +30,63 @@ module.exports = {
         });
       },
       CallExpression(node) {
-        const POSSIBLE_USELESS_METHODS = ["sample", "guard"];
-        for (const method of POSSIBLE_USELESS_METHODS) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
-
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
-
-          const resultAssignedInVariable = traverseParentByType(
+        if (
+          method.isNot(["sample", "guard"], {
             node,
-            "VariableDeclarator"
-          );
-          if (resultAssignedInVariable) {
-            continue;
-          }
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const resultReturnedFromFactory = traverseParentByType(
-            node,
-            "ReturnStatement"
-          );
-          if (resultReturnedFromFactory) {
-            continue;
-          }
+        const resultAssignedInVariable = traverseParentByType(
+          node,
+          "VariableDeclarator"
+        );
+        if (resultAssignedInVariable) {
+          return;
+        }
 
-          const resultPartOfChain = traverseParentByType(
-            node,
-            "ObjectExpression"
-          );
-          if (resultPartOfChain) {
-            continue;
-          }
+        const resultReturnedFromFactory = traverseParentByType(
+          node,
+          "ReturnStatement"
+        );
+        if (resultReturnedFromFactory) {
+          return;
+        }
 
-          const configHasTarget = node?.arguments?.[0]?.properties?.some(
-            (prop) => prop?.key.name === "target"
-          );
-          if (configHasTarget) {
-            continue;
-          }
+        const resultPartOfChain = traverseParentByType(
+          node,
+          "ObjectExpression"
+        );
+        if (resultPartOfChain) {
+          return;
+        }
 
-          const resultIsWatched = node?.parent?.property?.name === "watch";
-          if (resultIsWatched) {
-            continue;
-          }
+        const configHasTarget = node?.arguments?.[0]?.properties?.some(
+          (prop) => prop?.key.name === "target"
+        );
+        if (configHasTarget) {
+          return;
+        }
 
-          const resultIsArgument = node?.parent?.type === "CallExpression";
-          if (resultIsArgument) {
-            continue;
-          }
+        const resultIsWatched = node?.parent?.property?.name === "watch";
+        if (resultIsWatched) {
+          return;
+        }
 
-          context.report({
-            node,
-            messageId: "uselessMethod",
-            data: {
-              methodName: node?.callee?.name,
-            },
-          });
+        const resultIsArgument = node?.parent?.type === "CallExpression";
+        if (resultIsArgument) {
+          return;
         }
+
+        context.report({
+          node,
+          messageId: "uselessMethod",
+          data: {
+            methodName: node?.callee?.name,
+          },
+        });
       },
     };
   },

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

@@ -3,6 +3,8 @@ const {
   traverseNestedObjectNode,
 } = require("../../utils/traverse-nested-object-node");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
+const { replaceForwardBySample } = require("../../utils/replace-by-sample");
 
 module.exports = {
   meta: {
@@ -18,28 +20,31 @@ 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`.",
     },
     schema: [],
+    hasSuggestions: true,
   },
   create(context) {
+    const importNodes = new Map();
     const importedFromEffector = new Map();
 
     return {
       ImportDeclaration(node) {
         extractImportedFrom({
           importMap: importedFromEffector,
+          nodeMap: importNodes,
           node,
           packageName: "effector",
         });
       },
       CallExpression(node) {
-        const localMethod = importedFromEffector.get("forward");
-        if (!localMethod) {
-          return;
-        }
-
-        const isEffectorMethod = node?.callee?.name === localMethod;
-        if (!isEffectorMethod) {
+        if (
+          method.isNot("forward", {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
           return;
         }
 
@@ -72,14 +77,25 @@ module.exports = {
             return;
           }
 
-          // console.log(eventName);
-
           context.report({
             node,
             messageId,
             data: {
               eventName,
             },
+            suggest: [
+              {
+                messageId: "replaceWithSample",
+                *fix(fixer) {
+                  yield* replaceForwardBySample(forwardConfig, {
+                    fixer,
+                    node,
+                    context,
+                    importNodes,
+                  });
+                },
+              },
+            ],
           });
         }
 

package/utils/builders.js

@@ -0,0 +1,19 @@
+const buildObjectInText = {
+  fromArrayOfNodes({ properties, context }) {
+    const content = properties
+      .map((property) => context.getSourceCode().getText(property))
+      .join(", ");
+
+    return `{ ${content} }`;
+  },
+  fromMapOfNodes({ properties, context }) {
+    const content = Object.entries(properties)
+      .filter(([_, node]) => Boolean(node))
+      .map(([key, node]) => `${key}: ${context.getSourceCode().getText(node)}`)
+      .join(", ");
+
+    return `{ ${content} }`;
+  },
+};
+
+module.exports = { buildObjectInText };

package/utils/extract-imported-from.js

@@ -1,7 +1,8 @@
-function extractImportedFrom({ importMap, node, packageName }) {
+function extractImportedFrom({ importMap, nodeMap, node, packageName }) {
   if (node.source.value === packageName) {
     for (const s of node.specifiers) {
       importMap.set(s.imported.name, s.local.name);
+      nodeMap?.set(s.imported.name, s);
     }
   }
 }

package/utils/method.js

@@ -0,0 +1,23 @@
+function isSomeMethod(methodName, { node, importMap }) {
+  const normalizedMethodNames = Array.isArray(methodName)
+    ? methodName
+    : [methodName];
+
+  return normalizedMethodNames.some((method) => {
+    const localMethod = importMap.get(method);
+    if (!localMethod) {
+      return false;
+    }
+
+    const isEffectorMethod = node?.callee?.name === localMethod;
+
+    return isEffectorMethod;
+  });
+}
+
+const method = {
+  is: (...args) => isSomeMethod(...args),
+  isNot: (...args) => !isSomeMethod(...args),
+};
+
+module.exports = { method };

package/utils/replace-by-sample.js

@@ -0,0 +1,66 @@
+const { buildObjectInText } = require("./builders");
+
+function* replaceForwardBySample(
+  forwardConfig,
+  { fixer, node, context, importNodes }
+) {
+  let mapperFunctionNode = null;
+
+  let clockMapperUsed = false;
+  let targetMapperUsed = false;
+
+  let clockNode = forwardConfig.from.value;
+  let targetNode = forwardConfig.to.value;
+
+  if (
+    clockNode.type === "CallExpression" &&
+    clockNode?.callee?.property?.name === "map"
+  ) {
+    mapperFunctionNode = clockNode?.arguments?.[0];
+    clockNode = clockNode.callee.object;
+    clockMapperUsed = true;
+  }
+
+  if (
+    targetNode.type === "CallExpression" &&
+    targetNode?.callee?.property?.name === "prepend"
+  ) {
+    mapperFunctionNode = targetNode?.arguments?.[0];
+    targetNode = targetNode.callee.object;
+    targetMapperUsed = true;
+  }
+
+  // We cannot apply two mappers in one sample
+  // Let's revert mappers and use .map + .prepend
+  if (clockMapperUsed && targetMapperUsed) {
+    mapperFunctionNode = null;
+    clockNode = forwardConfig.from.value;
+    targetNode = forwardConfig.to.value;
+  }
+
+  yield* replaceBySample(
+    { clockNode, targetNode, mapperFunctionNode },
+    { node, fixer, context, importNodes, methodName: "forward" }
+  );
+}
+
+function* replaceBySample(
+  { clockNode, targetNode, mapperFunctionNode },
+  { node, fixer, context, importNodes, methodName }
+) {
+  yield fixer.replaceText(
+    node,
+    `sample(${buildObjectInText.fromMapOfNodes({
+      properties: {
+        clock: clockNode,
+        fn: mapperFunctionNode,
+        target: targetNode,
+      },
+      context,
+    })})`
+  );
+
+  yield fixer.replaceText(importNodes.get(methodName), "sample");
+}
+
+module.exports = { replaceForwardBySample };

package/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.md

@@ -1,11 +0,0 @@
-# effector/enforce-effect-naming-convention
-
-Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with effect. Your effect should be distingueshed by a suffix `Fx`. For example, `fetchUserInfoFx` is a effect, `fetchUserInfo` is not.
-
-```ts
-// 👍 nice name
-const fetchNameFx = createEffect();
-
-// 👎 bad name
-const fetchName = createEffect();
-```

package/rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md

@@ -1,11 +0,0 @@
-# effector/enforce-gate-naming-convention
-
-Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with gate. Every gate is a react-component, so it should be named as regular react-compoent.
-
-```ts
-// 👍 nice name
-const MyFavoritePageGate = createGate();
-
-// 👎 bad name
-const otherFavoritePageGate = createGate();
-```

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

@@ -1,52 +0,0 @@
-# effector/enforce-store-naming-convention
-
-Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with store. Depending on the configuration your stores should be distinguished by a prefix or a postfix $. Enforces prefix convention by default.
-
-## Prefix convention
-
-When configured as:
-
-```js
-module.exports = {
-  rules: {
-    "effector/enforce-store-naming-convention": "error",
-  },
-};
-```
-
-Prefix convention will be enforced:
-
-```ts
-// 👍 nice name
-const $name = createStore(null);
-
-// 👎 bad name
-const name = createStore(null);
-```
-
-## Postfix convention
-
-When configured as:
-
-```js
-module.exports = {
-  rules: {
-    "effector/enforce-store-naming-convention": "error",
-  },
-  settings: {
-    effector: {
-      storeNameConvention: "postfix",
-    },
-  },
-};
-```
-
-Postfix convention will be enforced:
-
-```ts
-// 👍 nice name
-const name$ = createStore(null);
-
-// 👎 bad name
-const name = createStrore(null);
-```

package/rules/no-ambiguity-target/no-ambiguity-target.md

@@ -1,12 +0,0 @@
-# effector/no-ambiguity-target
-
-Call of `gaurd`/`sample` with `target` and variable assignment is ambiguity. One of them should be omitted from source code.
-
-```ts
-// 👎 should be rewritten
-const result = guard({ clock: trigger, filter: Boolean, target });
-
-// 👍 makes sense
-guard({ clock: trigger, filter: Boolean, target });
-const result = target;
-```

package/rules/no-duplicate-on/no-duplicate-on.md

@@ -1,16 +0,0 @@
-# effector/no-duplicate-on
-
-Disallows duplcates `on`-handlers on particular store.
-
-```ts
-const increment = createEvent();
-
-// 👍 all explicitly
-const $goodCounter = createStore(0).on(increment, (counter) => counter + 1);
-
-// 👎 so, which handler should we choose?
-// it's better to remove one of them
-const $badCounter = createStore(0)
-  .on(increment, (counter) => counter + 1)
-  .on(increment, (counter) => counter + 2);
-```

package/rules/no-getState/no-getState.md

@@ -1,20 +0,0 @@
-# effector/no-getState
-
-`.getState` gives rise to difficult to debug imperative code and kind of race condition. Prefer declarative `sample` to pass data from store and `attach` for effects.
-
-```ts
-const $username = createStore(null);
-const userLoggedIn = createEvent();
-
-// 👍 good solution
-const fetchUserCommentsFx = createEffect((name) => /* ... */);
-sample({ source: $username, clock: userLoggedIn, target: fetchUserCommentsFx });
-
-// 👎 bad solution
-const fetchUserCommentsInBadWayFx = createEffect(() => {
-    const name = $username.getState();
-
-    /* ... */
-});
-forward({ from: userLoggedIn, to: fetchUserCommentsInBadWayFx });
-```

package/rules/no-unnecessary-combination/no-unnecessary-combination.md

@@ -1,25 +0,0 @@
-# effector/no-unnecessary-combination
-
-Call of `combine`/`merge` in `clock`/`source` is unnecessary. It can be omitted from source code.
-
-```ts
-// 👎 can be simplified
-const badEventOne = guard({
-  clock: combine($store1, $store2),
-  filter: $filter,
-});
-const badEventOne = guard({
-  clock: combine($store1, $store2, (store1, store2) => ({
-    x: store1,
-    y: store2,
-  })),
-  filter: $filter,
-});
-
-// 👍 better
-const goodEventOne = guard({ clock: [$store1, $store2], filter: $filter });
-const goodEventTwo = guard({
-  clock: { x: $store1, x: $store2 },
-  filter: $filter,
-});
-```

package/rules/no-unnecessary-duplication/no-unnecessary-duplication.md

@@ -1,32 +0,0 @@
-# effector/no-unnecessary-duplication
-
-Same `clock`/`source` in `sample` and `guard` don't make sense, any of these fields can be omitted in this case.
-
-```ts
-const $data = createStore(null);
-
-// 👎 can be simplified
-const target1 = sample({
-  source: $data,
-  clock: $data,
-  fn(data) {
-    return data.length;
-  },
-});
-
-// 👍 better
-const target2 = sample({
-  source: $data,
-  fn(data) {
-    return data.length;
-  },
-});
-
-// 👍 also nice solution
-const target3 = sample({
-  clock: $data,
-  fn(data) {
-    return data.length;
-  },
-});
-```

package/rules/no-useless-methods/no-useless-methods.md

@@ -1,14 +0,0 @@
-# effector/no-useless-methods
-
-Call of `gaurd`/`sample` without `target` or variable assignment is useless. It can be omitted from source code.
-
-```ts
-// 👎 can be omitted
-guard({ clock: trigger, filter: Boolean });
-
-// 👍 makes sense
-const target1 = guard({ clock: trigger, filter: Boolean });
-
-// 👍 make sense too
-guard({ clock: trigger, filter: Boolean, target: target2 });
-```

package/rules/no-watch/no-watch.md

@@ -1,42 +0,0 @@
-# effector/no-watch
-
-Method `.watch` leads to imperative code. Try replacing it with operators (`forward`, `sample`, etc) or use the `target` parameter of the operators.
-
-> Caution! This rule only works on projects using TypeScript.
-
-```ts
-const myFx = createEffect();
-const myEvent = createEvent();
-const $awesome = createStore();
-
-// 👍 good solutions
-forward({
-  from: myFx.finally,
-  to: myEvent,
-});
-
-guard({
-  clock: myEvent,
-  filter: Boolean,
-  target: myFx,
-});
-
-sample({
-  from: $awesome.updates,
-  fn: identity,
-  to: myEvent,
-});
-
-// 👎 bad solutions
-myFx.finally.watch(myEvent);
-
-myEvent.watch((payload) => {
-  if (Boolean(payload)) {
-    myFx(payload);
-  }
-});
-
-$awesome.updates.watch((data) => {
-  myEvent(identity(data));
-});
-```

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

@@ -1,27 +0,0 @@
-# effector/prefer-sample-over-forward-with-mapping
-
-Prefer `sample` over `forward` with `.map`/`.prepend`.
-
-```js
-const eventOne = createEvent();
-const eventTwo = createEvent();
-
-// 👎 looks weird
-forward({
-  from: eventOne.map((items) => items.length),
-  to: eventTwo,
-});
-
-// 👎 weird too
-forward({
-  from: eventOne,
-  to: eventTwo.prepend((items) => items.length),
-});
-
-// 👍 better
-sample({
-  source: eventOne,
-  fn: (items) => items.length,
-  target: eventTwo,
-});
-```

package/rules/strict-effect-handlers/strict-effect-handlers.md

@@ -1,38 +0,0 @@
-# effector/strict-effect-handlers
-
-[Related documentation](https://effector.dev/docs/api/effector/scope#imperative-effects-calls-with-scope)
-
-When effect calls another effects then it should call only effects, not common async functions and effect calls should have await:
-
-```ts
-// 👍 effect without inner effects:
-const delayFx = createEffect(async () => {
-  await new Promise((rs) => setTimeout(rs, 80));
-});
-```
-
-```ts
-const authUserFx = createEffect();
-const sendMessageFx = createEffect();
-
-// 👍 effect with inner effects
-const sendWithAuthFx = createEffect(async () => {
-  await authUserFx();
-  await delayFx();
-  await sendMessageFx();
-});
-```
-
-```ts
-// 👎 effect with inner effects and common async functions
-
-const sendWithAuthFx = createEffect(async () => {
-  await authUserFx();
-  //WRONG! wrap that in effect
-  await new Promise((rs) => setTimeout(rs, 80));
-  //context lost
-  await sendMessageFx();
-});
-```
-
-So, any effect might either call another effects or perform some async computations but not both.

package/rules/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "compilerOptions": {
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "module": "commonjs",
-    "lib": ["es2017", "es2019"],
-    "baseUrl": "./"
-  },
-  "include": ["./**/examples/**/*.ts"]
-}