eslint-plugin-react-x 5.23.4 → 5.24.0-beta.0

package/dist/index.js

@@ -145,7 +145,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.23.4";
+var version = "5.24.0-beta.0";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -162,8 +162,8 @@ var error_boundaries_default = createRule({
 		type: "problem",
 		docs: { description: "Validates usage of Error Boundaries instead of try/catch for errors in child components." },
 		messages: {
-			tryCatchWithJsx: "Use an Error Boundary to catch errors in child components. Try/catch can't catch errors during React's rendering process.",
-			tryCatchWithUse: "Use an Error Boundary instead of try/catch around the 'use' hook. The 'use' hook suspends the component, and its errors can only be caught by Error Boundaries."
+			"try-catch-with-jsx": "Use an Error Boundary to catch errors in child components. Try/catch can't catch errors during React's rendering process.",
+			"try-catch-with-use": "Use an Error Boundary instead of try/catch around the 'use' hook. The 'use' hook suspends the component, and its errors can only be caught by Error Boundaries."
 		},
 		schema: []
 	},
@@ -192,7 +192,7 @@ function create$50(context) {
 				const func = Traverse.findParent(stmt, (n) => funcs.some((f) => f.node === n));
 				if (stmt != null && func != null && !reported.has(stmt)) {
 					context.report({
-						messageId: "tryCatchWithUse",
+						messageId: "try-catch-with-use",
 						node: stmt
 					});
 					reported.add(stmt);
@@ -204,7 +204,7 @@ function create$50(context) {
 				const stmt = Traverse.findEnclosingTryBlock(ret);
 				if (stmt != null && !reported.has(stmt)) {
 					context.report({
-						messageId: "tryCatchWithJsx",
+						messageId: "try-catch-with-jsx",
 						node: stmt
 					});
 					reported.add(stmt);
@@ -1155,7 +1155,7 @@ function resolveToFunction(context, node, seen = /* @__PURE__ */ new Set()) {
 
 //#endregion
 //#region src/rules/globals/collect.ts
-function createFactCollector$3() {
+function createFactCollector$6() {
 	const facts = {
 		callEdges: [],
 		methodCalls: [],
@@ -1343,9 +1343,9 @@ var globals_default = createRule({
 		type: "problem",
 		docs: { description: "Validates against assignment/mutation of globals during render, part of ensuring that side effects must run outside of render." },
 		messages: {
-			mutatingGlobal: "Do not mutate '{{name}}' during render. Global variables exist outside React's control and make rendering impure.",
-			mutatingGlobalArrayMethod: "Do not call '{{method}}()' on '{{name}}' during render. Mutating global arrays during render makes rendering impure.",
-			mutatingGlobalProperty: "Do not mutate '{{name}}' during render. Modifying global objects during render makes rendering impure."
+			"mutating-global": "Do not mutate '{{name}}' during render. Global variables exist outside React's control and make rendering impure.",
+			"mutating-global-array-method": "Do not call '{{method}}()' on '{{name}}' during render. Mutating global arrays during render makes rendering impure.",
+			"mutating-global-property": "Do not mutate '{{name}}' during render. Modifying global objects during render makes rendering impure."
 		},
 		schema: []
 	},
@@ -1356,7 +1356,7 @@ var globals_default = createRule({
 function create$49(context) {
 	const hooks = core.getHookCollector(context);
 	const comps = core.getFunctionComponentCollector(context);
-	const facts = createFactCollector$3();
+	const facts = createFactCollector$6();
 	return merge(hooks.visitor, comps.visitor, facts.visitor, { "Program:exit"(program) {
 		const renderFunctions = [...comps.api.getAllComponents(program), ...hooks.api.getAllHooks(program)].map(({ node }) => node);
 		const directEffects = inferGlobalMutations(context, facts.facts);
@@ -1368,7 +1368,7 @@ function create$49(context) {
 			};
 			context.report({
 				data,
-				messageId: match(effect).with({ kind: "global" }, () => "mutatingGlobal").with({ kind: "method" }, () => "mutatingGlobalArrayMethod").with({ kind: "property" }, () => "mutatingGlobalProperty").exhaustive(),
+				messageId: match(effect).with({ kind: "global" }, () => "mutating-global").with({ kind: "method" }, () => "mutating-global-array-method").with({ kind: "property" }, () => "mutating-global-property").exhaustive(),
 				node: effect.node
 			});
 		}
@@ -1482,7 +1482,7 @@ function isRefLikeChain(context, node) {
 
 //#endregion
 //#region src/rules/immutability/collect.ts
-function createFactCollector$2() {
+function createFactCollector$5() {
 	const facts = {
 		mutations: [],
 		sinks: []
@@ -1746,9 +1746,9 @@ var immutability_default = createRule({
 		type: "problem",
 		docs: { description: "Validates against mutating props, state, and other immutable values, including through functions passed into frozen contexts such as JSX props, hook arguments, and hook return values." },
 		messages: {
-			default: "This function may (indirectly) reassign or modify '{{name}}' after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.",
-			direct: "Do not mutate '{{name}}' directly. {{detail}}",
-			mutates: "This modifies '{{name}}'."
+			"direct-mutation": "Do not mutate '{{name}}' directly. {{detail}}",
+			"indirect-mutation": "This function may (indirectly) reassign or modify '{{name}}' after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.",
+			"mutation-site": "This modifies '{{name}}'."
 		},
 		schema: []
 	},
@@ -1759,7 +1759,7 @@ var immutability_default = createRule({
 function create$48(context) {
 	const hooks = core.getHookCollector(context);
 	const comps = core.getFunctionComponentCollector(context);
-	const facts = createFactCollector$2();
+	const facts = createFactCollector$5();
 	return merge(hooks.visitor, comps.visitor, facts.visitor, { "Program:exit"(program) {
 		for (const hook of hooks.api.getAllHooks(program)) for (const expression of hook.rets) if (expression != null) facts.facts.sinks.push({
 			kind: "hook-return",
@@ -1780,12 +1780,12 @@ function create$48(context) {
 				reportedMutations.add(mutation.node);
 				context.report({
 					data: { name: mutation.name },
-					messageId: "default",
+					messageId: "indirect-mutation",
 					node: expression
 				});
 				context.report({
 					data: { name: mutation.name },
-					messageId: "mutates",
+					messageId: "mutation-site",
 					node: mutation.node
 				});
 			}
@@ -1799,7 +1799,7 @@ function create$48(context) {
 					name: mutation.name,
 					detail: mutation.detail
 				},
-				messageId: "direct",
+				messageId: "direct-mutation",
 				node: mutation.node
 			});
 		}
@@ -3026,27 +3026,6 @@ const constNull = constant(null);
 */
 const constUndefined = constant(void 0);
 /**
-* Returns no meaningful value when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that is called only for its effect and has no
-* meaningful return value.
-*
-* **Example** (Returning void from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constVoid(), undefined)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constVoid = constUndefined;
-/**
 * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
 * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
 *
@@ -3412,10 +3391,10 @@ const INDEX_PARAM_POSITIONS = /* @__PURE__ */ new Map([
 */
 function getNestedReturnStatements$1(node) {
 	const statements = [];
-	const boundaryNode = Check.isFunction(node) ? node : Traverse.findParent(node, Check.isFunction);
+	const boundary = 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, (n) => n === boundaryNode) != null) return;
+		if (Traverse.findParent(node, Check.isFunction, (n) => n === boundary) != null) return;
 		statements.push(node);
 	} });
 	return statements;
@@ -3430,7 +3409,7 @@ var no_missing_key_default = createRule({
 		docs: { description: "Disallows missing 'key' on items in list rendering." },
 		messages: {
 			default: "Missing 'key' for element when rendering list.",
-			unexpectedFragmentSyntax: "Use fragment component instead of '<>' because it does not support `key`."
+			"unexpected-fragment-syntax": "Use fragment component instead of '<>' because it does not support `key`."
 		},
 		schema: []
 	},
@@ -3468,7 +3447,7 @@ function create$24(context) {
 				node
 			}];
 			case AST_NODE_TYPES.JSXFragment: return [{
-				messageId: "unexpectedFragmentSyntax",
+				messageId: "unexpected-fragment-syntax",
 				node
 			}];
 			case AST_NODE_TYPES.ConditionalExpression: return [...visitItemExpression(node.consequent), ...visitItemExpression(node.alternate)];
@@ -3554,8 +3533,8 @@ var no_misused_capture_owner_stack_default = createRule({
 		type: "problem",
 		docs: { description: "Prevents incorrect usage of 'captureOwnerStack'." },
 		messages: {
-			missingDevelopmentOnlyCheck: `Don't call 'captureOwnerStack' directly. Use 'if (process.env.NODE_ENV !== "production") {...}' to conditionally access it.`,
-			useNamespaceImport: "Don't use named imports of 'captureOwnerStack' in files that are bundled for development and production. Use a namespace import instead."
+			"missing-development-only-check": `Don't call 'captureOwnerStack' directly. Use 'if (process.env.NODE_ENV !== "production") {...}' to conditionally access it.`,
+			"use-namespace-import": "Don't use named imports of 'captureOwnerStack' in files that are bundled for development and production. Use a namespace import instead."
 		},
 		schema: []
 	},
@@ -3570,7 +3549,7 @@ function create$23(context) {
 		CallExpression(node) {
 			if (!core.isCaptureOwnerStackCall(context, node)) return;
 			if (Traverse.findParent(node, (n) => isDevelopmentOnlyCheck(context, n)) == null) context.report({
-				messageId: "missingDevelopmentOnlyCheck",
+				messageId: "missing-development-only-check",
 				node
 			});
 		},
@@ -3580,7 +3559,7 @@ function create$23(context) {
 				if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) continue;
 				if (!Check.isIdentifier(specifier.imported, "captureOwnerStack")) continue;
 				context.report({
-					messageId: "useNamespaceImport",
+					messageId: "use-namespace-import",
 					node: specifier
 				});
 			}
@@ -4082,7 +4061,7 @@ var no_unstable_context_value_default = createRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Prevents non-stable values (i.e., object literals) from being used as a value for 'Context.Provider'." },
-		messages: { unstableContextValue: "A/an '{{kind}}' passed as the value prop to the context provider should not be constructed. It will change on every render. {{suggestion}}" },
+		messages: { "unstable-context-value": "A/an '{{kind}}' passed as the value prop to the context provider should not be constructed. It will change on every render. {{suggestion}}" },
 		schema: []
 	},
 	name: RULE_NAME$13,
@@ -4125,7 +4104,7 @@ function create$13(context) {
 							kind: getHumanReadableKind$1(constructionNode),
 							suggestion
 						},
-						messageId: "unstableContextValue",
+						messageId: "unstable-context-value",
 						node: constructionNode
 					});
 				}
@@ -5289,7 +5268,7 @@ function isAfterTerminatingNonNullGuard(node, getNullBranch) {
 * reachable during render and are not collected. All inference is deferred to
 * `Program:exit`.
 */
-function createFactCollector$1() {
+function createFactCollector$4() {
 	const facts = {
 		bindings: [],
 		callEdges: [],
@@ -5722,10 +5701,10 @@ var refs_default = createRule({
 		type: "problem",
 		docs: { description: "Validates correct usage of refs by checking that 'ref.current' is not read or written during render." },
 		messages: {
-			duplicateRefInit: "Ref is initialized more than once during render. Only a single 'if (ref.current == null)' initialization is allowed; move any additional initialization into an effect or event handler.",
-			readDuringRender: "Cannot access refs during render",
-			refPassedToFunction: "Passing a ref to a function may read its value during render",
-			writeDuringRender: "Cannot update ref during render"
+			"duplicate-ref-init": "Ref is initialized more than once during render. Only a single 'if (ref.current == null)' initialization is allowed; move any additional initialization into an effect or event handler.",
+			"read-during-render": "Cannot access refs during render",
+			"ref-passed-to-function": "Passing a ref to a function may read its value during render",
+			"write-during-render": "Cannot update ref during render"
 		},
 		schema: []
 	},
@@ -5736,7 +5715,7 @@ var refs_default = createRule({
 function create$6(context) {
 	const hooks = core.getHookCollector(context);
 	const comps = core.getFunctionComponentCollector(context);
-	const facts = createFactCollector$1();
+	const facts = createFactCollector$4();
 	return merge(hooks.visitor, comps.visitor, facts.visitor, { "Program:exit"(program) {
 		const boundaries = /* @__PURE__ */ new Set([...comps.api.getAllComponents(program).map((component) => component.node), ...hooks.api.getAllHooks(program).map((hook) => hook.node)]);
 		const resolver = createBindingResolver(context, facts.facts);
@@ -5744,7 +5723,7 @@ function create$6(context) {
 		const reachability = collectReachableFunctions(boundaries, callGraph);
 		const violations = [...inferRefViolations(facts.facts.refAccesses, boundaries, reachability, resolver), ...inferRefPassViolations(facts.facts.passSites, boundaries, reachability, resolver)];
 		for (const violation of violations) context.report({
-			messageId: match(violation).with({ kind: "duplicate-init" }, () => "duplicateRefInit").with({ kind: "pass" }, () => "refPassedToFunction").with({ kind: "read" }, () => "readDuringRender").with({ kind: "write" }, () => "writeDuringRender").exhaustive(),
+			messageId: match(violation).with({ kind: "duplicate-init" }, () => "duplicate-ref-init").with({ kind: "pass" }, () => "ref-passed-to-function").with({ kind: "read" }, () => "read-during-render").with({ kind: "write" }, () => "write-during-render").exhaustive(),
 			node: violation.node
 		});
 	} });
@@ -7885,7 +7864,43 @@ function last(array) {
 }
 
 //#endregion
-//#region src/rules/set-state-in-effect/lib.ts
+//#region src/rules/set-state-in-effect/helpers.ts
+const IDENTIFIER_VISITOR_KEYS = {
+	[AST_NODE_TYPES.ArrayExpression]: ["elements"],
+	[AST_NODE_TYPES.ArrayPattern]: ["elements"],
+	[AST_NODE_TYPES.AssignmentExpression]: ["left", "right"],
+	[AST_NODE_TYPES.AssignmentPattern]: ["left", "right"],
+	[AST_NODE_TYPES.AwaitExpression]: ["argument"],
+	[AST_NODE_TYPES.BinaryExpression]: ["left", "right"],
+	[AST_NODE_TYPES.CallExpression]: ["arguments", "callee"],
+	[AST_NODE_TYPES.ChainExpression]: ["expression"],
+	[AST_NODE_TYPES.ConditionalExpression]: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	[AST_NODE_TYPES.ForInStatement]: ["left", "right"],
+	[AST_NODE_TYPES.ForOfStatement]: ["left", "right"],
+	[AST_NODE_TYPES.ImportExpression]: ["source"],
+	[AST_NODE_TYPES.LogicalExpression]: ["left", "right"],
+	[AST_NODE_TYPES.MemberExpression]: ["object", "property"],
+	[AST_NODE_TYPES.NewExpression]: ["arguments", "callee"],
+	[AST_NODE_TYPES.ObjectExpression]: ["properties"],
+	[AST_NODE_TYPES.ObjectPattern]: ["properties"],
+	[AST_NODE_TYPES.Property]: ["value"],
+	[AST_NODE_TYPES.SequenceExpression]: ["expressions"],
+	[AST_NODE_TYPES.SpreadElement]: ["argument"],
+	[AST_NODE_TYPES.TaggedTemplateExpression]: ["tag", "quasi"],
+	[AST_NODE_TYPES.TemplateLiteral]: ["expressions"],
+	[AST_NODE_TYPES.TSAsExpression]: ["expression"],
+	[AST_NODE_TYPES.TSInstantiationExpression]: ["expression"],
+	[AST_NODE_TYPES.TSNonNullExpression]: ["expression"],
+	[AST_NODE_TYPES.TSSatisfiesExpression]: ["expression"],
+	[AST_NODE_TYPES.TSTypeAssertion]: ["expression"],
+	[AST_NODE_TYPES.UnaryExpression]: ["argument"],
+	[AST_NODE_TYPES.UpdateExpression]: ["argument"],
+	[AST_NODE_TYPES.YieldExpression]: ["argument"]
+};
 /**
 * Get all nested identifiers in a expression like node
 * @param node The node to get the nested identifiers from
@@ -7893,79 +7908,14 @@ function last(array) {
 */
 function getNestedIdentifiers(node) {
 	const identifiers = [];
-	if (Check.isIdentifier(node)) 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));
+	simpleTraverse(node, {
+		enter(node, parent) {
+			if (node.type !== AST_NODE_TYPES.Identifier) return;
+			if (parent?.type === AST_NODE_TYPES.MemberExpression && !parent.computed && parent.property === node) return;
+			identifiers.push(node);
+		},
+		visitorKeys: IDENTIFIER_VISITOR_KEYS
+	});
 	return identifiers;
 }
 function isHookDecl(node) {
@@ -7976,19 +7926,195 @@ function isHookDecl(node) {
 	const name = Extract.getCalleeName(init);
 	return name != null && core.isHookName(name);
 }
+function isThenCall(node) {
+	return Extract.unwrap(node.callee).type === AST_NODE_TYPES.MemberExpression && Extract.getCalleeName(node) === "then";
+}
+function isTerminatingStatement(node) {
+	if (node.type === AST_NODE_TYPES.ReturnStatement || node.type === AST_NODE_TYPES.ThrowStatement) return true;
+	if (node.type === AST_NODE_TYPES.BlockStatement) return node.body.some(isTerminatingStatement);
+	return false;
+}
+/**
+* Get the display name of a setState call reference for reporting.
+* @param node The setState call node (CallExpression or Identifier)
+* @param getText The source text getter
+* @returns The fully qualified name of the call
+*/
+function getCallName(node, getText) {
+	if (node.type === AST_NODE_TYPES.CallExpression) return Extract.getFullyQualifiedName(node.callee, getText);
+	return Extract.getFullyQualifiedName(node, getText);
+}
+/**
+* Get the actual CallExpression node from a setState call reference.
+* When the node is an Identifier that is the callee of a CallExpression,
+* returns the parent CallExpression; otherwise returns the node itself.
+* @param node The setState call node (CallExpression or Identifier)
+* @returns The actual CallExpression node
+*/
+function getSetStateCallExpression(node) {
+	return Check.isIdentifier(node) && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node ? node.parent : node;
+}
+
+//#endregion
+//#region src/rules/set-state-in-effect/collect.ts
+function createFactCollector$3(additionalStateHooks, additionalEffectHooks) {
+	const facts = {
+		calls: [],
+		setStateReferences: [],
+		setupIdentifiers: []
+	};
+	const functionEntries = [];
+	const setupFnRef = { current: null };
+	function isUseStateCall(node) {
+		return core.isUseStateLikeCall(node, additionalStateHooks);
+	}
+	function isUseEffectCall(node) {
+		return core.isUseEffectLikeCall(node, additionalEffectHooks);
+	}
+	function isUseEffectSetupCallback(node) {
+		return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectCall(node.parent);
+	}
+	function getFunctionKind(node) {
+		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";
+			case node.type !== AST_NODE_TYPES.FunctionDeclaration && parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node: return "immediate";
+			case isUseEffectSetupCallback(node): return "setup";
+			default: return "other";
+		}
+	}
+	return {
+		facts,
+		visitor: {
+			":function"(node) {
+				const kind = getFunctionKind(node);
+				functionEntries.push({
+					kind,
+					node
+				});
+				if (kind === "setup") setupFnRef.current = node;
+			},
+			":function:exit"(node) {
+				const { kind } = functionEntries.at(-1) ?? {};
+				if (kind === "setup" && setupFnRef.current === node) setupFnRef.current = null;
+				functionEntries.pop();
+			},
+			CallExpression(node) {
+				const entry = functionEntries.at(-1);
+				if (entry == null || entry.node.async) return;
+				if (isUseStateCall(node)) return;
+				if (isUseEffectCall(node)) {
+					if (!Check.isFunction(node.arguments.at(0))) facts.setupIdentifiers.push(...getNestedIdentifiers(node));
+					return;
+				}
+				facts.calls.push({
+					enclosingFunction: entry.node,
+					enclosingFunctionKind: entry.kind,
+					node,
+					setupFunction: setupFnRef.current
+				});
+			},
+			Identifier(node) {
+				if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) return;
+				switch (node.parent.type) {
+					case AST_NODE_TYPES.ArrowFunctionExpression:
+						facts.setStateReferences.push({
+							kind: "callback-body",
+							node
+						});
+						return;
+					case AST_NODE_TYPES.CallExpression:
+						if (node === node.parent.arguments.at(0)) facts.setStateReferences.push({
+							kind: "call-argument",
+							node
+						});
+						return;
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/set-state-in-effect/origins.ts
+/**
+* Create a resolver that answers whether an identifier or call originates from
+* a `useState`-like hook's setter function (the element at index 1 of the
+* returned tuple).
+* @param context The rule context
+* @returns The setState provenance resolver
+*/
+function createSetStateResolver$1(context) {
+	const { additionalStateHooks } = getSettingsFromContext(context);
+	function isUseStateCall(node) {
+		return core.isUseStateLikeCall(node, additionalStateHooks);
+	}
+	function isSetStateId(id, at) {
+		const initNode = resolveOrigin(context, id);
+		if (initNode == null) return false;
+		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
+		if (!isUseStateCall(initNode)) return false;
+		const variableNodeParent = initNode.parent;
+		if (!("id" in variableNodeParent) || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
+		return variableNodeParent.id.elements.findIndex((e) => e != null && Check.isIdentifier(e, id.name)) === at;
+	}
+	function isSetStateCall(node) {
+		const callee = Extract.unwrap(node.callee);
+		switch (callee.type) {
+			case AST_NODE_TYPES.CallExpression: {
+				const innerCallee = Extract.unwrap(callee.callee);
+				if (innerCallee.type !== AST_NODE_TYPES.MemberExpression) return false;
+				if (!("name" in innerCallee.object)) return false;
+				const isAt = Extract.getCalleeName(callee) === "at";
+				const [index] = callee.arguments;
+				if (!isAt || index == null) return false;
+				const indexScope = context.sourceCode.getScope(node);
+				return getStaticValue(index, indexScope)?.value === 1 && isSetStateId(innerCallee.object);
+			}
+			case AST_NODE_TYPES.Identifier: return isSetStateId(callee, 1);
+			case AST_NODE_TYPES.MemberExpression: {
+				if (!("name" in callee.object)) return false;
+				const property = callee.property;
+				const propertyScope = context.sourceCode.getScope(node);
+				return getStaticValue(property, propertyScope)?.value === 1 && isSetStateId(callee.object, 1);
+			}
+			default: return false;
+		}
+	}
+	return {
+		isSetStateCall,
+		isSetStateId,
+		isUseStateCall
+	};
+}
 function isInitializedFromRef(context, name, initialScope, seen = /* @__PURE__ */ new Set()) {
 	const { additionalRefHooks } = getSettingsFromContext(context);
 	if (seen.has(name)) return false;
 	seen.add(name);
-	for (const { node } of findVariable(initialScope, name)?.defs ?? []) {
+	for (const def of findVariable(initialScope, name)?.defs ?? []) {
+		if (def.type === DefinitionType.Parameter) {
+			if (def.name.type === AST_NODE_TYPES.Identifier && (def.name.name === "ref" || def.name.name.endsWith("Ref"))) return true;
+			continue;
+		}
+		const { node } = def;
 		if (node.type !== AST_NODE_TYPES.VariableDeclarator) continue;
 		const init = node.init == null ? null : Extract.unwrap(node.init);
 		if (init == null) continue;
 		switch (true) {
 			case init.type === AST_NODE_TYPES.MemberExpression: {
-				let object = Extract.unwrap(init.object);
-				while (object.type === AST_NODE_TYPES.MemberExpression) object = Extract.unwrap(object.object);
-				return Check.isIdentifier(object) && (object.name === "ref" || object.name.endsWith("Ref"));
+				let current = init;
+				while (current.type === AST_NODE_TYPES.MemberExpression) {
+					const property = Extract.unwrap(current.property);
+					const object = Extract.unwrap(current.object);
+					if (!current.computed && Check.isIdentifier(property, "current")) {
+						const sourceName = getRefSourceName(object);
+						if (sourceName === "ref" || sourceName?.endsWith("Ref") === true) return true;
+					}
+					current = object;
+				}
+				if (Check.isIdentifier(current) && (current.name === "ref" || current.name.endsWith("Ref"))) return true;
+				return getNestedIdentifiers(init).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id), seen));
 			}
 			case init.type === AST_NODE_TYPES.CallExpression && core.isUseRefLikeCall(init, additionalRefHooks): return true;
 			default: return getNestedIdentifiers(init).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id), seen));
@@ -7997,6 +8123,31 @@ function isInitializedFromRef(context, name, initialScope, seen = /* @__PURE__ *
 	return false;
 }
 /**
+* Check if the setState call is using a ref value, which is safe to use in an effect (ex: `setState(ref.current.scrollTop)`)
+* @param context The rule context
+* @param node The setState call argument to check
+* @returns `true` if the argument value is derived from a ref
+*/
+function isArgumentUsingRefValue(context, node) {
+	const isUsingRefValue = (n) => {
+		switch (n.type) {
+			case AST_NODE_TYPES.Identifier: return isInitializedFromRef(context, n.name, context.sourceCode.getScope(n));
+			case AST_NODE_TYPES.MemberExpression: return isUsingRefValue(n.object);
+			case AST_NODE_TYPES.CallExpression: return isUsingRefValue(n.callee) || getNestedIdentifiers(n).some(isUsingRefValue);
+			case AST_NODE_TYPES.BinaryExpression:
+			case AST_NODE_TYPES.LogicalExpression: return isUsingRefValue(n.left) || isUsingRefValue(n.right);
+			case AST_NODE_TYPES.UnaryExpression:
+			case AST_NODE_TYPES.UpdateExpression: return isUsingRefValue(n.argument);
+			case AST_NODE_TYPES.ConditionalExpression: return isUsingRefValue(n.consequent) || isUsingRefValue(n.alternate);
+			case AST_NODE_TYPES.SequenceExpression: return n.expressions.some(isUsingRefValue);
+			case AST_NODE_TYPES.AssignmentExpression: return isUsingRefValue(n.right);
+			default: return false;
+		}
+	};
+	if (isUsingRefValue(node)) return true;
+	return Check.isFunction(node) && context.sourceCode.getScope(node.body).references.some((r) => isUsingRefValue(r.identifier));
+}
+/**
 * Check if a setState call is inside a conditional block whose test expression
 * is derived from a ref value (e.g. `if (prevRef.current !== value) setState(...)`).
 * @param context The ESLint rule context
@@ -8027,23 +8178,133 @@ function isRefGatedContext(context, node) {
 	}
 	return false;
 }
-function isTerminatingStatement(node) {
-	if (node.type === AST_NODE_TYPES.ReturnStatement || node.type === AST_NODE_TYPES.ThrowStatement) return true;
-	if (node.type === AST_NODE_TYPES.BlockStatement) return node.body.some(isTerminatingStatement);
-	return false;
-}
 function isRefInExpression(context, node) {
 	return getNestedIdentifiers(node).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id)));
 }
 /**
-* Get the actual CallExpression node from a setState call reference.
-* When the node is an Identifier that is the callee of a CallExpression,
-* returns the parent CallExpression; otherwise returns the node itself.
-* @param node The setState call node (CallExpression or Identifier)
-* @returns The actual CallExpression node
+* Get the name that identifies the source of a `.current` member access.
+* @param node The object of the member expression
+* @returns The identifier name, the last property name of a member chain, or null
 */
-function getSetStateCallExpression(node) {
-	return Check.isIdentifier(node) && node.parent.type === AST_NODE_TYPES.CallExpression ? node.parent : node;
+function getRefSourceName(node) {
+	switch (node.type) {
+		case AST_NODE_TYPES.Identifier: return node.name;
+		case AST_NODE_TYPES.MemberExpression: {
+			const property = Extract.unwrap(node.property);
+			return !node.computed && property.type === AST_NODE_TYPES.Identifier ? property.name : null;
+		}
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/rules/set-state-in-effect/effects.ts
+/**
+* Infer the setState calls that run synchronously during an effect setup from
+* the collected facts: calls made directly in the setup body (or an IIFE within
+* it), and calls reached indirectly through local functions, hook callbacks, or
+* setup identifiers passed to the effect.
+* @param context The rule context
+* @param facts The collected facts
+* @returns The violations to report, in report order
+*/
+function inferViolations$2(context, facts) {
+	const { additionalEffectHooks } = getSettingsFromContext(context);
+	const resolver = createSetStateResolver$1(context);
+	const getText = (n) => context.sourceCode.getText(n);
+	const isUseEffectCall = (node) => core.isUseEffectLikeCall(node, additionalEffectHooks);
+	const setStateCallsByFn = /* @__PURE__ */ new Map();
+	const setStateInHookCallbacks = /* @__PURE__ */ new Map();
+	const setStateInEffectArg = /* @__PURE__ */ new Map();
+	const setStateInEffectSetup = /* @__PURE__ */ new Map();
+	const trackedFnCalls = [];
+	const violations = [];
+	for (const { enclosingFunction, enclosingFunctionKind, node, setupFunction } of facts.calls) {
+		if (resolver.isUseStateCall(node) || isThenCall(node)) continue;
+		if (!resolver.isSetStateCall(node)) {
+			if (setupFunction != null && enclosingFunction === setupFunction) trackedFnCalls.push(node);
+			continue;
+		}
+		if (enclosingFunctionKind === "deferred") continue;
+		if (setupFunction != null && (enclosingFunction === setupFunction || enclosingFunctionKind === "immediate" && Traverse.findParent(enclosingFunction, Check.isFunction) === setupFunction)) {
+			const args0 = node.arguments.at(0);
+			if (args0 == null) continue;
+			if (isArgumentUsingRefValue(context, args0)) continue;
+			if (isRefGatedContext(context, node)) continue;
+			violations.push({
+				name: getText(Extract.unwrap(node.callee)),
+				node
+			});
+			continue;
+		}
+		const init = Traverse.findParent(node, isHookDecl)?.init;
+		if (init == null) getOrInsertComputed(setStateCallsByFn, enclosingFunction, () => []).push(node);
+		else getOrInsertComputed(setStateInHookCallbacks, init, () => []).push(node);
+	}
+	for (const { kind, node } of facts.setStateReferences) {
+		if (!resolver.isSetStateId(node, 1)) continue;
+		if (kind === "callback-body") {
+			const parent = node.parent.parent;
+			if (parent?.type !== AST_NODE_TYPES.CallExpression) continue;
+			if (!core.isUseMemoCall(context, parent)) continue;
+			const init = Traverse.findParent(parent, isHookDecl)?.init;
+			if (init != null) getOrInsertComputed(setStateInEffectArg, init, () => []).push(node);
+			continue;
+		}
+		const parent = node.parent;
+		if (parent.type !== AST_NODE_TYPES.CallExpression) continue;
+		if (core.isUseCallbackCall(context, parent)) {
+			const init = Traverse.findParent(parent, isHookDecl)?.init;
+			if (init != null) getOrInsertComputed(setStateInEffectArg, init, () => []).push(node);
+			continue;
+		}
+		if (isUseEffectCall(parent)) getOrInsertComputed(setStateInEffectSetup, parent, () => []).push(node);
+	}
+	const isExemptSetStateCall = (setStateCall) => {
+		const callNode = getSetStateCallExpression(setStateCall);
+		if (isRefGatedContext(context, callNode)) return true;
+		if (callNode.type !== AST_NODE_TYPES.CallExpression) return false;
+		const args0 = callNode.arguments.at(0);
+		return args0 != null && isArgumentUsingRefValue(context, args0);
+	};
+	const getSetStateCalls = (id) => {
+		const variable = findVariable(context.sourceCode.getScope(id), id);
+		if (variable != null && variable.defs.some((def) => def.type === DefinitionType.Parameter)) return [];
+		const node = resolveOrigin(context, id);
+		switch (node?.type) {
+			case AST_NODE_TYPES.ArrowFunctionExpression:
+			case AST_NODE_TYPES.FunctionDeclaration:
+			case AST_NODE_TYPES.FunctionExpression: return setStateCallsByFn.get(node) ?? [];
+			case AST_NODE_TYPES.CallExpression: return setStateInHookCallbacks.get(node) ?? setStateInEffectArg.get(node) ?? [];
+		}
+		return [];
+	};
+	for (const [, calls] of setStateInEffectSetup) for (const call of calls) {
+		if (isExemptSetStateCall(call)) continue;
+		violations.push({
+			name: call.name,
+			node: call
+		});
+	}
+	for (const { callee } of trackedFnCalls) {
+		const unwrappedCallee = Extract.unwrap(callee);
+		if (!Check.isIdentifier(unwrappedCallee)) continue;
+		for (const setStateCall of getSetStateCalls(unwrappedCallee)) {
+			if (isExemptSetStateCall(setStateCall)) continue;
+			violations.push({
+				name: getCallName(setStateCall, getText),
+				node: setStateCall
+			});
+		}
+	}
+	for (const id of facts.setupIdentifiers) for (const setStateCall of getSetStateCalls(id)) {
+		if (isExemptSetStateCall(setStateCall)) continue;
+		violations.push({
+			name: getCallName(setStateCall, getText),
+			node: setStateCall
+		});
+	}
+	return violations;
 }
 
 //#endregion
@@ -8063,51 +8324,121 @@ var set_state_in_effect_default = createRule({
 function create$5(context) {
 	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
 	const { additionalEffectHooks, additionalStateHooks } = getSettingsFromContext(context);
-	const functionEntries = [];
-	const setupFnRef = { current: null };
-	const setupFnIds = [];
-	const trackedFnCalls = [];
-	const setStateCallsByFn = /* @__PURE__ */ new WeakMap();
-	const setStateInEffectArg = /* @__PURE__ */ new WeakMap();
-	const setStateInEffectSetup = /* @__PURE__ */ new Map();
-	const setStateInHookCallbacks = /* @__PURE__ */ new WeakMap();
-	const getText = (n) => context.sourceCode.getText(n);
-	const onSetupFunctionEnter = (node) => {
-		setupFnRef.current = node;
-	};
-	const onSetupFunctionExit = (node) => {
-		if (setupFnRef.current === node) setupFnRef.current = null;
-	};
-	function isThenCall(node) {
-		return Extract.unwrap(node.callee).type === AST_NODE_TYPES.MemberExpression && Extract.getCalleeName(node) === "then";
+	const facts = createFactCollector$3(additionalStateHooks, additionalEffectHooks);
+	return merge(facts.visitor, { "Program:exit"() {
+		for (const violation of inferViolations$2(context, facts.facts)) context.report({
+			data: { name: violation.name },
+			messageId: "default",
+			node: violation.node
+		});
+	} });
+}
+
+//#endregion
+//#region src/rules/set-state-in-render/helpers.ts
+function isComponentOrHookLikeFunction(node) {
+	const id = core.getFunctionId(node);
+	if (id == null) return false;
+	if (Check.isIdentifier(id)) return core.isFunctionComponentName(id.name) || core.isHookName(id.name);
+	if (id.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(id.property)) return core.isFunctionComponentName(id.property.name) || core.isHookName(id.property.name);
+	return false;
+}
+function isInsideConditional(node, stopAt) {
+	let current = node.parent;
+	while (current != null && current !== stopAt) {
+		switch (current.type) {
+			case AST_NODE_TYPES.IfStatement:
+			case AST_NODE_TYPES.ConditionalExpression:
+			case AST_NODE_TYPES.LogicalExpression:
+			case AST_NODE_TYPES.SwitchStatement:
+			case AST_NODE_TYPES.SwitchCase: return true;
+		}
+		current = current.parent;
 	}
+	return false;
+}
+
+//#endregion
+//#region src/rules/set-state-in-render/collect.ts
+function createFactCollector$2(additionalStateHooks) {
+	const facts = {
+		calls: [],
+		earlyReturns: []
+	};
+	const functionEntries = [];
+	const componentFnRef = { current: null };
 	function isUseStateCall(node) {
 		return core.isUseStateLikeCall(node, additionalStateHooks);
 	}
-	function isUseEffectCall(node) {
-		return core.isUseEffectLikeCall(node, additionalEffectHooks);
-	}
-	function isUseEffectSetupCallback(node) {
-		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 Extract.getFullyQualifiedName(node.callee, getText);
-		return Extract.getFullyQualifiedName(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) {
+		if (isComponentOrHookLikeFunction(node)) return "component";
 		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";
-			case node.type !== AST_NODE_TYPES.FunctionDeclaration && parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node: return "immediate";
-			case isUseEffectSetupCallback(node): return "setup";
-			default: return "other";
+		if (parent.type === AST_NODE_TYPES.CallExpression && parent.callee !== node) return "callback";
+		return "other";
+	}
+	return {
+		facts,
+		visitor: {
+			":function"(node) {
+				const kind = getFunctionKind(node);
+				functionEntries.push({
+					kind,
+					node
+				});
+				if (kind === "component") componentFnRef.current = node;
+			},
+			":function:exit"(node) {
+				if (functionEntries.at(-1)?.kind === "component" && componentFnRef.current === node) componentFnRef.current = null;
+				functionEntries.pop();
+			},
+			CallExpression(node) {
+				const entry = functionEntries.at(-1);
+				if (entry == null) return;
+				if (isUseStateCall(node)) return;
+				facts.calls.push({
+					componentFunction: componentFnRef.current,
+					enclosingFunction: entry.node,
+					enclosingFunctionKind: entry.kind,
+					node
+				});
+			},
+			ReturnStatement(node) {
+				const componentFn = componentFnRef.current;
+				if (componentFn == null) return;
+				const entry = functionEntries.at(-1);
+				if (entry == null || entry.node !== componentFn) return;
+				if (componentFn.body.type !== AST_NODE_TYPES.BlockStatement) return;
+				const body = componentFn.body.body;
+				let stmt = node;
+				while (stmt.parent !== componentFn.body) {
+					if (stmt.parent == null) return;
+					stmt = stmt.parent;
+				}
+				const idx = body.indexOf(stmt);
+				if (idx !== -1 && idx < body.length - 1) facts.earlyReturns.push({
+					componentFunction: componentFn,
+					node
+				});
+			}
 		}
+	};
+}
+
+//#endregion
+//#region src/rules/set-state-in-render/origins.ts
+/**
+* Create a resolver that answers whether an identifier or call originates from
+* a `useState`-like hook's setter function (the element at index 1 of the
+* returned tuple).
+* @param context The rule context
+* @returns The setState provenance resolver
+*/
+function createSetStateResolver(context) {
+	const { additionalStateHooks } = getSettingsFromContext(context);
+	function isUseStateCall(node) {
+		return core.isUseStateLikeCall(node, additionalStateHooks);
 	}
-	function isIdFromUseStateCall(id, at) {
+	function isSetStateId(id, at) {
 		const initNode = resolveOrigin(context, id);
 		if (initNode == null) return false;
 		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
@@ -8127,187 +8458,53 @@ function create$5(context) {
 				const [index] = callee.arguments;
 				if (!isAt || index == null) return false;
 				const indexScope = context.sourceCode.getScope(node);
-				return getStaticValue(index, indexScope)?.value === 1 && isIdFromUseStateCall(innerCallee.object);
+				return getStaticValue(index, indexScope)?.value === 1 && isSetStateId(innerCallee.object);
 			}
-			case AST_NODE_TYPES.Identifier: return isIdFromUseStateCall(callee, 1);
+			case AST_NODE_TYPES.Identifier: return isSetStateId(callee, 1);
 			case AST_NODE_TYPES.MemberExpression: {
 				if (!("name" in callee.object)) return false;
 				const property = callee.property;
 				const propertyScope = context.sourceCode.getScope(node);
-				return getStaticValue(property, propertyScope)?.value === 1 && isIdFromUseStateCall(callee.object, 1);
+				return getStaticValue(property, propertyScope)?.value === 1 && isSetStateId(callee.object, 1);
 			}
 			default: return false;
 		}
 	}
 	return {
-		":function"(node) {
-			const kind = getFunctionKind(node);
-			functionEntries.push({
-				kind,
-				node
-			});
-			if (kind === "setup") onSetupFunctionEnter(node);
-		},
-		":function:exit"(node) {
-			const { kind } = functionEntries.at(-1) ?? {};
-			if (kind === "setup") onSetupFunctionExit(node);
-			functionEntries.pop();
-		},
-		CallExpression(node) {
-			const setupFunction = setupFnRef.current;
-			const entry = functionEntries.at(-1);
-			if (entry == null || entry.node.async) return;
-			match(getCallKind(node)).with("setState", () => {
-				switch (true) {
-					case entry.kind === "deferred":
-					case entry.node.async: break;
-					case entry.node === 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) {
-							const isUsingRefValue = (n) => {
-								switch (n.type) {
-									case AST_NODE_TYPES.Identifier: return isInitializedFromRef(context, n.name, context.sourceCode.getScope(n));
-									case AST_NODE_TYPES.MemberExpression: return isUsingRefValue(n.object);
-									case AST_NODE_TYPES.CallExpression: return isUsingRefValue(n.callee) || getNestedIdentifiers(n).some(isUsingRefValue);
-									case AST_NODE_TYPES.BinaryExpression:
-									case AST_NODE_TYPES.LogicalExpression: return isUsingRefValue(n.left) || isUsingRefValue(n.right);
-									case AST_NODE_TYPES.UnaryExpression:
-									case AST_NODE_TYPES.UpdateExpression: return isUsingRefValue(n.argument);
-									case AST_NODE_TYPES.ConditionalExpression: return isUsingRefValue(n.consequent) || isUsingRefValue(n.alternate);
-									case AST_NODE_TYPES.SequenceExpression: return n.expressions.some(isUsingRefValue);
-									case AST_NODE_TYPES.AssignmentExpression: return isUsingRefValue(n.right);
-									default: return false;
-								}
-							};
-							if (isUsingRefValue(node)) return true;
-							return Check.isFunction(node) && context.sourceCode.getScope(node.body).references.some((r) => isUsingRefValue(r.identifier));
-						}
-						if (isArgumentUsingRefValue(context, args0)) return;
-						if (isRefGatedContext(context, node)) return;
-						context.report({
-							data: { name: context.sourceCode.getText(Extract.unwrap(node.callee)) },
-							messageId: "default",
-							node
-						});
-						return;
-					}
-					default: {
-						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 (Check.isFunction(node.arguments.at(0))) return;
-				setupFnIds.push(...getNestedIdentifiers(node));
-			}).with("other", () => {
-				if (entry.node !== setupFunction) return;
-				trackedFnCalls.push(node);
-			}).otherwise(constVoid);
-		},
-		Identifier(node) {
-			if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) return;
-			if (!isIdFromUseStateCall(node, 1)) return;
-			switch (node.parent.type) {
-				case AST_NODE_TYPES.ArrowFunctionExpression: {
-					const parent = node.parent.parent;
-					if (parent.type !== AST_NODE_TYPES.CallExpression) break;
-					if (!core.isUseMemoCall(context, parent)) break;
-					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 = Traverse.findParent(node.parent, isHookDecl)?.init;
-						if (init != null) getOrInsertComputed(setStateInEffectArg, init, () => []).push(node);
-						break;
-					}
-					if (isUseEffectCall(node.parent)) getOrInsertComputed(setStateInEffectSetup, node.parent, () => []).push(node);
-			}
-		},
-		"Program:exit"() {
-			const getSetStateCalls = (context, id) => {
-				const variable = findVariable(context.sourceCode.getScope(id), id);
-				if (variable != null && variable.defs.some((def) => def.type === DefinitionType.Parameter)) return [];
-				const node = resolveOrigin(context, id);
-				switch (node?.type) {
-					case AST_NODE_TYPES.ArrowFunctionExpression:
-					case AST_NODE_TYPES.FunctionDeclaration:
-					case AST_NODE_TYPES.FunctionExpression: return setStateCallsByFn.get(node) ?? [];
-					case AST_NODE_TYPES.CallExpression: return setStateInHookCallbacks.get(node) ?? setStateInEffectArg.get(node) ?? [];
-				}
-				return [];
-			};
-			for (const [, calls] of setStateInEffectSetup) for (const call of calls) {
-				if (isRefGatedContext(context, getSetStateCallExpression(call))) continue;
-				context.report({
-					data: { name: call.name },
-					messageId: "default",
-					node: call
-				});
-			}
-			for (const { callee } of trackedFnCalls) {
-				const unwrappedCallee = Extract.unwrap(callee);
-				if (!Check.isIdentifier(unwrappedCallee)) continue;
-				const setStateCalls = getSetStateCalls(context, unwrappedCallee);
-				for (const setStateCall of setStateCalls) {
-					if (isRefGatedContext(context, getSetStateCallExpression(setStateCall))) continue;
-					context.report({
-						data: { name: getCallName(setStateCall) },
-						messageId: "default",
-						node: setStateCall
-					});
-				}
-			}
-			for (const id of setupFnIds) {
-				const setStateCalls = getSetStateCalls(context, id);
-				for (const setStateCall of setStateCalls) {
-					if (isRefGatedContext(context, getSetStateCallExpression(setStateCall))) continue;
-					context.report({
-						data: { name: getCallName(setStateCall) },
-						messageId: "default",
-						node: setStateCall
-					});
-				}
-			}
-		}
+		isSetStateCall,
+		isSetStateId,
+		isUseStateCall
 	};
 }
 
 //#endregion
-//#region src/rules/set-state-in-render/lib.ts
-function isInsideConditional(node, stopAt) {
-	let current = node.parent;
-	while (current != null && current !== stopAt) {
-		switch (current.type) {
-			case AST_NODE_TYPES.IfStatement:
-			case AST_NODE_TYPES.ConditionalExpression:
-			case AST_NODE_TYPES.LogicalExpression:
-			case AST_NODE_TYPES.SwitchStatement:
-			case AST_NODE_TYPES.SwitchCase: return true;
-		}
-		current = current.parent;
-	}
-	return false;
-}
-function isInsideEventHandler(node, stopAt) {
-	let current = node.parent;
-	while (current != null && current !== stopAt) {
-		if (Check.isFunction(current) && current !== stopAt) return true;
-		current = current.parent;
+//#region src/rules/set-state-in-render/effects.ts
+/**
+* Infer the setState calls that run unconditionally during render from the
+* collected facts: calls made directly in a component function body that are
+* neither guarded by a conditional nor positioned after an early return.
+* @param context The rule context
+* @param facts The collected facts
+* @returns The violations to report, in report order
+*/
+function inferViolations$1(context, facts) {
+	const resolver = createSetStateResolver(context);
+	const getText = (n) => context.sourceCode.getText(n);
+	const earlyReturnPositions = /* @__PURE__ */ new Map();
+	for (const { componentFunction, node } of facts.earlyReturns) getOrInsertComputed(earlyReturnPositions, componentFunction, () => []).push(node.range[0]);
+	const violations = [];
+	for (const { componentFunction, enclosingFunction, node } of facts.calls) {
+		if (componentFunction == null) continue;
+		if (enclosingFunction !== componentFunction) continue;
+		if (!resolver.isSetStateCall(node)) continue;
+		if (isInsideConditional(node, componentFunction)) continue;
+		if (earlyReturnPositions.get(componentFunction)?.some((pos) => pos < node.range[0]) === true) continue;
+		violations.push({
+			name: getText(Extract.unwrap(node.callee)),
+			node
+		});
 	}
-	return false;
-}
-function isComponentOrHookLikeFunction(node) {
-	const id = core.getFunctionId(node);
-	if (id == null) return false;
-	if (Check.isIdentifier(id)) return core.isFunctionComponentName(id.name) || core.isHookName(id.name);
-	if (id.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(id.property)) return core.isFunctionComponentName(id.property.name) || core.isHookName(id.property.name);
-	return false;
+	return violations;
 }
 
 //#endregion
@@ -8326,103 +8523,19 @@ var set_state_in_render_default = createRule({
 });
 function create$4(context) {
 	const { additionalStateHooks } = getSettingsFromContext(context);
-	const functionEntries = [];
-	const componentFnRef = { current: null };
-	const componentHasEarlyReturn = { current: false };
-	function isUseStateCall(node) {
-		return core.isUseStateLikeCall(node, additionalStateHooks);
-	}
-	function isIdFromUseStateCall(topLevelId, at) {
-		const initNode = resolveOrigin(context, topLevelId);
-		if (initNode == null) return false;
-		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
-		if (!isUseStateCall(initNode)) return false;
-		const initNodeParent = initNode.parent;
-		if (!("id" in initNodeParent) || initNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
-		return initNodeParent.id.elements.findIndex((e) => e != null && Check.isIdentifier(e, topLevelId.name)) === at;
-	}
-	function isSetStateCall(node) {
-		const callee = Extract.unwrap(node.callee);
-		switch (callee.type) {
-			case AST_NODE_TYPES.CallExpression: {
-				const innerCallee = Extract.unwrap(callee.callee);
-				if (innerCallee.type !== AST_NODE_TYPES.MemberExpression) return false;
-				if (!("name" in innerCallee.object)) return false;
-				const isAt = Extract.getCalleeName(callee) === "at";
-				const [index] = callee.arguments;
-				if (!isAt || index == null) return false;
-				const indexScope = context.sourceCode.getScope(node);
-				return getStaticValue(index, indexScope)?.value === 1 && isIdFromUseStateCall(innerCallee.object);
-			}
-			case AST_NODE_TYPES.Identifier: return isIdFromUseStateCall(callee, 1);
-			case AST_NODE_TYPES.MemberExpression: {
-				if (!("name" in callee.object)) return false;
-				const property = callee.property;
-				const propertyScope = context.sourceCode.getScope(node);
-				return getStaticValue(property, propertyScope)?.value === 1 && isIdFromUseStateCall(callee.object, 1);
-			}
-			default: return false;
-		}
-	}
-	function getFunctionKind(node) {
-		if (isComponentOrHookLikeFunction(node)) return "component";
-		const parent = Traverse.findParent(node, not(Check.isTypeExpression)) ?? node.parent;
-		if (parent.type === AST_NODE_TYPES.CallExpression && parent.callee !== node) return "callback";
-		return "other";
-	}
-	return {
-		":function"(node) {
-			const kind = getFunctionKind(node);
-			functionEntries.push({
-				kind,
-				node
-			});
-			if (kind === "component") {
-				componentFnRef.current = node;
-				componentHasEarlyReturn.current = false;
-			}
-		},
-		":function:exit"(node) {
-			if (functionEntries.at(-1)?.kind === "component" && componentFnRef.current === node) {
-				componentFnRef.current = null;
-				componentHasEarlyReturn.current = false;
-			}
-			functionEntries.pop();
-		},
-		CallExpression(node) {
-			const componentFn = componentFnRef.current;
-			if (componentFn == null) return;
-			if (!isSetStateCall(node)) return;
-			if (isInsideEventHandler(node, componentFn)) return;
-			if (isInsideConditional(node, componentFn)) return;
-			if (componentHasEarlyReturn.current) return;
-			context.report({
-				data: { name: context.sourceCode.getText(Extract.unwrap(node.callee)) },
-				messageId: "default",
-				node
-			});
-		},
-		ReturnStatement(node) {
-			const componentFn = componentFnRef.current;
-			if (componentFn == null) return;
-			const entry = functionEntries.at(-1);
-			if (entry == null || entry.node !== componentFn) return;
-			if (componentFn.body.type !== AST_NODE_TYPES.BlockStatement) return;
-			const body = componentFn.body.body;
-			let stmt = node;
-			while (stmt.parent !== componentFn.body) {
-				if (stmt.parent == null) return;
-				stmt = stmt.parent;
-			}
-			const idx = body.indexOf(stmt);
-			if (idx !== -1 && idx < body.length - 1) componentHasEarlyReturn.current = true;
-		}
-	};
+	const facts = createFactCollector$2(additionalStateHooks);
+	return merge(facts.visitor, { "Program:exit"() {
+		for (const violation of inferViolations$1(context, facts.facts)) context.report({
+			data: { name: violation.name },
+			messageId: "default",
+			node: violation.node
+		});
+	} });
 }
 
 //#endregion
 //#region src/rules/static-components/collect.ts
-function createFactCollector() {
+function createFactCollector$1() {
 	const facts = { componentUsages: [] };
 	return {
 		facts,
@@ -8570,7 +8683,7 @@ var static_components_default = createRule({
 		docs: { description: "Validates that components are static, not recreated every render." },
 		messages: {
 			default: "Cannot create components during render. Components created during render will reset their state each time they are created. Declare components outside of render.",
-			createdHere: "The component is created during render here."
+			"created-here": "The component is created during render here."
 		},
 		schema: []
 	},
@@ -8582,7 +8695,7 @@ function create$3(context) {
 	const hint = core.FunctionComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.FunctionComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.FunctionComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fc = core.getFunctionComponentCollector(context, { hint });
 	const cc = core.getClassComponentCollector(context);
-	const facts = createFactCollector();
+	const facts = createFactCollector$1();
 	return merge(fc.visitor, cc.visitor, facts.visitor, { "Program:exit"(program) {
 		const componentNodes = [...fc.api.getAllComponents(program), ...cc.api.getAllComponents(program)].map((component) => component.node);
 		const isInsideRender = createRenderBoundaryChecker(componentNodes);
@@ -8597,7 +8710,7 @@ function create$3(context) {
 				reportedCreations.add(effect.creationNode);
 				context.report({
 					data: { name: effect.name },
-					messageId: "createdHere",
+					messageId: "created-here",
 					node: effect.creationNode
 				});
 			}
@@ -8681,14 +8794,17 @@ function create$2(context) {
 }
 
 //#endregion
-//#region src/rules/use-memo/lib.ts
-function isDeclaredInsideCallback(variable, callback) {
-	let scope = variable.scope;
-	while (scope != null) {
-		if (scope.block === callback) return true;
-		scope = scope.upper;
-	}
-	return false;
+//#region src/rules/use-memo/helpers.ts
+/**
+* Check whether the result of a `useMemo` call is used (assigned, returned,
+* passed as an argument, etc.) rather than discarded as a bare statement.
+* @param node The `useMemo` call expression
+* @returns `true` when the call result flows into a surrounding expression
+*/
+function isResultUsed(node) {
+	let parent = node.parent;
+	while (Check.isTypeExpression(parent)) parent = parent.parent;
+	return 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 || parent.type === AST_NODE_TYPES.ForOfStatement || parent.type === AST_NODE_TYPES.ForInStatement;
 }
 /**
 * Gets the nested return statements in the node that are within the same function
@@ -8697,108 +8813,168 @@ function isDeclaredInsideCallback(variable, callback) {
 */
 function getNestedReturnStatements(node) {
 	const statements = [];
-	const boundaryNode = Check.isFunction(node) ? node : Traverse.findParent(node, Check.isFunction);
+	const boundary = 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, (n) => n === boundaryNode) != null) return;
+		if (Traverse.findParent(node, Check.isFunction, (n) => n === boundary) != null) return;
 		statements.push(node);
 	} });
 	return statements;
 }
 
 //#endregion
-//#region src/rules/use-memo/use-memo.ts
-const RULE_NAME$1 = "use-memo";
-var use_memo_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Validates that 'useMemo' is called with a callback that returns a value." },
-		messages: {
-			mustReturnAValue: "useMemo() callbacks must return a value.\n\nThis useMemo() callback doesn't return a value. useMemo() is for computing and caching values, not for arbitrary side effects.",
-			noAsyncOrGeneratorFunctions: "useMemo() callbacks may not be async or generator functions.\n\nuseMemo() callbacks are called once and must synchronously return a value.",
-			noParameters: "useMemo() callbacks may not accept parameters.\n\nuseMemo() callbacks are called by React to cache calculations across re-renders. They should not take parameters. Instead, directly reference the props, state, or local variables needed for the computation.",
-			noReassigningOuterVariables: "useMemo() callbacks may not reassign variables declared outside of the callback.\n\nuseMemo() callbacks must be pure functions and cannot reassign variables defined outside of the callback function.",
-			resultMustBeUsed: "useMemo() result is unused.\n\nThis useMemo() value is unused. useMemo() is for computing and caching values, not for arbitrary side effects."
-		},
-		schema: []
-	},
-	name: RULE_NAME$1,
-	create: create$1,
-	defaultOptions: []
-});
-function create$1(context) {
-	if (!context.sourceCode.text.includes("useMemo")) return {};
-	function validateNoOuterVariableReassignment(callback) {
-		const violations = [];
-		if (callback.body == null) return violations;
-		function checkWriteTarget(node, target) {
+//#region src/rules/use-memo/collect.ts
+function createFactCollector(isUseMemoCall) {
+	const facts = { calls: [] };
+	function collectWrites(callback) {
+		const writes = [];
+		function pushWrite(node, target) {
 			if (!Check.isIdentifier(target)) return;
 			if (Traverse.findParent(node, Check.isFunction, (n) => n === callback) != null) return;
-			const scope = context.sourceCode.getScope(target);
-			const variable = findVariable(scope, target);
-			if (variable != null && variable.defs.length > 0 && isDeclaredInsideCallback(variable, callback)) return;
-			violations.push({
-				messageId: "noReassigningOuterVariables",
-				node: target
+			writes.push({
+				node,
+				target
 			});
 		}
 		simpleTraverse(callback.body, { enter(node) {
 			switch (node.type) {
 				case AST_NODE_TYPES.AssignmentExpression:
-					for (const target of Extract.getAssignmentTargets(node.left)) checkWriteTarget(node, target);
+					for (const target of Extract.getAssignmentTargets(node.left)) pushWrite(node, target);
 					return;
 				case AST_NODE_TYPES.ForInStatement:
 				case AST_NODE_TYPES.ForOfStatement:
 					if (node.left.type === AST_NODE_TYPES.VariableDeclaration) return;
-					for (const target of Extract.getAssignmentTargets(node.left)) checkWriteTarget(node, target);
+					for (const target of Extract.getAssignmentTargets(node.left)) pushWrite(node, target);
 					return;
 			}
 		} });
-		return violations;
+		return writes;
 	}
-	return { CallExpression(node) {
-		if (!core.isUseMemoCall(context, node)) return;
-		let parent = node.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 || parent.type === AST_NODE_TYPES.ForOfStatement || parent.type === AST_NODE_TYPES.ForInStatement)) {
-			context.report({
-				messageId: "resultMustBeUsed",
-				node
+	return {
+		facts,
+		visitor: { CallExpression(node) {
+			if (!isUseMemoCall(node)) return;
+			const callbackArg = node.arguments[0] ?? null;
+			const callback = callbackArg != null ? Extract.unwrap(callbackArg) : null;
+			const callbackFunction = callback != null && Check.isFunction(callback) ? callback : null;
+			facts.calls.push({
+				callback: callbackFunction,
+				callbackArg,
+				isResultUsed: isResultUsed(node),
+				node,
+				returnStatements: callbackFunction != null ? getNestedReturnStatements(callbackFunction) : [],
+				writes: callbackFunction != null ? collectWrites(callbackFunction) : []
 			});
-			return;
+		} }
+	};
+}
+
+//#endregion
+//#region src/rules/use-memo/origins.ts
+function isDeclaredInsideCallback(variable, callback) {
+	let scope = variable.scope;
+	while (scope != null) {
+		if (scope.block === callback) return true;
+		scope = scope.upper;
+	}
+	return false;
+}
+/**
+* Resolve whether an identifier written inside a `useMemo` callback refers to a
+* variable declared outside the callback. Unresolved identifiers and variables
+* without definitions are treated as outer variables.
+* @param context The rule context
+* @param target The written identifier
+* @param callback The `useMemo` callback the write occurs in
+* @returns `true` when the write reassigns an outer variable
+*/
+function isOuterVariable(context, target, callback) {
+	const scope = context.sourceCode.getScope(target);
+	const variable = findVariable(scope, target);
+	if (variable == null || variable.defs.length === 0) return true;
+	return !isDeclaredInsideCallback(variable, callback);
+}
+
+//#endregion
+//#region src/rules/use-memo/effects.ts
+/**
+* Infer the `useMemo` usage violations from the collected facts: unused
+* results, callbacks with parameters, async or generator callbacks, outer
+* variable reassignments, and callbacks that never return a value.
+* @param context The rule context
+* @param facts The collected facts
+* @returns The violations to report, in report order
+*/
+function inferViolations(context, facts) {
+	const violations = [];
+	for (const fact of facts.calls) {
+		if (!fact.isResultUsed) {
+			violations.push({
+				kind: "result-must-be-used",
+				node: fact.node
+			});
+			continue;
 		}
-		const [callbackArg] = node.arguments;
-		if (callbackArg == null) return;
-		const callback = Extract.unwrap(callbackArg);
-		if (!Check.isFunction(callback)) return;
+		const { callback, callbackArg } = fact;
+		if (callbackArg == null || callback == null) continue;
 		if (callback.params.length > 0) {
 			const firstParam = callback.params[0];
-			if (firstParam == null) return;
-			context.report({
-				messageId: "noParameters",
+			if (firstParam == null) continue;
+			violations.push({
+				kind: "no-parameters",
 				node: Check.isIdentifier(firstParam) ? firstParam : callback
 			});
 		}
-		if (callback.async || callback.generator) context.report({
-			messageId: "noAsyncOrGeneratorFunctions",
+		if (callback.async || callback.generator) violations.push({
+			kind: "no-async-or-generator-functions",
 			node: callback
 		});
-		for (const violation of validateNoOuterVariableReassignment(callback)) context.report(violation);
-		if (callback.type === AST_NODE_TYPES.ArrowFunctionExpression && callback.body.type !== AST_NODE_TYPES.BlockStatement) return;
-		if (callback.body.type !== AST_NODE_TYPES.BlockStatement) return;
-		const returnStatements = getNestedReturnStatements(callback);
-		if (returnStatements.length === 0) {
-			context.report({
-				messageId: "mustReturnAValue",
-				node: callbackArg
+		for (const write of fact.writes) {
+			if (!isOuterVariable(context, write.target, callback)) continue;
+			violations.push({
+				kind: "no-reassigning-outer-variables",
+				node: write.target
 			});
-			return;
 		}
-		if (!returnStatements.some((stmt) => stmt.argument != null)) context.report({
-			messageId: "mustReturnAValue",
+		if (callback.type === AST_NODE_TYPES.ArrowFunctionExpression && callback.body.type !== AST_NODE_TYPES.BlockStatement) continue;
+		if (callback.body.type !== AST_NODE_TYPES.BlockStatement) continue;
+		if (!fact.returnStatements.some((stmt) => stmt.argument != null)) violations.push({
+			kind: "must-return-a-value",
 			node: callbackArg
 		});
-	} };
+	}
+	return violations;
+}
+
+//#endregion
+//#region src/rules/use-memo/use-memo.ts
+const RULE_NAME$1 = "use-memo";
+var use_memo_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Validates that 'useMemo' is called with a callback that returns a value." },
+		messages: {
+			"must-return-a-value": "useMemo() callbacks must return a value.\n\nThis useMemo() callback doesn't return a value. useMemo() is for computing and caching values, not for arbitrary side effects.",
+			"no-async-or-generator-functions": "useMemo() callbacks may not be async or generator functions.\n\nuseMemo() callbacks are called once and must synchronously return a value.",
+			"no-parameters": "useMemo() callbacks may not accept parameters.\n\nuseMemo() callbacks are called by React to cache calculations across re-renders. They should not take parameters. Instead, directly reference the props, state, or local variables needed for the computation.",
+			"no-reassigning-outer-variables": "useMemo() callbacks may not reassign variables declared outside of the callback.\n\nuseMemo() callbacks must be pure functions and cannot reassign variables defined outside of the callback function.",
+			"result-must-be-used": "useMemo() result is unused.\n\nThis useMemo() value is unused. useMemo() is for computing and caching values, not for arbitrary side effects."
+		},
+		schema: []
+	},
+	name: RULE_NAME$1,
+	create: create$1,
+	defaultOptions: []
+});
+function create$1(context) {
+	if (!context.sourceCode.text.includes("useMemo")) return {};
+	const facts = createFactCollector(core.isUseMemoCall(context));
+	return merge(facts.visitor, { "Program:exit"() {
+		for (const violation of inferViolations(context, facts.facts)) context.report({
+			messageId: violation.kind,
+			node: violation.node
+		});
+	} });
 }
 
 //#endregion
@@ -8808,6 +8984,59 @@ const LAZY_INIT_ALLOW_LIST = [
 	"String",
 	"Number"
 ];
+const EXPRESSION_VISITOR_KEYS = {
+	[AST_NODE_TYPES.ArrayExpression]: ["elements"],
+	[AST_NODE_TYPES.ArrayPattern]: ["elements"],
+	[AST_NODE_TYPES.AssignmentExpression]: ["left", "right"],
+	[AST_NODE_TYPES.AssignmentPattern]: ["left", "right"],
+	[AST_NODE_TYPES.AwaitExpression]: ["argument"],
+	[AST_NODE_TYPES.BinaryExpression]: ["left", "right"],
+	[AST_NODE_TYPES.CallExpression]: ["arguments", "callee"],
+	[AST_NODE_TYPES.ChainExpression]: ["expression"],
+	[AST_NODE_TYPES.ConditionalExpression]: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	[AST_NODE_TYPES.Decorator]: ["expression"],
+	[AST_NODE_TYPES.DoWhileStatement]: ["test"],
+	[AST_NODE_TYPES.ExpressionStatement]: ["expression"],
+	[AST_NODE_TYPES.ForInStatement]: ["left", "right"],
+	[AST_NODE_TYPES.ForOfStatement]: ["left", "right"],
+	[AST_NODE_TYPES.ForStatement]: ["test"],
+	[AST_NODE_TYPES.IfStatement]: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	[AST_NODE_TYPES.ImportExpression]: ["source"],
+	[AST_NODE_TYPES.JSXExpressionContainer]: ["expression"],
+	[AST_NODE_TYPES.JSXSpreadChild]: ["expression"],
+	[AST_NODE_TYPES.LogicalExpression]: ["left", "right"],
+	[AST_NODE_TYPES.MemberExpression]: ["object", "property"],
+	[AST_NODE_TYPES.NewExpression]: ["arguments", "callee"],
+	[AST_NODE_TYPES.ObjectExpression]: ["properties"],
+	[AST_NODE_TYPES.ObjectPattern]: ["properties"],
+	[AST_NODE_TYPES.Property]: ["value"],
+	[AST_NODE_TYPES.SequenceExpression]: ["expressions"],
+	[AST_NODE_TYPES.SpreadElement]: ["argument"],
+	[AST_NODE_TYPES.SwitchCase]: ["test", "consequent"],
+	[AST_NODE_TYPES.TaggedTemplateExpression]: ["tag", "quasi"],
+	[AST_NODE_TYPES.TemplateLiteral]: ["expressions"],
+	[AST_NODE_TYPES.TSAsExpression]: ["expression"],
+	[AST_NODE_TYPES.TSClassImplements]: ["expression"],
+	[AST_NODE_TYPES.TSExportAssignment]: ["expression"],
+	[AST_NODE_TYPES.TSExternalModuleReference]: ["expression"],
+	[AST_NODE_TYPES.TSInstantiationExpression]: ["expression"],
+	[AST_NODE_TYPES.TSInterfaceHeritage]: ["expression"],
+	[AST_NODE_TYPES.TSNonNullExpression]: ["expression"],
+	[AST_NODE_TYPES.TSSatisfiesExpression]: ["expression"],
+	[AST_NODE_TYPES.TSTypeAssertion]: ["expression"],
+	[AST_NODE_TYPES.UnaryExpression]: ["argument"],
+	[AST_NODE_TYPES.UpdateExpression]: ["argument"],
+	[AST_NODE_TYPES.WhileStatement]: ["test"],
+	[AST_NODE_TYPES.YieldExpression]: ["argument"]
+};
 /**
 * Get all nested expressions of type T in an expression like node
 * @param type The type of the expression to retrieve within the node
@@ -8818,72 +9047,13 @@ function getNestedExpressionsOfType(type) {
 	const isNodeOfType = Check.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));
+		simpleTraverse(node, {
+			enter(node, parent) {
+				if (parent?.type === AST_NODE_TYPES.MemberExpression && !parent.computed && parent.property === node) return;
+				if (isNodeOfType(node)) expressions.push(node);
+			},
+			visitorKeys: EXPRESSION_VISITOR_KEYS
+		});
 		return expressions;
 	};
 	return recurse;
@@ -8932,9 +9102,9 @@ var use_state_default = createRule({
 		type: "suggestion",
 		docs: { description: "Enforces correct usage of 'useState', including destructuring, symmetric naming of the value and setter, and wrapping expensive initializers in a lazy initializer function." },
 		messages: {
-			invalidAssignment: "useState should be destructured into a value and setter pair, e.g., const [state, setState] = useState(...).",
-			invalidInitialization: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'.",
-			invalidSetterName: "The setter should be named 'set' followed by the capitalized state variable name, e.g., 'setState' for 'state'."
+			"invalid-assignment": "useState should be destructured into a value and setter pair, e.g., const [state, setState] = useState(...).",
+			"invalid-initialization": "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'.",
+			"invalid-setter-name": "The setter should be named 'set' followed by the capitalized state variable name, e.g., 'setState' for 'state'."
 		},
 		schema
 	},
@@ -8955,7 +9125,7 @@ function create(context) {
 					if (LAZY_INIT_ALLOW_LIST.includes(expr.callee.name)) continue;
 					if (Traverse.findParent(expr, (n) => core.isUseCall(context, n)) != null) continue;
 					context.report({
-						messageId: "invalidInitialization",
+						messageId: "invalid-initialization",
 						node: expr
 					});
 				}
@@ -8965,7 +9135,7 @@ function create(context) {
 					if (LAZY_INIT_ALLOW_LIST.includes(expr.callee.name)) continue;
 					if (Traverse.findParent(expr, (n) => core.isUseCall(context, n)) != null) continue;
 					context.report({
-						messageId: "invalidInitialization",
+						messageId: "invalid-initialization",
 						node: expr
 					});
 				}
@@ -8978,7 +9148,7 @@ function create(context) {
 		if (parent.type !== AST_NODE_TYPES.VariableDeclarator) {
 			if (!enforceAssignment) return;
 			context.report({
-				messageId: "invalidAssignment",
+				messageId: "invalid-assignment",
 				node
 			});
 			return;
@@ -8987,7 +9157,7 @@ function create(context) {
 		if (id?.type !== AST_NODE_TYPES.ArrayPattern) {
 			if (!enforceAssignment) return;
 			context.report({
-				messageId: "invalidAssignment",
+				messageId: "invalid-assignment",
 				node: id ?? node
 			});
 			return;
@@ -8996,7 +9166,7 @@ function create(context) {
 		if (value == null) {
 			if (!enforceAssignment) return;
 			context.report({
-				messageId: "invalidAssignment",
+				messageId: "invalid-assignment",
 				node: id
 			});
 			return;
@@ -9004,20 +9174,20 @@ function create(context) {
 		if (setter == null || !enforceSetterName) return;
 		if (value.type !== AST_NODE_TYPES.Identifier) {
 			context.report({
-				messageId: "invalidAssignment",
+				messageId: "invalid-assignment",
 				node: value
 			});
 			return;
 		}
 		if (setter.type !== AST_NODE_TYPES.Identifier || !setter.name.startsWith("set")) {
 			context.report({
-				messageId: "invalidSetterName",
+				messageId: "invalid-setter-name",
 				node: setter
 			});
 			return;
 		}
 		if (snakeCase(setter.name) !== `set_${snakeCase(value.name)}`) context.report({
-			messageId: "invalidSetterName",
+			messageId: "invalid-setter-name",
 			node: setter
 		});
 	} };