eslint-plugin-effector 0.15.0 → 0.17.0

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

@@ -1,107 +0,0 @@
-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/mandatory-scope-binding/mandatory-scope-binding.js

@@ -1,81 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils");
-
-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: {
-    type: "problem",
-    docs: {
-      description:
-        "Forbids `Event` and `Effect` usage without `useUnit` in React components.",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("mandatory-scope-binding"),
-    },
-    messages: {
-      useEventNeeded:
-        "{{ unitName }} must be wrapped with `useUnit` from `effector-react` before usage inside React components",
-    },
-    schema: [],
-  },
-  create(context) {
-    let parserServices;
-    try {
-      parserServices = ESLintUtils.getParserServices(context);
-    } catch (err) {
-      // no types information
-    }
-
-    // TypeScript-only rule, since units can be imported from anywhere
-    if (!parserServices?.program) {
-      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 isInsideEffectorHook({ node, context }) {
-  const calleeParentNode = traverseParentByType(node.parent, "CallExpression");
-
-  if (!calleeParentNode?.callee) return false;
-
-  return nodeTypeIs.effectorReactHook({
-    node: calleeParentNode.callee,
-    context,
-    hook: ["useEvent", "useUnit", "useStore"],
-  });
-}

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

@@ -1,74 +0,0 @@
-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: {
-    type: "problem",
-    docs: {
-      description: "Forbids ambiguity targets in `sample` and `guard`",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("no-ambiguity-target"),
-    },
-    messages: {
-      ambiguityTarget:
-        "Method `{{ methodName }}` returns `target` and assigns the result to a variable. Consider removing one of them.",
-    },
-    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 configHasTarget = node?.arguments?.[0]?.properties?.some(
-          (prop) => prop?.key.name === "target"
-        );
-        if (!configHasTarget) {
-          return;
-        }
-
-        const resultAssignedInVariable = traverseParentByType(
-          node,
-          "VariableDeclarator",
-          { stopOnTypes: ["BlockStatement"] }
-        );
-        const resultPartOfChain = traverseParentByType(
-          node,
-          "ObjectExpression",
-          { stopOnTypes: ["BlockStatement"] }
-        );
-
-        if (resultAssignedInVariable || resultPartOfChain) {
-          context.report({
-            node,
-            messageId: "ambiguityTarget",
-            data: {
-              methodName: node?.callee?.name,
-            },
-          });
-
-          return;
-        }
-      },
-    };
-  },
-};

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

@@ -1,120 +0,0 @@
-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/rules/no-duplicate-on/no-duplicate-on.js

@@ -1,137 +0,0 @@
-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 = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Forbids duplicate `.on` calls on store",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("no-duplicate-on"),
-    },
-    messages: {
-      duplicateOn:
-        "Method `.on` is called on store `{{ storeName }}` more than once for {{ unitName }}.",
-    },
-    schema: [],
-  },
-  create(context) {
-    const usedOns = new Map();
-
-    function isEventUsedInStoreOn(scope, storeName, unitName) {
-      const usedOnsOnScope = usedOns.get(scope);
-
-      if (!usedOnsOnScope) {
-        return false;
-      }
-
-      const usedUnits = usedOnsOnScope.get(storeName);
-
-      if (!usedUnits) {
-        return false;
-      }
-
-      return usedUnits.has(unitName);
-    }
-
-    function markUnitAsUsedInStoreOn(scope, storeName, unitNames) {
-      let usedOnsOnScope = usedOns.get(scope);
-
-      if (!usedOnsOnScope) {
-        usedOnsOnScope = new Map();
-        usedOns.set(scope, usedOnsOnScope);
-      }
-
-      let usedUnits = usedOnsOnScope.get(storeName);
-
-      if (!usedUnits) {
-        usedUnits = new Set();
-        usedOnsOnScope.set(storeName, usedUnits);
-      }
-
-      usedUnits.add(...unitNames);
-    }
-
-    return {
-      'CallExpression[callee.property.name="on"]'(node) {
-        const storeObject = traverseNestedObjectNode(
-          getNestedCallee(node) ?? getAssignedVariable(node)
-        );
-        const storeName = getStoreName(storeObject);
-
-        if (!is.store({ context, node: storeObject })) {
-          return;
-        }
-
-        const triggerObjects = normalizePossibleArrayNode(node.arguments[0]);
-        const unitNames = triggerObjects.map(getNestedObjectName);
-
-        const scope = context.getScope();
-
-        for (const unitName of unitNames) {
-          const unitAlreadyUsed = isEventUsedInStoreOn(
-            scope,
-            storeName,
-            unitName
-          );
-
-          if (unitAlreadyUsed) {
-            context.report({
-              node,
-              messageId: "duplicateOn",
-              data: {
-                storeName,
-                unitName,
-              },
-            });
-
-            return;
-          }
-        }
-
-        markUnitAsUsedInStoreOn(scope, storeName, unitNames);
-      },
-    };
-  },
-};
-
-function normalizePossibleArrayNode(node) {
-  if (!node) {
-    return [];
-  }
-
-  if (node.type === "ArrayExpression") {
-    return node.elements;
-  }
-
-  return [node];
-}
-
-function getNestedCallee(node) {
-  const { callee } = node;
-
-  if (callee.object?.type === "CallExpression") {
-    return getNestedCallee(callee.object);
-  }
-
-  return callee.object;
-}
-
-function getAssignedVariable(node) {
-  const { parent } = node;
-
-  if (parent.type === "VariableDeclarator") {
-    return parent;
-  }
-
-  return getAssignedVariable(parent);
-}
-
-function getStoreName(node) {
-  return node?.name ?? node?.id?.name;
-}

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

@@ -1,73 +0,0 @@
-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");
-const { extractConfig } = require("../../utils/extract-config");
-
-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: "Replace `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 = extractConfig(["from", "to"], { node });
-
-        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-getState/no-getState.js

@@ -1,50 +0,0 @@
-const {
-  traverseNestedObjectNode,
-} = require("../../utils/traverse-nested-object-node");
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { is } = require("../../utils/is");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Forbids `.getState` calls on any Effector store",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("no-getState"),
-    },
-    messages: {
-      abusiveCall:
-        "Method `.getState` called on store `{{ storeName }}` can lead to race conditions. Replace it with `sample` or `guard`.",
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      'CallExpression[callee.property.name="getState"]'(node) {
-        const storeNode = traverseNestedObjectNode(node.callee?.object);
-
-        const isEffectorStore = is.store({
-          context,
-          node: storeNode,
-        });
-
-        if (!isEffectorStore) {
-          return;
-        }
-
-        reportGetStateCall({ context, node, storeName: storeNode.name });
-      },
-    };
-  },
-};
-
-function reportGetStateCall({ context, node, storeName }) {
-  context.report({
-    node,
-    messageId: "abusiveCall",
-    data: {
-      storeName,
-    },
-  });
-}