refactor: move utility functions closer to where they are used

Rel1cx · Rel1cx · commit 3d023c7964db · 2025-02-24T22:16:21.000+08:00
diff --git a/.pkgs/eslint-plugin-local/dist/index.js b/.pkgs/eslint-plugin-local/dist/index.js
@@ -1,6 +1,8 @@
 import * as AST from '@eslint-react/ast';
 import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as VAR from '@eslint-react/var';
+import { _ } from '@eslint-react/eff';
+import { findVariable } from '@eslint-react/var';
+import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from '@typescript-eslint/types';
 import { nullThrows, NullThrowsReasons } from '@typescript-eslint/utils/eslint-utils';
 
 // package.json
@@ -10,6 +12,40 @@ function getDocsUrl() {
   return "TODO: add docs for local ESLint rules";
 }
 var createRule = ESLintUtils.RuleCreator(getDocsUrl);
+function isInitializedFromSource(name2, source, initialScope) {
+  const latestDef = findVariable(name2, initialScope)?.defs.at(-1);
+  if (latestDef == null) return false;
+  const { node, parent } = latestDef;
+  if (node.type === AST_NODE_TYPES$1.VariableDeclarator && node.init != null) {
+    const { init } = node;
+    if (init.type === AST_NODE_TYPES$1.MemberExpression && init.object.type === AST_NODE_TYPES$1.Identifier) {
+      return isInitializedFromSource(init.object.name, source, initialScope);
+    }
+    if (init.type === AST_NODE_TYPES$1.Identifier) {
+      return isInitializedFromSource(init.name, source, initialScope);
+    }
+    const args = getRequireExpressionArguments(init);
+    const arg0 = args?.[0];
+    if (arg0 == null || !AST.isStringLiteral(arg0)) {
+      return false;
+    }
+    return arg0.value === source || arg0.value.startsWith(`${source}/`);
+  }
+  return parent?.type === AST_NODE_TYPES$1.ImportDeclaration && parent.source.value === source;
+}
+function getRequireExpressionArguments(node) {
+  switch (true) {
+    // require('source')
+    case (node.type === AST_NODE_TYPES$1.CallExpression && node.callee.type === AST_NODE_TYPES$1.Identifier && node.callee.name === "require"): {
+      return node.arguments;
+    }
+    // require('source').variable
+    case node.type === AST_NODE_TYPES$1.MemberExpression: {
+      return getRequireExpressionArguments(node.object);
+    }
+  }
+  return _;
+}
 
 // src/rules/avoid-multiline-template-expression.ts
 var RULE_NAME = "avoid-multiline-template-expression";
@@ -43,6 +79,8 @@ var avoid_multiline_template_expression_default = createRule({
   },
   defaultOptions: []
 });
+
+// src/rules/no-shadow-underscore.ts
 var RULE_NAME2 = "no-shadow-underscore";
 var RULE_FEATURES2 = [
   "CHK"
@@ -64,7 +102,7 @@ var no_shadow_underscore_default = createRule({
     return {
       "Identifier[name='_']"(node) {
         const initialScope = context.sourceCode.getScope(node);
-        const isFromImport = VAR.isInitializedFromSource("_", "@eslint-react/eff", initialScope);
+        const isFromImport = isInitializedFromSource("_", "@eslint-react/eff", initialScope);
         if (!isFromImport) {
           context.report({
             messageId: "noShadowUnderscore",
diff --git a/.pkgs/eslint-plugin-local/src/rules/no-shadow-underscore.ts b/.pkgs/eslint-plugin-local/src/rules/no-shadow-underscore.ts
@@ -1,9 +1,8 @@
 import type { RuleFeature } from "@eslint-react/shared";
-import * as VAR from "@eslint-react/var";
 import type { TSESTree } from "@typescript-eslint/types";
 import type { CamelCase } from "string-ts";
 
-import { createRule } from "../utils";
+import { createRule, isInitializedFromSource } from "../utils";
 
 export const RULE_NAME = "no-shadow-underscore";
 
@@ -30,7 +29,7 @@ export default createRule<[], MessageID>({
     return {
       "Identifier[name='_']"(node: TSESTree.Identifier & { name: "_" }) {
         const initialScope = context.sourceCode.getScope(node);
-        const isFromImport = VAR.isInitializedFromSource("_", "@eslint-react/eff", initialScope);
+        const isFromImport = isInitializedFromSource("_", "@eslint-react/eff", initialScope);
         if (!isFromImport) {
           context.report({
             messageId: "noShadowUnderscore",
diff --git a/.pkgs/eslint-plugin-local/src/utils/index.ts b/.pkgs/eslint-plugin-local/src/utils/index.ts
@@ -1 +1,2 @@
 export * from "./create-rule";
+export * from "./is-initialized-from-source";
diff --git a/.pkgs/eslint-plugin-local/src/utils/is-initialized-from-source.ts b/.pkgs/eslint-plugin-local/src/utils/is-initialized-from-source.ts
@@ -0,0 +1,63 @@
+import * as AST from "@eslint-react/ast";
+import { _ } from "@eslint-react/eff";
+import { findVariable } from "@eslint-react/var";
+import type { Scope } from "@typescript-eslint/scope-manager";
+import type { TSESTree } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
+
+/**
+ * Check if an identifier is initialized from the given source
+ * @param name The top-level identifier's name
+ * @param source The import source to check against
+ * @param initialScope Initial scope to search for the identifier
+ * @returns Whether the identifier is initialized from the given source
+ */
+export function isInitializedFromSource(
+  name: string,
+  source: string,
+  initialScope: Scope,
+): boolean {
+  const latestDef = findVariable(name, initialScope)?.defs.at(-1);
+  if (latestDef == null) return false;
+  const { node, parent } = latestDef;
+  if (node.type === T.VariableDeclarator && node.init != null) {
+    const { init } = node;
+    // check for: `variable = Source.variable`
+    if (init.type === T.MemberExpression && init.object.type === T.Identifier) {
+      return isInitializedFromSource(init.object.name, source, initialScope);
+    }
+    // check for: `{ variable } = Source`
+    if (init.type === T.Identifier) {
+      return isInitializedFromSource(init.name, source, initialScope);
+    }
+    // check for: `variable = require('source')` or `variable = require('source').variable`
+    const args = getRequireExpressionArguments(init);
+    const arg0 = args?.[0];
+    if (arg0 == null || !AST.isStringLiteral(arg0)) {
+      return false;
+    }
+    // check for: `require('source')` or `require('source/...')`
+    return arg0.value === source
+      || arg0
+        .value
+        .startsWith(`${source}/`);
+  }
+  // latest definition is an import declaration: import { variable } from 'source'
+  return parent?.type === T.ImportDeclaration && parent.source.value === source;
+}
+
+function getRequireExpressionArguments(node: TSESTree.Node): TSESTree.CallExpressionArgument[] | _ {
+  switch (true) {
+    // require('source')
+    case node.type === T.CallExpression
+      && node.callee.type === T.Identifier
+      && node.callee.name === "require": {
+      return node.arguments;
+    }
+    // require('source').variable
+    case node.type === T.MemberExpression: {
+      return getRequireExpressionArguments(node.object);
+    }
+  }
+  return _;
+}
diff --git a/packages/core/docs/functions/isInitializedFromReact.md b/packages/core/docs/functions/isInitializedFromReact.md
@@ -6,22 +6,32 @@
 
 # Function: isInitializedFromReact()
 
-> **isInitializedFromReact**(`name`, `importSource`, `initialScope`): `boolean`
+> **isInitializedFromReact**(`name`, `source`, `initialScope`): `boolean`
+
+Check if an identifier is initialized from react
 
 ## Parameters
 
 ### name
 
 `string`
 
-### importSource
+The top-level identifier's name
+
+### source
 
 `string`
 
+The import source to check against
+
 ### initialScope
 
 [`Scope`](../-internal-/type-aliases/Scope.md)
 
+Initial scope to search for the identifier
+
 ## Returns
 
 `boolean`
+
+Whether the identifier is initialized from react
diff --git a/packages/core/src/utils/is-initialized-from-react.ts b/packages/core/src/utils/is-initialized-from-react.ts
@@ -1,15 +1,64 @@
+import * as AST from "@eslint-react/ast";
+import { _ } from "@eslint-react/eff";
 import * as VAR from "@eslint-react/var";
 import type { Scope } from "@typescript-eslint/scope-manager";
+import type { TSESTree } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 
+/**
+ * Check if an identifier is initialized from react
+ * @param name The top-level identifier's name
+ * @param source The import source to check against
+ * @param initialScope Initial scope to search for the identifier
+ * @returns Whether the identifier is initialized from react
+ */
 export function isInitializedFromReact(
   name: string,
-  importSource: string,
+  source: string,
   initialScope: Scope,
-) {
-  return name.toLowerCase() === "react"
-    || VAR.isInitializedFromSource(
-      name,
-      importSource,
-      initialScope,
-    );
+): boolean {
+  if (name.toLowerCase() === "react") return true;
+  const latestDef = VAR.findVariable(name, initialScope)?.defs.at(-1);
+  if (latestDef == null) return false;
+  const { node, parent } = latestDef;
+  if (node.type === T.VariableDeclarator && node.init != null) {
+    const { init } = node;
+    // check for: `variable = Source.variable`
+    if (init.type === T.MemberExpression && init.object.type === T.Identifier) {
+      return isInitializedFromReact(init.object.name, source, initialScope);
+    }
+    // check for: `{ variable } = Source`
+    if (init.type === T.Identifier) {
+      return isInitializedFromReact(init.name, source, initialScope);
+    }
+    // check for: `variable = require('source')` or `variable = require('source').variable`
+    const args = getRequireExpressionArguments(init);
+    const arg0 = args?.[0];
+    if (arg0 == null || !AST.isStringLiteral(arg0)) {
+      return false;
+    }
+    // check for: `require('source')` or `require('source/...')`
+    return arg0.value === source
+      || arg0
+        .value
+        .startsWith(`${source}/`);
+  }
+  // latest definition is an import declaration: import { variable } from 'source'
+  return parent?.type === T.ImportDeclaration && parent.source.value === source;
+}
+
+function getRequireExpressionArguments(node: TSESTree.Node): TSESTree.CallExpressionArgument[] | _ {
+  switch (true) {
+    // require('source')
+    case node.type === T.CallExpression
+      && node.callee.type === T.Identifier
+      && node.callee.name === "require": {
+      return node.arguments;
+    }
+    // require('source').variable
+    case node.type === T.MemberExpression: {
+      return getRequireExpressionArguments(node.object);
+    }
+  }
+  return _;
 }

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`	`1`	`export * from "./create-rule";`
	`2`	`+export * from "./is-initialized-from-source";`