@eslint-react/var 3.0.0-next.8 → 3.0.0-next.80

package/dist/index.d.ts

@@ -1,69 +1,7 @@
-import { unit } from "@eslint-react/eff";
 import { TSESTree } from "@typescript-eslint/types";
-import { Scope, Variable } from "@typescript-eslint/scope-manager";
 import { RuleContext } from "@eslint-react/shared";
 
-//#region src/var-assignment-target.d.ts
-/**
- * Finds the enclosing assignment target (variable, property, etc.) for a given node
- *
- * @todo Verify correctness and completeness of this function
- * @param node The starting node
- * @returns The enclosing assignment target node, or undefined if not found
- */
-declare function findEnclosingAssignmentTarget(node: TSESTree.Node): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | undefined;
-/**
- * Type representing the possible assignment targets returned by `findEnclosingAssignmentTarget`
- */
-type AssignmentTarget = ReturnType<typeof findEnclosingAssignmentTarget>;
-/**
- * Check if two assignment targets are equal
- * Compares nodes directly or by their values
- * @param context The rule context
- * @param a The first node to compare
- * @param b The second node to compare
- * @returns True if the assignment targets are equal
- * @internal
- */
-declare function isAssignmentTargetEqual(context: RuleContext, a: TSESTree.Node, b: TSESTree.Node): boolean;
-//#endregion
-//#region src/var-definition.d.ts
-/**
- * Get the definition node of a variable at a specific definition index
- * @param variable The variable to get the definition node from
- * @param at The index of the definition to retrieve (negative index supported)
- * @returns The definition node or unit if not found
- */
-declare function getVariableDefinitionNode(variable: Variable | unit, at: number): unit | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
-/**
- * Get the definition node of a variable at a specific definition index (loose version)
- * Also returns the function node if the definition is a parameter
- * @param variable The variable to get the definition node from
- * @param at The index of the definition to retrieve
- * @returns The definition node or unit if not found
- */
-declare function getVariableDefinitionNodeLoose(variable: Variable | unit, at: number): unit | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
-//#endregion
-//#region src/var-import-source.d.ts
-/**
- * Find the import source of a variable
- * @param name The variable name
- * @param initialScope The initial scope to search
- * @returns The import source or undefined if not found
- */
-declare function findImportSource(name: string, initialScope: Scope): string | undefined;
-//#endregion
-//#region src/var-node-equality.d.ts
-/**
- * Determine whether node value equals to another node value
- * @param a node to compare
- * @param b node to compare
- * @param initialScopes initial scopes of the two nodes
- * @returns `true` if node value equal
- */
-declare function isNodeEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [aScope: Scope, bScope: Scope]): boolean;
-//#endregion
-//#region src/var-object-type.d.ts
+//#region src/compute-object-type.d.ts
 /**
  * Represents the type classification of an object node
  */
@@ -72,10 +10,10 @@ type ObjectType = {
   node: TSESTree.JSXElement | TSESTree.JSXFragment;
 } | {
   kind: "array";
-  node: TSESTree.ArrayExpression;
+  node: TSESTree.ArrayExpression | TSESTree.CallExpression;
 } | {
   kind: "plain";
-  node: TSESTree.ObjectExpression;
+  node: TSESTree.ObjectExpression | TSESTree.CallExpression;
 } | {
   kind: "class";
   node: TSESTree.ClassExpression;
@@ -87,57 +25,90 @@ type ObjectType = {
   node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
 } | {
   kind: "regexp";
-  node: TSESTree.RegExpLiteral;
+  node: TSESTree.RegExpLiteral | TSESTree.CallExpression;
 } | {
   kind: "unknown";
   node: TSESTree.Node;
-  reason: "call-expression" | "unsupported-node";
+  reason?: string;
 };
 /**
  * Detect the ObjectType of a given node
+ * @param context The context of the rule
  * @param node The node to check
- * @param initialScope  The initial scope to check for variable declarations
  * @returns The ObjectType of the node, or undefined if not detected
  */
-declare function getObjectType(node: TSESTree.Node | unit, initialScope: Scope): ObjectType | unit;
+declare function computeObjectType(context: RuleContext, node: TSESTree.Node | null): ObjectType | null;
 //#endregion
-//#region src/var-property.d.ts
+//#region src/find-enclosing-assignment-target.d.ts
+/**
+ * Finds the enclosing assignment target (variable, property, etc.) for a given node
+ *
+ * @todo Verify correctness and completeness of this function
+ * @param node The starting node
+ * @returns The enclosing assignment target node, or null if not found
+ */
+declare function findEnclosingAssignmentTarget(node: TSESTree.Node): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | null;
 /**
- * Find a property by name in an array of properties
- * Handles spread elements by recursively resolving the referenced object
- * @param name The property name to find
- * @param properties The array of properties to search
- * @param initialScope The scope to use for variable resolution
- * @param seen Set of already seen variable names to prevent circular references
- * @returns The found property or unit if not found
+ * Type representing the possible assignment targets returned by `findEnclosingAssignmentTarget`
  */
-declare function findProperty(name: string, properties: (TSESTree.Property | TSESTree.RestElement | TSESTree.SpreadElement)[], initialScope: Scope, seen?: Set<string>): (typeof properties)[number] | unit;
+type AssignmentTarget = ReturnType<typeof findEnclosingAssignmentTarget>;
 //#endregion
-//#region src/var-scope.d.ts
+//#region src/is-assignment-target-equal.d.ts
 /**
- * Get all variables from the given scope up to the global scope
- * @param initialScope The scope to start from
- * @returns All variables from the given scope up to the global scope
+ * Check if two assignment targets are equal
+ * Compares nodes directly or by their values
+ * @param context The rule context
+ * @param a The first node to compare
+ * @param b The second node to compare
+ * @returns True if the assignment targets are equal
+ * @internal
  */
-declare function getVariables(initialScope: Scope): Variable[];
+declare function isAssignmentTargetEqual(context: RuleContext, a: TSESTree.Node, b: TSESTree.Node): boolean;
+//#endregion
+//#region src/is-value-equal.d.ts
 /**
- * Find a variable by name or identifier node in the scope chain
- * @param initialScope The scope to start searching from
- * @returns The found variable or unit if not found
- * @overload
- * @param nameOrNode The variable name or identifier node to find
- * @param initialScope The scope to start searching from
- * @returns The found variable or unit if not found
+ * Determine whether node value equals to another node value
+ * @param context rule context
+ * @param a node to compare
+ * @param b node to compare
+ * @returns `true` if node value equal
  */
-declare const findVariable: {
-  (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | unit) => Variable | unit;
-  (nameOrNode: string | TSESTree.Identifier | unit, initialScope: Scope): Variable | unit;
-};
+declare function isValueEqual(context: RuleContext, a: TSESTree.Node, b: TSESTree.Node): boolean;
+//#endregion
+//#region src/resolve.d.ts
 /**
- * Get all child scopes recursively from a given scope
- * @param scope The scope to get child scopes from
- * @returns Array of all child scopes including the input scope
+ * Resolves an identifier to the AST node that represents its value,
+ * suitable for use in ESLint rule analysis.
+ *
+ * The resolution follows these rules per definition type:
+ *
+ * | Definition type          | `def.node`                                   | Returns                            |
+ * |--------------------------|----------------------------------------------|------------------------------------|
+ * | `Variable`               | `VariableDeclarator`                         | `def.node.init` (or `null`)        |
+ * | `FunctionName`           | `FunctionDeclaration` / `FunctionExpression` | `def.node`                         |
+ * | `ClassName`              | `ClassDeclaration` / `ClassExpression`       | `def.node`                         |
+ * | `Parameter`              | containing function node                     | `def.node` (if a real function)    |
+ * | `TSEnumName`             | `TSEnumDeclaration`                          | `def.node`                         |
+ * | `TSEnumMember`           | `TSEnumMember`                               | `def.node.initializer` (or `null`) |
+ * | `ImportBinding`          | import specifier                             | `null`                             |
+ * | `CatchClause`            | `CatchClause`                                | `null`                             |
+ * | `TSModuleName`           | `TSModuleDeclaration`                        | `null`                             |
+ * | `Type`                   | type alias node                              | `null`                             |
+ * | `ImplicitGlobalVariable` | any node                                     | `null`                             |
+ *
+ * @param context The ESLint rule context used for scope lookup.
+ * @param node The identifier to resolve.
+ * @param options Optional settings:
+ * - `at`: Index of the definition to resolve (default: `0` for the first definition).
+ * - `localOnly`: If `true`, only consider variables declared in the same scope as the identifier
+ *   will miss variables declared in an outer scope). When `false` (default), traverse the scope
+ *   chain upward via `findVariable` so that references to outer-scope bindings are resolved
+ *   correctly.
+ * @returns The resolved node, or `null` if the identifier cannot be resolved to a value node.
  */
-declare function getChildScopes(scope: Scope): readonly Scope[];
+declare function resolve(context: RuleContext, node: TSESTree.Identifier, options?: Partial<{
+  at: number;
+  localOnly: boolean;
+}>): TSESTree.Node | null;
 //#endregion
-export { AssignmentTarget, ObjectType, findEnclosingAssignmentTarget, findImportSource, findProperty, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, getVariableDefinitionNodeLoose, getVariables, isAssignmentTargetEqual, isNodeEqual };
+export { AssignmentTarget, ObjectType, computeObjectType, findEnclosingAssignmentTarget, isAssignmentTargetEqual, isValueEqual, resolve };

package/dist/index.js

@@ -1,87 +1,184 @@
 import * as ast from "@eslint-react/ast";
-import { dual, identity, unit } from "@eslint-react/eff";
+import { isIdentifier } from "@eslint-react/ast";
+import { DefinitionType } from "@typescript-eslint/scope-manager";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import * as astUtils from "@typescript-eslint/utils/ast-utils";
-import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
-import { P, match } from "ts-pattern";
+import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 
-//#region src/var-definition.ts
+//#region src/resolve.ts
 /**
-* Get the definition node of a variable at a specific definition index
-* @param variable The variable to get the definition node from
-* @param at The index of the definition to retrieve (negative index supported)
-* @returns The definition node or unit if not found
+* Resolves an identifier to the AST node that represents its value,
+* suitable for use in ESLint rule analysis.
+*
+* The resolution follows these rules per definition type:
+*
+* | Definition type          | `def.node`                                   | Returns                            |
+* |--------------------------|----------------------------------------------|------------------------------------|
+* | `Variable`               | `VariableDeclarator`                         | `def.node.init` (or `null`)        |
+* | `FunctionName`           | `FunctionDeclaration` / `FunctionExpression` | `def.node`                         |
+* | `ClassName`              | `ClassDeclaration` / `ClassExpression`       | `def.node`                         |
+* | `Parameter`              | containing function node                     | `def.node` (if a real function)    |
+* | `TSEnumName`             | `TSEnumDeclaration`                          | `def.node`                         |
+* | `TSEnumMember`           | `TSEnumMember`                               | `def.node.initializer` (or `null`) |
+* | `ImportBinding`          | import specifier                             | `null`                             |
+* | `CatchClause`            | `CatchClause`                                | `null`                             |
+* | `TSModuleName`           | `TSModuleDeclaration`                        | `null`                             |
+* | `Type`                   | type alias node                              | `null`                             |
+* | `ImplicitGlobalVariable` | any node                                     | `null`                             |
+*
+* @param context The ESLint rule context used for scope lookup.
+* @param node The identifier to resolve.
+* @param options Optional settings:
+* - `at`: Index of the definition to resolve (default: `0` for the first definition).
+* - `localOnly`: If `true`, only consider variables declared in the same scope as the identifier
+*   will miss variables declared in an outer scope). When `false` (default), traverse the scope
+*   chain upward via `findVariable` so that references to outer-scope bindings are resolved
+*   correctly.
+* @returns The resolved node, or `null` if the identifier cannot be resolved to a value node.
 */
-function getVariableDefinitionNode(variable, at) {
-	if (variable == null) return unit;
+function resolve(context, node, options) {
+	const { at = 0, localOnly = false } = options ?? {};
+	const scope = context.sourceCode.getScope(node);
+	const variable = localOnly ? scope.set.get(node.name) : findVariable(scope, node);
+	if (variable == null) return null;
 	const def = variable.defs.at(at);
-	if (def == null) return unit;
-	switch (true) {
-		case def.type === DefinitionType.FunctionName && def.node.type === AST_NODE_TYPES.FunctionDeclaration: return def.node;
-		case def.type === DefinitionType.ClassName && def.node.type === AST_NODE_TYPES.ClassDeclaration: return def.node;
-		case "init" in def.node && def.node.init != null && !("declarations" in def.node.init): return def.node.init;
-		default: return unit;
+	if (def == null) return null;
+	switch (def.type) {
+		case DefinitionType.FunctionName: return def.node;
+		case DefinitionType.ClassName: return def.node;
+		case DefinitionType.Variable: {
+			const { init } = def.node;
+			if (init == null) return null;
+			if ("declarations" in init) return null;
+			return init;
+		}
+		case DefinitionType.Parameter: return ast.isFunction(def.node) ? def.node : null;
+		case DefinitionType.TSEnumName: return def.node;
+		case DefinitionType.TSEnumMember: return def.node.initializer ?? null;
+		case DefinitionType.ImportBinding: return null;
+		case DefinitionType.CatchClause: return null;
+		case DefinitionType.TSModuleName: return null;
+		case DefinitionType.Type: return null;
+		case DefinitionType.ImplicitGlobalVariable: return null;
+		default: return null;
 	}
 }
-/**
-* Get the definition node of a variable at a specific definition index (loose version)
-* Also returns the function node if the definition is a parameter
-* @param variable The variable to get the definition node from
-* @param at The index of the definition to retrieve
-* @returns The definition node or unit if not found
-*/
-function getVariableDefinitionNodeLoose(variable, at) {
-	if (variable == null) return unit;
-	const node = getVariableDefinitionNode(variable, at);
-	if (node != null) return node;
-	const def = variable.defs.at(at);
-	if (def?.type === DefinitionType.Parameter && ast.isFunction(def.node)) return def.node;
-	return unit;
-}
 
 //#endregion
-//#region src/var-scope.ts
+//#region src/compute-object-type.ts
 /**
-* Get all variables from the given scope up to the global scope
-* @param initialScope The scope to start from
-* @returns All variables from the given scope up to the global scope
+* Detect the ObjectType of a given node
+* @param context The context of the rule
+* @param node The node to check
+* @returns The ObjectType of the node, or undefined if not detected
 */
-function getVariables(initialScope) {
-	let scope = initialScope;
-	const variables = [...scope.variables];
-	while (scope.type !== ScopeType.global) {
-		scope = scope.upper;
-		variables.push(...scope.variables);
+function computeObjectType(context, node) {
+	if (node == null) return null;
+	switch (node.type) {
+		case AST_NODE_TYPES.JSXElement:
+		case AST_NODE_TYPES.JSXFragment: return {
+			kind: "jsx",
+			node
+		};
+		case AST_NODE_TYPES.ArrayExpression: return {
+			kind: "array",
+			node
+		};
+		case AST_NODE_TYPES.ObjectExpression: return {
+			kind: "plain",
+			node
+		};
+		case AST_NODE_TYPES.ClassExpression: return {
+			kind: "class",
+			node
+		};
+		case AST_NODE_TYPES.NewExpression:
+		case AST_NODE_TYPES.ThisExpression: return {
+			kind: "instance",
+			node
+		};
+		case AST_NODE_TYPES.FunctionDeclaration:
+		case AST_NODE_TYPES.FunctionExpression:
+		case AST_NODE_TYPES.ArrowFunctionExpression: return {
+			kind: "function",
+			node
+		};
+		case AST_NODE_TYPES.Literal:
+			if ("regex" in node) return {
+				kind: "regexp",
+				node
+			};
+			return null;
+		case AST_NODE_TYPES.Identifier: {
+			if ((context.sourceCode.getScope(node).set.get(node.name)?.defs.at(-1))?.type === DefinitionType.Parameter) return null;
+			const initNode = resolve(context, node, {
+				at: -1,
+				localOnly: true
+			});
+			if (initNode == null) return null;
+			return computeObjectType(context, initNode);
+		}
+		case AST_NODE_TYPES.MemberExpression:
+			if (!("object" in node)) return null;
+			return computeObjectType(context, node.object);
+		case AST_NODE_TYPES.AssignmentExpression:
+		case AST_NODE_TYPES.AssignmentPattern:
+			if (!("right" in node)) return null;
+			return computeObjectType(context, node.right);
+		case AST_NODE_TYPES.LogicalExpression: return computeObjectType(context, node.right);
+		case AST_NODE_TYPES.ConditionalExpression: return computeObjectType(context, node.consequent) ?? computeObjectType(context, node.alternate);
+		case AST_NODE_TYPES.SequenceExpression:
+			if (node.expressions.length === 0) return null;
+			return computeObjectType(context, node.expressions[node.expressions.length - 1] ?? null);
+		case AST_NODE_TYPES.CallExpression:
+			switch (true) {
+				case isIdentifier(node.callee, "Boolean"): return null;
+				case isIdentifier(node.callee, "String"): return null;
+				case isIdentifier(node.callee, "Number"): return null;
+				case isIdentifier(node.callee, "Object"): return {
+					kind: "plain",
+					node
+				};
+				case isIdentifier(node.callee, "Array"): return {
+					kind: "array",
+					node
+				};
+				case isIdentifier(node.callee, "RegExp"): return {
+					kind: "regexp",
+					node
+				};
+			}
+			return {
+				kind: "unknown",
+				node,
+				reason: "call-expression"
+			};
+		default:
+			if (!("expression" in node) || typeof node.expression !== "object") return null;
+			return computeObjectType(context, node.expression);
 	}
-	return variables.reverse();
 }
+
+//#endregion
+//#region src/find-enclosing-assignment-target.ts
 /**
-* Find a variable by name or identifier node in the scope chain
-* @param initialScope The scope to start searching from
-* @returns The found variable or unit if not found
-* @overload
-* @param nameOrNode The variable name or identifier node to find
-* @param initialScope The scope to start searching from
-* @returns The found variable or unit if not found
-*/
-const findVariable = dual(2, (nameOrNode, initialScope) => {
-	if (nameOrNode == null) return unit;
-	return astUtils.findVariable(initialScope, nameOrNode) ?? unit;
-});
-/**
-* Get all child scopes recursively from a given scope
-* @param scope The scope to get child scopes from
-* @returns Array of all child scopes including the input scope
+* Finds the enclosing assignment target (variable, property, etc.) for a given node
+*
+* @todo Verify correctness and completeness of this function
+* @param node The starting node
+* @returns The enclosing assignment target node, or null if not found
 */
-function getChildScopes(scope) {
-	const scopes = [scope];
-	for (const childScope of scope.childScopes) scopes.push(...getChildScopes(childScope));
-	return scopes;
+function findEnclosingAssignmentTarget(node) {
+	switch (true) {
+		case node.type === AST_NODE_TYPES.VariableDeclarator: return node.id;
+		case node.type === AST_NODE_TYPES.AssignmentExpression: return node.left;
+		case node.type === AST_NODE_TYPES.PropertyDefinition: return node.key;
+		case node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node: return null;
+		default: return findEnclosingAssignmentTarget(node.parent);
+	}
 }
 
 //#endregion
-//#region src/var-node-equality.ts
+//#region src/is-value-equal.ts
 const thisBlockTypes = [
 	AST_NODE_TYPES.FunctionDeclaration,
 	AST_NODE_TYPES.FunctionExpression,
@@ -90,35 +187,35 @@ const thisBlockTypes = [
 ];
 /**
 * Determine whether node value equals to another node value
+* @param context rule context
 * @param a node to compare
 * @param b node to compare
-* @param initialScopes initial scopes of the two nodes
 * @returns `true` if node value equal
 */
-function isNodeEqual(a, b, initialScopes) {
+function isValueEqual(context, a, b) {
 	a = ast.isTypeExpression(a) ? ast.getUnderlyingExpression(a) : a;
 	b = ast.isTypeExpression(b) ? ast.getUnderlyingExpression(b) : b;
-	const [aScope, bScope] = initialScopes;
+	const [aScope, bScope] = [context.sourceCode.getScope(a), context.sourceCode.getScope(b)];
 	switch (true) {
 		case a === b: return true;
 		case a.type === AST_NODE_TYPES.Literal && b.type === AST_NODE_TYPES.Literal: return a.value === b.value;
 		case a.type === AST_NODE_TYPES.TemplateElement && b.type === AST_NODE_TYPES.TemplateElement: return a.value.cooked === b.value.cooked;
 		case a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier: {
-			const aVar = findVariable(a, aScope);
-			const bVar = findVariable(b, bScope);
-			const aVarNode = getVariableDefinitionNodeLoose(aVar, 0);
-			const bVarNode = getVariableDefinitionNodeLoose(bVar, 0);
-			const aVarNodeParent = aVarNode?.parent;
-			const bVarNodeParent = bVarNode?.parent;
+			const aDefNode = resolve(context, a);
+			const bDefNode = resolve(context, b);
+			const aDefNodeParent = aDefNode?.parent;
+			const bDefNodeParent = bDefNode?.parent;
+			const aVar = findVariable(aScope, a);
+			const bVar = findVariable(bScope, b);
 			const aDef = aVar?.defs.at(0);
 			const bDef = bVar?.defs.at(0);
 			const aDefParentParent = aDef?.parent?.parent;
 			const bDefParentParent = bDef?.parent?.parent;
 			switch (true) {
-				case aVarNodeParent?.type === AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === AST_NODE_TYPES.CallExpression && ast.isFunction(aVarNode) && ast.isFunction(bVarNode): {
-					if (!ast.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) return false;
-					const aParams = aVarNode.params;
-					const bParams = bVarNode.params;
+				case aDefNodeParent?.type === AST_NODE_TYPES.CallExpression && bDefNodeParent?.type === AST_NODE_TYPES.CallExpression && ast.isFunction(aDefNode) && ast.isFunction(bDefNode): {
+					if (!ast.isNodeEqual(aDefNodeParent.callee, bDefNodeParent.callee)) return false;
+					const aParams = aDefNode.params;
+					const bParams = bDefNode.params;
 					const aPos = aParams.findIndex((x) => ast.isNodeEqual(x, a));
 					const bPos = bParams.findIndex((x) => ast.isNodeEqual(x, b));
 					return aPos !== -1 && bPos !== -1 && aPos === bPos;
@@ -134,7 +231,7 @@ function isNodeEqual(a, b, initialScopes) {
 				default: return aVar != null && bVar != null && aVar === bVar;
 			}
 		}
-		case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return ast.isNodeEqual(a.property, b.property) && isNodeEqual(a.object, b.object, initialScopes);
+		case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return ast.isNodeEqual(a.property, b.property) && isValueEqual(context, a.object, b.object);
 		case a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression:
 			if (aScope.block === bScope.block) return true;
 			return ast.findParentNode(a, ast.isOneOf(thisBlockTypes)) === ast.findParentNode(b, ast.isOneOf(thisBlockTypes));
@@ -147,24 +244,7 @@ function isNodeEqual(a, b, initialScopes) {
 }
 
 //#endregion
-//#region src/var-assignment-target.ts
-/** eslint-disable jsdoc/require-param */
-/**
-* Finds the enclosing assignment target (variable, property, etc.) for a given node
-*
-* @todo Verify correctness and completeness of this function
-* @param node The starting node
-* @returns The enclosing assignment target node, or undefined if not found
-*/
-function findEnclosingAssignmentTarget(node) {
-	switch (true) {
-		case node.type === AST_NODE_TYPES.VariableDeclarator: return node.id;
-		case node.type === AST_NODE_TYPES.AssignmentExpression: return node.left;
-		case node.type === AST_NODE_TYPES.PropertyDefinition: return node.key;
-		case node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node: return unit;
-		default: return findEnclosingAssignmentTarget(node.parent);
-	}
-}
+//#region src/is-assignment-target-equal.ts
 /**
 * Check if two assignment targets are equal
 * Compares nodes directly or by their values
@@ -175,152 +255,8 @@ function findEnclosingAssignmentTarget(node) {
 * @internal
 */
 function isAssignmentTargetEqual(context, a, b) {
-	return ast.isNodeEqual(a, b) || isNodeEqual(a, b, [context.sourceCode.getScope(a), context.sourceCode.getScope(b)]);
-}
-
-//#endregion
-//#region src/var-import-source.ts
-/**
-* Get the arguments of a require expression
-* @param node The node to match
-* @returns The require expression arguments or undefined if the node is not a require expression
-*/
-function getRequireExpressionArguments(node) {
-	return match(node).with({
-		type: AST_NODE_TYPES.CallExpression,
-		arguments: P.select(),
-		callee: {
-			type: AST_NODE_TYPES.Identifier,
-			name: "require"
-		}
-	}, identity).with({
-		type: AST_NODE_TYPES.MemberExpression,
-		object: P.select()
-	}, getRequireExpressionArguments).otherwise(() => null);
-}
-/**
-* Find the import source of a variable
-* @param name The variable name
-* @param initialScope The initial scope to search
-* @returns The import source or undefined if not found
-*/
-function findImportSource(name, initialScope) {
-	const latestDef = findVariable(name, initialScope)?.defs.at(-1);
-	if (latestDef == null) return unit;
-	const { node, parent } = latestDef;
-	if (node.type === AST_NODE_TYPES.VariableDeclarator && node.init != null) {
-		const { init } = node;
-		if (init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier) return findImportSource(init.object.name, initialScope);
-		if (init.type === AST_NODE_TYPES.Identifier) return findImportSource(init.name, initialScope);
-		const arg0 = getRequireExpressionArguments(init)?.[0];
-		if (arg0 == null || !ast.isLiteral(arg0, "string")) return unit;
-		return arg0.value;
-	}
-	if (parent?.type === AST_NODE_TYPES.ImportDeclaration) return parent.source.value;
-	return unit;
-}
-
-//#endregion
-//#region src/var-object-type.ts
-/**
-* Detect the ObjectType of a given node
-* @param node The node to check
-* @param initialScope  The initial scope to check for variable declarations
-* @returns The ObjectType of the node, or undefined if not detected
-*/
-function getObjectType(node, initialScope) {
-	if (node == null) return unit;
-	switch (node.type) {
-		case AST_NODE_TYPES.JSXElement:
-		case AST_NODE_TYPES.JSXFragment: return {
-			kind: "jsx",
-			node
-		};
-		case AST_NODE_TYPES.ArrayExpression: return {
-			kind: "array",
-			node
-		};
-		case AST_NODE_TYPES.ObjectExpression: return {
-			kind: "plain",
-			node
-		};
-		case AST_NODE_TYPES.ClassExpression: return {
-			kind: "class",
-			node
-		};
-		case AST_NODE_TYPES.NewExpression:
-		case AST_NODE_TYPES.ThisExpression: return {
-			kind: "instance",
-			node
-		};
-		case AST_NODE_TYPES.FunctionDeclaration:
-		case AST_NODE_TYPES.FunctionExpression:
-		case AST_NODE_TYPES.ArrowFunctionExpression: return {
-			kind: "function",
-			node
-		};
-		case AST_NODE_TYPES.Literal:
-			if ("regex" in node) return {
-				kind: "regexp",
-				node
-			};
-			return unit;
-		case AST_NODE_TYPES.Identifier:
-			if (!("name" in node) || typeof node.name !== "string") return unit;
-			return getObjectType(getVariableDefinitionNode(initialScope.set.get(node.name), -1), initialScope);
-		case AST_NODE_TYPES.MemberExpression:
-			if (!("object" in node)) return unit;
-			return getObjectType(node.object, initialScope);
-		case AST_NODE_TYPES.AssignmentExpression:
-		case AST_NODE_TYPES.AssignmentPattern:
-			if (!("right" in node)) return unit;
-			return getObjectType(node.right, initialScope);
-		case AST_NODE_TYPES.LogicalExpression: return getObjectType(node.right, initialScope);
-		case AST_NODE_TYPES.ConditionalExpression: return getObjectType(node.consequent, initialScope) ?? getObjectType(node.alternate, initialScope);
-		case AST_NODE_TYPES.SequenceExpression:
-			if (node.expressions.length === 0) return unit;
-			return getObjectType(node.expressions[node.expressions.length - 1], initialScope);
-		case AST_NODE_TYPES.CallExpression: return {
-			kind: "unknown",
-			node,
-			reason: "call-expression"
-		};
-		default:
-			if (!("expression" in node) || typeof node.expression !== "object") return unit;
-			return getObjectType(node.expression, initialScope);
-	}
-}
-
-//#endregion
-//#region src/var-property.ts
-/**
-* Find a property by name in an array of properties
-* Handles spread elements by recursively resolving the referenced object
-* @param name The property name to find
-* @param properties The array of properties to search
-* @param initialScope The scope to use for variable resolution
-* @param seen Set of already seen variable names to prevent circular references
-* @returns The found property or unit if not found
-*/
-function findProperty(name, properties, initialScope, seen = /* @__PURE__ */ new Set()) {
-	return properties.findLast((prop) => {
-		if (prop.type === AST_NODE_TYPES.Property) return "name" in prop.key && prop.key.name === name;
-		if (prop.type === AST_NODE_TYPES.SpreadElement) switch (prop.argument.type) {
-			case AST_NODE_TYPES.Identifier: {
-				if (seen.has(prop.argument.name)) return false;
-				const variableNode = getVariableDefinitionNode(findVariable(prop.argument.name, initialScope), 0);
-				if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) {
-					seen.add(prop.argument.name);
-					return findProperty(name, variableNode.properties, initialScope, seen) != null;
-				}
-				return false;
-			}
-			case AST_NODE_TYPES.ObjectExpression: return findProperty(name, prop.argument.properties, initialScope, seen) != null;
-			default: return false;
-		}
-		return false;
-	});
+	return ast.isNodeEqual(a, b) || isValueEqual(context, a, b);
 }
 
 //#endregion
-export { findEnclosingAssignmentTarget, findImportSource, findProperty, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, getVariableDefinitionNodeLoose, getVariables, isAssignmentTargetEqual, isNodeEqual };
+export { computeObjectType, findEnclosingAssignmentTarget, isAssignmentTargetEqual, isValueEqual, resolve };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/var",
-  "version": "3.0.0-next.8",
+  "version": "3.0.0-next.80",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -34,17 +34,18 @@
     "@typescript-eslint/types": "canary",
     "@typescript-eslint/utils": "canary",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-next.8",
-    "@eslint-react/eff": "3.0.0-next.8",
-    "@eslint-react/shared": "3.0.0-next.8"
+    "@eslint-react/ast": "3.0.0-next.80",
+    "@eslint-react/shared": "3.0.0-next.80"
   },
   "devDependencies": {
-    "tsdown": "^0.20.3",
-    "@local/configs": "0.0.0"
+    "@typescript-eslint/typescript-estree": "canary",
+    "tsdown": "^0.21.0",
+    "@local/configs": "0.0.0",
+    "@local/eff": "3.0.0-beta.72"
   },
   "peerDependencies": {
-    "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-    "typescript": ">=4.8.4 <6.0.0"
+    "eslint": "^10.0.0",
+    "typescript": "*"
   },
   "engines": {
     "node": ">=22.0.0"
@@ -52,6 +53,6 @@
   "scripts": {
     "build": "tsdown --dts-resolve",
     "lint:publish": "publint",
-    "lint:ts": "tsc --noEmit"
+    "lint:ts": "tsl"
   }
 }