eslint-plugin-react-x 2.14.0-next.0 → 3.0.0-next.0

package/dist/index.js

@@ -1,12 +1,13 @@
 import { DEFAULT_ESLINT_REACT_SETTINGS, WEBSITE_URL, coerceSettings, defineRuleListener, getConfigAdapters, getSettingsFromContext, report, toRegExp } from "@eslint-react/shared";
-import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import * as ast from "@eslint-react/ast";
+import * as core from "@eslint-react/core";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import { P, isMatching, match } from "ts-pattern";
 import ts from "typescript";
-import * as core from "@eslint-react/core";
-import * as ast from "@eslint-react/ast";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { findEnclosingAssignmentTarget, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, isAssignmentTargetEqual } from "@eslint-react/var";
-import { constFalse, constTrue, flow, getOrElseUpdate, identity, unit } from "@eslint-react/eff";
+import { DefinitionType } from "@typescript-eslint/scope-manager";
+import { constFalse, constTrue, constVoid, flow, getOrElseUpdate, identity, not, unit } from "@eslint-react/eff";
 import { compare } from "compare-versions";
 import { getConstrainedTypeAtLocation, isTypeReadonly } from "@typescript-eslint/type-utils";
 import { isPropertyReadonlyInType, unionConstituents } from "ts-api-utils";
@@ -42,10 +43,8 @@ const rules$8 = {
 	"react-x/no-duplicate-key": "off",
 	"react-x/no-implicit-key": "off",
 	"react-x/no-misused-capture-owner-stack": "off",
-	"react-x/no-unnecessary-key": "off",
 	"react-x/no-unnecessary-use-callback": "off",
 	"react-x/no-unnecessary-use-memo": "off",
-	"react-x/no-unnecessary-use-ref": "off",
 	"react-x/no-unused-props": "off",
 	"react-x/prefer-read-only-props": "off"
 };
@@ -67,7 +66,7 @@ const rules$7 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "2.14.0-next.0";
+var version = "3.0.0-next.0";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -220,9 +219,512 @@ function getTypeVariants(types) {
 	return variants;
 }
 
+//#endregion
+//#region src/rules/component-hook-factories.ts
+const RULE_NAME$63 = "component-hook-factories";
+var component_hook_factories_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallows higher order functions that define components or hooks inside them." },
+		messages: {
+			component: "Do not define component '{{name}}' inside a function. Components should be defined at the module level. Move it to the top level.",
+			hook: "Do not define hook '{{name}}' inside a function. Hooks should be defined at the module level. Move it to the top level."
+		},
+		schema: []
+	},
+	name: RULE_NAME$63,
+	create: create$63,
+	defaultOptions: []
+});
+function create$63(context) {
+	const hint = core.ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.ComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.ComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
+	const fCollector = core.useComponentCollector(context, { hint });
+	const cCollector = core.useComponentCollectorLegacy(context);
+	const hCollector = core.useHookCollector(context);
+	const reported = /* @__PURE__ */ new Set();
+	return defineRuleListener(fCollector.visitor, cCollector.visitor, hCollector.visitor, { "Program:exit"(program) {
+		const fComponents = [...fCollector.ctx.getAllComponents(program)];
+		const cComponents = [...cCollector.ctx.getAllComponents(program)];
+		const hooks = [...hCollector.ctx.getAllHooks(program)];
+		for (const { name, node } of fComponents) {
+			if (name == null) continue;
+			if (ast.findParentNode(node, ast.isFunction) == null) continue;
+			if (reported.has(node)) continue;
+			context.report({
+				messageId: "component",
+				node,
+				data: { name }
+			});
+			reported.add(node);
+		}
+		for (const { name = "unknown", node } of cComponents) {
+			if (ast.findParentNode(node, ast.isFunction) == null) continue;
+			context.report({
+				messageId: "component",
+				node,
+				data: { name }
+			});
+		}
+		for (const { name, node } of hooks) {
+			if (ast.findParentNode(node, ast.isFunction) == null) continue;
+			if (reported.has(node)) continue;
+			context.report({
+				messageId: "hook",
+				node,
+				data: { name }
+			});
+			reported.add(node);
+		}
+	} });
+}
+
+//#endregion
+//#region src/rules/error-boundaries.ts
+const RULE_NAME$62 = "error-boundaries";
+var error_boundaries_default = createRule({
+	meta: {
+		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."
+		},
+		schema: []
+	},
+	name: RULE_NAME$62,
+	create: create$62,
+	defaultOptions: []
+});
+function create$62(context) {
+	if (!context.sourceCode.text.includes("try")) return {};
+	const { ctx, visitor } = core.useComponentCollector(context);
+	const reported = /* @__PURE__ */ new Set();
+	return defineRuleListener(visitor, {
+		CallExpression(node) {
+			if (!core.isUseCall(node)) return;
+			const stmt = ast.findParentNode(node, ast.is(AST_NODE_TYPES.TryStatement));
+			if (stmt != null && !reported.has(stmt)) {
+				context.report({
+					messageId: "tryCatchWithUse",
+					node
+				});
+				reported.add(stmt);
+			}
+		},
+		"Program:exit"(node) {
+			for (const { rets } of ctx.getAllComponents(node)) for (const ret of rets) {
+				if (ret == null) continue;
+				const stmt = ast.findParentNode(ret, ast.is(AST_NODE_TYPES.TryStatement));
+				if (stmt != null && !reported.has(stmt)) {
+					context.report({
+						messageId: "tryCatchWithJsx",
+						node: stmt
+					});
+					reported.add(stmt);
+				}
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/rules/exhaustive-deps.ts
+const RULE_NAME$61 = "exhaustive-deps";
+/**
+* Built-in hooks that accept dependency arrays.
+* Maps hook name to the index of the callback argument.
+*/
+const HOOKS_WITH_DEPS = {
+	useCallback: 0,
+	useEffect: 0,
+	useImperativeHandle: 1,
+	useInsertionEffect: 0,
+	useLayoutEffect: 0,
+	useMemo: 0
+};
+/**
+* Hooks whose return values (at specific destructuring indices) are stable.
+*/
+const STABLE_HOOK_PATTERNS = {
+	useReducer: 1,
+	useRef: "all",
+	useState: 1,
+	useTransition: 1
+};
+/**
+* Get the name of a hook from a call expression.
+* @param node - the call expression node
+*/
+function getHookName$1(node) {
+	if (node.callee.type === AST_NODE_TYPES.Identifier) return node.callee.name;
+	if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier) return node.callee.property.name;
+	return null;
+}
+/**
+* Check if a hook name is one of the built-in hooks with dependency arrays.
+* @param name - the hook name to check
+*/
+function isBuiltInHookWithDeps(name) {
+	return name in HOOKS_WITH_DEPS;
+}
+/**
+* Get the callback argument index for a given hook.
+* @param hookName - the hook name to look up
+*/
+function getCallbackIndex(hookName) {
+	return HOOKS_WITH_DEPS[hookName] ?? 0;
+}
+/**
+* Get the text representation of a member expression chain.
+* Handles both regular (obj.prop) and optional (obj?.prop) member expressions.
+* @param node - the member expression node
+*/
+function getMemberExpressionText(node) {
+	const parts = [];
+	let current = node;
+	while (current.type === AST_NODE_TYPES.MemberExpression) {
+		const memberExpr = current;
+		if (memberExpr.computed) return null;
+		if (memberExpr.property.type !== AST_NODE_TYPES.Identifier) return null;
+		const sep = memberExpr.optional ? "?." : ".";
+		parts.unshift(`${sep}${memberExpr.property.name}`);
+		current = memberExpr.object;
+	}
+	if (current.type !== AST_NODE_TYPES.Identifier) return null;
+	parts.unshift(current.name);
+	return parts.join("");
+}
+/**
+* Check if a variable is defined at module level (outside any function).
+* @param variable - the variable to check
+*/
+function isModuleLevelVariable(variable) {
+	for (const def of variable.defs) {
+		let node = def.name.parent;
+		while (node != null) {
+			if (ast.isFunction(node)) return false;
+			node = node.parent;
+		}
+	}
+	return true;
+}
+/**
+* Check if a variable is an import.
+* @param variable - the variable to check
+*/
+function isImportVariable(variable) {
+	return variable.defs.length > 0 && variable.defs.every((def) => def.type === DefinitionType.ImportBinding);
+}
+/**
+* Check if a variable is a stable value from a known React hook pattern.
+* E.g., setState from useState, dispatch from useReducer, ref from useRef,
+* startTransition from useTransition.
+* @param variable - the variable to check
+*/
+function isStableHookValue(variable) {
+	if (variable.defs.length === 0) return false;
+	const def = variable.defs[0];
+	if (def == null) return false;
+	if (def.type !== DefinitionType.Variable) return false;
+	const defNode = def.node;
+	const init = defNode.init;
+	if (init == null || init.type !== AST_NODE_TYPES.CallExpression) return false;
+	const hookName = getHookName$1(init);
+	if (hookName == null) return false;
+	const stablePattern = STABLE_HOOK_PATTERNS[hookName];
+	if (stablePattern == null) return false;
+	if (stablePattern === "all") return true;
+	const id = defNode.id;
+	if (id.type !== AST_NODE_TYPES.ArrayPattern) return false;
+	const stableIndex = stablePattern;
+	const element = id.elements[stableIndex];
+	if (element == null || element.type !== AST_NODE_TYPES.Identifier) return false;
+	return element.name === variable.name;
+}
+/**
+* Check if a variable is stable (should not be required in dependency arrays).
+* @param variable - the variable to check
+*/
+function isStableVariable(variable) {
+	return isModuleLevelVariable(variable) || isImportVariable(variable) || isStableHookValue(variable);
+}
+/**
+* Find the enclosing component or hook function for a node.
+* @param node - the node to start searching from
+*/
+function findComponentOrHookScope(node) {
+	let current = node.parent;
+	while (current != null) {
+		if (ast.isFunction(current)) {
+			const id = ast.getFunctionId(current);
+			if (id != null && id.type === AST_NODE_TYPES.Identifier) {
+				if (core.isHookName(id.name) || /^[A-Z]/.test(id.name)) return current;
+			}
+			if (id != null && id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) {
+				if (core.isHookName(id.property.name) || /^[A-Z]/.test(id.property.name)) return current;
+			}
+		}
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Check if a variable is defined within the given function scope (reactive).
+* @param variable - the variable to check
+* @param scopeNode - the function scope to check against
+*/
+function isDefinedInScope(variable, scopeNode) {
+	for (const def of variable.defs) {
+		let node = def.name;
+		for (;;) {
+			if (node === scopeNode) return true;
+			if (node.parent == null) break;
+			node = node.parent;
+		}
+		if (def.type === DefinitionType.Parameter) {
+			let paramNode = def.node;
+			for (;;) {
+				if (paramNode === scopeNode) return true;
+				if (paramNode.parent == null) break;
+				paramNode = paramNode.parent;
+			}
+		}
+	}
+	return false;
+}
+var exhaustive_deps_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Enforces that React hook dependency arrays contain all reactive values used in the callback." },
+		fixable: "code",
+		messages: {
+			missingDeps: "React Hook '{{hookName}}' has missing dependencies: {{deps}}. Either include them or remove the dependency array.",
+			nonLiteralDeps: "React Hook '{{hookName}}' was passed a dependency list that is not an array literal. This means we can't statically verify whether you've passed the correct dependencies.",
+			unnecessaryDeps: "React Hook '{{hookName}}' has unnecessary dependencies: {{deps}}. Either exclude them or remove the dependency array."
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { additionalHooks: { type: "string" } }
+		}]
+	},
+	name: RULE_NAME$61,
+	create: create$61,
+	defaultOptions: [{}]
+});
+function create$61(context) {
+	const additionalHooks = context.options[0]?.additionalHooks;
+	const additionalHooksRegex = additionalHooks != null && additionalHooks.length > 0 ? new RegExp(additionalHooks) : null;
+	/** Collected hook calls for later analysis. */
+	const collectedHookCalls = [];
+	const getText = (n) => context.sourceCode.getText(n);
+	/**
+	* Check if a hook name matches the additionalHooks regex option.
+	* @param name - the hook name to check
+	*/
+	function isAdditionalHook(name) {
+		return additionalHooksRegex != null && additionalHooksRegex.test(name);
+	}
+	/**
+	* Check if a call expression is a hook call that we should check for deps.
+	* @param node - the call expression to check
+	*/
+	function isHookWithDeps(node) {
+		const name = getHookName$1(node);
+		if (name == null) return false;
+		return isBuiltInHookWithDeps(name) || isAdditionalHook(name);
+	}
+	/**
+	* Extract the callback and dependency array from a hook call.
+	* @param node - the hook call expression
+	* @param hookName - the resolved hook name
+	*/
+	function extractCallbackAndDeps(node, hookName) {
+		const args = node.arguments;
+		if (args.length === 0) return null;
+		const callbackIndex = getCallbackIndex(hookName);
+		const callback = args[callbackIndex];
+		if (callback == null) return null;
+		const depsArgIndex = callbackIndex + 1;
+		if (args.length <= depsArgIndex) return null;
+		const depsArg = args[args.length - 1];
+		if (depsArg == null) return null;
+		if (depsArg.type === AST_NODE_TYPES.ArrayExpression) return {
+			callback,
+			depsArgNode: depsArg,
+			depsNode: depsArg
+		};
+		return {
+			callback,
+			depsArgNode: depsArg,
+			depsNode: null
+		};
+	}
+	/**
+	* Collect all reactive dependency candidates from a callback node.
+	* Walks the callback body, finds all identifier references and member expressions,
+	* resolves them via scope analysis, and classifies them as reactive or stable.
+	* @param callbackNode - the callback argument node
+	* @param componentScope - the enclosing component or hook function
+	*/
+	function collectReactiveDeps(callbackNode, componentScope) {
+		const reactiveDeps = /* @__PURE__ */ new Set();
+		const callbackScope = context.sourceCode.getScope(callbackNode);
+		const references = collectScopeReferences(callbackScope);
+		for (const ref of references) {
+			const identifier = ref.identifier;
+			if (identifier.type !== AST_NODE_TYPES.Identifier) continue;
+			const memberExprText = getEnclosingMemberExpressionText(identifier);
+			if (memberExprText != null) {
+				const variable = findVariable(identifier.name, callbackScope);
+				if (variable == null) continue;
+				if (isStableVariable(variable)) continue;
+				if (!isDefinedInScope(variable, componentScope)) continue;
+				reactiveDeps.add(memberExprText);
+				continue;
+			}
+			const variable = findVariable(identifier.name, callbackScope);
+			if (variable == null) continue;
+			if (isStableVariable(variable)) continue;
+			if (!isDefinedInScope(variable, componentScope)) continue;
+			reactiveDeps.add(identifier.name);
+		}
+		return reactiveDeps;
+	}
+	/**
+	* Recursively collect all references from a scope and its child scopes,
+	* but stop at function boundaries that are not the callback itself.
+	* @param scope - the scope to collect references from
+	*/
+	function collectScopeReferences(scope) {
+		const refs = [];
+		for (const ref of scope.references) {
+			if (ref.isWriteOnly()) continue;
+			refs.push(ref);
+		}
+		for (const childScope of scope.childScopes) refs.push(...collectScopeReferences(childScope));
+		return refs;
+	}
+	/**
+	* If an identifier is the root of a member expression chain,
+	* return the full text of that member expression.
+	* @param identifier - the identifier node to check
+	*/
+	function getEnclosingMemberExpressionText(identifier) {
+		const { parent } = identifier;
+		if (parent.type !== AST_NODE_TYPES.MemberExpression) return null;
+		if (parent.object !== identifier) return null;
+		let outermost = parent;
+		let current = parent;
+		while (current.parent.type === AST_NODE_TYPES.MemberExpression && current.parent.object === current && !current.parent.computed) {
+			outermost = current.parent;
+			current = current.parent;
+		}
+		return getMemberExpressionText(outermost);
+	}
+	/**
+	* Get the set of declared dependencies from a dependency array node.
+	* @param depsNode - the array expression node
+	*/
+	function getDeclaredDeps(depsNode) {
+		const deps = /* @__PURE__ */ new Set();
+		for (const element of depsNode.elements) {
+			if (element == null) continue;
+			if (element.type === AST_NODE_TYPES.SpreadElement) continue;
+			deps.add(getText(element));
+		}
+		return deps;
+	}
+	/**
+	* Generate a fix that produces a corrected dependency array.
+	* Removes unnecessary deps, adds missing deps, and sorts all alphabetically.
+	* @param depsNode - the dependency array node
+	* @param missing - set of missing dependency names
+	* @param unnecessary - set of unnecessary dependency names
+	*/
+	function generateFix(depsNode, missing, unnecessary) {
+		return (fixer) => {
+			const allDeps = [...depsNode.elements.filter((el) => el != null && el.type !== AST_NODE_TYPES.SpreadElement).map((el) => getText(el)).filter((text) => !unnecessary.has(text)), ...missing].toSorted();
+			return fixer.replaceText(depsNode, `[${allDeps.join(", ")}]`);
+		};
+	}
+	/**
+	* Analyze a collected hook call and report missing/unnecessary dependencies.
+	* @param hookCall - the collected hook call to analyze
+	*/
+	function analyzeHookCall(hookCall) {
+		const { node, callback, depsNode, hookName } = hookCall;
+		if (depsNode == null) return;
+		const componentScope = findComponentOrHookScope(node);
+		if (componentScope == null) return;
+		const reactiveDeps = collectReactiveDeps(callback, componentScope);
+		const declaredDeps = getDeclaredDeps(depsNode);
+		const missingDeps = /* @__PURE__ */ new Set();
+		for (const dep of reactiveDeps) if (!declaredDeps.has(dep)) missingDeps.add(dep);
+		const unnecessaryDeps = /* @__PURE__ */ new Set();
+		for (const dep of declaredDeps) if (!reactiveDeps.has(dep)) unnecessaryDeps.add(dep);
+		const hasMissing = missingDeps.size > 0;
+		const hasUnnecessary = unnecessaryDeps.size > 0;
+		if (!hasMissing && !hasUnnecessary) return;
+		const fix = generateFix(depsNode, missingDeps, unnecessaryDeps);
+		if (hasMissing) {
+			const depsList = [...missingDeps].toSorted().map((d) => `'${d}'`).join(", ");
+			context.report({
+				messageId: "missingDeps",
+				node: depsNode,
+				data: {
+					deps: depsList,
+					hookName
+				},
+				fix
+			});
+		}
+		if (hasUnnecessary) {
+			const depsList = [...unnecessaryDeps].toSorted().map((d) => `'${d}'`).join(", ");
+			context.report({
+				messageId: "unnecessaryDeps",
+				node: depsNode,
+				data: {
+					deps: depsList,
+					hookName
+				},
+				...!hasMissing ? { fix } : {}
+			});
+		}
+	}
+	return {
+		CallExpression(node) {
+			if (!isHookWithDeps(node)) return;
+			const hookName = getHookName$1(node);
+			if (hookName == null) return;
+			const result = extractCallbackAndDeps(node, hookName);
+			if (result == null) return;
+			const { callback, depsArgNode, depsNode } = result;
+			if (depsNode == null && depsArgNode != null) {
+				context.report({
+					messageId: "nonLiteralDeps",
+					node: depsArgNode,
+					data: { hookName }
+				});
+				return;
+			}
+			collectedHookCalls.push({
+				node,
+				callback,
+				depsArgNode,
+				depsNode,
+				hookName
+			});
+		},
+		"Program:exit"() {
+			for (const hookCall of collectedHookCalls) analyzeHookCall(hookCall);
+		}
+	};
+}
+
 //#endregion
 //#region src/rules/jsx-dollar.ts
-const RULE_NAME$63 = "jsx-dollar";
+const RULE_NAME$60 = "jsx-dollar";
 var jsx_dollar_default = createRule({
 	meta: {
 		type: "problem",
@@ -235,11 +737,11 @@ var jsx_dollar_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$63,
-	create: create$63,
+	name: RULE_NAME$60,
+	create: create$60,
 	defaultOptions: []
 });
-function create$63(context) {
+function create$60(context) {
 	/**
 	* Visitor function for JSXElement and JSXFragment nodes
 	* @param node The JSXElement or JSXFragment node to be checked
@@ -280,7 +782,7 @@ function create$63(context) {
 
 //#endregion
 //#region src/rules/jsx-key-before-spread.ts
-const RULE_NAME$62 = "jsx-key-before-spread";
+const RULE_NAME$59 = "jsx-key-before-spread";
 var jsx_key_before_spread_default = createRule({
 	meta: {
 		type: "problem",
@@ -288,11 +790,11 @@ var jsx_key_before_spread_default = createRule({
 		messages: { default: "The 'key' prop must be placed before any spread props when using the new JSX transform." },
 		schema: []
 	},
-	name: RULE_NAME$62,
-	create: create$62,
+	name: RULE_NAME$59,
+	create: create$59,
 	defaultOptions: []
 });
-function create$62(context) {
+function create$59(context) {
 	const { jsx } = {
 		...core.getJsxConfigFromContext(context),
 		...core.getJsxConfigFromAnnotation(context)
@@ -316,7 +818,7 @@ function create$62(context) {
 
 //#endregion
 //#region src/rules/jsx-no-comment-textnodes.ts
-const RULE_NAME$61 = "jsx-no-comment-textnodes";
+const RULE_NAME$58 = "jsx-no-comment-textnodes";
 var jsx_no_comment_textnodes_default = createRule({
 	meta: {
 		type: "problem",
@@ -324,11 +826,11 @@ var jsx_no_comment_textnodes_default = createRule({
 		messages: { default: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces." },
 		schema: []
 	},
-	name: RULE_NAME$61,
-	create: create$61,
+	name: RULE_NAME$58,
+	create: create$58,
 	defaultOptions: []
 });
-function create$61(context) {
+function create$58(context) {
 	function hasCommentLike(node) {
 		if (ast.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) return false;
 		return /^\s*\/(?:\/|\*)/mu.test(context.sourceCode.getText(node));
@@ -349,7 +851,7 @@ function create$61(context) {
 
 //#endregion
 //#region src/rules/jsx-no-duplicate-props.ts
-const RULE_NAME$60 = "jsx-no-duplicate-props";
+const RULE_NAME$57 = "jsx-no-duplicate-props";
 var jsx_no_duplicate_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -357,11 +859,11 @@ var jsx_no_duplicate_props_default = createRule({
 		messages: { default: "This JSX property is assigned multiple times." },
 		schema: []
 	},
-	name: RULE_NAME$60,
-	create: create$60,
+	name: RULE_NAME$57,
+	create: create$57,
 	defaultOptions: []
 });
-function create$60(context) {
+function create$57(context) {
 	return { JSXOpeningElement(node) {
 		const props = [];
 		for (const attr of node.attributes) {
@@ -382,7 +884,7 @@ function create$60(context) {
 
 //#endregion
 //#region src/rules/jsx-no-iife.ts
-const RULE_NAME$59 = "jsx-no-iife";
+const RULE_NAME$56 = "jsx-no-iife";
 var jsx_no_iife_default = createRule({
 	meta: {
 		type: "problem",
@@ -390,11 +892,11 @@ var jsx_no_iife_default = createRule({
 		messages: { default: "Avoid using immediately-invoked function expressions in JSX." },
 		schema: []
 	},
-	name: RULE_NAME$59,
-	create: create$59,
+	name: RULE_NAME$56,
+	create: create$56,
 	defaultOptions: []
 });
-function create$59(context) {
+function create$56(context) {
 	return {
 		"JSXElement :function"(node) {
 			if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) context.report({
@@ -413,7 +915,7 @@ function create$59(context) {
 
 //#endregion
 //#region src/rules/jsx-no-undef.ts
-const RULE_NAME$58 = "jsx-no-undef";
+const RULE_NAME$55 = "jsx-no-undef";
 var jsx_no_undef_default = createRule({
 	meta: {
 		type: "problem",
@@ -421,11 +923,11 @@ var jsx_no_undef_default = createRule({
 		messages: { default: "JSX variable '{{name}}' is not defined." },
 		schema: []
 	},
-	name: RULE_NAME$58,
-	create: create$58,
+	name: RULE_NAME$55,
+	create: create$55,
 	defaultOptions: []
 });
-function create$58(context) {
+function create$55(context) {
 	return { JSXOpeningElement(node) {
 		const name = match(node.name).with({ type: AST_NODE_TYPES.JSXIdentifier }, (n) => n.name).with({
 			type: AST_NODE_TYPES.JSXMemberExpression,
@@ -444,8 +946,8 @@ function create$58(context) {
 
 //#endregion
 //#region src/rules/jsx-shorthand-boolean.ts
-const RULE_NAME$57 = "jsx-shorthand-boolean";
-const defaultOptions$4 = [1];
+const RULE_NAME$54 = "jsx-shorthand-boolean";
+const defaultOptions$3 = [1];
 const schema$3 = [{
 	type: "integer",
 	enum: [-1, 1]
@@ -458,12 +960,12 @@ var jsx_shorthand_boolean_default = createRule({
 		messages: { default: "{{message}}" },
 		schema: schema$3
 	},
-	name: RULE_NAME$57,
-	create: create$57,
-	defaultOptions: defaultOptions$4
+	name: RULE_NAME$54,
+	create: create$54,
+	defaultOptions: defaultOptions$3
 });
-function create$57(context) {
-	const policy = context.options[0] ?? defaultOptions$4[0];
+function create$54(context) {
+	const policy = context.options[0] ?? defaultOptions$3[0];
 	return { JSXAttribute(node) {
 		const { value } = node;
 		const propName = core.getJsxAttributeName(context, node);
@@ -490,8 +992,8 @@ function create$57(context) {
 
 //#endregion
 //#region src/rules/jsx-shorthand-fragment.ts
-const RULE_NAME$56 = "jsx-shorthand-fragment";
-const defaultOptions$3 = [1];
+const RULE_NAME$53 = "jsx-shorthand-fragment";
+const defaultOptions$2 = [1];
 const schema$2 = [{
 	type: "integer",
 	enum: [-1, 1]
@@ -504,12 +1006,12 @@ var jsx_shorthand_fragment_default = createRule({
 		messages: { default: "{{message}}" },
 		schema: schema$2
 	},
-	name: RULE_NAME$56,
-	create: create$56,
-	defaultOptions: defaultOptions$3
+	name: RULE_NAME$53,
+	create: create$53,
+	defaultOptions: defaultOptions$2
 });
-function create$56(context) {
-	const policy = context.options[0] ?? defaultOptions$3[0];
+function create$53(context) {
+	const policy = context.options[0] ?? defaultOptions$2[0];
 	const jsxConfig = {
 		...core.getJsxConfigFromContext(context),
 		...core.getJsxConfigFromAnnotation(context)
@@ -543,7 +1045,7 @@ function create$56(context) {
 
 //#endregion
 //#region src/rules/jsx-uses-react.ts
-const RULE_NAME$55 = "jsx-uses-react";
+const RULE_NAME$52 = "jsx-uses-react";
 var jsx_uses_react_default = createRule({
 	meta: {
 		type: "problem",
@@ -551,11 +1053,11 @@ var jsx_uses_react_default = createRule({
 		messages: { default: "Marked {{name}} as used." },
 		schema: []
 	},
-	name: RULE_NAME$55,
-	create: create$55,
+	name: RULE_NAME$52,
+	create: create$52,
 	defaultOptions: []
 });
-function create$55(context) {
+function create$52(context) {
 	const { jsx, jsxFactory, jsxFragmentFactory } = {
 		...core.getJsxConfigFromContext(context),
 		...core.getJsxConfigFromAnnotation(context)
@@ -586,7 +1088,7 @@ function debugReport(context, node, name) {
 
 //#endregion
 //#region src/rules/jsx-uses-vars.ts
-const RULE_NAME$54 = "jsx-uses-vars";
+const RULE_NAME$51 = "jsx-uses-vars";
 var jsx_uses_vars_default = createRule({
 	meta: {
 		type: "problem",
@@ -594,11 +1096,11 @@ var jsx_uses_vars_default = createRule({
 		messages: { default: "An identifier in JSX is marked as used." },
 		schema: []
 	},
-	name: RULE_NAME$54,
-	create: create$54,
+	name: RULE_NAME$51,
+	create: create$51,
 	defaultOptions: []
 });
-function create$54(context) {
+function create$51(context) {
 	return { JSXOpeningElement(node) {
 		switch (node.name.type) {
 			case AST_NODE_TYPES.JSXIdentifier:
@@ -616,7 +1118,7 @@ function create$54(context) {
 
 //#endregion
 //#region src/rules/no-access-state-in-setstate.ts
-const RULE_NAME$53 = "no-access-state-in-setstate";
+const RULE_NAME$50 = "no-access-state-in-setstate";
 function isKeyLiteral$2(node, key) {
 	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
 		type: AST_NODE_TYPES.TemplateLiteral,
@@ -630,11 +1132,11 @@ var no_access_state_in_setstate_default = createRule({
 		messages: { default: "Do not access 'this.state' within 'setState'. Use the update function instead." },
 		schema: []
 	},
-	name: RULE_NAME$53,
-	create: create$53,
+	name: RULE_NAME$50,
+	create: create$50,
 	defaultOptions: []
 });
-function create$53(context) {
+function create$50(context) {
 	if (!context.sourceCode.text.includes("setState")) return {};
 	const classStack = [];
 	const methodStack = [];
@@ -705,7 +1207,7 @@ function create$53(context) {
 
 //#endregion
 //#region src/rules/no-array-index-key.ts
-const RULE_NAME$52 = "no-array-index-key";
+const RULE_NAME$49 = "no-array-index-key";
 const REACT_CHILDREN_METHOD = ["forEach", "map"];
 function getIndexParamPosition(methodName) {
 	switch (methodName) {
@@ -764,11 +1266,11 @@ var no_array_index_key_default = createRule({
 		messages: { default: "Do not use item index in the array as its key." },
 		schema: []
 	},
-	name: RULE_NAME$52,
-	create: create$52,
+	name: RULE_NAME$49,
+	create: create$49,
 	defaultOptions: []
 });
-function create$52(context) {
+function create$49(context) {
 	const indexParamNames = [];
 	function isArrayIndex(node) {
 		return node.type === AST_NODE_TYPES.Identifier && indexParamNames.some((name) => name != null && name === node.name);
@@ -834,19 +1336,19 @@ function create$52(context) {
 
 //#endregion
 //#region src/rules/no-children-count.ts
-const RULE_NAME$51 = "no-children-count";
+const RULE_NAME$48 = "no-children-count";
 var no_children_count_default = createRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Disallows the use of 'Children.count' from the 'react' package." },
 		messages: { default: "Using 'Children.count' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
-	},
-	name: RULE_NAME$51,
-	create: create$51,
+	},
+	name: RULE_NAME$48,
+	create: create$48,
 	defaultOptions: []
 });
-function create$51(context) {
+function create$48(context) {
 	return { MemberExpression(node) {
 		if (core.isChildrenCount(context, node)) context.report({
 			messageId: "default",
@@ -857,7 +1359,7 @@ function create$51(context) {
 
 //#endregion
 //#region src/rules/no-children-for-each.ts
-const RULE_NAME$50 = "no-children-for-each";
+const RULE_NAME$47 = "no-children-for-each";
 var no_children_for_each_default = createRule({
 	meta: {
 		type: "problem",
@@ -865,11 +1367,11 @@ var no_children_for_each_default = createRule({
 		messages: { default: "Using 'Children.forEach' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$50,
-	create: create$50,
+	name: RULE_NAME$47,
+	create: create$47,
 	defaultOptions: []
 });
-function create$50(context) {
+function create$47(context) {
 	return { MemberExpression(node) {
 		if (core.isChildrenForEach(context, node)) context.report({
 			messageId: "default",
@@ -880,7 +1382,7 @@ function create$50(context) {
 
 //#endregion
 //#region src/rules/no-children-map.ts
-const RULE_NAME$49 = "no-children-map";
+const RULE_NAME$46 = "no-children-map";
 var no_children_map_default = createRule({
 	meta: {
 		type: "problem",
@@ -888,11 +1390,11 @@ var no_children_map_default = createRule({
 		messages: { default: "Using 'Children.map' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$49,
-	create: create$49,
+	name: RULE_NAME$46,
+	create: create$46,
 	defaultOptions: []
 });
-function create$49(context) {
+function create$46(context) {
 	return { MemberExpression(node) {
 		if (core.isChildrenMap(context, node)) context.report({
 			messageId: "default",
@@ -903,7 +1405,7 @@ function create$49(context) {
 
 //#endregion
 //#region src/rules/no-children-only.ts
-const RULE_NAME$48 = "no-children-only";
+const RULE_NAME$45 = "no-children-only";
 var no_children_only_default = createRule({
 	meta: {
 		type: "problem",
@@ -911,11 +1413,11 @@ var no_children_only_default = createRule({
 		messages: { default: "Using 'Children.only' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$48,
-	create: create$48,
+	name: RULE_NAME$45,
+	create: create$45,
 	defaultOptions: []
 });
-function create$48(context) {
+function create$45(context) {
 	return { MemberExpression(node) {
 		if (core.isChildrenOnly(context, node)) context.report({
 			messageId: "default",
@@ -926,7 +1428,7 @@ function create$48(context) {
 
 //#endregion
 //#region src/rules/no-children-prop.ts
-const RULE_NAME$47 = "no-children-prop";
+const RULE_NAME$44 = "no-children-prop";
 var no_children_prop_default = createRule({
 	meta: {
 		type: "problem",
@@ -934,11 +1436,11 @@ var no_children_prop_default = createRule({
 		messages: { default: "Do not pass 'children' as props." },
 		schema: []
 	},
-	name: RULE_NAME$47,
-	create: create$47,
+	name: RULE_NAME$44,
+	create: create$44,
 	defaultOptions: []
 });
-function create$47(context) {
+function create$44(context) {
 	return { JSXElement(node) {
 		const childrenProp = core.getJsxAttribute(context, node)("children");
 		if (childrenProp != null) context.report({
@@ -950,7 +1452,7 @@ function create$47(context) {
 
 //#endregion
 //#region src/rules/no-children-to-array.ts
-const RULE_NAME$46 = "no-children-to-array";
+const RULE_NAME$43 = "no-children-to-array";
 var no_children_to_array_default = createRule({
 	meta: {
 		type: "problem",
@@ -958,11 +1460,11 @@ var no_children_to_array_default = createRule({
 		messages: { default: "Using 'Children.toArray' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$46,
-	create: create$46,
+	name: RULE_NAME$43,
+	create: create$43,
 	defaultOptions: []
 });
-function create$46(context) {
+function create$43(context) {
 	return { MemberExpression(node) {
 		if (core.isChildrenToArray(context, node)) context.report({
 			messageId: "default",
@@ -973,7 +1475,7 @@ function create$46(context) {
 
 //#endregion
 //#region src/rules/no-class-component.ts
-const RULE_NAME$45 = "no-class-component";
+const RULE_NAME$42 = "no-class-component";
 var no_class_component_default = createRule({
 	meta: {
 		type: "problem",
@@ -981,11 +1483,11 @@ var no_class_component_default = createRule({
 		messages: { default: "Avoid using class components. Use function components instead." },
 		schema: []
 	},
-	name: RULE_NAME$45,
-	create: create$45,
+	name: RULE_NAME$42,
+	create: create$42,
 	defaultOptions: []
 });
-function create$45(context) {
+function create$42(context) {
 	if (!context.sourceCode.text.includes("Component")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1002,7 +1504,7 @@ function create$45(context) {
 
 //#endregion
 //#region src/rules/no-clone-element.ts
-const RULE_NAME$44 = "no-clone-element";
+const RULE_NAME$41 = "no-clone-element";
 var no_clone_element_default = createRule({
 	meta: {
 		type: "problem",
@@ -1010,11 +1512,11 @@ var no_clone_element_default = createRule({
 		messages: { default: "Using 'cloneElement' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$44,
-	create: create$44,
+	name: RULE_NAME$41,
+	create: create$41,
 	defaultOptions: []
 });
-function create$44(context) {
+function create$41(context) {
 	return { CallExpression(node) {
 		if (core.isCloneElementCall(context, node)) context.report({
 			messageId: "default",
@@ -1025,7 +1527,7 @@ function create$44(context) {
 
 //#endregion
 //#region src/rules/no-component-will-mount.ts
-const RULE_NAME$43 = "no-component-will-mount";
+const RULE_NAME$40 = "no-component-will-mount";
 var no_component_will_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -1034,11 +1536,11 @@ var no_component_will_mount_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillMount' instead." },
 		schema: []
 	},
-	name: RULE_NAME$43,
-	create: create$43,
+	name: RULE_NAME$40,
+	create: create$40,
 	defaultOptions: []
 });
-function create$43(context) {
+function create$40(context) {
 	if (!context.sourceCode.text.includes("componentWillMount")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1058,7 +1560,7 @@ function create$43(context) {
 
 //#endregion
 //#region src/rules/no-component-will-receive-props.ts
-const RULE_NAME$42 = "no-component-will-receive-props";
+const RULE_NAME$39 = "no-component-will-receive-props";
 var no_component_will_receive_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -1067,11 +1569,11 @@ var no_component_will_receive_props_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillReceiveProps' instead." },
 		schema: []
 	},
-	name: RULE_NAME$42,
-	create: create$42,
+	name: RULE_NAME$39,
+	create: create$39,
 	defaultOptions: []
 });
-function create$42(context) {
+function create$39(context) {
 	if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1091,7 +1593,7 @@ function create$42(context) {
 
 //#endregion
 //#region src/rules/no-component-will-update.ts
-const RULE_NAME$41 = "no-component-will-update";
+const RULE_NAME$38 = "no-component-will-update";
 var no_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -1100,11 +1602,11 @@ var no_component_will_update_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillUpdate' instead." },
 		schema: []
 	},
-	name: RULE_NAME$41,
-	create: create$41,
+	name: RULE_NAME$38,
+	create: create$38,
 	defaultOptions: []
 });
-function create$41(context) {
+function create$38(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1124,7 +1626,7 @@ function create$41(context) {
 
 //#endregion
 //#region src/rules/no-context-provider.ts
-const RULE_NAME$40 = "no-context-provider";
+const RULE_NAME$37 = "no-context-provider";
 var no_context_provider_default = createRule({
 	meta: {
 		type: "problem",
@@ -1133,11 +1635,11 @@ var no_context_provider_default = createRule({
 		messages: { default: "In React 19, you can render '<Context>' as a provider instead of '<Context.Provider>'." },
 		schema: []
 	},
-	name: RULE_NAME$40,
-	create: create$40,
+	name: RULE_NAME$37,
+	create: create$37,
 	defaultOptions: []
 });
-function create$40(context) {
+function create$37(context) {
 	if (!context.sourceCode.text.includes("Provider")) return {};
 	const { version } = getSettingsFromContext(context);
 	if (compare(version, "19.0.0", "<")) return {};
@@ -1164,7 +1666,7 @@ function create$40(context) {
 
 //#endregion
 //#region src/rules/no-create-ref.ts
-const RULE_NAME$39 = "no-create-ref";
+const RULE_NAME$36 = "no-create-ref";
 var no_create_ref_default = createRule({
 	meta: {
 		type: "problem",
@@ -1172,11 +1674,11 @@ var no_create_ref_default = createRule({
 		messages: { default: "[Deprecated] Use 'useRef' instead." },
 		schema: []
 	},
-	name: RULE_NAME$39,
-	create: create$39,
+	name: RULE_NAME$36,
+	create: create$36,
 	defaultOptions: []
 });
-function create$39(context) {
+function create$36(context) {
 	return { CallExpression(node) {
 		if (core.isCreateRefCall(context, node) && ast.findParentNode(node, core.isClassComponent) == null) context.report({
 			messageId: "default",
@@ -1187,7 +1689,7 @@ function create$39(context) {
 
 //#endregion
 //#region src/rules/no-direct-mutation-state.ts
-const RULE_NAME$38 = "no-direct-mutation-state";
+const RULE_NAME$35 = "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";
 }
@@ -1198,11 +1700,11 @@ var no_direct_mutation_state_default = createRule({
 		messages: { default: "Do not mutate state directly. Use 'setState()' instead." },
 		schema: []
 	},
-	name: RULE_NAME$38,
-	create: create$38,
+	name: RULE_NAME$35,
+	create: create$35,
 	defaultOptions: []
 });
-function create$38(context) {
+function create$35(context) {
 	return { AssignmentExpression(node) {
 		if (!core.isAssignmentToThisState(node)) return;
 		const parentClass = ast.findParentNode(node, ast.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]));
@@ -1216,7 +1718,7 @@ function create$38(context) {
 
 //#endregion
 //#region src/rules/no-duplicate-key.ts
-const RULE_NAME$37 = "no-duplicate-key";
+const RULE_NAME$34 = "no-duplicate-key";
 var no_duplicate_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -1224,11 +1726,11 @@ var no_duplicate_key_default = createRule({
 		messages: { default: "The 'key' prop must be unique to its sibling elements." },
 		schema: []
 	},
-	name: RULE_NAME$37,
-	create: create$37,
+	name: RULE_NAME$34,
+	create: create$34,
 	defaultOptions: []
 });
-function create$37(context) {
+function create$34(context) {
 	if (!context.sourceCode.text.includes("key=")) return {};
 	const keyedEntries = /* @__PURE__ */ new Map();
 	function isKeyValueEqual(a, b) {
@@ -1283,7 +1785,7 @@ function create$37(context) {
 
 //#endregion
 //#region src/rules/no-forward-ref.ts
-const RULE_NAME$36 = "no-forward-ref";
+const RULE_NAME$33 = "no-forward-ref";
 var no_forward_ref_default = createRule({
 	meta: {
 		type: "problem",
@@ -1292,11 +1794,11 @@ var no_forward_ref_default = createRule({
 		messages: { default: "In React 19, 'forwardRef' is no longer necessary. Pass 'ref' as a prop instead." },
 		schema: []
 	},
-	name: RULE_NAME$36,
-	create: create$36,
+	name: RULE_NAME$33,
+	create: create$33,
 	defaultOptions: []
 });
-function create$36(context) {
+function create$33(context) {
 	if (!context.sourceCode.text.includes("forwardRef")) return {};
 	const { version } = getSettingsFromContext(context);
 	if (compare(version, "19.0.0", "<")) return {};
@@ -1391,7 +1893,7 @@ function getComponentPropsFixes(context, fixer, node, typeArguments) {
 
 //#endregion
 //#region src/rules/no-implicit-key.ts
-const RULE_NAME$35 = "no-implicit-key";
+const RULE_NAME$32 = "no-implicit-key";
 var no_implicit_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -1399,11 +1901,11 @@ var no_implicit_key_default = createRule({
 		messages: { default: "This spread attribute implicitly passes the 'key' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'key' prop, use 'key={value}'." },
 		schema: []
 	},
-	name: RULE_NAME$35,
-	create: create$35,
+	name: RULE_NAME$32,
+	create: create$32,
 	defaultOptions: []
 });
-function create$35(context) {
+function create$32(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const checker = services.program.getTypeChecker();
 	return { JSXSpreadAttribute(node) {
@@ -1421,7 +1923,7 @@ function create$35(context) {
 
 //#endregion
 //#region src/rules/no-leaked-conditional-rendering.ts
-const RULE_NAME$34 = "no-leaked-conditional-rendering";
+const RULE_NAME$31 = "no-leaked-conditional-rendering";
 var no_leaked_conditional_rendering_default = createRule({
 	meta: {
 		type: "problem",
@@ -1429,11 +1931,11 @@ var no_leaked_conditional_rendering_default = createRule({
 		messages: { default: "Potential leaked value {{value}} that might cause unintentionally rendered values or rendering crashes." },
 		schema: []
 	},
-	name: RULE_NAME$34,
-	create: create$34,
+	name: RULE_NAME$31,
+	create: create$31,
 	defaultOptions: []
 });
-function create$34(context) {
+function create$31(context) {
 	if (!context.sourceCode.text.includes("&&")) return {};
 	const { version } = getSettingsFromContext(context);
 	const allowedVariants = [
@@ -1490,7 +1992,7 @@ function create$34(context) {
 
 //#endregion
 //#region src/rules/no-missing-component-display-name.ts
-const RULE_NAME$33 = "no-missing-component-display-name";
+const RULE_NAME$30 = "no-missing-component-display-name";
 var no_missing_component_display_name_default = createRule({
 	meta: {
 		type: "problem",
@@ -1498,11 +2000,11 @@ var no_missing_component_display_name_default = createRule({
 		messages: { default: "Add missing 'displayName' for component." },
 		schema: []
 	},
-	name: RULE_NAME$33,
-	create: create$33,
+	name: RULE_NAME$30,
+	create: create$30,
 	defaultOptions: []
 });
-function create$33(context) {
+function create$30(context) {
 	if (!context.sourceCode.text.includes("memo") && !context.sourceCode.text.includes("forwardRef")) return {};
 	const { ctx, visitor } = core.useComponentCollector(context, {
 		collectDisplayName: true,
@@ -1524,7 +2026,7 @@ function create$33(context) {
 
 //#endregion
 //#region src/rules/no-missing-context-display-name.ts
-const RULE_NAME$32 = "no-missing-context-display-name";
+const RULE_NAME$29 = "no-missing-context-display-name";
 var no_missing_context_display_name_default = createRule({
 	meta: {
 		type: "problem",
@@ -1533,11 +2035,11 @@ var no_missing_context_display_name_default = createRule({
 		messages: { default: "Add missing 'displayName' for context." },
 		schema: []
 	},
-	name: RULE_NAME$32,
-	create: create$32,
+	name: RULE_NAME$29,
+	create: create$29,
 	defaultOptions: []
 });
-function create$32(context) {
+function create$29(context) {
 	if (!context.sourceCode.text.includes("createContext")) return {};
 	const createCalls = [];
 	const displayNameAssignments = [];
@@ -1589,7 +2091,7 @@ function create$32(context) {
 
 //#endregion
 //#region src/rules/no-missing-key.ts
-const RULE_NAME$31 = "no-missing-key";
+const RULE_NAME$28 = "no-missing-key";
 var no_missing_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -1600,11 +2102,11 @@ var no_missing_key_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$31,
-	create: create$31,
+	name: RULE_NAME$28,
+	create: create$28,
 	defaultOptions: []
 });
-function create$31(ctx) {
+function create$28(ctx) {
 	let inChildrenToArray = false;
 	function check(node) {
 		if (node.type === AST_NODE_TYPES.JSXElement) return core.getJsxAttribute(ctx, node)("key") == null ? {
@@ -1668,7 +2170,7 @@ function create$31(ctx) {
 
 //#endregion
 //#region src/rules/no-misused-capture-owner-stack.ts
-const RULE_NAME$30 = "no-misused-capture-owner-stack";
+const RULE_NAME$27 = "no-misused-capture-owner-stack";
 var no_misused_capture_owner_stack_default = createRule({
 	meta: {
 		type: "problem",
@@ -1679,11 +2181,11 @@ var no_misused_capture_owner_stack_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$30,
-	create: create$30,
+	name: RULE_NAME$27,
+	create: create$27,
 	defaultOptions: []
 });
-function create$30(context) {
+function create$27(context) {
 	if (!context.sourceCode.text.includes("captureOwnerStack")) return {};
 	const { importSource } = getSettingsFromContext(context);
 	return {
@@ -1714,7 +2216,7 @@ function isDevelopmentOnlyCheck(node) {
 
 //#endregion
 //#region src/rules/no-nested-component-definitions.ts
-const RULE_NAME$29 = "no-nested-component-definitions";
+const RULE_NAME$26 = "no-nested-component-definitions";
 var no_nested_component_definitions_default = createRule({
 	meta: {
 		type: "problem",
@@ -1722,11 +2224,11 @@ var no_nested_component_definitions_default = createRule({
 		messages: { default: "Do not nest component definitions inside other components or props. {{suggestion}}" },
 		schema: []
 	},
-	name: RULE_NAME$29,
-	create: create$29,
+	name: RULE_NAME$26,
+	create: create$26,
 	defaultOptions: []
 });
-function create$29(context) {
+function create$26(context) {
 	const hint = core.ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.ComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.ComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fCollector = core.useComponentCollector(context, { hint });
 	const cCollector = core.useComponentCollectorLegacy(context);
@@ -1831,7 +2333,7 @@ function isInsideCreateElementProps(context, node) {
 
 //#endregion
 //#region src/rules/no-nested-lazy-component-declarations.ts
-const RULE_NAME$28 = "no-nested-lazy-component-declarations";
+const RULE_NAME$25 = "no-nested-lazy-component-declarations";
 var no_nested_lazy_component_declarations_default = createRule({
 	meta: {
 		type: "problem",
@@ -1839,11 +2341,11 @@ var no_nested_lazy_component_declarations_default = createRule({
 		messages: { default: "Do not declare lazy components inside other components. Instead, always declare them at the top level of your module." },
 		schema: []
 	},
-	name: RULE_NAME$28,
-	create: create$28,
+	name: RULE_NAME$25,
+	create: create$25,
 	defaultOptions: []
 });
-function create$28(context) {
+function create$25(context) {
 	const hint = core.ComponentDetectionHint.None;
 	const collector = core.useComponentCollector(context, { hint });
 	const collectorLegacy = core.useComponentCollectorLegacy(context);
@@ -1872,7 +2374,7 @@ function create$28(context) {
 
 //#endregion
 //#region src/rules/no-redundant-should-component-update.ts
-const RULE_NAME$27 = "no-redundant-should-component-update";
+const RULE_NAME$24 = "no-redundant-should-component-update";
 function isShouldComponentUpdate(node) {
 	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
@@ -1883,11 +2385,11 @@ var no_redundant_should_component_update_default = createRule({
 		messages: { default: "'{{componentName}}' does not need 'shouldComponentUpdate' when extending 'React.PureComponent'." },
 		schema: []
 	},
-	name: RULE_NAME$27,
-	create: create$27,
+	name: RULE_NAME$24,
+	create: create$24,
 	defaultOptions: []
 });
-function create$27(context) {
+function create$24(context) {
 	if (!context.sourceCode.text.includes("shouldComponentUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1905,7 +2407,7 @@ function create$27(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-did-mount.ts
-const RULE_NAME$26 = "no-set-state-in-component-did-mount";
+const RULE_NAME$23 = "no-set-state-in-component-did-mount";
 var no_set_state_in_component_did_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -1913,11 +2415,11 @@ var no_set_state_in_component_did_mount_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentDidMount` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$26,
-	create: create$26,
+	name: RULE_NAME$23,
+	create: create$23,
 	defaultOptions: []
 });
-function create$26(context) {
+function create$23(context) {
 	if (!context.sourceCode.text.includes("componentDidMount")) return {};
 	return { CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
@@ -1935,7 +2437,7 @@ function create$26(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-did-update.ts
-const RULE_NAME$25 = "no-set-state-in-component-did-update";
+const RULE_NAME$22 = "no-set-state-in-component-did-update";
 var no_set_state_in_component_did_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -1943,11 +2445,11 @@ var no_set_state_in_component_did_update_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentDidUpdate` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$25,
-	create: create$25,
+	name: RULE_NAME$22,
+	create: create$22,
 	defaultOptions: []
 });
-function create$25(context) {
+function create$22(context) {
 	if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
 	return { CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
@@ -1965,7 +2467,7 @@ function create$25(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-will-update.ts
-const RULE_NAME$24 = "no-set-state-in-component-will-update";
+const RULE_NAME$21 = "no-set-state-in-component-will-update";
 var no_set_state_in_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -1973,11 +2475,11 @@ var no_set_state_in_component_will_update_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentWillUpdate` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$24,
-	create: create$24,
+	name: RULE_NAME$21,
+	create: create$21,
 	defaultOptions: []
 });
-function create$24(context) {
+function create$21(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
 	return { CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
@@ -1993,70 +2495,9 @@ function create$24(context) {
 	} };
 }
 
-//#endregion
-//#region src/rules/no-unnecessary-key.ts
-const RULE_NAME$23 = "no-unnecessary-key";
-var no_unnecessary_key_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallows unnecessary 'key' props on nested child elements when rendering lists." },
-		messages: { default: "Unnecessary `key` prop on this element. {{reason}}" },
-		schema: []
-	},
-	name: RULE_NAME$23,
-	create: create$23,
-	defaultOptions: []
-});
-function create$23(context) {
-	if (!context.sourceCode.text.includes("key=")) return {};
-	const jsxConfig = {
-		...core.getJsxConfigFromContext(context),
-		...core.getJsxConfigFromAnnotation(context)
-	};
-	return { JSXAttribute(node) {
-		if (node.name.name !== "key") return;
-		const jsxElement = node.parent.parent;
-		if (core.isJsxFragmentElement(context, jsxElement, jsxConfig)) return;
-		if (jsxElement.openingElement.attributes.some((attr) => attr.type === AST_NODE_TYPES.JSXSpreadAttribute)) return;
-		if (ast.findParentNode(jsxElement, (n) => core.isRenderFunctionLoose(context, n)) != null) return;
-		const mapCallback = ast.findParentNode(jsxElement, isArrayMethodCallback);
-		if (mapCallback == null || ast.findParentNode(jsxElement, ast.isFunction) !== mapCallback) return;
-		if (context.sourceCode.getScope(mapCallback) !== context.sourceCode.getScope(jsxElement)) return;
-		const keyedElementOrElse = ast.findParentNode(jsxElement, (n) => {
-			if (n === mapCallback) return true;
-			return ast.isJSXElement(n) && core.getJsxAttribute(context, n)("key") != null;
-		});
-		if (keyedElementOrElse == null || keyedElementOrElse === mapCallback) return;
-		context.report({
-			messageId: "default",
-			node,
-			data: { reason: "A parent element already has a `key` prop in the same list rendering context." }
-		});
-	} };
-}
-function getArrayMethodCallbackPosition(methodName) {
-	switch (methodName) {
-		case "filter":
-		case "flatMap":
-		case "forEach":
-		case "map":
-		case "reduce":
-		case "reduceRight": return 0;
-		case "from":
-		case "fromAsync": return 1;
-		default: return -1;
-	}
-}
-function isArrayMethodCallback(node) {
-	const parent = node.parent;
-	if (parent?.type !== AST_NODE_TYPES.CallExpression) return false;
-	if (parent.callee.type !== AST_NODE_TYPES.MemberExpression || parent.callee.property.type !== AST_NODE_TYPES.Identifier) return false;
-	return parent.arguments[getArrayMethodCallbackPosition(parent.callee.property.name)] === node;
-}
-
 //#endregion
 //#region src/rules/no-unnecessary-use-callback.ts
-const RULE_NAME$22 = "no-unnecessary-use-callback";
+const RULE_NAME$20 = "no-unnecessary-use-callback";
 var no_unnecessary_use_callback_default = createRule({
 	meta: {
 		type: "problem",
@@ -2067,11 +2508,11 @@ var no_unnecessary_use_callback_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$22,
-	create: create$22,
+	name: RULE_NAME$20,
+	create: create$20,
 	defaultOptions: []
 });
-function create$22(context) {
+function create$20(context) {
 	if (!context.sourceCode.text.includes("useCallback")) return {};
 	return { VariableDeclarator(node) {
 		const { id, init } = node;
@@ -2133,7 +2574,7 @@ function checkForUsageInsideUseEffect$1(sourceCode, node) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-memo.ts
-const RULE_NAME$21 = "no-unnecessary-use-memo";
+const RULE_NAME$19 = "no-unnecessary-use-memo";
 var no_unnecessary_use_memo_default = createRule({
 	meta: {
 		type: "problem",
@@ -2144,11 +2585,11 @@ var no_unnecessary_use_memo_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$21,
-	create: create$21,
+	name: RULE_NAME$19,
+	create: create$19,
 	defaultOptions: []
 });
-function create$21(context) {
+function create$19(context) {
 	if (!context.sourceCode.text.includes("useMemo")) return {};
 	return { VariableDeclarator(node) {
 		const { id, init } = node;
@@ -2214,7 +2655,7 @@ function checkForUsageInsideUseEffect(sourceCode, node) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-prefix.ts
-const RULE_NAME$20 = "no-unnecessary-use-prefix";
+const RULE_NAME$18 = "no-unnecessary-use-prefix";
 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));
@@ -2226,11 +2667,11 @@ var no_unnecessary_use_prefix_default = createRule({
 		messages: { default: "If your function doesn't call any Hooks, avoid the 'use' prefix. Instead, write it as a regular function without the 'use' prefix." },
 		schema: []
 	},
-	name: RULE_NAME$20,
-	create: create$20,
+	name: RULE_NAME$18,
+	create: create$18,
 	defaultOptions: []
 });
-function create$20(context) {
+function create$18(context) {
 	const { ctx, visitor } = core.useHookCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
 		for (const { id, name, node, hookCalls } of ctx.getAllHooks(program)) {
@@ -2250,7 +2691,7 @@ function create$20(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-mount.ts
-const RULE_NAME$19 = "no-unsafe-component-will-mount";
+const RULE_NAME$17 = "no-unsafe-component-will-mount";
 var no_unsafe_component_will_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -2258,11 +2699,11 @@ var no_unsafe_component_will_mount_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillMount'." },
 		schema: []
 	},
-	name: RULE_NAME$19,
-	create: create$19,
+	name: RULE_NAME$17,
+	create: create$17,
 	defaultOptions: []
 });
-function create$19(context) {
+function create$17(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillMount")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2278,7 +2719,7 @@ function create$19(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-receive-props.ts
-const RULE_NAME$18 = "no-unsafe-component-will-receive-props";
+const RULE_NAME$16 = "no-unsafe-component-will-receive-props";
 var no_unsafe_component_will_receive_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -2286,11 +2727,11 @@ var no_unsafe_component_will_receive_props_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillReceiveProps'." },
 		schema: []
 	},
-	name: RULE_NAME$18,
-	create: create$18,
+	name: RULE_NAME$16,
+	create: create$16,
 	defaultOptions: []
 });
-function create$18(context) {
+function create$16(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillReceiveProps")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2306,7 +2747,7 @@ function create$18(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-update.ts
-const RULE_NAME$17 = "no-unsafe-component-will-update";
+const RULE_NAME$15 = "no-unsafe-component-will-update";
 var no_unsafe_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -2314,11 +2755,11 @@ var no_unsafe_component_will_update_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillUpdate'." },
 		schema: []
 	},
-	name: RULE_NAME$17,
-	create: create$17,
+	name: RULE_NAME$15,
+	create: create$15,
 	defaultOptions: []
 });
-function create$17(context) {
+function create$15(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2334,7 +2775,7 @@ function create$17(context) {
 
 //#endregion
 //#region src/rules/no-unstable-context-value.ts
-const RULE_NAME$16 = "no-unstable-context-value";
+const RULE_NAME$14 = "no-unstable-context-value";
 var no_unstable_context_value_default = createRule({
 	meta: {
 		type: "problem",
@@ -2342,13 +2783,13 @@ var no_unstable_context_value_default = createRule({
 		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}}" },
 		schema: []
 	},
-	name: RULE_NAME$16,
-	create: create$16,
+	name: RULE_NAME$14,
+	create: create$14,
 	defaultOptions: []
 });
-function create$16(context) {
-	if (ast.getFileDirectives(context.sourceCode.ast).some((d) => d.directive === "use memo")) return {};
-	const { version } = getSettingsFromContext(context);
+function create$14(context) {
+	const { isCompilerEnabled, version } = getSettingsFromContext(context);
+	if (isCompilerEnabled && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
 	const isReact18OrBelow = compare(version, "19.0.0", "<");
 	const { ctx, visitor } = core.useComponentCollector(context);
 	const constructions = /* @__PURE__ */ new WeakMap();
@@ -2359,6 +2800,7 @@ function create$16(context) {
 			if (!isContextName(selfName, isReact18OrBelow)) return;
 			const functionEntry = ctx.getCurrentEntry();
 			if (functionEntry == null) return;
+			if (isCompilerEnabled && ast.isDirectiveInFunction(functionEntry.node, "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;
@@ -2394,8 +2836,8 @@ function isContextName(name, isReact18OrBelow) {
 
 //#endregion
 //#region src/rules/no-unstable-default-props.ts
-const RULE_NAME$15 = "no-unstable-default-props";
-const defaultOptions$2 = [{ safeDefaultProps: [] }];
+const RULE_NAME$13 = "no-unstable-default-props";
+const defaultOptions$1 = [{ safeDefaultProps: [] }];
 const schema$1 = [{
 	type: "object",
 	additionalProperties: false,
@@ -2411,9 +2853,9 @@ var no_unstable_default_props_default = createRule({
 		messages: { default: "A/an '{{kind}}' as default prop. This could lead to potential infinite render loop in React. Use a variable instead of '{{kind}}'." },
 		schema: schema$1
 	},
-	name: RULE_NAME$15,
-	create: create$15,
-	defaultOptions: defaultOptions$2
+	name: RULE_NAME$13,
+	create: create$13,
+	defaultOptions: defaultOptions$1
 });
 function extractIdentifier(node) {
 	if (node.type === AST_NODE_TYPES.NewExpression && node.callee.type === AST_NODE_TYPES.Identifier) return node.callee.name;
@@ -2423,8 +2865,9 @@ function extractIdentifier(node) {
 	}
 	return null;
 }
-function create$15(context, [options]) {
-	if (ast.getFileDirectives(context.sourceCode.ast).some((d) => d.directive === "use memo")) return {};
+function create$13(context, [options]) {
+	const { isCompilerEnabled } = getSettingsFromContext(context);
+	if (isCompilerEnabled && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
 	const { ctx, visitor } = core.useComponentCollector(context);
 	const declarators = /* @__PURE__ */ new WeakMap();
 	const { safeDefaultProps = [] } = options;
@@ -2467,7 +2910,7 @@ function create$15(context, [options]) {
 
 //#endregion
 //#region src/rules/no-unused-class-component-members.ts
-const RULE_NAME$14 = "no-unused-class-component-members";
+const RULE_NAME$12 = "no-unused-class-component-members";
 const LIFECYCLE_METHODS = new Set([
 	"componentDidCatch",
 	"componentDidMount",
@@ -2498,11 +2941,11 @@ var no_unused_class_component_members_default = createRule({
 		messages: { default: "Unused method or property '{{methodName}}'' of class '{{className}}'." },
 		schema: []
 	},
-	name: RULE_NAME$14,
-	create: create$14,
+	name: RULE_NAME$12,
+	create: create$12,
 	defaultOptions: []
 });
-function create$14(context) {
+function create$12(context) {
 	const classStack = [];
 	const methodStack = [];
 	const propertyDefs = /* @__PURE__ */ new WeakMap();
@@ -2583,7 +3026,7 @@ function create$14(context) {
 
 //#endregion
 //#region src/rules/no-unused-props.ts
-const RULE_NAME$13 = "no-unused-props";
+const RULE_NAME$11 = "no-unused-props";
 var no_unused_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -2591,11 +3034,11 @@ var no_unused_props_default = createRule({
 		messages: { default: "Prop `{{name}}` is declared but never used" },
 		schema: []
 	},
-	name: RULE_NAME$13,
-	create: create$13,
+	name: RULE_NAME$11,
+	create: create$11,
 	defaultOptions: []
 });
-function create$13(context) {
+function create$11(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const { ctx, visitor } = core.useComponentCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2614,7 +3057,7 @@ function create$13(context) {
 				if (usedPropKeys.has(declaredProp.name)) totalUsedProps.add(declaredProp);
 			}
 		}
-		const unusedProps = [...totalDeclaredProps].filter((x) => !totalUsedProps.has(x));
+		const unusedProps = totalDeclaredProps.difference(totalUsedProps);
 		for (const unusedProp of unusedProps) reportUnusedProp(context, services, unusedProp);
 	} });
 }
@@ -2693,7 +3136,7 @@ function reportUnusedProp(context, services, prop) {
 
 //#endregion
 //#region src/rules/no-unused-state.ts
-const RULE_NAME$12 = "no-unused-state";
+const RULE_NAME$10 = "no-unused-state";
 function isKeyLiteral(node, key) {
 	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
 		type: AST_NODE_TYPES.TemplateLiteral,
@@ -2707,11 +3150,11 @@ var no_unused_state_default = createRule({
 		messages: { default: "Unused class component state in '{{className}}'" },
 		schema: []
 	},
-	name: RULE_NAME$12,
-	create: create$12,
+	name: RULE_NAME$10,
+	create: create$10,
 	defaultOptions: []
 });
-function create$12(context) {
+function create$10(context) {
 	const classStack = [];
 	const methodStack = [];
 	const constructorStack = [];
@@ -2820,7 +3263,7 @@ function create$12(context) {
 
 //#endregion
 //#region src/rules/no-use-context.ts
-const RULE_NAME$11 = "no-use-context";
+const RULE_NAME$9 = "no-use-context";
 var no_use_context_default = createRule({
 	meta: {
 		type: "problem",
@@ -2829,11 +3272,11 @@ var no_use_context_default = createRule({
 		messages: { default: "In React 19, 'use' is preferred over 'useContext' because it is more flexible." },
 		schema: []
 	},
-	name: RULE_NAME$11,
-	create: create$11,
+	name: RULE_NAME$9,
+	create: create$9,
 	defaultOptions: []
 });
-function create$11(context) {
+function create$9(context) {
 	if (!context.sourceCode.text.includes("useContext")) return {};
 	const settings = getSettingsFromContext(context);
 	if (compare(settings.version, "19.0.0", "<")) return {};
@@ -2898,7 +3341,7 @@ function getCorrelativeTokens(context, node) {
 
 //#endregion
 //#region src/rules/no-useless-forward-ref.ts
-const RULE_NAME$10 = "no-useless-forward-ref";
+const RULE_NAME$8 = "no-useless-forward-ref";
 var no_useless_forward_ref_default = createRule({
 	meta: {
 		type: "problem",
@@ -2906,11 +3349,11 @@ var no_useless_forward_ref_default = createRule({
 		messages: { default: "A 'forwardRef' is used with this component but no 'ref' parameter is set." },
 		schema: []
 	},
-	name: RULE_NAME$10,
-	create: create$10,
+	name: RULE_NAME$8,
+	create: create$8,
 	defaultOptions: []
 });
-function create$10(context) {
+function create$8(context) {
 	return { CallExpression(node) {
 		if (!core.isForwardRefCall(context, node)) return;
 		const [component] = node.arguments;
@@ -2925,8 +3368,8 @@ function create$10(context) {
 
 //#endregion
 //#region src/rules/no-useless-fragment.ts
-const RULE_NAME$9 = "no-useless-fragment";
-const defaultOptions$1 = [{
+const RULE_NAME$7 = "no-useless-fragment";
+const defaultOptions = [{
 	allowEmptyFragment: false,
 	allowExpressions: true
 }];
@@ -2947,17 +3390,17 @@ const schema = [{
 var no_useless_fragment_default = createRule({
 	meta: {
 		type: "problem",
-		defaultOptions: [...defaultOptions$1],
+		defaultOptions: [...defaultOptions],
 		docs: { description: "Disallows useless fragment elements." },
 		fixable: "code",
 		messages: { default: "A fragment {{reason}} is useless." },
 		schema
 	},
-	name: RULE_NAME$9,
-	create: create$9,
-	defaultOptions: defaultOptions$1
+	name: RULE_NAME$7,
+	create: create$7,
+	defaultOptions
 });
-function create$9(context, [option]) {
+function create$7(context, [option]) {
 	const { allowEmptyFragment = false, allowExpressions = true } = option;
 	const jsxConfig = {
 		...core.getJsxConfigFromContext(context),
@@ -3065,7 +3508,7 @@ function trimLikeReact(text) {
 
 //#endregion
 //#region src/rules/prefer-destructuring-assignment.ts
-const RULE_NAME$8 = "prefer-destructuring-assignment";
+const RULE_NAME$6 = "prefer-destructuring-assignment";
 var prefer_destructuring_assignment_default = createRule({
 	meta: {
 		type: "problem",
@@ -3073,11 +3516,11 @@ var prefer_destructuring_assignment_default = createRule({
 		messages: { default: "Use destructuring assignment for component props." },
 		schema: []
 	},
-	name: RULE_NAME$8,
-	create: create$8,
+	name: RULE_NAME$6,
+	create: create$6,
 	defaultOptions: []
 });
-function create$8(context) {
+function create$6(context) {
 	const { ctx, visitor } = core.useComponentCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
 		for (const component of ctx.getAllComponents(program)) {
@@ -3101,7 +3544,7 @@ function create$8(context) {
 
 //#endregion
 //#region src/rules/prefer-namespace-import.ts
-const RULE_NAME$7 = "prefer-namespace-import";
+const RULE_NAME$5 = "prefer-namespace-import";
 var prefer_namespace_import_default = createRule({
 	meta: {
 		type: "problem",
@@ -3110,11 +3553,11 @@ var prefer_namespace_import_default = createRule({
 		messages: { default: "Prefer importing React as 'import * as React from \"{{importSource}}\"';" },
 		schema: []
 	},
-	name: RULE_NAME$7,
-	create: create$7,
+	name: RULE_NAME$5,
+	create: create$5,
 	defaultOptions: []
 });
-function create$7(context) {
+function create$5(context) {
 	const { importSource } = getSettingsFromContext(context);
 	return { [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
 		const hasOtherSpecifiers = node.parent.specifiers.length > 1;
@@ -3138,7 +3581,7 @@ function create$7(context) {
 
 //#endregion
 //#region src/rules/prefer-read-only-props.ts
-const RULE_NAME$6 = "prefer-read-only-props";
+const RULE_NAME$4 = "prefer-read-only-props";
 var prefer_read_only_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -3146,11 +3589,11 @@ var prefer_read_only_props_default = createRule({
 		messages: { default: "A function component's props should be read-only." },
 		schema: []
 	},
-	name: RULE_NAME$6,
-	create: create$6,
+	name: RULE_NAME$4,
+	create: create$4,
 	defaultOptions: []
 });
-function create$6(context) {
+function create$4(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const checker = services.program.getTypeChecker();
 	const { ctx, visitor } = core.useComponentCollector(context);
@@ -3191,7 +3634,7 @@ function isClassOrInterfaceReadonlyLoose(checker, type) {
 
 //#endregion
 //#region src/rules/prefer-use-state-lazy-initialization.ts
-const RULE_NAME$5 = "prefer-use-state-lazy-initialization";
+const RULE_NAME$3 = "prefer-use-state-lazy-initialization";
 const ALLOW_LIST = [
 	"Boolean",
 	"String",
@@ -3204,11 +3647,11 @@ var prefer_use_state_lazy_initialization_default = createRule({
 		messages: { default: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'." },
 		schema: []
 	},
-	name: RULE_NAME$5,
-	create: create$5,
+	name: RULE_NAME$3,
+	create: create$3,
 	defaultOptions: []
 });
-function create$5(context) {
+function create$3(context) {
 	return { CallExpression(node) {
 		if (!core.isUseStateCall(node)) return;
 		const [useStateInput] = node.arguments;
@@ -3236,170 +3679,220 @@ function create$5(context) {
 }
 
 //#endregion
-//#region src/rules-removed/no-default-props.ts
-const RULE_NAME$4 = "no-default-props";
-var no_default_props_default = createRule({
+//#region src/rules/rules-of-hooks.ts
+const RULE_NAME$2 = "rules-of-hooks";
+var rules_of_hooks_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallows the 'defaultProps' property in favor of ES6 default parameters." },
-		messages: { default: "[Deprecated] Use ES6 default parameters instead." },
+		docs: { description: "Enforces the [Rules of Hooks](https://react.dev/reference/rules/rules-of-react#rules-of-hooks)." },
+		messages: {
+			afterEarlyReturn: "React Hook '{{name}}' is called after an early return. React Hooks must be called in the exact same order in every component render.",
+			asyncHook: "React Hook '{{name}}' is called in an async function. React Hooks must be called in a synchronous React function component or custom Hook.",
+			classHook: "React Hook '{{name}}' cannot be called in a class component. React Hooks can only be called in function components or custom Hooks.",
+			conditionalHook: "React Hook '{{name}}' is called conditionally. React Hooks must be called in the exact same order in every component render.",
+			invalidContext: "React Hook '{{name}}' is called in function '{{funcName}}' that is neither a React function component nor a custom React Hook function. React component names must start with an uppercase letter. React Hook names must start with the word 'use'.",
+			loopHook: "React Hook '{{name}}' may be executed more than once. React Hooks must be called in the exact same order in every component render.",
+			nestedHook: "React Hook '{{name}}' is called in a nested function. React Hooks must be called at the top level of a React function component or custom Hook.",
+			topLevelHook: "React Hook '{{name}}' cannot be called at the top level. React Hooks must be called in a React function component or custom Hook.",
+			useInTryCatch: "React Hook '{{name}}' cannot be called inside a try/catch block. To handle errors, wrap your component in an error boundary."
+		},
 		schema: []
 	},
-	name: RULE_NAME$4,
-	create: create$4,
+	name: RULE_NAME$2,
+	create: create$2,
 	defaultOptions: []
 });
-function create$4(context) {
-	if (!context.sourceCode.text.includes("defaultProps")) return {};
-	return { AssignmentExpression(node) {
-		if (node.operator !== "=" || node.left.type !== AST_NODE_TYPES.MemberExpression) return;
-		const { object, property } = node.left;
-		if (object.type !== AST_NODE_TYPES.Identifier) return;
-		if (property.type !== AST_NODE_TYPES.Identifier || property.name !== "defaultProps") return;
-		if (!core.isComponentNameLoose(object.name)) return;
-		const variableNode = getVariableDefinitionNode(findVariable(object.name, context.sourceCode.getScope(node)), 0);
-		if (variableNode == null) return;
-		if (!ast.isFunction(variableNode)) return;
-		context.report({
-			messageId: "default",
-			node: property
-		});
-	} };
+function getHookName(node) {
+	if (node.callee.type === AST_NODE_TYPES.Identifier) return node.callee.name;
+	if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier) return node.callee.property.name;
+	return "unknown";
 }
-
-//#endregion
-//#region src/rules-removed/no-forbidden-props.ts
-const RULE_NAME$3 = "no-forbidden-props";
-const defaultOptions = [{ forbid: [{ prop: "/_/" }] }];
-var no_forbidden_props_default = createRule({
-	meta: {
-		type: "problem",
-		defaultOptions: [...defaultOptions],
-		deprecated: {
-			deprecatedSince: "2.3.2",
-			message: "This rule is deprecated and will be removed in future versions.",
-			replacedBy: [{ rule: {
-				name: "no-restricted-syntax",
-				url: "https://eslint.org/docs/latest/rules/no-restricted-syntax"
-			} }]
-		},
-		docs: { description: "Disallows certain props on components." },
-		messages: { default: "Prop \"{{name}}\" is forbidden." },
-		schema: [{
-			type: "object",
-			additionalProperties: false,
-			properties: { forbid: {
-				type: "array",
-				items: { anyOf: [
-					{ type: "string" },
-					{
-						type: "object",
-						additionalProperties: false,
-						properties: {
-							excludedNodes: {
-								type: "array",
-								items: { type: "string" },
-								uniqueItems: true
-							},
-							prop: { type: "string" }
-						},
-						required: ["prop"]
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						properties: {
-							includedNodes: {
-								type: "array",
-								items: { type: "string" },
-								uniqueItems: true
-							},
-							prop: { type: "string" }
-						},
-						required: ["prop"]
-					}
-				] }
-			} }
-		}]
-	},
-	name: RULE_NAME$3,
-	create: create$3,
-	defaultOptions
-});
-function create$3(context, [option]) {
-	const { forbid } = option;
-	return { JSXOpeningElement(node) {
-		let nodeName = null;
-		if (node.name.type === AST_NODE_TYPES.JSXIdentifier) nodeName = node.name.name;
-		else if (node.name.type === AST_NODE_TYPES.JSXNamespacedName) nodeName = node.name.name.name;
-		for (const attr of node.attributes) {
-			if (attr.type === AST_NODE_TYPES.JSXSpreadAttribute) continue;
-			const name = attr.name.name;
-			if (typeof name !== "string") continue;
-			for (const forbiddenPropItem of forbid) {
-				if (typeof forbiddenPropItem !== "string" && nodeName != null) {
-					if ("excludedNodes" in forbiddenPropItem && forbiddenPropItem.excludedNodes.includes(nodeName)) continue;
-					if ("includedNodes" in forbiddenPropItem && !forbiddenPropItem.includedNodes.includes(nodeName)) continue;
+function isUseCall(node) {
+	if (node.callee.type === AST_NODE_TYPES.Identifier) return node.callee.name === "use";
+	if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier) return node.callee.property.name === "use";
+	return false;
+}
+function getFunctionEntryKind(node) {
+	const id = ast.getFunctionId(node);
+	if (id == null) return "other";
+	if (id.type === AST_NODE_TYPES.Identifier) {
+		if (core.isHookName(id.name)) return "hook";
+		if (/^[A-Z]/.test(id.name)) return "component";
+	}
+	if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) {
+		if (core.isHookName(id.property.name)) return "hook";
+		if (/^[A-Z]/.test(id.property.name)) return "component";
+	}
+	return "other";
+}
+function isConditionalNode(node) {
+	return node.type === AST_NODE_TYPES.IfStatement || node.type === AST_NODE_TYPES.SwitchStatement || node.type === AST_NODE_TYPES.ConditionalExpression || node.type === AST_NODE_TYPES.LogicalExpression;
+}
+function isLoopNode(node) {
+	return node.type === AST_NODE_TYPES.ForStatement || node.type === AST_NODE_TYPES.ForInStatement || node.type === AST_NODE_TYPES.ForOfStatement || node.type === AST_NODE_TYPES.WhileStatement || node.type === AST_NODE_TYPES.DoWhileStatement;
+}
+function isTryCatchNode(node) {
+	return node.type === AST_NODE_TYPES.TryStatement;
+}
+function create$2(context) {
+	const functionStack = [];
+	function findEnclosingComponentOrHook() {
+		for (let i = functionStack.length - 1; i >= 0; i--) {
+			const entry = functionStack[i];
+			if (entry == null) continue;
+			if (entry.kind === "component" || entry.kind === "hook") return entry;
+		}
+	}
+	function checkHookCall(node) {
+		const hookName = getHookName(node);
+		const isUse = isUseCall(node);
+		if (functionStack.length === 0) {
+			context.report({
+				messageId: "topLevelHook",
+				node,
+				data: { name: hookName }
+			});
+			return;
+		}
+		const boundary = findEnclosingComponentOrHook();
+		if (boundary == null) {
+			if (ast.findParentNode(node, ast.isClass) != null) {
+				context.report({
+					messageId: "classHook",
+					node,
+					data: { name: hookName }
+				});
+				return;
+			}
+			const currentEntry = functionStack.at(-1);
+			if (currentEntry == null) return;
+			const funcId = ast.getFunctionId(currentEntry.node);
+			const funcName = funcId != null && funcId.type === AST_NODE_TYPES.Identifier ? funcId.name : "anonymous";
+			context.report({
+				messageId: "invalidContext",
+				node,
+				data: {
+					name: hookName,
+					funcName
 				}
-				if (toRegExp(typeof forbiddenPropItem === "string" ? forbiddenPropItem : forbiddenPropItem.prop).test(name)) context.report({
-					messageId: "default",
-					node: attr,
-					data: { name }
+			});
+			return;
+		}
+		const currentEntry = functionStack.at(-1);
+		if (currentEntry != null && currentEntry.isAsync) {
+			context.report({
+				messageId: "asyncHook",
+				node,
+				data: { name: hookName }
+			});
+			return;
+		}
+		if (boundary.isAsync) {
+			context.report({
+				messageId: "asyncHook",
+				node,
+				data: { name: hookName }
+			});
+			return;
+		}
+		let current = node.parent;
+		while (current != null && current !== boundary.node) {
+			if (ast.isClass(current)) {
+				context.report({
+					messageId: "classHook",
+					node,
+					data: { name: hookName }
+				});
+				return;
+			}
+			if (ast.isFunction(current) && current !== boundary.node) {
+				const nestedKind = getFunctionEntryKind(current);
+				if (nestedKind === "component" || nestedKind === "hook") break;
+				context.report({
+					messageId: "nestedHook",
+					node,
+					data: { name: hookName }
+				});
+				return;
+			}
+			if (!isUse && isConditionalNode(current)) {
+				context.report({
+					messageId: "conditionalHook",
+					node,
+					data: { name: hookName }
+				});
+				return;
+			}
+			if (!isUse && isLoopNode(current)) {
+				context.report({
+					messageId: "loopHook",
+					node,
+					data: { name: hookName }
+				});
+				return;
+			}
+			if (isUse && isTryCatchNode(current)) {
+				context.report({
+					messageId: "useInTryCatch",
+					node,
+					data: { name: hookName }
 				});
+				return;
 			}
+			current = current.parent;
 		}
-	} };
-}
-
-//#endregion
-//#region src/rules-removed/no-prop-types.ts
-const RULE_NAME$2 = "no-prop-types";
-var no_prop_types_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallows 'propTypes' in favor of TypeScript or another type-checking solution." },
-		messages: { default: "[Deprecated] Use TypeScript or another type-checking solution instead." },
-		schema: []
-	},
-	name: RULE_NAME$2,
-	create: create$2,
-	defaultOptions: []
-});
-function create$2(context) {
-	if (!context.sourceCode.text.includes("propTypes")) return {};
+		if (boundary.hasEarlyReturn) {
+			context.report({
+				messageId: "afterEarlyReturn",
+				node,
+				data: { name: hookName }
+			});
+			return;
+		}
+	}
 	return {
-		AssignmentExpression(node) {
-			if (node.operator !== "=" || node.left.type !== AST_NODE_TYPES.MemberExpression) return;
-			const { object, property } = node.left;
-			if (object.type !== AST_NODE_TYPES.Identifier) return;
-			if (property.type !== AST_NODE_TYPES.Identifier || property.name !== "propTypes") return;
-			if (!core.isComponentNameLoose(object.name)) return;
-			const variableNode = getVariableDefinitionNode(findVariable(object.name, context.sourceCode.getScope(node)), 0);
-			if (variableNode != null && (ast.isFunction(variableNode) || core.isClassComponent(variableNode))) context.report({
-				messageId: "default",
-				node: property
+		":function"(node) {
+			const kind = getFunctionEntryKind(node);
+			functionStack.push({
+				kind,
+				node,
+				hasEarlyReturn: false,
+				isAsync: node.async
 			});
 		},
-		PropertyDefinition(node) {
-			if (!core.isClassComponent(node.parent.parent)) return;
-			if (!node.static || node.key.type !== AST_NODE_TYPES.Identifier || node.key.name !== "propTypes") return;
-			context.report({
-				messageId: "default",
-				node
-			});
+		":function:exit"() {
+			functionStack.pop();
+		},
+		CallExpression(node) {
+			if (!core.isHookCall(node)) return;
+			checkHookCall(node);
+		},
+		ReturnStatement(node) {
+			if (functionStack.length === 0) return;
+			const entry = functionStack.at(-1);
+			if (entry == null) return;
+			const fnNode = entry.node;
+			if (fnNode.body.type !== AST_NODE_TYPES.BlockStatement) return;
+			const body = fnNode.body.body;
+			let stmt = node;
+			while (stmt.parent !== fnNode.body) {
+				if (stmt.parent == null) return;
+				stmt = stmt.parent;
+			}
+			const idx = body.indexOf(stmt);
+			if (idx !== -1 && idx < body.length - 1) entry.hasEarlyReturn = true;
 		}
 	};
 }
 
 //#endregion
-//#region src/rules-removed/no-string-refs.ts
-const RULE_NAME$1 = "no-string-refs";
-var no_string_refs_default = createRule({
+//#region src/rules/set-state-in-effect.ts
+const RULE_NAME$1 = "set-state-in-effect";
+var set_state_in_effect_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Replaces string refs with callback refs." },
-		fixable: "code",
-		messages: { default: "[Deprecated] Use callback refs instead." },
+		docs: { description: "Validates against calling ['setState'](https://react.dev/reference/react/useState#setstate) synchronously in an effect, which can lead to re-renders that degrade performance." },
+		messages: { default: "Do not call the 'set' function '{{name}}' of 'useState' synchronously in an effect. This can lead to unnecessary re-renders and performance issues." },
 		schema: []
 	},
 	name: RULE_NAME$1,
@@ -3407,56 +3900,203 @@ var no_string_refs_default = createRule({
 	defaultOptions: []
 });
 function create$1(context) {
-	const state = { isWithinClassComponent: false };
-	function onClassBodyEnter(node) {
-		if (core.isClassComponent(node.parent)) state.isWithinClassComponent = true;
+	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+	const { 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 node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "then";
 	}
-	function onClassBodyExit() {
-		state.isWithinClassComponent = false;
+	function isUseStateCall(node) {
+		return core.isUseStateLikeCall(node, additionalStateHooks);
+	}
+	function isUseEffectSetupCallback(node) {
+		return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && core.isUseEffectLikeCall(node.parent);
+	}
+	function getCallName(node) {
+		if (node.type === AST_NODE_TYPES.CallExpression) return ast.getFullyQualifiedName(node.callee, getText);
+		return ast.getFullyQualifiedName(node, getText);
+	}
+	function getCallKind(node) {
+		return match(node).when(isUseStateCall, () => "useState").when(core.isUseEffectLikeCall, () => "useEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
+	}
+	function getFunctionKind(node) {
+		const parent = ast.findParentNode(node, not(ast.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";
+		}
+	}
+	function isIdFromUseStateCall(topLevelId, at) {
+		const variableNode = getVariableDefinitionNode(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
+		if (variableNode == null) return false;
+		if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
+		if (!isUseStateCall(variableNode)) return false;
+		const variableNodeParent = variableNode.parent;
+		if (!("id" in variableNodeParent) || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
+		return variableNodeParent.id.elements.findIndex((e) => e?.type === AST_NODE_TYPES.Identifier && e.name === topLevelId.name) === at;
+	}
+	function isSetStateCall(node) {
+		switch (node.callee.type) {
+			case AST_NODE_TYPES.CallExpression: {
+				const { callee } = node.callee;
+				if (callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+				if (!("name" in callee.object)) return false;
+				const isAt = callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "at";
+				const [index] = node.callee.arguments;
+				if (!isAt || index == null) return false;
+				return getStaticValue(index, context.sourceCode.getScope(node))?.value === 1 && isIdFromUseStateCall(callee.object);
+			}
+			case AST_NODE_TYPES.Identifier: return isIdFromUseStateCall(node.callee, 1);
+			case AST_NODE_TYPES.MemberExpression: {
+				if (!("name" in node.callee.object)) return false;
+				const property = node.callee.property;
+				return getStaticValue(property, context.sourceCode.getScope(node))?.value === 1 && isIdFromUseStateCall(node.callee.object, 1);
+			}
+			default: return false;
+		}
 	}
 	return {
-		ClassBody: onClassBodyEnter,
-		"ClassBody:exit": onClassBodyExit,
-		JSXAttribute(node) {
-			if (node.name.name !== "ref") return;
-			const refName = getJsxAttributeValueText(context, node.value);
-			if (refName == null) return;
-			context.report({
-				messageId: "default",
-				node,
-				fix(fixer) {
-					if (node.value == null) return null;
-					if (!state.isWithinClassComponent) return null;
-					return fixer.replaceText(node.value, `{(ref) => { this.refs[${refName}] = ref; }}`);
+		":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" && ast.findParentNode(entry.node, ast.isFunction) === setupFunction:
+						context.report({
+							messageId: "default",
+							node,
+							data: { name: context.sourceCode.getText(node.callee) }
+						});
+						return;
+					default: {
+						const init = ast.findParentNode(node, isVariableDeclaratorFromHookCall)?.init;
+						if (init == null) getOrElseUpdate(setStateCallsByFn, entry.node, () => []).push(node);
+						else getOrElseUpdate(setStateInHookCallbacks, init, () => []).push(node);
+					}
+				}
+			}).with("useEffect", () => {
+				if (ast.isFunction(node.arguments.at(0))) return;
+				setupFnIds.push(...ast.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(parent)) break;
+					const init = ast.findParentNode(parent, isVariableDeclaratorFromHookCall)?.init;
+					if (init != null) getOrElseUpdate(setStateInEffectArg, init, () => []).push(node);
+					break;
+				}
+				case AST_NODE_TYPES.CallExpression:
+					if (node !== node.parent.arguments.at(0)) break;
+					if (core.isUseCallbackCall(node.parent)) {
+						const init = ast.findParentNode(node.parent, isVariableDeclaratorFromHookCall)?.init;
+						if (init != null) getOrElseUpdate(setStateInEffectArg, init, () => []).push(node);
+						break;
+					}
+					if (core.isUseEffectLikeCall(node.parent)) getOrElseUpdate(setStateInEffectSetup, node.parent, () => []).push(node);
+			}
+		},
+		"Program:exit"() {
+			const getSetStateCalls = (id, initialScope) => {
+				const node = getVariableDefinitionNode(findVariable(id, initialScope), 0);
+				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) context.report({
+				messageId: "default",
+				node: call,
+				data: { name: call.name }
 			});
+			for (const { callee } of trackedFnCalls) {
+				if (!("name" in callee)) continue;
+				const { name } = callee;
+				const setStateCalls = getSetStateCalls(name, context.sourceCode.getScope(callee));
+				for (const setStateCall of setStateCalls) context.report({
+					messageId: "default",
+					node: setStateCall,
+					data: { name: getCallName(setStateCall) }
+				});
+			}
+			for (const id of setupFnIds) {
+				const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
+				for (const setStateCall of setStateCalls) context.report({
+					messageId: "default",
+					node: setStateCall,
+					data: { name: getCallName(setStateCall) }
+				});
+			}
 		}
 	};
 }
-/**
-* Extracts the text content from a JSX attribute's value
-* @param context The rule context
-* @param node The JSX attribute value node
-* @returns The text of the attribute value, or null if not a string-like value
-*/
-function getJsxAttributeValueText(context, node) {
-	if (node == null) return null;
-	switch (true) {
-		case node.type === AST_NODE_TYPES.Literal && typeof node.value === "string": return context.sourceCode.getText(node);
-		case node.type === AST_NODE_TYPES.JSXExpressionContainer && node.expression.type === AST_NODE_TYPES.Literal && typeof node.expression.value === "string": return context.sourceCode.getText(node.expression);
-		case node.type === AST_NODE_TYPES.JSXExpressionContainer && node.expression.type === AST_NODE_TYPES.TemplateLiteral: return context.sourceCode.getText(node.expression);
-		default: return null;
+function isInitFromHookCall(init) {
+	if (init?.type !== AST_NODE_TYPES.CallExpression) return false;
+	switch (init.callee.type) {
+		case AST_NODE_TYPES.Identifier: return core.isHookName(init.callee.name);
+		case AST_NODE_TYPES.MemberExpression: return init.callee.property.type === AST_NODE_TYPES.Identifier && core.isHookName(init.callee.property.name);
+		default: return false;
 	}
 }
+function isVariableDeclaratorFromHookCall(node) {
+	if (node.type !== AST_NODE_TYPES.VariableDeclarator) return false;
+	if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
+	return isInitFromHookCall(node.init);
+}
 
 //#endregion
-//#region src/rules-removed/no-unnecessary-use-ref.ts
-const RULE_NAME = "no-unnecessary-use-ref";
-var no_unnecessary_use_ref_default = createRule({
+//#region src/rules/set-state-in-render.ts
+const RULE_NAME = "set-state-in-render";
+var set_state_in_render_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallows unnecessary usage of 'useRef'." },
-		messages: { default: "Unnecessary use of 'useRef'. Instead, co-locate the value inside the effect that uses it." },
+		docs: { description: "Validates against unconditionally setting state during render, which can trigger additional renders and potential infinite render loops." },
+		messages: { default: "Do not call the 'set' function '{{name}}' unconditionally during render. This will trigger an infinite render loop." },
 		schema: []
 	},
 	name: RULE_NAME,
@@ -3464,27 +4104,126 @@ var no_unnecessary_use_ref_default = createRule({
 	defaultOptions: []
 });
 function create(context) {
-	if (!context.sourceCode.text.includes("useRef")) return {};
-	return { VariableDeclarator(node) {
-		const { id, init } = node;
-		if (id.type !== AST_NODE_TYPES.Identifier || init == null || !core.isUseRefCall(init)) return;
-		const [ref, ...rest] = context.sourceCode.getDeclaredVariables(node);
-		if (ref == null || rest.length > 0) return;
-		if (ref.name.toLowerCase().startsWith("prev")) return;
-		const effects = /* @__PURE__ */ new Set();
-		let globalUsages = 0;
-		for (const { identifier, init } of ref.references) {
-			if (init != null) continue;
-			const effect = ast.findParentNode(identifier, core.isUseEffectLikeCall);
-			if (effect == null) globalUsages++;
-			else effects.add(effect);
-		}
-		if (globalUsages > 0 || effects.size !== 1) return;
-		context.report({
-			messageId: "default",
-			node: node.parent
-		});
-	} };
+	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 variableNode = getVariableDefinitionNode(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
+		if (variableNode == null) return false;
+		if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
+		if (!isUseStateCall(variableNode)) return false;
+		const variableNodeParent = variableNode.parent;
+		if (!("id" in variableNodeParent) || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
+		return variableNodeParent.id.elements.findIndex((e) => e?.type === AST_NODE_TYPES.Identifier && e.name === topLevelId.name) === at;
+	}
+	function isSetStateCall(node) {
+		switch (node.callee.type) {
+			case AST_NODE_TYPES.CallExpression: {
+				const { callee } = node.callee;
+				if (callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+				if (!("name" in callee.object)) return false;
+				const isAt = callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "at";
+				const [index] = node.callee.arguments;
+				if (!isAt || index == null) return false;
+				return getStaticValue(index, context.sourceCode.getScope(node))?.value === 1 && isIdFromUseStateCall(callee.object);
+			}
+			case AST_NODE_TYPES.Identifier: return isIdFromUseStateCall(node.callee, 1);
+			case AST_NODE_TYPES.MemberExpression: {
+				if (!("name" in node.callee.object)) return false;
+				const property = node.callee.property;
+				return getStaticValue(property, context.sourceCode.getScope(node))?.value === 1 && isIdFromUseStateCall(node.callee.object, 1);
+			}
+			default: 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;
+				default: break;
+			}
+			current = current.parent;
+		}
+		return false;
+	}
+	function isInsideEventHandler(node, stopAt) {
+		let current = node.parent;
+		while (current != null && current !== stopAt) {
+			if (ast.isFunction(current) && current !== stopAt) return true;
+			current = current.parent;
+		}
+		return false;
+	}
+	function isComponentLikeFunction(node) {
+		const id = ast.getFunctionId(node);
+		if (id == null) return false;
+		if (id.type === AST_NODE_TYPES.Identifier) return core.isComponentName(id.name);
+		if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) return core.isComponentName(id.property.name);
+		return false;
+	}
+	function getFunctionKind(node) {
+		if (isComponentLikeFunction(node)) return "component";
+		const parent = ast.findParentNode(node, not(ast.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({
+				messageId: "default",
+				node,
+				data: { name: context.sourceCode.getText(node.callee) }
+			});
+		},
+		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;
+		}
+	};
 }
 
 //#endregion
@@ -3495,6 +4234,9 @@ const plugin = {
 		version
 	},
 	rules: {
+		"component-hook-factories": component_hook_factories_default,
+		"error-boundaries": error_boundaries_default,
+		"exhaustive-deps": exhaustive_deps_default,
 		"jsx-dollar": jsx_dollar_default,
 		"jsx-key-before-spread": jsx_key_before_spread_default,
 		"jsx-no-comment-textnodes": jsx_no_comment_textnodes_default,
@@ -3535,7 +4277,6 @@ const plugin = {
 		"no-set-state-in-component-did-mount": no_set_state_in_component_did_mount_default,
 		"no-set-state-in-component-did-update": no_set_state_in_component_did_update_default,
 		"no-set-state-in-component-will-update": no_set_state_in_component_will_update_default,
-		"no-unnecessary-key": no_unnecessary_key_default,
 		"no-unnecessary-use-callback": no_unnecessary_use_callback_default,
 		"no-unnecessary-use-memo": no_unnecessary_use_memo_default,
 		"no-unnecessary-use-prefix": no_unnecessary_use_prefix_default,
@@ -3554,11 +4295,9 @@ const plugin = {
 		"prefer-namespace-import": prefer_namespace_import_default,
 		"prefer-read-only-props": prefer_read_only_props_default,
 		"prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default,
-		"no-default-props": no_default_props_default,
-		"no-forbidden-props": no_forbidden_props_default,
-		"no-prop-types": no_prop_types_default,
-		"no-string-refs": no_string_refs_default,
-		"no-unnecessary-use-ref": no_unnecessary_use_ref_default
+		"rules-of-hooks": rules_of_hooks_default,
+		"set-state-in-effect": set_state_in_effect_default,
+		"set-state-in-render": set_state_in_render_default
 	}
 };
 
@@ -3572,6 +4311,9 @@ var recommended_exports = /* @__PURE__ */ __exportAll({
 });
 const name$5 = "react-x/recommended";
 const rules$6 = {
+	"react-x/component-hook-factories": "error",
+	"react-x/error-boundaries": "error",
+	"react-x/exhaustive-deps": "warn",
 	"react-x/jsx-key-before-spread": "warn",
 	"react-x/jsx-no-comment-textnodes": "warn",
 	"react-x/jsx-no-duplicate-props": "warn",
@@ -3590,25 +4332,25 @@ const rules$6 = {
 	"react-x/no-component-will-update": "error",
 	"react-x/no-context-provider": "warn",
 	"react-x/no-create-ref": "error",
-	"react-x/no-default-props": "error",
 	"react-x/no-direct-mutation-state": "error",
 	"react-x/no-forward-ref": "warn",
 	"react-x/no-missing-key": "error",
 	"react-x/no-nested-component-definitions": "error",
 	"react-x/no-nested-lazy-component-declarations": "error",
-	"react-x/no-prop-types": "error",
 	"react-x/no-redundant-should-component-update": "error",
 	"react-x/no-set-state-in-component-did-mount": "warn",
 	"react-x/no-set-state-in-component-did-update": "warn",
 	"react-x/no-set-state-in-component-will-update": "warn",
-	"react-x/no-string-refs": "error",
 	"react-x/no-unnecessary-use-prefix": "warn",
 	"react-x/no-unsafe-component-will-mount": "warn",
 	"react-x/no-unsafe-component-will-receive-props": "warn",
 	"react-x/no-unsafe-component-will-update": "warn",
 	"react-x/no-use-context": "warn",
 	"react-x/no-useless-forward-ref": "warn",
-	"react-x/prefer-use-state-lazy-initialization": "warn"
+	"react-x/prefer-use-state-lazy-initialization": "warn",
+	"react-x/rules-of-hooks": "error",
+	"react-x/set-state-in-effect": "warn",
+	"react-x/set-state-in-render": "error"
 };
 const plugins$5 = { "react-x": plugin };
 const settings$5 = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };