eslint-plugin-effector 0.16.0 → 0.17.0

package/utils/react.js

@@ -1,214 +0,0 @@
-// borrowed from
-// https://github.com/facebook/react/blob/main/packages/eslint-plugin-react-hooks/src/RulesOfHooks.js
-
-/**
- * Catch all identifiers that begin with "use" followed by an uppercase Latin
- * character to exclude identifiers like "user".
- */
-
-function isHookName(s) {
-  return /^use[A-Z0-9].*$/.test(s);
-}
-
-/**
- * We consider hooks to be a hook name identifier or a member expression
- * containing a hook name.
- */
-
-function isHook(node) {
-  if (node.type === "Identifier") {
-    return isHookName(node.name);
-  } else if (
-    node.type === "MemberExpression" &&
-    !node.computed &&
-    isHook(node.property)
-  ) {
-    const obj = node.object;
-    const isPascalCaseNameSpace = /^[A-Z].*/;
-    return obj.type === "Identifier" && isPascalCaseNameSpace.test(obj.name);
-  } else {
-    return false;
-  }
-}
-
-/**
- * Checks if the node is a React component name. React component names must
- * always start with a non-lowercase letter. So `MyComponent` or `_MyComponent`
- * are valid component names for instance.
- */
-function isComponentName(node) {
-  if (node.type === "Identifier") {
-    return !/^[a-z]/.test(node.name);
-  } else {
-    return false;
-  }
-}
-
-function isReactFunction(node, functionName) {
-  return (
-    node.name === functionName ||
-    (node.type === "MemberExpression" &&
-      node.object.name === "React" &&
-      node.property.name === functionName)
-  );
-}
-
-/**
- * Checks if the node is a callback argument of forwardRef. This render function
- * should follow the rules of hooks.
- */
-
-function isForwardRefCallback(node) {
-  return !!(
-    node.parent &&
-    node.parent.callee &&
-    isReactFunction(node.parent.callee, "forwardRef")
-  );
-}
-
-/**
- * Checks if the node is a callback argument of React.memo. This anonymous
- * functional component should follow the rules of hooks.
- */
-
-function isMemoCallback(node) {
-  return !!(
-    node.parent &&
-    node.parent.callee &&
-    isReactFunction(node.parent.callee, "memo")
-  );
-}
-
-function isInsideReactComponent(node) {
-  while (node) {
-    const functionName = getFunctionName(node);
-    if (functionName) {
-      if (isComponentName(functionName) || isHook(functionName)) {
-        return true;
-      }
-    }
-    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);
-    if (functionName) {
-      if (isHook(functionName)) {
-        return true;
-      }
-    }
-    node = node.parent;
-  }
-  return false;
-}
-
-module.exports = {
-  isInsideReactComponent,
-  isInsideReactHook,
-};
-
-/**
- * Gets the static name of a function AST node. For function declarations it is
- * easy. For anonymous function expressions it is much harder. If you search for
- * `IsAnonymousFunctionDefinition()` in the ECMAScript spec you'll find places
- * where JS gives anonymous function expressions names. We roughly detect the
- * same AST nodes with some exceptions to better fit our use case.
- */
-
-function getFunctionName(node) {
-  if (
-    node.type === "FunctionDeclaration" ||
-    (node.type === "FunctionExpression" && node.id)
-  ) {
-    // function useHook() {}
-    // const whatever = function useHook() {};
-    //
-    // Function declaration or function expression names win over any
-    // assignment statements or other renames.
-    return node.id;
-  } else if (
-    node.type === "FunctionExpression" ||
-    node.type === "ArrowFunctionExpression"
-  ) {
-    if (
-      node.parent.type === "VariableDeclarator" &&
-      node.parent.init === node
-    ) {
-      // const useHook = () => {};
-      return node.parent.id;
-    } else if (
-      node.parent.type === "AssignmentExpression" &&
-      node.parent.right === node &&
-      node.parent.operator === "="
-    ) {
-      // useHook = () => {};
-      return node.parent.left;
-    } else if (
-      node.parent.type === "Property" &&
-      node.parent.value === node &&
-      !node.parent.computed
-    ) {
-      // {useHook: () => {}}
-      // {useHook() {}}
-      return node.parent.key;
-
-      // NOTE: We could also support `ClassProperty` and `MethodDefinition`
-      // here to be pedantic. However, hooks in a class are an anti-pattern. So
-      // we don't allow it to error early.
-      //
-      // class {useHook = () => {}}
-      // class {useHook() {}}
-    } else if (
-      node.parent.type === "AssignmentPattern" &&
-      node.parent.right === node &&
-      !node.parent.computed
-    ) {
-      // const {useHook = () => {}} = {};
-      // ({useHook = () => {}} = {});
-      //
-      // Kinda clowny, but we'd said we'd follow spec convention for
-      // `IsAnonymousFunctionDefinition()` usage.
-      return node.parent.left;
-    } else {
-      return undefined;
-    }
-  } else {
-    return undefined;
-  }
-}

package/utils/read-example.js

@@ -1,63 +0,0 @@
-const { readFileSync } = require("fs");
-const { join } = require("path");
-const glob = require("glob");
-
-function readExample(dirname, exampleName) {
-  return readFileSync(join(dirname, "examples", exampleName)).toString();
-}
-
-function getCorrectExamples(dirname, config = {}) {
-  const { ext, namesOnly = true } = config;
-  const pattern = `correct-*.${resolveExtension(ext)}`;
-  const correct = glob.sync(join(dirname, "examples", pattern));
-
-  let result = correct;
-
-  if (namesOnly) {
-    result = result.map((path) => {
-      const rightSlashIdx = path.lastIndexOf("/");
-
-      return path.slice(rightSlashIdx + 1);
-    });
-  }
-
-  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, namesOnly = true } = config;
-  const pattern = `incorrect-*.${resolveExtension(ext)}`;
-  const incorrect = glob.sync(join(dirname, "examples", pattern));
-
-  let result = incorrect;
-
-  if (namesOnly) {
-    result = result.map((path) => {
-      const rightSlashIdx = path.lastIndexOf("/");
-
-      return path.slice(rightSlashIdx + 1);
-    });
-  }
-
-  return result;
-}
-
-module.exports = { readExample, getCorrectExamples, getIncorrectExamples };

package/utils/replace-by-sample.js

@@ -1,98 +0,0 @@
-const { buildObjectInText } = require("./builders");
-
-function* replaceGuardBySample(
-  guardConfig,
-  { fixer, node, context, importNodes }
-) {
-  let mapperFunctionNode = null;
-
-  let clockNode = guardConfig.clock?.value;
-  let targetNode = guardConfig.target?.value;
-  let sourceNode = guardConfig.source?.value;
-  let filterNode = guardConfig.filter?.value;
-
-  if (
-    targetNode?.type === "CallExpression" &&
-    targetNode?.callee?.property?.name === "prepend"
-  ) {
-    mapperFunctionNode = targetNode?.arguments?.[0];
-    targetNode = targetNode.callee.object;
-    targetMapperUsed = true;
-  }
-
-  yield* replaceBySample(
-    { clockNode, sourceNode, filterNode, mapperFunctionNode, targetNode },
-    { node, fixer, context, importNodes, methodName: "guard" }
-  );
-}
-
-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, mapperFunctionNode, targetNode },
-    { node, fixer, context, importNodes, methodName: "forward" }
-  );
-}
-
-function* replaceBySample(
-  { clockNode, sourceNode, filterNode, mapperFunctionNode, targetNode },
-  { node, fixer, context, importNodes, methodName }
-) {
-  yield fixer.replaceText(
-    node,
-    `sample(${buildObjectInText.fromMapOfNodes({
-      properties: {
-        clock: clockNode,
-        source: sourceNode,
-        filter: filterNode,
-        fn: mapperFunctionNode,
-        target: targetNode,
-      },
-      context,
-    })})`
-  );
-
-  const importNode = importNodes.get(methodName);
-
-  if (!importNodes.has("sample")) {
-    yield fixer.insertTextAfter(importNode, ", sample");
-  }
-}
-
-module.exports = { replaceForwardBySample, replaceGuardBySample };

package/utils/traverse-nested-object-node.js

@@ -1,9 +0,0 @@
-function traverseNestedObjectNode(node) {
-  if (node.type === "MemberExpression") {
-    return traverseNestedObjectNode(node.property);
-  }
-
-  return node;
-}
-
-module.exports = { traverseNestedObjectNode };

package/utils/traverse-parent-by-type.js

@@ -1,15 +0,0 @@
-function traverseParentByType(node, type, config) {
-  const stopOnTypes = config?.stopOnTypes ?? [];
-
-  if (!node || stopOnTypes.includes(node.type)) {
-    return null;
-  }
-
-  if (node.type === type) {
-    return node;
-  }
-
-  return traverseParentByType(node.parent, type, config);
-}
-
-module.exports = { traverseParentByType };

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

@@ -1,13 +0,0 @@
-const { getStoreNameConvention } = require("./get-store-name-convention");
-
-function validateStoreNameConvention(context) {
-  const storeNameConvention = getStoreNameConvention(context);
-
-  if (storeNameConvention !== "prefix" && storeNameConvention !== "postfix") {
-    throw new Error(
-      "Invalid Configuration of effector-plugin-eslint/enforce-store-naming-convention. The value should be equal to prefix or postfix."
-    );
-  }
-}
-
-module.exports = { validateStoreNameConvention };