eslint-plugin-effector 0.16.0 → 0.17.0

package/rules/prefer-useUnit/prefer-useUnit.js

@@ -1,56 +0,0 @@
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { extractImportedFrom } = require("../../utils/extract-imported-from");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Suggests to replace old hooks `useStore`/`useEvent` by the new one `useUnit`",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("prefer-useUnit"),
-    },
-    messages: {
-      useUnitNeeded: "`{{ hookName }}` could be replaced by `useUnit`",
-    },
-    schema: [],
-  },
-  create(context) {
-    const importedFromEffectorReact = new Map();
-
-    return {
-      ImportDeclaration(node) {
-        extractImportedFrom({
-          importMap: importedFromEffectorReact,
-          packageName: "effector-react",
-          node,
-        });
-      },
-      CallExpression(node) {
-        const OLD_HOOKS = ["useStore", "useEvent"];
-        const NEW_HOOK = ["useUnit"];
-
-        for (const oldHookName of OLD_HOOKS) {
-          const localOldHookName = importedFromEffectorReact.get(oldHookName);
-          if (!localOldHookName) {
-            continue;
-          }
-
-          const isOldHook = node.callee.name === localOldHookName;
-          if (!isOldHook) {
-            continue;
-          }
-
-          context.report({
-            node,
-            messageId: "useUnitNeeded",
-            data: {
-              hookName: oldHookName,
-            },
-          });
-        }
-      },
-    };
-  },
-};

package/rules/require-pickup-in-persist/require-pickup-in-persist.js

@@ -1,47 +0,0 @@
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      category: "Quality",
-      url: createLinkToRule("require-pickup-in-persist"),
-    },
-    messages: {
-      pickupMissing:
-        "This `persist` call does not specify a `pickup` event that is required for scoped usage of `effector-storage`.",
-    },
-    schema: [],
-  },
-  create(context) {
-    const pickupImports = new Set();
-
-    /**
-     * Finds `effector-storage` packages, scoped and unscoped, including
-     * contents of these packages. See examples for a full list.
-     */
-    const PACKAGE_NAME = /^@?effector-storage(\u002F[\w-]+)*$/;
-
-    const declarationSelector = `ImportDeclaration[source.value=${PACKAGE_NAME}]`;
-    const persistImportSelector = `ImportSpecifier[imported.name="persist"]`;
-
-    const configSelector = `[arguments.length=1][arguments.0.type="ObjectExpression"]`;
-    const callSelector = `[callee.type="Identifier"]`;
-
-    return {
-      [`${declarationSelector} > ${persistImportSelector}`](node) {
-        pickupImports.add(node.local.name);
-      },
-      [`CallExpression${configSelector}${callSelector}`](node) {
-        if (!pickupImports.has(node.callee.name)) return;
-
-        const config = node.arguments[0];
-
-        if (config.properties.some((prop) => prop.key?.name === "pickup"))
-          return;
-
-        context.report({ node, messageId: "pickupMissing" });
-      },
-    };
-  },
-};

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

@@ -1,76 +0,0 @@
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { is } = require("../../utils/is");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Forbids mix of async functions and effects calls in effect handlers.",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("strict-effect-handlers"),
-    },
-    messages: {
-      mixedCallsInHandler:
-        "Handler of effect `{{ effectName }}` can lead to scope loosing in Fork API.",
-      mixedCallsInFunction:
-        "Function `{{ functionName }}` can lead to scope loosing in Fork API.",
-    },
-    schema: [],
-  },
-  create(context) {
-    function onEffectHandler(node) {
-      const functionBody = node.body?.body;
-
-      if (!Array.isArray(functionBody)) {
-        return;
-      }
-
-      const calledNodes = functionBody
-        .filter((bodyNode) => bodyNode.expression?.type === "AwaitExpression")
-        .map((awaitNode) => ({
-          node: awaitNode.expression.argument.callee,
-          context,
-        }));
-
-      const hasEffects = calledNodes.some(is.effect);
-      const hasRegularAsyncFunctions = calledNodes.some(is.not.effect);
-
-      const hasError = hasEffects && hasRegularAsyncFunctions;
-
-      if (!hasError) {
-        return;
-      }
-
-      const isEffectHandler = is.effect({
-        node: node.parent?.parent,
-        context,
-      });
-
-      if (isEffectHandler) {
-        const effectName = node.parent?.parent?.id?.name ?? "Unknown";
-
-        context.report({
-          node: node.parent,
-          messageId: "mixedCallsInHandler",
-          data: { effectName },
-        });
-      } else {
-        const functionName = node.id?.name ?? "Unknown";
-
-        context.report({
-          node,
-          messageId: "mixedCallsInFunction",
-          data: { functionName },
-        });
-      }
-    }
-
-    return {
-      ArrowFunctionExpression: onEffectHandler,
-      FunctionExpression: onEffectHandler,
-      FunctionDeclaration: onEffectHandler,
-    };
-  },
-};

package/utils/are-nodes-same-in-text.js

@@ -1,22 +0,0 @@
-const prettier = require("prettier");
-
-function areNodesSameInText({ context, nodes }) {
-  const texts = nodes.map((node) => {
-    let sourceText = context.getSourceCode().getText(node);
-
-    const shouldBeWrapped =
-      sourceText.startsWith("{") && sourceText.endsWith("}");
-
-    if (shouldBeWrapped) {
-      sourceText = `(${sourceText})`;
-    }
-
-    return prettier.format(sourceText, {
-      parser: "babel-ts",
-    });
-  });
-
-  return texts.every((text) => text === texts[0]);
-}
-
-module.exports = { areNodesSameInText };

package/utils/builders.js

@@ -1,19 +0,0 @@
-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/create-link-to-rule.js

@@ -1,5 +0,0 @@
-function createLinkToRule(name) {
-  return `https://eslint.effector.dev/rules/${name}`;
-}
-
-module.exports = { createLinkToRule };

package/utils/extract-config.js

@@ -1,26 +0,0 @@
-function extractConfig(fields, { node }) {
-  const config = {};
-
-  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/extract-imported-from.js

@@ -1,18 +0,0 @@
-function extractImportedFrom({ importMap, nodeMap, node, packageName }) {
-  const normalizePackageName = Array.isArray(packageName)
-    ? packageName
-    : [packageName];
-
-  if (normalizePackageName.includes(node.source.value)) {
-    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);
-    }
-  }
-}
-
-module.exports = { extractImportedFrom };

package/utils/get-corrected-store-name.js

@@ -1,45 +0,0 @@
-const { getStoreNameConvention } = require("./get-store-name-convention");
-
-function getCorrectedStoreName(storeName, context) {
-  const storeNameConvention = getStoreNameConvention(context);
-
-  // handle edge case
-  if (storeName.startsWith("$") && storeName.endsWith("$")) {
-    const storeNameWithoutConvention = trimByPattern(storeName, "$");
-    return formatStoreName(storeNameWithoutConvention, storeNameConvention);
-  }
-
-  const correctedStoreName = formatStoreName(storeName, storeNameConvention);
-
-  return correctedStoreName;
-}
-
-function formatStoreName(storeName, convention) {
-  return convention === "prefix" ? `$${storeName}` : `${storeName}$`;
-}
-
-function trimByPattern(s, template) {
-  let l = 0,
-    r = s.length - 1;
-
-  while (l <= r) {
-    const head = s[l];
-    const tail = s[r];
-
-    if (head === template) {
-      l++;
-    }
-
-    if (tail === template) {
-      r--;
-    }
-
-    if (head !== template && tail !== template) {
-      return s.slice(l, r + 1);
-    }
-  }
-
-  return s;
-}
-
-module.exports = { getCorrectedStoreName };

package/utils/get-nested-object-name.js

@@ -1,18 +0,0 @@
-function getNestedObjectName(node) {
-  let root = node;
-  let name = "";
-
-  while (root.type === "MemberExpression") {
-    name = `${root.property.name}.${name}`;
-    root = root.object;
-  }
-
-  if (root.type === "Identifier") {
-    name = `${root.name}.${name}`;
-  }
-
-  // Remove last dot
-  return name.slice(0, -1);
-}
-
-module.exports = { getNestedObjectName };

package/utils/get-store-name-convention.js

@@ -1,6 +0,0 @@
-function getStoreNameConvention(context) {
-  // prefix convention is default
-  return context.settings.effector?.storeNameConvention || "prefix";
-}
-
-module.exports = { getStoreNameConvention };

package/utils/is.js

@@ -1,39 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils");
-
-const { nodeTypeIs } = require("./node-type-is");
-const { namingOf } = require("./naming");
-
-function isSomething({ isValidNaming, isTypeCorrect }) {
-  return ({ node, context }) => {
-    let parserServices;
-    try {
-      parserServices = ESLintUtils.getParserServices(context);
-    } catch (e) {
-      // no types info
-    }
-
-    if (parserServices?.program) {
-      return isTypeCorrect({ node, context });
-    }
-
-    return isValidNaming({ name: node?.name ?? node?.id?.name, context });
-  };
-}
-
-const isStore = isSomething({
-  isTypeCorrect: nodeTypeIs.store,
-  isValidNaming: namingOf.store.isValid,
-});
-
-const isEffect = isSomething({
-  isTypeCorrect: nodeTypeIs.effect,
-  isValidNaming: namingOf.effect.isValid,
-});
-
-const is = {
-  store: (opts) => isStore(opts),
-  effect: (opts) => isEffect(opts),
-  not: { store: (opts) => !isStore(opts), effect: (opts) => !isEffect(opts) },
-};
-
-module.exports = { is };

package/utils/method.js

@@ -1,23 +0,0 @@
-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/naming.js

@@ -1,47 +0,0 @@
-const { getStoreNameConvention } = require("./get-store-name-convention");
-
-function isEffectNameValid({ name }) {
-  return Boolean(name?.endsWith("Fx"));
-}
-
-function isGateNameValid({ name }) {
-  const [firstChar] = name.split("");
-
-  return Boolean(firstChar?.toUpperCase() === firstChar);
-}
-
-function isStoreNameValid({ name, context }) {
-  const storeNameConvention = getStoreNameConvention(context);
-
-  // validate edge case
-  if (name?.length > 1 && name?.startsWith("$") && name?.endsWith("$")) {
-    return false;
-  }
-
-  if (storeNameConvention === "prefix" && name?.startsWith("$")) {
-    return true;
-  }
-
-  if (storeNameConvention === "postfix" && name?.endsWith("$")) {
-    return true;
-  }
-
-  return false;
-}
-
-const namingOf = {
-  effect: {
-    isValid: (opts) => isEffectNameValid(opts),
-    isInvalid: (opts) => !isEffectNameValid(opts),
-  },
-  store: {
-    isValid: (opts) => isStoreNameValid(opts),
-    isInvalid: (opts) => !isStoreNameValid(opts),
-  },
-  gate: {
-    isValid: (opts) => isGateNameValid(opts),
-    isInvalid: (opts) => !isGateNameValid(opts),
-  },
-};
-
-module.exports = { namingOf };

package/utils/node-is-type.js

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

package/utils/node-type-is.js

@@ -1,106 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils");
-
-function hasType({ node, possibleTypes, context, from }) {
-  try {
-    const parserServices = ESLintUtils.getParserServices(context);
-    const checker = parserServices.program.getTypeChecker();
-    const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-    const type = checker.getTypeAtLocation(
-      originalNode?.initializer ?? originalNode
-    );
-
-    const symbol = type?.symbol ?? type?.aliasSymbol;
-
-    return (
-      possibleTypes.includes(symbol?.escapedName) &&
-      Boolean(symbol?.parent?.escapedName?.includes(from))
-    );
-  } catch (e) {
-    return false;
-  }
-}
-
-const nodeTypeIs = {
-  effect: (opts) =>
-    hasType({ ...opts, possibleTypes: ["Effect"], from: "effector" }),
-  store: (opts) =>
-    hasType({
-      ...opts,
-      possibleTypes: ["Store", "StoreWritable"],
-      from: "effector",
-    }),
-  event: (opts) =>
-    hasType({
-      ...opts,
-      possibleTypes: ["Event", "EventCallable"],
-      from: "effector",
-    }),
-  unit: (opts) =>
-    hasType({
-      ...opts,
-      possibleTypes: [
-        "Effect",
-        "Store",
-        "Event",
-        "EventCallable",
-        "StoreWritable",
-      ],
-      from: "effector",
-    }),
-  gate: (opts) =>
-    hasType({ ...opts, possibleTypes: ["Gate"], from: "effector-react" }),
-  effectorReactHook: (opts) =>
-    hasType({
-      ...opts,
-      possibleTypes: opts.hook
-        ? [].concat(opts.hook)
-        : [
-            "useStore",
-            "useStoreMap",
-            "useList",
-            "useEvent",
-            "useGate",
-            "useUnit",
-          ],
-      from: "effector-react",
-    }),
-  not: {
-    effect: (opts) =>
-      !hasType({
-        ...opts,
-        possibleTypes: ["Effect"],
-        from: "effector",
-      }),
-    store: (opts) =>
-      !hasType({
-        ...opts,
-        possibleTypes: ["Store", "StoreWritable"],
-        from: "effector",
-      }),
-    event: (opts) =>
-      !hasType({
-        ...opts,
-        possibleTypes: ["Event", "EventCallable"],
-        from: "effector",
-      }),
-    unit: (opts) =>
-      !hasType({
-        ...opts,
-        possibleTypes: [
-          "Effect",
-          "Store",
-          "Event",
-          "EventCallable",
-          "StoreWritable",
-        ],
-        from: "effector",
-      }),
-    gate: (opts) =>
-      !hasType({ ...opts, possibleTypes: ["Gate"], from: "effector-react" }),
-    effectorReactHook: (opts) => !nodeTypeIs.effectorReactHook(opts),
-  },
-};
-
-module.exports = {
-  nodeTypeIs,
-};