@eslint-react/var 2.14.0-next.0 → 3.0.0-next.0

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { TSESTree } from "@typescript-eslint/types";
 import { Scope, Variable } from "@typescript-eslint/scope-manager";
 import { RuleContext } from "@eslint-react/shared";
 
-//#region src/find-enclosing-assignment-target.d.ts
+//#region src/var-assignment-target.d.ts
 /**
  * Finds the enclosing assignment target (variable, property, etc.) for a given node
  *
@@ -16,8 +16,35 @@ declare function findEnclosingAssignmentTarget(node: TSESTree.Node): TSESTree.Ar
  * 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/find-import-source.d.ts
+//#region src/var-import-source.d.ts
 /**
  * Find the import source of a variable
  * @param name The variable name
@@ -26,27 +53,17 @@ type AssignmentTarget = ReturnType<typeof findEnclosingAssignmentTarget>;
  */
 declare function findImportSource(name: string, initialScope: Scope): string | undefined;
 //#endregion
-//#region src/find-property.d.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
- */
-declare function findProperty(name: string, properties: (TSESTree.Property | TSESTree.RestElement | TSESTree.SpreadElement)[], initialScope: Scope, seen?: Set<string>): (typeof properties)[number] | unit;
-//#endregion
-//#region src/get-child-scopes.d.ts
+//#region src/var-node-equality.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
+ * 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 getChildScopes(scope: Scope): readonly Scope[];
+declare function isNodeEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [aScope: Scope, bScope: Scope]): boolean;
 //#endregion
-//#region src/get-object-type.d.ts
+//#region src/var-object-type.d.ts
 /**
  * Represents the type classification of an object node
  */
@@ -84,24 +101,19 @@ type ObjectType = {
  */
 declare function getObjectType(node: TSESTree.Node | unit, initialScope: Scope): ObjectType | unit;
 //#endregion
-//#region src/get-variable-definition-node.d.ts
+//#region src/var-property.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
+ * 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
  */
-declare function getVariableDefinitionNodeLoose(variable: Variable | unit, at: number): unit | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
+declare function findProperty(name: string, properties: (TSESTree.Property | TSESTree.RestElement | TSESTree.SpreadElement)[], initialScope: Scope, seen?: Set<string>): (typeof properties)[number] | unit;
 //#endregion
-//#region src/get-variables-from-scope.d.ts
+//#region src/var-scope.d.ts
 /**
  * Get all variables from the given scope up to the global scope
  * @param initialScope The scope to start from
@@ -121,27 +133,11 @@ declare const findVariable: {
   (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | unit) => Variable | unit;
   (nameOrNode: string | TSESTree.Identifier | unit, initialScope: Scope): Variable | unit;
 };
-//#endregion
-//#region src/is-assignment-target-equal.d.ts
-/**
- * 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/is-node-value-equal.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
+ * 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
  */
-declare function isNodeValueEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [aScope: Scope, bScope: Scope]): boolean;
+declare function getChildScopes(scope: Scope): readonly Scope[];
 //#endregion
-export { AssignmentTarget, ObjectType, findEnclosingAssignmentTarget, findImportSource, findProperty, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, getVariableDefinitionNodeLoose, getVariables, isAssignmentTargetEqual, isNodeValueEqual };
+export { AssignmentTarget, ObjectType, findEnclosingAssignmentTarget, findImportSource, findProperty, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, getVariableDefinitionNodeLoose, getVariables, isAssignmentTargetEqual, isNodeEqual };

package/dist/index.js

@@ -1,32 +1,47 @@
+import * as ast from "@eslint-react/ast";
 import { dual, identity, unit } from "@eslint-react/eff";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import * as ast from "@eslint-react/ast";
-import { P, match } from "ts-pattern";
-import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
 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";
 
-//#region src/find-enclosing-assignment-target.ts
-/** eslint-disable jsdoc/require-param */
+//#region src/var-definition.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
+* 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
 */
-function findEnclosingAssignmentTarget(node) {
+function getVariableDefinitionNode(variable, at) {
+	if (variable == null) return unit;
+	const def = variable.defs.at(at);
+	if (def == null) return unit;
 	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);
+		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;
 	}
 }
+/**
+* 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/get-variables-from-scope.ts
+//#region src/var-scope.ts
 /**
 * Get all variables from the given scope up to the global scope
 * @param initialScope The scope to start from
@@ -54,9 +69,117 @@ 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
+*/
+function getChildScopes(scope) {
+	const scopes = [scope];
+	for (const childScope of scope.childScopes) scopes.push(...getChildScopes(childScope));
+	return scopes;
+}
 
 //#endregion
-//#region src/find-import-source.ts
+//#region src/var-node-equality.ts
+const thisBlockTypes = [
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.FunctionExpression,
+	AST_NODE_TYPES.ClassBody,
+	AST_NODE_TYPES.Program
+];
+/**
+* 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
+*/
+function isNodeEqual(a, b, initialScopes) {
+	a = ast.isTypeExpression(a) ? ast.getUnderlyingExpression(a) : a;
+	b = ast.isTypeExpression(b) ? ast.getUnderlyingExpression(b) : b;
+	const [aScope, bScope] = initialScopes;
+	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 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;
+					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;
+				}
+				case aDefParentParent?.type === AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === AST_NODE_TYPES.ForOfStatement: {
+					const aLeft = aDefParentParent.left;
+					const bLeft = bDefParentParent.left;
+					if (aLeft.type !== bLeft.type) return false;
+					const aRight = aDefParentParent.right;
+					const bRight = bDefParentParent.right;
+					return ast.isNodeEqual(aRight, bRight);
+				}
+				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.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));
+		default: {
+			const aStatic = getStaticValue(a, aScope);
+			const bStatic = getStaticValue(b, bScope);
+			return aStatic != null && bStatic != null && aStatic.value === bStatic.value;
+		}
+	}
+}
+
+//#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);
+	}
+}
+/**
+* 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
+*/
+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
@@ -98,86 +221,7 @@ function findImportSource(name, initialScope) {
 }
 
 //#endregion
-//#region src/get-variable-definition-node.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
-*/
-function getVariableDefinitionNode(variable, at) {
-	if (variable == null) return unit;
-	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;
-	}
-}
-/**
-* 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/find-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;
-	});
-}
-
-//#endregion
-//#region src/get-child-scopes.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
-*/
-function getChildScopes(scope) {
-	const scopes = [scope];
-	for (const childScope of scope.childScopes) scopes.push(...getChildScopes(childScope));
-	return scopes;
-}
-
-//#endregion
-//#region src/get-object-type.ts
+//#region src/var-object-type.ts
 /**
 * Detect the ObjectType of a given node
 * @param node The node to check
@@ -248,85 +292,35 @@ function getObjectType(node, initialScope) {
 }
 
 //#endregion
-//#region src/is-node-value-equal.ts
-const thisBlockTypes = [
-	AST_NODE_TYPES.FunctionDeclaration,
-	AST_NODE_TYPES.FunctionExpression,
-	AST_NODE_TYPES.ClassBody,
-	AST_NODE_TYPES.Program
-];
+//#region src/var-property.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
+* 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 isNodeValueEqual(a, b, initialScopes) {
-	a = ast.isTypeExpression(a) ? ast.getUnderlyingExpression(a) : a;
-	b = ast.isTypeExpression(b) ? ast.getUnderlyingExpression(b) : b;
-	const [aScope, bScope] = initialScopes;
-	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 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;
-					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;
-				}
-				case aDefParentParent?.type === AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === AST_NODE_TYPES.ForOfStatement: {
-					const aLeft = aDefParentParent.left;
-					const bLeft = bDefParentParent.left;
-					if (aLeft.type !== bLeft.type) return false;
-					const aRight = aDefParentParent.right;
-					const bRight = bDefParentParent.right;
-					return ast.isNodeEqual(aRight, bRight);
+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;
 				}
-				default: return aVar != null && bVar != null && aVar === bVar;
+				return false;
 			}
+			case AST_NODE_TYPES.ObjectExpression: return findProperty(name, prop.argument.properties, initialScope, seen) != null;
+			default: return false;
 		}
-		case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return ast.isNodeEqual(a.property, b.property) && isNodeValueEqual(a.object, b.object, initialScopes);
-		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));
-		default: {
-			const aStatic = getStaticValue(a, aScope);
-			const bStatic = getStaticValue(b, bScope);
-			return aStatic != null && bStatic != null && aStatic.value === bStatic.value;
-		}
-	}
-}
-
-//#endregion
-//#region src/is-assignment-target-equal.ts
-/**
-* 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
-*/
-function isAssignmentTargetEqual(context, a, b) {
-	return ast.isNodeEqual(a, b) || isNodeValueEqual(a, b, [context.sourceCode.getScope(a), context.sourceCode.getScope(b)]);
+		return false;
+	});
 }
 
 //#endregion
-export { findEnclosingAssignmentTarget, findImportSource, findProperty, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, getVariableDefinitionNodeLoose, getVariables, isAssignmentTargetEqual, isNodeValueEqual };
+export { findEnclosingAssignmentTarget, findImportSource, findProperty, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, getVariableDefinitionNodeLoose, getVariables, isAssignmentTargetEqual, isNodeEqual };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/var",
-  "version": "2.14.0-next.0",
+  "version": "3.0.0-next.0",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -30,13 +30,13 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.55.0",
-    "@typescript-eslint/types": "^8.55.0",
-    "@typescript-eslint/utils": "^8.55.0",
+    "@typescript-eslint/scope-manager": "^8.56.0",
+    "@typescript-eslint/types": "^8.56.0",
+    "@typescript-eslint/utils": "^8.56.0",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "2.14.0-next.0",
-    "@eslint-react/eff": "2.14.0-next.0",
-    "@eslint-react/shared": "2.14.0-next.0"
+    "@eslint-react/ast": "3.0.0-next.0",
+    "@eslint-react/eff": "3.0.0-next.0",
+    "@eslint-react/shared": "3.0.0-next.0"
   },
   "devDependencies": {
     "tsdown": "^0.20.3",
@@ -47,7 +47,7 @@
     "typescript": ">=4.8.4 <6.0.0"
   },
   "engines": {
-    "node": ">=20.19.0"
+    "node": ">=22.0.0"
   },
   "scripts": {
     "build": "tsdown --dts-resolve",