refactor(utilities/var): improve 'isInitializedFromSource' function readability

Author: Rel1cx

.github/CONTRIBUTING.md

@@ -59,17 +59,17 @@ Before submitting your contribution though, please make sure to take a moment an
 - `packages/plugins/eslint-plugin-react-x`: ESLint plugin for `"react"`.
 - `packages/plugins/eslint-plugin-react-dom`: ESLint plugin for `"react-dom"`.
 - `packages/plugins/eslint-plugin-react-web-api` - ESLint plugin for interacting with Web APIs
-- `packages/plugins/eslint-plugin-react-hooks-extra`:ESLint plugin for React Hooks related rules.
+- `packages/plugins/eslint-plugin-react-hooks-extra`: ESLint plugin for React Hooks related rules.
 - `packages/plugins/eslint-plugin-react-naming-convention`: ESLint plugin for React naming conventions.
 - `packages/plugins/eslint-plugin-react-debug`: ESLint plugin for debugging ESLint React rules.
 - `packages/plugins/eslint-plugin`: The main ESLint plugin of ESLint React. Contains all the rules from the above plugins.
 - `packages/utilities/eff`: A subset of effect to produce a more lightweight version of the library.
 - `packages/utilities/ast`: TSESTree AST utility module.
 - `packages/utilities/var`: TSESTree AST utility module for static analysis of variables
 - `packages/utilities/jsx`: TSESTree AST utility module for static analysis of JSX.
-- `packages/core`: ESLint React's ESLint utility module for static analysis of React core APIs and Patterns.
-- `packages/types`: ESLint React's type definitions.
-- `packages/shared`: ESLint React's Shared constants and functions.
+- `packages/core`: Utility module for static analysis of React core APIs and Patterns.
+- `packages/types`: Type definitions.
+- `packages/shared`: Shared constants and functions.
 - `website`: The documentation website for ESLint React.
 
 ### Developing Documentation

packages/utilities/var/src/get-variable-def.ts

@@ -5,8 +5,6 @@ import { DefinitionType } from "@typescript-eslint/scope-manager";
 import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 
-import { getVariableDef } from "./get-variable-def";
-
 /**
  * Get the init node of the nth definition of a variable
  * @param at The index number of def in defs
@@ -26,7 +24,7 @@ export function getVariableNode(at: number) {
   > => {
     return F.pipe(
       O.some(variable),
-      O.flatMap(getVariableDef(at)),
+      O.flatMapNullable(v => v.defs.at(at)),
       O.flatMapNullable(def => {
         switch (true) {
           case def.type === DefinitionType.FunctionName

packages/utilities/var/src/get-variable-node.ts

@@ -4,7 +4,6 @@ export * from "./get-child-scopes";
 export * from "./get-scope";
 export * from "./get-static-value";
 export * from "./get-variable-declarator-id";
-export * from "./get-variable-def";
 export * from "./get-variable-node";
 export * from "./get-variables";
 export * from "./is-initialized-from-source";

packages/utilities/var/src/index.ts

@@ -1,7 +1,9 @@
-import { isString, O } from "@eslint-react/eff";
+import * as AST from "@eslint-react/ast";
+import { F, O } from "@eslint-react/eff";
 import type { Scope } from "@typescript-eslint/scope-manager";
+import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import { isMatching, match } from "ts-pattern";
+import { isMatching } from "ts-pattern";
 
 import { findVariable } from "./find-variable";
 
@@ -19,8 +21,7 @@ export function isInitializedFromSource(
 ): boolean {
   const maybeLatestDef = O.flatMapNullable(findVariable(name, initialScope), (v) => v.defs.at(-1));
   if (O.isNone(maybeLatestDef)) return false;
-  const latestDef = maybeLatestDef.value;
-  const { node, parent } = latestDef;
+  const { node, parent } = maybeLatestDef.value;
   if (node.type === AST_NODE_TYPES.VariableDeclarator && node.init) {
     const { init } = node;
     // check for: `variable = Source.variable`
@@ -31,28 +32,31 @@ export function isInitializedFromSource(
     if (init.type === AST_NODE_TYPES.Identifier) {
       return isInitializedFromSource(init.name, source, initialScope);
     }
-    const maybeRequireExpression = match(init)
-      .with({
-        type: AST_NODE_TYPES.CallExpression,
-        callee: { type: AST_NODE_TYPES.Identifier, name: "require" },
-      }, (exp) => O.some(exp))
-      .with(
-        {
-          type: AST_NODE_TYPES.MemberExpression,
-          object: {
-            type: AST_NODE_TYPES.CallExpression,
-            callee: { type: AST_NODE_TYPES.Identifier, name: "require" },
-          },
-        },
-        ({ object }) => O.some(object),
-      )
-      .otherwise(O.none);
-    if (O.isNone(maybeRequireExpression)) return false;
-    const requireExpression = maybeRequireExpression.value;
-    const [firstArg] = requireExpression.arguments;
-    if (firstArg?.type !== AST_NODE_TYPES.Literal || !isString(firstArg.value)) return false;
-    return firstArg.value === source || firstArg.value.startsWith(`${source}/`);
+    // check for: `variable = require('source')` or `variable = require('source').variable`
+    return F.pipe(
+      getRequireExpressionArgument(init),
+      O.flatMapNullable((args) => args[0]),
+      O.filter(AST.isStringLiteral),
+      // check for: `require('source')` or `require('source/...')`
+      O.exists((arg) => arg.value === source || arg.value.startsWith(`${source}/`)),
+    );
   }
   // latest definition is an import declaration: import { variable } from 'source'
   return isMatching({ type: "ImportDeclaration", source: { value: source } }, parent);
 }
+
+function getRequireExpressionArgument(node: TSESTree.Node): O.Option<TSESTree.CallExpressionArgument[]> {
+  switch (true) {
+    // require('source')
+    case node.type === AST_NODE_TYPES.CallExpression
+      && node.callee.type === AST_NODE_TYPES.Identifier
+      && node.callee.name === "require": {
+      return O.some(node.arguments);
+    }
+    // require('source').variable
+    case node.type === AST_NODE_TYPES.MemberExpression: {
+      return getRequireExpressionArgument(node.object);
+    }
+  }
+  return O.none();
+}

packages/utilities/var/src/is-initialized-from-source.ts

@@ -6,7 +6,6 @@ import { AST_NODE_TYPES } from "@typescript-eslint/types";
 
 import { findVariable } from "./find-variable";
 import { getStaticValue } from "./get-static-value";
-import { getVariableDef } from "./get-variable-def";
 import { getVariableNode } from "./get-variable-node";
 
 const thisBlockTypes = [
@@ -49,8 +48,8 @@ export function isNodeValueEqual(
       const bVarNode = O.flatMap(bVar, getVariableNode(0));
       const aVarNodeParent = O.flatMapNullable(aVarNode, (n) => n.parent);
       const bVarNodeParent = O.flatMapNullable(bVarNode, (n) => n.parent);
-      const aDef = O.flatMap(aVar, getVariableDef(0));
-      const bDef = O.flatMap(bVar, getVariableDef(0));
+      const aDef = O.flatMapNullable(aVar, v => v.defs.at(0));
+      const bDef = O.flatMapNullable(bVar, v => v.defs.at(0));
       const aDefParentParent = O.flatMapNullable(aDef, (d) => d.parent?.parent);
       const bDefParentParent = O.flatMapNullable(bDef, (d) => d.parent?.parent);
       switch (true) {