eslint-plugin-react-x 5.2.1-next.1 → 5.2.2-beta.0

package/dist/index.js

@@ -1,18 +1,19 @@
 import { DEFAULT_ESLINT_REACT_SETTINGS, getSettingsFromContext, toRegExp } from "@eslint-react/shared";
-import * as ast from "@eslint-react/ast";
+import { Check, Compare, Extract, Select, Traverse, is, isOneOf } from "@eslint-react/ast";
 import * as core from "@eslint-react/core";
 import { isUseRefCall } from "@eslint-react/core";
 import { merge } from "@eslint-react/eslint";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import { JsxDetectionHint, findParentAttribute, getElementFullType, hasAttribute, isJsxLike } from "@eslint-react/jsx";
-import { computeObjectType, findEnclosingAssignmentTarget, isAssignmentTargetEqual, resolve } from "@eslint-react/var";
+import { computeObjectType, isAssignmentTargetEqual, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
 import { DefinitionType } from "@typescript-eslint/scope-manager";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { P, isMatching, match } from "ts-pattern";
 import { compare } from "compare-versions";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
 import { unionConstituents } from "ts-api-utils";
+import { simpleTraverse } from "@typescript-eslint/typescript-estree";
 import { snakeCase } from "string-ts";
 
 //#region \0rolldown/runtime.js
@@ -142,7 +143,7 @@ const rules$7 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.2.1-next.1";
+var version = "5.2.2-beta.0";
 
 //#endregion
 //#region src/rules/component-hook-factories/lib.ts
@@ -182,6 +183,12 @@ function isHigherOrderComponent(fn) {
 		return false;
 	});
 }
+function isTestMock$1(node) {
+	return node != null && node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.Identifier && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "mock";
+}
+function isTestMockCallback$1(node) {
+	return node != null && Check.isFunction(node) && node.parent.type === AST_NODE_TYPES.CallExpression && isTestMock$1(node.parent.callee) && node.parent.arguments[1] === node;
+}
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -219,9 +226,9 @@ function create$48(context) {
 		const hooks = [...hCollector.api.getAllHooks(program)];
 		for (const { name, node } of fComponents) {
 			if (name == null) continue;
-			const parentFn = ast.findParent(node, ast.isFunction);
+			const parentFn = Traverse.findParent(node, Check.isFunction);
 			if (parentFn == null) continue;
-			if (ast.findParent(node, ast.isTestMockCallback) != null) continue;
+			if (Traverse.findParent(node, isTestMockCallback$1) != null) continue;
 			if (isHigherOrderComponent(parentFn)) continue;
 			if (reported.has(node)) continue;
 			context.report({
@@ -232,9 +239,9 @@ function create$48(context) {
 			reported.add(node);
 		}
 		for (const { name = "unknown", node } of cComponents) {
-			const parentFn = ast.findParent(node, ast.isFunction);
+			const parentFn = Traverse.findParent(node, Check.isFunction);
 			if (parentFn == null) continue;
-			if (ast.findParent(node, ast.isTestMockCallback) != null) continue;
+			if (Traverse.findParent(node, isTestMockCallback$1) != null) continue;
 			if (isHigherOrderComponent(parentFn)) continue;
 			context.report({
 				data: { name },
@@ -243,8 +250,8 @@ function create$48(context) {
 			});
 		}
 		for (const { name, node } of hooks) {
-			if (ast.findParent(node, ast.isFunction) == null) continue;
-			if (ast.findParent(node, ast.isTestMockCallback) != null) continue;
+			if (Traverse.findParent(node, Check.isFunction) == null) continue;
+			if (Traverse.findParent(node, isTestMockCallback$1) != null) continue;
 			if (reported.has(node)) continue;
 			context.report({
 				data: { name },
@@ -290,8 +297,8 @@ function create$47(context) {
 			const hooks = hCollector.api.getAllHooks(node);
 			const funcs = [...comps, ...hooks];
 			for (const call of useCalls) {
-				const stmt = ast.findParent(call, ast.is(AST_NODE_TYPES.TryStatement));
-				const func = ast.findParent(stmt, (n) => funcs.some((f) => f.node === n));
+				const stmt = Traverse.findParent(call, is(AST_NODE_TYPES.TryStatement));
+				const func = Traverse.findParent(stmt, (n) => funcs.some((f) => f.node === n));
 				if (stmt != null && func != null && !reported.has(stmt)) {
 					context.report({
 						messageId: "tryCatchWithUse",
@@ -303,7 +310,7 @@ function create$47(context) {
 			for (const { rets } of funcs) for (const ret of rets) {
 				if (ret == null) continue;
 				if (!isJsxLike(context, ret, hint)) continue;
-				const stmt = ast.findParent(ret, ast.is(AST_NODE_TYPES.TryStatement));
+				const stmt = Traverse.findParent(ret, is(AST_NODE_TYPES.TryStatement));
 				if (stmt != null && !reported.has(stmt)) {
 					context.report({
 						messageId: "tryCatchWithJsx",
@@ -1305,7 +1312,7 @@ function create$46(context) {
 		if (variable == null) return null;
 		for (const def of variable.defs) {
 			if (def.type !== DefinitionType.Parameter) continue;
-			if (!ast.isFunction(def.node)) continue;
+			if (!Check.isFunction(def.node)) continue;
 			const fn = def.node;
 			const firstParam = fn.params.at(0);
 			if (firstParam?.type === AST_NODE_TYPES.Identifier && firstParam.name === id.name) return fn;
@@ -1318,10 +1325,10 @@ function create$46(context) {
 			const { object, property } = node.callee;
 			if (property.type !== AST_NODE_TYPES.Identifier) return;
 			if (!MUTATING_ARRAY_METHODS.has(property.name)) return;
-			const rootId = ast.getRootIdentifier(object);
+			const rootId = Extract.rootIdentifier(object);
 			if (rootId == null) return;
 			if (rootId.name === "draft") return;
-			const enclosingFn = ast.findParent(node, ast.isFunction);
+			const enclosingFn = Traverse.findParent(node, Check.isFunction);
 			if (enclosingFn == null) return;
 			const isState = isStateValue(rootId);
 			const propsDefiningFunc = !isState ? getPropsDefiningFunction(rootId) : null;
@@ -1339,10 +1346,10 @@ function create$46(context) {
 		},
 		AssignmentExpression(node) {
 			if (node.left.type !== AST_NODE_TYPES.MemberExpression) return;
-			const rootId = ast.getRootIdentifier(node.left);
+			const rootId = Extract.rootIdentifier(node.left);
 			if (rootId == null) return;
 			if (rootId.name === "draft") return;
-			const enclosingFn = ast.findParent(node, ast.isFunction);
+			const enclosingFn = Traverse.findParent(node, Check.isFunction);
 			if (enclosingFn == null) return;
 			const isState = isStateValue(rootId);
 			const propsDefiningFunc = !isState ? getPropsDefiningFunction(rootId) : null;
@@ -1367,7 +1374,7 @@ function create$46(context) {
 						insideComponentOrHook = true;
 						break;
 					}
-					current = ast.findParent(current, ast.isFunction);
+					current = Traverse.findParent(current, Check.isFunction);
 				}
 				if (!insideComponentOrHook) continue;
 				if (propsDefiningFunc != null) {
@@ -1606,14 +1613,14 @@ function create$45(context) {
 			classStack.pop();
 		},
 		MemberExpression(node) {
-			if (!ast.isThisExpressionLoose(node.object)) return;
+			if (!Check.thisExpression(node.object)) return;
 			const [currClass, isComponent = false] = classStack.at(-1) ?? [];
 			if (currClass == null || !isComponent) return;
 			const [currMethod, isStatic = false] = methodStack.at(-1) ?? [];
 			if (currMethod == null || isStatic) return;
 			const [setState, hasThisState = false] = setStateStack.at(-1) ?? [];
 			if (setState == null || hasThisState) return;
-			if (ast.getPropertyName(node.property) !== "state") return;
+			if (Extract.propertyName(node.property) !== "state") return;
 			context.report({
 				messageId: "default",
 				node
@@ -1638,8 +1645,8 @@ function create$45(context) {
 			if (currMethod == null || isStatic) return;
 			const [setState, hasThisState = false] = setStateStack.at(-1) ?? [];
 			if (setState == null || hasThisState) return;
-			if (node.init == null || !ast.isThisExpressionLoose(node.init) || node.id.type !== AST_NODE_TYPES.ObjectPattern) return;
-			if (!node.id.properties.some((prop) => prop.type === AST_NODE_TYPES.Property && isKeyLiteral$1(prop, prop.key) && ast.getPropertyName(prop.key) === "state")) return;
+			if (node.init == null || !Check.thisExpression(node.init) || node.id.type !== AST_NODE_TYPES.ObjectPattern) return;
+			if (!node.id.properties.some((prop) => prop.type === AST_NODE_TYPES.Property && isKeyLiteral$1(prop, prop.key) && Extract.propertyName(prop.key) === "state")) return;
 			context.report({
 				messageId: "default",
 				node
@@ -1691,7 +1698,7 @@ function getMapIndexParamName(context, node) {
 	if (indexPosition === -1) return null;
 	const callbackArg = node.arguments[core.isChildrenMap(context, callee) || core.isChildrenForEach(context, callee) ? 1 : 0];
 	if (callbackArg == null) return null;
-	if (!ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(callbackArg)) return null;
+	if (!isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(callbackArg)) return null;
 	const { params } = callbackArg;
 	if (params.length < indexPosition + 1) return null;
 	const param = params.at(indexPosition);
@@ -2106,7 +2113,7 @@ var no_create_ref_default = createRule({
 });
 function create$32(context) {
 	return merge({ CallExpression(node) {
-		if (core.isCreateRefCall(context, node) && ast.findParent(node, core.isClassComponent) == null) context.report({
+		if (core.isCreateRefCall(context, node) && Traverse.findParent(node, core.isClassComponent) == null) context.report({
 			messageId: "default",
 			node
 		});
@@ -2117,7 +2124,7 @@ function create$32(context) {
 //#region src/rules/no-direct-mutation-state/no-direct-mutation-state.ts
 const RULE_NAME$31 = "no-direct-mutation-state";
 function isConstructorFunction(node) {
-	return ast.isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && ast.isMethodOrProperty(node.parent) && node.parent.key.type === AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
+	return isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && Check.isMethodOrProperty(node.parent) && node.parent.key.type === AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
 }
 var no_direct_mutation_state_default = createRule({
 	meta: {
@@ -2133,9 +2140,9 @@ var no_direct_mutation_state_default = createRule({
 function create$31(context) {
 	return merge({ AssignmentExpression(node) {
 		if (!core.isAssignmentToThisState(node)) return;
-		const parentClass = ast.findParent(node, ast.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]));
+		const parentClass = Traverse.findParent(node, isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]));
 		if (parentClass == null) return;
-		if (core.isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== ast.findParent(node, isConstructorFunction)) context.report({
+		if (core.isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== Traverse.findParent(node, isConstructorFunction)) context.report({
 			messageId: "default",
 			node
 		});
@@ -2163,7 +2170,7 @@ function create$30(context) {
 		const aValue = a.value;
 		const bValue = b.value;
 		if (aValue == null || bValue == null) return false;
-		return ast.isNodeEqual(aValue, bValue);
+		return Compare.areEqual(aValue, bValue);
 	}
 	return merge({
 		"JSXAttribute[name.name='key']"(node) {
@@ -2182,12 +2189,12 @@ function create$30(context) {
 					break;
 				}
 				default: {
-					const call = ast.findParent(jsxElement, (n) => n.type === AST_NODE_TYPES.CallExpression && n.callee.type === AST_NODE_TYPES.MemberExpression && n.callee.property.type === AST_NODE_TYPES.Identifier && n.callee.property.name === "map");
-					const iter = ast.findParent(jsxElement, (n) => n === call || ast.isFunction(n));
-					if (!ast.isFunction(iter)) return;
+					const call = Traverse.findParent(jsxElement, (n) => n.type === AST_NODE_TYPES.CallExpression && n.callee.type === AST_NODE_TYPES.MemberExpression && n.callee.property.type === AST_NODE_TYPES.Identifier && n.callee.property.name === "map");
+					const iter = Traverse.findParent(jsxElement, (n) => n === call || Check.isFunction(n));
+					if (!Check.isFunction(iter)) return;
 					const arg0 = call?.arguments[0];
 					if (call == null || arg0 == null) return;
-					if (ast.getUnderlyingExpression(arg0) !== iter) return;
+					if (Extract.unwrapped(arg0) !== iter) return;
 					keyedEntries.set(call, {
 						hasDuplicate: node.value?.type === AST_NODE_TYPES.Literal,
 						keys: [node],
@@ -2234,7 +2241,7 @@ function create$29(context) {
 	if (compare(version, "19.0.0", "<")) return {};
 	return merge({ CallExpression(node) {
 		if (!core.isForwardRefCall(context, node)) return;
-		const id = ast.getFunctionId(node);
+		const id = core.getFunctionId(node);
 		const suggest = canFix(context, node) ? [{
 			fix: getFix(context, node),
 			messageId: "replace"
@@ -2272,7 +2279,7 @@ function canFix(context, node) {
 function getFix(context, node) {
 	return (fixer) => {
 		const [componentNode] = node.arguments;
-		if (componentNode == null || !ast.isFunction(componentNode)) return [];
+		if (componentNode == null || !Check.isFunction(componentNode)) return [];
 		return [
 			fixer.removeRange([node.range[0], componentNode.range[0]]),
 			fixer.removeRange([componentNode.range[1], node.range[1]]),
@@ -2492,16 +2499,16 @@ function create$25(context) {
 	*/
 	function getReportDescriptor(node) {
 		if (node == null) return null;
-		if (ast.is(AST_NODE_TYPES.JSXExpressionContainer)(node)) return getReportDescriptor(node.expression);
-		if (ast.isJSX(node)) return null;
-		if (ast.isTypeExpression(node)) return getReportDescriptor(node.expression);
+		if (is(AST_NODE_TYPES.JSXExpressionContainer)(node)) return getReportDescriptor(node.expression);
+		if (Check.isJSX(node)) return null;
+		if (Check.isTypeExpression(node)) return getReportDescriptor(node.expression);
 		return match(node).with({
 			type: AST_NODE_TYPES.LogicalExpression,
 			operator: "&&"
 		}, ({ left, right }) => {
 			if (left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "!") return getReportDescriptor(right);
 			const initialScope = context.sourceCode.getScope(left);
-			if (ast.isIdentifier(left, "NaN") || getStaticValue(left, initialScope)?.value === "NaN") return {
+			if (Check.identifier(left, "NaN") || getStaticValue(left, initialScope)?.value === "NaN") return {
 				data: { value: context.sourceCode.getText(left) },
 				messageId: "default",
 				node: left
@@ -2546,7 +2553,7 @@ function create$24(context) {
 	});
 	return merge(visitor, { "Program:exit"(program) {
 		for (const { displayName, flag, node } of api.getAllComponents(program)) {
-			const id = ast.getFunctionId(node);
+			const id = core.getFunctionId(node);
 			const isMemoOrForwardRef = (flag & (core.FunctionComponentFlag.ForwardRef | core.FunctionComponentFlag.Memo)) > 0n;
 			if (id != null) continue;
 			if (!isMemoOrForwardRef) continue;
@@ -2578,16 +2585,13 @@ function create$23(context) {
 	const createCalls = [];
 	const displayNameAssignments = [];
 	return merge({
-		[ast.SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION](node) {
-			displayNameAssignments.push(node);
-		},
 		CallExpression(node) {
 			if (!core.isCreateContextCall(context, node)) return;
 			createCalls.push(node);
 		},
 		"Program:exit"() {
 			for (const call of createCalls) {
-				const id = findEnclosingAssignmentTarget(call);
+				const id = resolveEnclosingAssignmentTarget(call);
 				if (id == null) {
 					context.report({
 						messageId: "default",
@@ -2619,6 +2623,9 @@ function create$23(context) {
 					node: id
 				});
 			}
+		},
+		[Select.displayNameAssignment](node) {
+			displayNameAssignments.push(node);
 		}
 	});
 }
@@ -2636,6 +2643,21 @@ function report(context) {
 		return context.report(descriptor);
 	};
 }
+/**
+* Gets the nested return statements in the node that are within the same function
+* @param node The AST node
+* @returns The nested return statements in the node
+*/
+function getNestedReturnStatements(node) {
+	const statements = [];
+	const boundaryNode = Check.isFunction(node) ? node : Traverse.findParent(node, Check.isFunction);
+	simpleTraverse(node, { enter(node) {
+		if (node.type !== AST_NODE_TYPES.ReturnStatement) return;
+		if (Traverse.findParent(node, Check.isFunction) !== boundaryNode) return;
+		statements.push(node);
+	} });
+	return statements;
+}
 
 //#endregion
 //#region src/rules/no-missing-key/no-missing-key.ts
@@ -2678,7 +2700,7 @@ function create$22(context) {
 	}
 	function checkBlock(node) {
 		const descriptors = [];
-		for (const stmt of ast.getNestedReturnStatements(node)) {
+		for (const stmt of getNestedReturnStatements(node)) {
 			if (stmt.argument == null) continue;
 			const desc = check(stmt.argument);
 			if (desc == null) continue;
@@ -2689,7 +2711,7 @@ function create$22(context) {
 	return merge({
 		ArrayExpression(node) {
 			if (inChildrenToArray) return;
-			const elements = node.elements.filter(ast.is(AST_NODE_TYPES.JSXElement));
+			const elements = node.elements.filter(is(AST_NODE_TYPES.JSXElement));
 			if (elements.length === 0) return;
 			for (const el of elements) if (!hasAttribute(context, el, "key")) context.report({
 				messageId: "default",
@@ -2705,7 +2727,7 @@ function create$22(context) {
 			const idx = name === "from" ? 1 : name === "map" ? 0 : -1;
 			if (idx < 0) return;
 			const cb = node.arguments[idx];
-			if (!ast.isFunction(cb)) return;
+			if (!Check.isFunction(cb)) return;
 			if (cb.body.type === AST_NODE_TYPES.BlockStatement) checkBlock(cb.body).forEach(report(context));
 			else report(context)(checkExpr(cb.body));
 		},
@@ -2722,6 +2744,32 @@ function create$22(context) {
 	});
 }
 
+//#endregion
+//#region src/rules/no-misused-capture-owner-stack/lib.ts
+/**
+* Check if the given node is a member expression that accesses `process.env.NODE_ENV`
+* @param node The AST node
+* @returns True if the node is a member expression that accesses `process.env.NODE_ENV`, false otherwise
+*/
+function isProcessEnvNodeEnv(node) {
+	return node != null && node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.MemberExpression && node.object.object.type === AST_NODE_TYPES.Identifier && node.object.object.name === "process" && node.object.property.type === AST_NODE_TYPES.Identifier && node.object.property.name === "env" && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "NODE_ENV";
+}
+/**
+* Check if the given node is a binary expression that compares `process.env.NODE_ENV` with a string literal.
+* @param node The AST node
+* @param operator The operator used in the comparison
+* @param value The string literal value to compare against
+* @returns True if the node is a binary expression that compares `process.env.NODE_ENV` with the specified value, false otherwise
+*/
+function isProcessEnvNodeEnvCompare(node, operator, value) {
+	if (node == null) return false;
+	if (node.type !== AST_NODE_TYPES.BinaryExpression) return false;
+	if (node.operator !== operator) return false;
+	if (isProcessEnvNodeEnv(node.left) && Check.literal(node.right, "string")) return node.right.value === value;
+	if (Check.literal(node.left, "string") && isProcessEnvNodeEnv(node.right)) return node.left.value === value;
+	return false;
+}
+
 //#endregion
 //#region src/rules/no-misused-capture-owner-stack/no-misused-capture-owner-stack.ts
 const RULE_NAME$21 = "no-misused-capture-owner-stack";
@@ -2745,7 +2793,7 @@ function create$21(context) {
 	return merge({
 		CallExpression(node) {
 			if (!core.isCaptureOwnerStackCall(context, node)) return;
-			if (ast.findParent(node, isDevelopmentOnlyCheck) == null) context.report({
+			if (Traverse.findParent(node, isDevelopmentOnlyCheck) == null) context.report({
 				messageId: "missingDevelopmentOnlyCheck",
 				node
 			});
@@ -2765,7 +2813,7 @@ function create$21(context) {
 }
 function isDevelopmentOnlyCheck(node) {
 	if (node.type !== AST_NODE_TYPES.IfStatement) return false;
-	return ast.isProcessEnvNodeEnvCompare(node.test, "!==", "production");
+	return isProcessEnvNodeEnvCompare(node.test, "!==", "production");
 }
 
 //#endregion
@@ -2790,9 +2838,9 @@ function create$20(context) {
 		const fComponents = [...fCollector.api.getAllComponents(program)];
 		const cComponents = [...cCollector.api.getAllComponents(program)];
 		function findEnclosingComponent(node) {
-			return ast.findParent(node, (n) => {
-				if (ast.isFunction(n)) return fComponents.some((c) => c.node === n);
-				if (ast.isClass(n)) return cComponents.some((c) => c.node === n);
+			return Traverse.findParent(node, (n) => {
+				if (Check.isFunction(n)) return fComponents.some((c) => c.node === n);
+				if (Check.isClass(n)) return cComponents.some((c) => c.node === n);
 				return false;
 			});
 		}
@@ -2868,7 +2916,7 @@ function isInsideJSXAttributeValue(node) {
 * @returns `true` if the node is inside a class component's render block
 */
 function isInsideRenderMethod(node) {
-	return ast.findParent(node, (n) => core.isRenderMethodLike(n) && core.isClassComponent(n.parent.parent)) != null;
+	return Traverse.findParent(node, (n) => core.isRenderMethodLike(n) && core.isClassComponent(n.parent.parent)) != null;
 }
 /**
 * Determine whether the node is inside `createElement`'s props argument
@@ -2877,9 +2925,9 @@ function isInsideRenderMethod(node) {
 * @returns `true` if the node is inside `createElement`'s props
 */
 function isInsideCreateElementProps(context, node) {
-	const call = ast.findParent(node, core.isCreateElementCall(context));
+	const call = Traverse.findParent(node, core.isCreateElementCall(context));
 	if (call == null) return false;
-	const prop = ast.findParent(node, ast.is(AST_NODE_TYPES.ObjectExpression));
+	const prop = Traverse.findParent(node, is(AST_NODE_TYPES.ObjectExpression));
 	if (prop == null) return false;
 	return prop === call.arguments[1];
 }
@@ -2905,7 +2953,7 @@ function create$19(context) {
 	const lazyCalls = /* @__PURE__ */ new Set();
 	return merge(fCollector.visitor, cCollector.visitor, hCollector.visitor, {
 		ImportExpression(node) {
-			const lazyCall = ast.findParent(node, (n) => core.isLazyCall(context, n));
+			const lazyCall = Traverse.findParent(node, (n) => core.isLazyCall(context, n));
 			if (lazyCall != null) lazyCalls.add(lazyCall);
 		},
 		"Program:exit"(program) {
@@ -2914,7 +2962,7 @@ function create$19(context) {
 				...hCollector.api.getAllHooks(program),
 				...cCollector.api.getAllComponents(program)
 			];
-			for (const lazy of lazyCalls) if (ast.findParent(lazy, (n) => significantParents.some((p) => p.node === n))) context.report({
+			for (const lazy of lazyCalls) if (Traverse.findParent(lazy, (n) => significantParents.some((p) => p.node === n))) context.report({
 				messageId: "default",
 				node: lazy
 			});
@@ -2940,8 +2988,8 @@ function create$18(context) {
 	if (!context.sourceCode.text.includes("componentDidMount")) return {};
 	return merge({ CallExpression(node) {
 		if (!core.isThisSetStateCall(node)) return;
-		const enclosingClassNode = ast.findParent(node, core.isClassComponent);
-		const enclosingMethodNode = ast.findParent(node, (n) => n === enclosingClassNode || core.isComponentDidMount(n));
+		const enclosingClassNode = Traverse.findParent(node, core.isClassComponent);
+		const enclosingMethodNode = Traverse.findParent(node, (n) => n === enclosingClassNode || core.isComponentDidMount(n));
 		if (enclosingClassNode == null || enclosingMethodNode == null || enclosingMethodNode === enclosingClassNode) return;
 		const enclosingMethodScope = context.sourceCode.getScope(enclosingMethodNode);
 		const setStateCallParentScope = context.sourceCode.getScope(node).upper;
@@ -2970,8 +3018,8 @@ function create$17(context) {
 	if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
 	return merge({ CallExpression(node) {
 		if (!core.isThisSetStateCall(node)) return;
-		const enclosingClassNode = ast.findParent(node, core.isClassComponent);
-		const enclosingMethodNode = ast.findParent(node, (n) => n === enclosingClassNode || core.isComponentDidUpdate(n));
+		const enclosingClassNode = Traverse.findParent(node, core.isClassComponent);
+		const enclosingMethodNode = Traverse.findParent(node, (n) => n === enclosingClassNode || core.isComponentDidUpdate(n));
 		if (enclosingClassNode == null || enclosingMethodNode == null || enclosingMethodNode === enclosingClassNode) return;
 		const enclosingMethodScope = context.sourceCode.getScope(enclosingMethodNode);
 		const setStateCallParentScope = context.sourceCode.getScope(node).upper;
@@ -3000,8 +3048,8 @@ function create$16(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
 	return merge({ CallExpression(node) {
 		if (!core.isThisSetStateCall(node)) return;
-		const enclosingClassNode = ast.findParent(node, core.isClassComponent);
-		const enclosingMethodNode = ast.findParent(node, (n) => n === enclosingClassNode || core.isComponentWillUpdate(n));
+		const enclosingClassNode = Traverse.findParent(node, core.isClassComponent);
+		const enclosingMethodNode = Traverse.findParent(node, (n) => n === enclosingClassNode || core.isComponentWillUpdate(n));
 		if (enclosingClassNode == null || enclosingMethodNode == null || enclosingMethodNode === enclosingClassNode) return;
 		const enclosingMethodScope = context.sourceCode.getScope(enclosingMethodNode);
 		const setStateCallParentScope = context.sourceCode.getScope(node).upper;
@@ -3013,12 +3061,21 @@ function create$16(context) {
 }
 
 //#endregion
-//#region src/rules/no-unnecessary-use-prefix/no-unnecessary-use-prefix.ts
-const RULE_NAME$15 = "no-unnecessary-use-prefix";
+//#region src/rules/no-unnecessary-use-prefix/lib.ts
 const WELL_KNOWN_HOOKS = ["useMDXComponents"];
 function containsUseComments(context, node) {
 	return context.sourceCode.getCommentsInside(node).some(({ value }) => /use\([\s\S]*?\)/u.test(value) || /use[A-Z0-9]\w*\([\s\S]*?\)/u.test(value));
 }
+function isTestMock(node) {
+	return node != null && node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.Identifier && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "mock";
+}
+function isTestMockCallback(node) {
+	return node != null && Check.isFunction(node) && node.parent.type === AST_NODE_TYPES.CallExpression && isTestMock(node.parent.callee) && node.parent.arguments[1] === node;
+}
+
+//#endregion
+//#region src/rules/no-unnecessary-use-prefix/no-unnecessary-use-prefix.ts
+const RULE_NAME$15 = "no-unnecessary-use-prefix";
 var no_unnecessary_use_prefix_default = createRule({
 	meta: {
 		type: "problem",
@@ -3036,10 +3093,10 @@ function create$15(context) {
 		for (const { id, name, hookCalls, node } of api.getAllHooks(program)) {
 			if (name == null) continue;
 			if (hookCalls.length > 0) continue;
-			if (ast.isFunctionEmpty(node)) continue;
+			if (core.isFunctionEmpty(node)) continue;
 			if (WELL_KNOWN_HOOKS.includes(name)) continue;
 			if (containsUseComments(context, node)) continue;
-			if (ast.findParent(node, ast.isTestMockCallback) != null) continue;
+			if (Traverse.findParent(node, isTestMockCallback) != null) continue;
 			context.report({
 				data: { name },
 				messageId: "default",
@@ -3150,7 +3207,7 @@ var no_unstable_context_value_default = createRule({
 function create$11(context) {
 	const { compilationMode, version } = getSettingsFromContext(context);
 	if (compilationMode === "infer" || compilationMode === "all") return {};
-	if (compilationMode === "annotation" && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
+	if (compilationMode === "annotation" && context.sourceCode.ast.body.some((stmt) => Check.directive(stmt) && stmt.directive === "use memo")) return {};
 	const isReact18OrBelow = compare(version, "19.0.0", "<");
 	const { api, visitor } = core.getFunctionComponentCollector(context);
 	const constructions = /* @__PURE__ */ new WeakMap();
@@ -3159,9 +3216,9 @@ function create$11(context) {
 			const selfName = getElementFullType(node.parent).split(".").at(-1);
 			if (selfName == null) return;
 			if (!isContextName(selfName, isReact18OrBelow)) return;
-			const enclosingFunction = ast.findParent(node, ast.isFunction);
+			const enclosingFunction = Traverse.findParent(node, Check.isFunction);
 			if (enclosingFunction == null) return;
-			if (compilationMode === "annotation" && ast.isDirectiveInFunction(enclosingFunction, "use memo")) return;
+			if (compilationMode === "annotation" && core.isFunctionHasDirective(enclosingFunction, "use memo")) return;
 			const attribute = node.attributes.find((attribute) => attribute.type === AST_NODE_TYPES.JSXAttribute && attribute.name.name === "value");
 			if (attribute == null || !("value" in attribute)) return;
 			const value = attribute.value;
@@ -3180,7 +3237,7 @@ function create$11(context) {
 					const suggestion = kind === "function" ? "Consider wrapping it in a useCallback hook." : "Consider wrapping it in a useMemo hook.";
 					context.report({
 						data: {
-							kind: ast.getHumanReadableKind(constructionNode),
+							kind: Extract.humanReadableKind(constructionNode),
 							suggestion
 						},
 						messageId: "unstableContextValue",
@@ -3231,17 +3288,17 @@ function extractIdentifier(node) {
 function create$10(context, [options]) {
 	const { compilationMode } = getSettingsFromContext(context);
 	if (compilationMode === "infer" || compilationMode === "all") return {};
-	if (compilationMode === "annotation" && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
+	if (compilationMode === "annotation" && context.sourceCode.ast.body.some((stmt) => Check.directive(stmt) && stmt.directive === "use memo")) return {};
 	const { api, visitor } = core.getFunctionComponentCollector(context);
+	const SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR = [
+		"VariableDeclarator",
+		"[id.type='ObjectPattern']",
+		"[init.type='Identifier']"
+	].join("");
 	const declarators = /* @__PURE__ */ new WeakMap();
 	const { safeDefaultProps = [] } = options;
 	const safePatterns = safeDefaultProps.map((s) => toRegExp(s));
 	return merge(visitor, {
-		[ast.SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR](node) {
-			const enclosingFunction = ast.findParent(node, ast.isFunction);
-			if (enclosingFunction == null) return;
-			getOrInsertComputed(declarators, enclosingFunction, () => []).push(node);
-		},
 		"Program:exit"(program) {
 			for (const { node: component } of api.getAllComponents(program)) {
 				const { params } = component;
@@ -3262,12 +3319,17 @@ function create$10(context, [options]) {
 						if (identifier != null && safePatterns.some((pattern) => pattern.test(identifier))) continue;
 					}
 					context.report({
-						data: { kind: ast.getHumanReadableKind(right) },
+						data: { kind: Extract.humanReadableKind(right) },
 						messageId: "default",
 						node: right
 					});
 				}
 			}
+		},
+		[SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR](node) {
+			const enclosingFunction = Traverse.findParent(node, Check.isFunction);
+			if (enclosingFunction == null) return;
+			getOrInsertComputed(declarators, enclosingFunction, () => []).push(node);
 		}
 	});
 }
@@ -3323,12 +3385,12 @@ function create$9(context) {
 	function classExit() {
 		const currentClass = classStack.pop();
 		if (currentClass == null || !core.isClassComponent(currentClass)) return;
-		const id = ast.getClassId(currentClass);
+		const id = core.getClassId(currentClass);
 		const defs = propertyDefs.get(currentClass);
 		const usages = propertyUsages.get(currentClass);
 		if (defs == null) return;
 		for (const def of defs) {
-			const methodName = ast.getPropertyName(def);
+			const methodName = Extract.propertyName(def);
 			if (methodName == null) continue;
 			if ((usages?.has(methodName) ?? false) || LIFECYCLE_METHODS.has(methodName)) continue;
 			context.report({
@@ -3361,12 +3423,12 @@ function create$9(context) {
 			const currentMethod = methodStack.at(-1);
 			if (currentClass == null || currentMethod == null) return;
 			if (!core.isClassComponent(currentClass) || currentMethod.static) return;
-			if (!ast.isThisExpressionLoose(node.object) || !isKeyLiteral(node, node.property)) return;
+			if (!Check.thisExpression(node.object) || !isKeyLiteral(node, node.property)) return;
 			if (node.parent.type === AST_NODE_TYPES.AssignmentExpression && node.parent.left === node) {
 				propertyDefs.get(currentClass)?.add(node.property);
 				return;
 			}
-			const propertyName = ast.getPropertyName(node.property);
+			const propertyName = Extract.propertyName(node.property);
 			if (propertyName != null) propertyUsages.get(currentClass)?.add(propertyName);
 		},
 		MethodDefinition: methodEnter,
@@ -3378,9 +3440,9 @@ function create$9(context) {
 			const currentMethod = methodStack.at(-1);
 			if (currentClass == null || currentMethod == null) return;
 			if (!core.isClassComponent(currentClass) || currentMethod.static) return;
-			if (node.init != null && ast.isThisExpressionLoose(node.init) && node.id.type === AST_NODE_TYPES.ObjectPattern) {
+			if (node.init != null && Check.thisExpression(node.init) && node.id.type === AST_NODE_TYPES.ObjectPattern) {
 				for (const prop of node.id.properties) if (prop.type === AST_NODE_TYPES.Property && isKeyLiteral(prop, prop.key)) {
-					const keyName = ast.getPropertyName(prop.key);
+					const keyName = Extract.propertyName(prop.key);
 					if (keyName != null) propertyUsages.get(currentClass)?.add(keyName);
 				}
 			}
@@ -3848,11 +3910,11 @@ function create$6(context) {
 	const nEntries = [];
 	return merge(hCollector.visitor, cCollector.visitor, {
 		CallExpression(node) {
-			const expr = ast.getUnderlyingExpression(node.callee);
+			const expr = Extract.unwrapped(node.callee);
 			switch (true) {
 				case expr.type === AST_NODE_TYPES.Identifier: {
 					if (!IMPURE_FUNCS.get("globalThis")?.has(expr.name)) return;
-					const func = ast.findParent(node, ast.isFunction);
+					const func = Traverse.findParent(node, Check.isFunction);
 					if (func == null) return;
 					cEntries.push({
 						func,
@@ -3864,7 +3926,7 @@ function create$6(context) {
 					const objectName = expr.object.name;
 					const propertyName = expr.property.name;
 					if (!IMPURE_FUNCS.get(objectName)?.has(propertyName)) return;
-					const func = ast.findParent(node, ast.isFunction);
+					const func = Traverse.findParent(node, Check.isFunction);
 					if (func == null) return;
 					cEntries.push({
 						func,
@@ -3875,11 +3937,11 @@ function create$6(context) {
 			}
 		},
 		NewExpression(node) {
-			const expr = ast.getUnderlyingExpression(node.callee);
+			const expr = Extract.unwrapped(node.callee);
 			if (expr.type !== AST_NODE_TYPES.Identifier) return;
 			if (!IMPURE_CTORS.has(expr.name)) return;
 			if (expr.name === "Date" && node.arguments.length > 0) return;
-			const func = ast.findParent(node, ast.isFunction);
+			const func = Traverse.findParent(node, Check.isFunction);
 			if (func == null) return;
 			nEntries.push({
 				func,
@@ -3931,12 +3993,12 @@ function create$5(context) {
 	*/
 	function isInNullCheckTest(node) {
 		let parent = node.parent;
-		while (ast.isTypeExpression(parent)) parent = parent.parent;
+		while (Check.isTypeExpression(parent)) parent = parent.parent;
 		if (!isMatching({
 			type: AST_NODE_TYPES.BinaryExpression,
 			operator: P.union("===", "==", "!==", "!=")
 		}, parent)) return false;
-		const otherSide = parent.left === node || ast.getUnderlyingExpression(parent.left) === node ? parent.right : parent.left;
+		const otherSide = parent.left === node || Extract.unwrapped(parent.left) === node ? parent.right : parent.left;
 		if (otherSide.type !== AST_NODE_TYPES.Literal || otherSide.value != null) return false;
 		return parent.parent.type === AST_NODE_TYPES.IfStatement && parent.parent.test === parent;
 	}
@@ -3952,8 +4014,8 @@ function create$5(context) {
 		if (op !== "===" && op !== "==" && op !== "!==" && op !== "!=") return false;
 		const { left, right } = test;
 		const checkSides = (a, b) => {
-			a = ast.isTypeExpression(a) ? ast.getUnderlyingExpression(a) : a;
-			return a.type === AST_NODE_TYPES.MemberExpression && a.object.type === AST_NODE_TYPES.Identifier && a.object.name === refName && b.type === AST_NODE_TYPES.Literal && b.value == null && ast.getPropertyName(a.property) === "current";
+			a = Check.isTypeExpression(a) ? Extract.unwrapped(a) : a;
+			return a.type === AST_NODE_TYPES.MemberExpression && a.object.type === AST_NODE_TYPES.Identifier && a.object.name === refName && b.type === AST_NODE_TYPES.Literal && b.value == null && Extract.propertyName(a.property) === "current";
 		};
 		return checkSides(left, right) || checkSides(right, left);
 	}
@@ -3978,12 +4040,12 @@ function create$5(context) {
 			}
 		},
 		MemberExpression(node) {
-			if (!ast.isIdentifier(node.property, "current")) return;
+			if (!Check.identifier(node.property, "current")) return;
 			refAccesses.push({
 				isWrite: (() => {
 					let parent = node.parent;
-					while (ast.isTypeExpression(parent)) parent = parent.parent;
-					return match(parent).with({ type: AST_NODE_TYPES.AssignmentExpression }, (p) => p.left === node || ast.getUnderlyingExpression(p.left) === node).with({ type: AST_NODE_TYPES.UpdateExpression }, (p) => p.argument === node || ast.getUnderlyingExpression(p.argument) === node).otherwise(() => false);
+					while (Check.isTypeExpression(parent)) parent = parent.parent;
+					return match(parent).with({ type: AST_NODE_TYPES.AssignmentExpression }, (p) => p.left === node || Extract.unwrapped(p.left) === node).with({ type: AST_NODE_TYPES.UpdateExpression }, (p) => p.argument === node || Extract.unwrapped(p.argument) === node).otherwise(() => false);
 				})(),
 				node
 			});
@@ -3992,7 +4054,7 @@ function create$5(context) {
 			const comps = cCollector.api.getAllComponents(program);
 			const hooks = hCollector.api.getAllHooks(program);
 			const funcs = new Set([...comps.map((c) => c.node), ...hooks.map((h) => h.node)]);
-			const isCompOrHookFn = (n) => ast.isFunction(n) && funcs.has(n);
+			const isCompOrHookFn = (n) => Check.isFunction(n) && funcs.has(n);
 			for (const { isWrite, node } of refAccesses) {
 				const obj = node.object;
 				if (obj.type !== AST_NODE_TYPES.Identifier) continue;
@@ -4002,9 +4064,9 @@ function create$5(context) {
 					case isInitializedFromRef(obj.name, context.sourceCode.getScope(node.object)): break;
 					default: continue;
 				}
-				const boundary = ast.findParent(node, isCompOrHookFn);
+				const boundary = Traverse.findParent(node, isCompOrHookFn);
 				if (boundary == null) continue;
-				if (ast.findParent(node, ast.isFunction) !== boundary) continue;
+				if (Traverse.findParent(node, Check.isFunction) !== boundary) continue;
 				const refName = obj.name;
 				let isLazyInit = isInNullCheckTest(node);
 				if (!isLazyInit) {
@@ -6198,6 +6260,91 @@ function last(array) {
 	return array[array.length - 1];
 }
 
+//#endregion
+//#region src/rules/set-state-in-effect/lib.ts
+/**
+* Get all nested identifiers in a expression like node
+* @param node The node to get the nested identifiers from
+* @returns All nested identifiers
+*/
+function getNestedIdentifiers(node) {
+	const identifiers = [];
+	if (node.type === AST_NODE_TYPES.Identifier) identifiers.push(node);
+	if ("arguments" in node) {
+		const chunk = node.arguments.flatMap(getNestedIdentifiers);
+		identifiers.push(...chunk);
+	}
+	if ("elements" in node) {
+		const chunk = node.elements.filter((x) => x != null).flatMap(getNestedIdentifiers);
+		identifiers.push(...chunk);
+	}
+	if ("properties" in node) {
+		const chunk = node.properties.flatMap(getNestedIdentifiers);
+		identifiers.push(...chunk);
+	}
+	if ("expressions" in node) {
+		const chunk = node.expressions.flatMap(getNestedIdentifiers);
+		identifiers.push(...chunk);
+	}
+	if ("left" in node) {
+		const chunk = getNestedIdentifiers(node.left);
+		identifiers.push(...chunk);
+	}
+	if ("right" in node) {
+		const chunk = getNestedIdentifiers(node.right);
+		identifiers.push(...chunk);
+	}
+	if (node.type === AST_NODE_TYPES.Property) {
+		const chunk = getNestedIdentifiers(node.value);
+		identifiers.push(...chunk);
+	}
+	if (node.type === AST_NODE_TYPES.SpreadElement) {
+		const chunk = getNestedIdentifiers(node.argument);
+		identifiers.push(...chunk);
+	}
+	if (node.type === AST_NODE_TYPES.MemberExpression) {
+		identifiers.push(...getNestedIdentifiers(node.object));
+		if (node.computed) identifiers.push(...getNestedIdentifiers(node.property));
+	}
+	if (node.type === AST_NODE_TYPES.UnaryExpression) {
+		const chunk = getNestedIdentifiers(node.argument);
+		identifiers.push(...chunk);
+	}
+	if (node.type === AST_NODE_TYPES.ChainExpression) {
+		const chunk = getNestedIdentifiers(node.expression);
+		identifiers.push(...chunk);
+	}
+	if (node.type === AST_NODE_TYPES.TSNonNullExpression) {
+		const chunk = getNestedIdentifiers(node.expression);
+		identifiers.push(...chunk);
+	}
+	if (node.type === AST_NODE_TYPES.TSAsExpression) {
+		const chunk = getNestedIdentifiers(node.expression);
+		identifiers.push(...chunk);
+	}
+	if (node.type === AST_NODE_TYPES.TSSatisfiesExpression) {
+		const chunk = getNestedIdentifiers(node.expression);
+		identifiers.push(...chunk);
+	}
+	if (node.type === AST_NODE_TYPES.ConditionalExpression) {
+		identifiers.push(...getNestedIdentifiers(node.test));
+		identifiers.push(...getNestedIdentifiers(node.consequent));
+		identifiers.push(...getNestedIdentifiers(node.alternate));
+	}
+	if (node.type === AST_NODE_TYPES.AwaitExpression) identifiers.push(...getNestedIdentifiers(node.argument));
+	if (node.type === AST_NODE_TYPES.YieldExpression && node.argument != null) identifiers.push(...getNestedIdentifiers(node.argument));
+	if (node.type === AST_NODE_TYPES.UpdateExpression) identifiers.push(...getNestedIdentifiers(node.argument));
+	if (node.type === AST_NODE_TYPES.CallExpression || node.type === AST_NODE_TYPES.NewExpression) identifiers.push(...getNestedIdentifiers(node.callee));
+	if (node.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+		identifiers.push(...getNestedIdentifiers(node.tag));
+		identifiers.push(...getNestedIdentifiers(node.quasi));
+	}
+	if (node.type === AST_NODE_TYPES.ImportExpression) identifiers.push(...getNestedIdentifiers(node.source));
+	if (node.type === AST_NODE_TYPES.TSTypeAssertion) identifiers.push(...getNestedIdentifiers(node.expression));
+	if (node.type === AST_NODE_TYPES.TSInstantiationExpression) identifiers.push(...getNestedIdentifiers(node.expression));
+	return identifiers;
+}
+
 //#endregion
 //#region src/rules/set-state-in-effect/set-state-in-effect.ts
 const RULE_NAME$4 = "set-state-in-effect";
@@ -6243,14 +6390,14 @@ function create$4(context) {
 		return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectCall(node.parent);
 	}
 	function getCallName(node) {
-		if (node.type === AST_NODE_TYPES.CallExpression) return ast.getFullyQualifiedName(node.callee, getText);
-		return ast.getFullyQualifiedName(node, getText);
+		if (node.type === AST_NODE_TYPES.CallExpression) return Extract.fullyQualifiedName(node.callee, getText);
+		return Extract.fullyQualifiedName(node, getText);
 	}
 	function getCallKind(node) {
 		return match(node).when(isUseStateCall, () => "useState").when(isUseEffectCall, () => "useEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
 	}
 	function getFunctionKind(node) {
-		const parent = ast.findParent(node, not(ast.isTypeExpression)) ?? node.parent;
+		const parent = Traverse.findParent(node, not(Check.isTypeExpression)) ?? node.parent;
 		switch (true) {
 			case node.async:
 			case parent.type === AST_NODE_TYPES.CallExpression && isThenCall(parent): return "deferred";
@@ -6306,7 +6453,7 @@ function create$4(context) {
 			if (init == null) continue;
 			switch (true) {
 				case init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier && (init.object.name === "ref" || init.object.name.endsWith("Ref")): return true;
-				case init.type === AST_NODE_TYPES.CallExpression && isUseRefCall(context, init): return true;
+				case init.type === AST_NODE_TYPES.CallExpression && core.isUseRefCall(context, init): return true;
 			}
 		}
 		return false;
@@ -6334,7 +6481,7 @@ function create$4(context) {
 					case entry.kind === "deferred":
 					case entry.node.async: break;
 					case entry.node === setupFunction:
-					case entry.kind === "immediate" && ast.findParent(entry.node, ast.isFunction) === setupFunction: {
+					case entry.kind === "immediate" && Traverse.findParent(entry.node, Check.isFunction) === setupFunction: {
 						const args0 = node.arguments.at(0);
 						if (args0 == null) return;
 						function isArgumentUsingRefValue(context, node) {
@@ -6342,12 +6489,12 @@ function create$4(context) {
 								switch (n.type) {
 									case AST_NODE_TYPES.Identifier: return isInitializedFromRef(n.name, context.sourceCode.getScope(n));
 									case AST_NODE_TYPES.MemberExpression: return isUsingRefValue(n.object);
-									case AST_NODE_TYPES.CallExpression: return isUsingRefValue(n.callee) || ast.getNestedIdentifiers(n).some(isUsingRefValue);
+									case AST_NODE_TYPES.CallExpression: return isUsingRefValue(n.callee) || getNestedIdentifiers(n).some(isUsingRefValue);
 									default: return false;
 								}
 							};
 							if (isUsingRefValue(node)) return true;
-							return ast.isFunction(node) && context.sourceCode.getScope(node.body).references.some((r) => isUsingRefValue(r.identifier));
+							return Check.isFunction(node) && context.sourceCode.getScope(node.body).references.some((r) => isUsingRefValue(r.identifier));
 						}
 						if (isArgumentUsingRefValue(context, args0)) return;
 						context.report({
@@ -6358,14 +6505,14 @@ function create$4(context) {
 						return;
 					}
 					default: {
-						const init = ast.findParent(node, isHookDecl)?.init;
+						const init = Traverse.findParent(node, isHookDecl)?.init;
 						if (init == null) getOrInsertComputed(setStateCallsByFn, entry.node, () => []).push(node);
 						else getOrInsertComputed(setStateInHookCallbacks, init, () => []).push(node);
 					}
 				}
 			}).with("useEffect", () => {
-				if (ast.isFunction(node.arguments.at(0))) return;
-				setupFnIds.push(...ast.getNestedIdentifiers(node));
+				if (Check.isFunction(node.arguments.at(0))) return;
+				setupFnIds.push(...getNestedIdentifiers(node));
 			}).with("other", () => {
 				if (entry.node !== setupFunction) return;
 				trackedFnCalls.push(node);
@@ -6379,14 +6526,14 @@ function create$4(context) {
 					const parent = node.parent.parent;
 					if (parent.type !== AST_NODE_TYPES.CallExpression) break;
 					if (!core.isUseMemoCall(context, parent)) break;
-					const init = ast.findParent(parent, isHookDecl)?.init;
+					const init = Traverse.findParent(parent, isHookDecl)?.init;
 					if (init != null) getOrInsertComputed(setStateInEffectArg, init, () => []).push(node);
 					break;
 				}
 				case AST_NODE_TYPES.CallExpression:
 					if (node !== node.parent.arguments.at(0)) break;
 					if (core.isUseCallbackCall(context, node.parent)) {
-						const init = ast.findParent(node.parent, isHookDecl)?.init;
+						const init = Traverse.findParent(node.parent, isHookDecl)?.init;
 						if (init != null) getOrInsertComputed(setStateInEffectArg, init, () => []).push(node);
 						break;
 					}
@@ -6499,13 +6646,13 @@ function create$3(context) {
 	function isInsideEventHandler(node, stopAt) {
 		let current = node.parent;
 		while (current != null && current !== stopAt) {
-			if (ast.isFunction(current) && current !== stopAt) return true;
+			if (Check.isFunction(current) && current !== stopAt) return true;
 			current = current.parent;
 		}
 		return false;
 	}
 	function isComponentOrHookLikeFunction(node) {
-		const id = ast.getFunctionId(node);
+		const id = core.getFunctionId(node);
 		if (id == null) return false;
 		if (id.type === AST_NODE_TYPES.Identifier) return core.isFunctionComponentName(id.name) || core.isHookName(id.name);
 		if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) return core.isFunctionComponentName(id.property.name) || core.isHookName(id.property.name);
@@ -6513,7 +6660,7 @@ function create$3(context) {
 	}
 	function getFunctionKind(node) {
 		if (isComponentOrHookLikeFunction(node)) return "component";
-		const parent = ast.findParent(node, not(ast.isTypeExpression)) ?? node.parent;
+		const parent = Traverse.findParent(node, not(Check.isTypeExpression)) ?? node.parent;
 		if (parent.type === AST_NODE_TYPES.CallExpression && parent.callee !== node) return "callback";
 		return "other";
 	}
@@ -6599,7 +6746,7 @@ function create$2(context) {
 	return merge(hCollector.visitor, cCollector.visitor, {
 		CallExpression(node) {
 			if (!isEvalCall(node)) return;
-			const func = ast.findParent(node, ast.isFunction);
+			const func = Traverse.findParent(node, Check.isFunction);
 			if (func == null) return;
 			evalCalls.push({
 				func,
@@ -6638,7 +6785,7 @@ function create$2(context) {
 			}
 		},
 		WithStatement(node) {
-			const func = ast.findParent(node, ast.isFunction);
+			const func = Traverse.findParent(node, Check.isFunction);
 			if (func == null) return;
 			withStmts.push({
 				func,
@@ -6670,7 +6817,7 @@ function create$1(context) {
 	return merge({ CallExpression(node) {
 		if (!core.isUseMemoCall(context, node)) return;
 		let parent = node.parent;
-		while (ast.isTypeExpression(parent)) parent = parent.parent;
+		while (Check.isTypeExpression(parent)) parent = parent.parent;
 		if (!(parent.type === AST_NODE_TYPES.VariableDeclarator || parent.type === AST_NODE_TYPES.AssignmentExpression || parent.type === AST_NODE_TYPES.AssignmentPattern || parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.ReturnStatement || parent.type === AST_NODE_TYPES.JSXExpressionContainer || parent.type === AST_NODE_TYPES.CallExpression || parent.type === AST_NODE_TYPES.NewExpression || parent.type === AST_NODE_TYPES.ArrayExpression || parent.type === AST_NODE_TYPES.ConditionalExpression || parent.type === AST_NODE_TYPES.LogicalExpression || parent.type === AST_NODE_TYPES.SequenceExpression || parent.type === AST_NODE_TYPES.SpreadElement || parent.type === AST_NODE_TYPES.TemplateLiteral || parent.type === AST_NODE_TYPES.BinaryExpression || parent.type === AST_NODE_TYPES.UnaryExpression || parent.type === AST_NODE_TYPES.MemberExpression || parent.type === AST_NODE_TYPES.TaggedTemplateExpression || parent.type === AST_NODE_TYPES.ChainExpression || parent.type === AST_NODE_TYPES.ArrowFunctionExpression)) {
 			context.report({
 				messageId: "notAssignedToVariable",
@@ -6680,10 +6827,10 @@ function create$1(context) {
 		}
 		const [callbackArg] = node.arguments;
 		if (callbackArg == null) return;
-		if (!ast.isFunction(callbackArg)) return;
+		if (!Check.isFunction(callbackArg)) return;
 		if (callbackArg.type === AST_NODE_TYPES.ArrowFunctionExpression && callbackArg.body.type !== AST_NODE_TYPES.BlockStatement) return;
 		if (callbackArg.body.type !== AST_NODE_TYPES.BlockStatement) return;
-		const returnStatements = ast.getNestedReturnStatements(callbackArg);
+		const returnStatements = getNestedReturnStatements(callbackArg);
 		if (returnStatements.length === 0) {
 			context.report({
 				messageId: "missingReturnValue",
@@ -6698,6 +6845,101 @@ function create$1(context) {
 	} });
 }
 
+//#endregion
+//#region src/rules/use-state/lib.ts
+/**
+* Get all nested expressions of type T in an expression like node
+* @param type The type of the expression to retrieve within the node
+* @returns A partially applied function bound to a predicate of type AST. The returned function can be called passing a
+* node, and it will return an array of all nested expressions of type AST.
+*/
+function getNestedExpressionsOfType(type) {
+	const isNodeOfType = is(type);
+	const recurse = (node) => {
+		const expressions = [];
+		if (isNodeOfType(node)) expressions.push(node);
+		if ("arguments" in node) {
+			const chunk = node.arguments.flatMap(recurse);
+			expressions.push(...chunk);
+		}
+		if ("expression" in node && node.expression !== true && node.expression !== false) {
+			const chunk = recurse(node.expression);
+			expressions.push(...chunk);
+		}
+		if ("left" in node) {
+			const chunk = recurse(node.left);
+			expressions.push(...chunk);
+		}
+		if ("right" in node) {
+			const chunk = recurse(node.right);
+			expressions.push(...chunk);
+		}
+		if ("test" in node && node.test != null) {
+			const chunk = recurse(node.test);
+			expressions.push(...chunk);
+		}
+		if ("consequent" in node) {
+			const chunk = Array.isArray(node.consequent) ? node.consequent.flatMap(recurse) : recurse(node.consequent);
+			expressions.push(...chunk);
+		}
+		if ("alternate" in node && node.alternate != null) {
+			const chunk = Array.isArray(node.alternate) ? node.alternate.flatMap(recurse) : recurse(node.alternate);
+			expressions.push(...chunk);
+		}
+		if ("elements" in node) {
+			const chunk = node.elements.filter((x) => x != null).flatMap(recurse);
+			expressions.push(...chunk);
+		}
+		if ("properties" in node) {
+			const chunk = node.properties.flatMap(recurse);
+			expressions.push(...chunk);
+		}
+		if ("expressions" in node) {
+			const chunk = node.expressions.flatMap(recurse);
+			expressions.push(...chunk);
+		}
+		if (node.type === AST_NODE_TYPES.Property) {
+			const chunk = recurse(node.value);
+			expressions.push(...chunk);
+		}
+		if (node.type === AST_NODE_TYPES.SpreadElement) {
+			const chunk = recurse(node.argument);
+			expressions.push(...chunk);
+		}
+		if (node.type === AST_NODE_TYPES.MemberExpression) {
+			expressions.push(...recurse(node.object));
+			if (node.computed) expressions.push(...recurse(node.property));
+		}
+		if (node.type === AST_NODE_TYPES.UnaryExpression) {
+			const chunk = recurse(node.argument);
+			expressions.push(...chunk);
+		}
+		if (node.type === AST_NODE_TYPES.AwaitExpression) expressions.push(...recurse(node.argument));
+		if (node.type === AST_NODE_TYPES.YieldExpression && node.argument != null) expressions.push(...recurse(node.argument));
+		if (node.type === AST_NODE_TYPES.UpdateExpression) expressions.push(...recurse(node.argument));
+		if (node.type === AST_NODE_TYPES.CallExpression || node.type === AST_NODE_TYPES.NewExpression) expressions.push(...recurse(node.callee));
+		if (node.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+			expressions.push(...recurse(node.tag));
+			expressions.push(...recurse(node.quasi));
+		}
+		if (node.type === AST_NODE_TYPES.ImportExpression) expressions.push(...recurse(node.source));
+		return expressions;
+	};
+	return recurse;
+}
+/**
+* Get all nested new expressions in an expression like node
+* @param node The node to get the nested new expressions from
+* @returns All nested new expressions
+*/
+const getNestedNewExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.NewExpression);
+/**
+* Get all nested call expressions in a expression like node
+* @param node The node to get the nested call expressions from
+* @returns All nested call expressions
+*/
+const getNestedCallExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.CallExpression);
+
 //#endregion
 //#region src/rules/use-state/use-state.ts
 const RULE_NAME = "use-state";
@@ -6752,20 +6994,20 @@ function create(context) {
 		if (enforceLazyInitialization) {
 			const [useStateInput] = node.arguments;
 			if (useStateInput != null) {
-				for (const expr of ast.getNestedNewExpressions(useStateInput)) {
+				for (const expr of getNestedNewExpressions(useStateInput)) {
 					if (!("name" in expr.callee)) continue;
 					if (LAZY_INIT_ALLOW_LIST.includes(expr.callee.name)) continue;
-					if (ast.findParent(expr, (n) => core.isUseCall(context, n)) != null) continue;
+					if (Traverse.findParent(expr, (n) => core.isUseCall(context, n)) != null) continue;
 					context.report({
 						messageId: "invalidInitialization",
 						node: expr
 					});
 				}
-				for (const expr of ast.getNestedCallExpressions(useStateInput)) {
+				for (const expr of getNestedCallExpressions(useStateInput)) {
 					if (!("name" in expr.callee)) continue;
 					if (core.isHookName(expr.callee.name)) continue;
 					if (LAZY_INIT_ALLOW_LIST.includes(expr.callee.name)) continue;
-					if (ast.findParent(expr, (n) => core.isUseCall(context, n)) != null) continue;
+					if (Traverse.findParent(expr, (n) => core.isUseCall(context, n)) != null) continue;
 					context.report({
 						messageId: "invalidInitialization",
 						node: expr
@@ -6781,7 +7023,7 @@ function create(context) {
 			});
 			return;
 		}
-		const id = findEnclosingAssignmentTarget(node);
+		const id = resolveEnclosingAssignmentTarget(node);
 		if (id?.type !== AST_NODE_TYPES.ArrayPattern) {
 			if (!enforceAssignment) return;
 			context.report({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.2.1-next.1",
+  "version": "5.2.2-beta.0",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -40,17 +40,18 @@
     "@typescript-eslint/scope-manager": "^8.58.1",
     "@typescript-eslint/type-utils": "^8.58.1",
     "@typescript-eslint/types": "^8.58.1",
+    "@typescript-eslint/typescript-estree": "^8.58.1",
     "@typescript-eslint/utils": "^8.58.1",
     "compare-versions": "^6.1.1",
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.5.0",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.2.1-next.1",
-    "@eslint-react/core": "5.2.1-next.1",
-    "@eslint-react/eslint": "5.2.1-next.1",
-    "@eslint-react/shared": "5.2.1-next.1",
-    "@eslint-react/jsx": "5.2.1-next.1",
-    "@eslint-react/var": "5.2.1-next.1"
+    "@eslint-react/ast": "5.2.2-beta.0",
+    "@eslint-react/core": "5.2.2-beta.0",
+    "@eslint-react/eslint": "5.2.2-beta.0",
+    "@eslint-react/jsx": "5.2.2-beta.0",
+    "@eslint-react/var": "5.2.2-beta.0",
+    "@eslint-react/shared": "5.2.2-beta.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",
@@ -58,8 +59,8 @@
     "eslint": "^10.2.0",
     "tsdown": "^0.21.7",
     "tsl-dx": "^0.10.3",
-    "@local/eff": "3.0.0-beta.72",
-    "@local/configs": "0.0.0"
+    "@local/configs": "0.0.0",
+    "@local/eff": "3.0.0-beta.72"
   },
   "peerDependencies": {
     "eslint": "^10.2.0",