eslint-plugin-react-x 5.18.10 → 5.19.1

package/dist/index.js

@@ -4,12 +4,12 @@ import { Check, Compare, Extract, Traverse } from "@eslint-react/ast";
 import * as core from "@eslint-react/core";
 import { merge } from "@eslint-react/eslint";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { P, isMatching, match } from "ts-pattern";
 import { isAssignmentTargetEqual, isInitializedFromReact, resolve, resolveEnclosingAssignmentTarget, resolveObjectType } from "@eslint-react/var";
 import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { findParentAttribute, getElementFullType, hasAttribute } from "@eslint-react/jsx";
 import { compare } from "compare-versions";
-import { P, isMatching, match } from "ts-pattern";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
 import { unionConstituents } from "ts-api-utils";
 import "typescript";
@@ -145,7 +145,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.18.10";
+var version = "5.19.1";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1143,6 +1143,97 @@ const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
 	"unshift"
 ]);
 /**
+* Collect every write target in an assignment, including destructuring
+* patterns such as `[local, globalValue] = source`.
+*/
+function getAssignmentTargets(node) {
+	const target = Extract.unwrap(node);
+	switch (target.type) {
+		case AST_NODE_TYPES.Identifier:
+		case AST_NODE_TYPES.MemberExpression: return [target];
+		case AST_NODE_TYPES.ArrayPattern: return target.elements.flatMap((element) => element == null ? [] : getAssignmentTargets(element));
+		case AST_NODE_TYPES.AssignmentPattern: return getAssignmentTargets(target.left);
+		case AST_NODE_TYPES.ObjectPattern: return target.properties.flatMap((property) => {
+			if (property.type === AST_NODE_TYPES.RestElement) return getAssignmentTargets(property.argument);
+			return getAssignmentTargets(property.value);
+		});
+		case AST_NODE_TYPES.RestElement: return getAssignmentTargets(target.argument);
+		default: return [];
+	}
+}
+/** Resolve a direct call target, following simple function aliases. */
+function resolveToFunction(context, node, seen = /* @__PURE__ */ new Set()) {
+	const expression = Extract.unwrap(node);
+	if (Check.isFunction(expression)) return expression;
+	if (!Check.isIdentifier(expression) || seen.has(expression)) return null;
+	seen.add(expression);
+	const resolved = resolve(context, expression);
+	if (resolved == null) return null;
+	return resolveToFunction(context, resolved, seen);
+}
+
+//#endregion
+//#region src/rules/globals/collect.ts
+function createGlobalsCollector() {
+	const facts = {
+		callEdges: [],
+		methodCalls: [],
+		writes: []
+	};
+	function getEnclosingFunction(node) {
+		return Traverse.findParent(node, Check.isFunction);
+	}
+	function pushWrite(node, target) {
+		const enclosingFunction = getEnclosingFunction(node);
+		if (enclosingFunction == null) return;
+		facts.writes.push({
+			enclosingFunction,
+			node,
+			target
+		});
+	}
+	return {
+		facts,
+		visitor: {
+			AssignmentExpression(node) {
+				for (const target of getAssignmentTargets(node.left)) pushWrite(node, target);
+			},
+			CallExpression(node) {
+				const caller = getEnclosingFunction(node);
+				if (caller != null) facts.callEdges.push({
+					callee: node.callee,
+					caller
+				});
+				const callee = Extract.unwrap(node.callee);
+				if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
+				const method = Extract.getCalleeName(node);
+				if (method == null || !MUTATING_ARRAY_METHODS.has(method)) return;
+				if (caller == null) return;
+				facts.methodCalls.push({
+					enclosingFunction: caller,
+					method,
+					node,
+					receiver: callee.object
+				});
+			},
+			UnaryExpression(node) {
+				if (node.operator !== "delete") return;
+				const argument = Extract.unwrap(node.argument);
+				if (argument.type !== AST_NODE_TYPES.MemberExpression) return;
+				pushWrite(node, argument);
+			},
+			UpdateExpression(node) {
+				const argument = Extract.unwrap(node.argument);
+				if (argument.type !== AST_NODE_TYPES.Identifier && argument.type !== AST_NODE_TYPES.MemberExpression) return;
+				pushWrite(node, argument);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/globals/origins.ts
+/**
 * Return whether an identifier is an unresolved global or is declared in the
 * global/module scope.
 */
@@ -1174,34 +1265,85 @@ function resolveGlobalOrigin(context, node, seen = /* @__PURE__ */ new Set()) {
 	if (initializer.type !== AST_NODE_TYPES.Identifier && initializer.type !== AST_NODE_TYPES.MemberExpression) return null;
 	return resolveGlobalOrigin(context, initializer, seen);
 }
+
+//#endregion
+//#region src/rules/globals/effects.ts
 /**
-* Collect every write target in an assignment, including destructuring
-* patterns such as `[local, globalValue] = source`.
+* Classify the collected writes and mutating method calls, keeping only the
+* ones that reach a global/module binding, grouped by the function that
+* performs them.
 */
-function getAssignmentTargets(node) {
-	const target = Extract.unwrap(node);
-	switch (target.type) {
-		case AST_NODE_TYPES.Identifier:
-		case AST_NODE_TYPES.MemberExpression: return [target];
-		case AST_NODE_TYPES.ArrayPattern: return target.elements.flatMap((element) => element == null ? [] : getAssignmentTargets(element));
-		case AST_NODE_TYPES.AssignmentPattern: return getAssignmentTargets(target.left);
-		case AST_NODE_TYPES.ObjectPattern: return target.properties.flatMap((property) => {
-			if (property.type === AST_NODE_TYPES.RestElement) return getAssignmentTargets(property.argument);
-			return getAssignmentTargets(property.value);
+function inferGlobalMutations(context, facts) {
+	const directEffects = /* @__PURE__ */ new Map();
+	function pushEffect(enclosingFunction, effect) {
+		const effects = directEffects.get(enclosingFunction) ?? [];
+		effects.push(effect);
+		directEffects.set(enclosingFunction, effects);
+	}
+	for (const write of facts.writes) {
+		if (Check.isIdentifier(write.target)) {
+			if (!isGlobalVariable(context, write.target)) continue;
+			pushEffect(write.enclosingFunction, {
+				kind: "global",
+				name: write.target.name,
+				method: null,
+				node: write.node
+			});
+			continue;
+		}
+		if (resolveGlobalOrigin(context, write.target.object) == null) continue;
+		pushEffect(write.enclosingFunction, {
+			kind: "property",
+			name: context.sourceCode.getText(write.target),
+			method: null,
+			node: write.node
 		});
-		case AST_NODE_TYPES.RestElement: return getAssignmentTargets(target.argument);
-		default: return [];
 	}
+	for (const call of facts.methodCalls) {
+		const origin = resolveGlobalOrigin(context, call.receiver);
+		if (origin == null) continue;
+		pushEffect(call.enclosingFunction, {
+			kind: "method",
+			name: origin.name,
+			method: call.method,
+			node: call.node
+		});
+	}
+	return directEffects;
 }
-/** Resolve a direct call target, following simple function aliases. */
-function resolveToFunction(context, node, seen = /* @__PURE__ */ new Set()) {
-	const expression = Extract.unwrap(node);
-	if (Check.isFunction(expression)) return expression;
-	if (!Check.isIdentifier(expression) || seen.has(expression)) return null;
-	seen.add(expression);
-	const resolved = resolve(context, expression);
-	if (resolved == null) return null;
-	return resolveToFunction(context, resolved, seen);
+/** Resolve the collected call edges into a function-to-function call graph. */
+function inferCallGraph(context, callEdges) {
+	const callGraph = /* @__PURE__ */ new Map();
+	for (const edge of callEdges) {
+		const callee = resolveToFunction(context, edge.callee);
+		if (callee == null) continue;
+		const callees = callGraph.get(edge.caller) ?? /* @__PURE__ */ new Set();
+		callees.add(callee);
+		callGraph.set(edge.caller, callees);
+	}
+	return callGraph;
+}
+/**
+* Like the SPEC's function signatures, these summaries keep creation of an
+* effect separate from applying it in a component or hook render: walk the
+* call graph from each render function and gather every reachable effect once.
+*/
+function collectReachableEffects(renderFunctions, directEffects, callGraph) {
+	const visited = /* @__PURE__ */ new Set();
+	const reported = /* @__PURE__ */ new Set();
+	const reachable = [];
+	function applyFunctionEffects(func) {
+		if (visited.has(func)) return;
+		visited.add(func);
+		for (const effect of directEffects.get(func) ?? []) {
+			if (reported.has(effect)) continue;
+			reported.add(effect);
+			reachable.push(effect);
+		}
+		for (const callee of callGraph.get(func) ?? []) applyFunctionEffects(callee);
+	}
+	for (const func of renderFunctions) applyFunctionEffects(func);
+	return reachable;
 }
 
 //#endregion
@@ -1223,87 +1365,25 @@ var globals_default = createRule({
 	defaultOptions: []
 });
 function create$49(context) {
-	const hc = core.getHookCollector(context);
-	const fc = core.getFunctionComponentCollector(context);
-	const directEffects = /* @__PURE__ */ new Map();
-	const callGraph = /* @__PURE__ */ new Map();
-	function getEnclosingFunction(node) {
-		return Traverse.findParent(node, Check.isFunction);
-	}
-	function recordEffect(node, messageId, data) {
-		const enclosing = getEnclosingFunction(node);
-		if (enclosing == null) return;
-		const effects = directEffects.get(enclosing) ?? [];
-		effects.push({
-			data,
-			messageId,
-			node
-		});
-		directEffects.set(enclosing, effects);
-	}
-	function recordWrite(node, target) {
-		if (Check.isIdentifier(target)) {
-			if (!isGlobalVariable(context, target)) return;
-			recordEffect(node, "mutatingGlobal", { name: target.name });
-			return;
-		}
-		if (resolveGlobalOrigin(context, target.object) == null) return;
-		recordEffect(node, "mutatingGlobalProperty", { name: context.sourceCode.getText(target) });
-	}
-	function recordCallEdge(node) {
-		const caller = getEnclosingFunction(node);
-		if (caller == null) return;
-		const callee = resolveToFunction(context, node.callee);
-		if (callee == null) return;
-		const callees = callGraph.get(caller) ?? /* @__PURE__ */ new Set();
-		callees.add(callee);
-		callGraph.set(caller, callees);
-	}
-	return merge(hc.visitor, fc.visitor, {
-		AssignmentExpression(node) {
-			for (const target of getAssignmentTargets(node.left)) recordWrite(node, target);
-		},
-		CallExpression(node) {
-			recordCallEdge(node);
-			const callee = Extract.unwrap(node.callee);
-			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			const method = Extract.getCalleeName(node);
-			if (method == null || !MUTATING_ARRAY_METHODS.has(method)) return;
-			const origin = resolveGlobalOrigin(context, callee.object);
-			if (origin == null) return;
-			recordEffect(node, "mutatingGlobalArrayMethod", {
-				name: origin.name,
-				method
+	const hooks = core.getHookCollector(context);
+	const comps = core.getFunctionComponentCollector(context);
+	const globs = createGlobalsCollector();
+	return merge(hooks.visitor, comps.visitor, globs.visitor, { "Program:exit"(program) {
+		const renderFunctions = [...comps.api.getAllComponents(program), ...hooks.api.getAllHooks(program)].map(({ node }) => node);
+		const directEffects = inferGlobalMutations(context, globs.facts);
+		const callGraph = inferCallGraph(context, globs.facts.callEdges);
+		for (const effect of collectReachableEffects(renderFunctions, directEffects, callGraph)) {
+			const data = effect.method == null ? { name: effect.name } : {
+				name: effect.name,
+				method: effect.method
+			};
+			context.report({
+				data,
+				messageId: match(effect).with({ kind: "global" }, () => "mutatingGlobal").with({ kind: "method" }, () => "mutatingGlobalArrayMethod").with({ kind: "property" }, () => "mutatingGlobalProperty").exhaustive(),
+				node: effect.node
 			});
-		},
-		"Program:exit"(program) {
-			const renderFunctions = [...fc.api.getAllComponents(program), ...hc.api.getAllHooks(program)];
-			const visited = /* @__PURE__ */ new Set();
-			const reported = /* @__PURE__ */ new Set();
-			function applyFunctionEffects(func) {
-				if (visited.has(func)) return;
-				visited.add(func);
-				for (const effect of directEffects.get(func) ?? []) {
-					if (reported.has(effect)) continue;
-					reported.add(effect);
-					context.report(effect);
-				}
-				for (const callee of callGraph.get(func) ?? []) applyFunctionEffects(callee);
-			}
-			for (const { node } of renderFunctions) applyFunctionEffects(node);
-		},
-		UnaryExpression(node) {
-			if (node.operator !== "delete") return;
-			const argument = Extract.unwrap(node.argument);
-			if (argument.type !== AST_NODE_TYPES.MemberExpression) return;
-			recordWrite(node, argument);
-		},
-		UpdateExpression(node) {
-			const argument = Extract.unwrap(node.argument);
-			if (argument.type !== AST_NODE_TYPES.Identifier && argument.type !== AST_NODE_TYPES.MemberExpression) return;
-			recordWrite(node, argument);
 		}
-	});
+	} });
 }
 
 //#endregion
@@ -1314,7 +1394,7 @@ function create$49(context) {
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
 */
-const MUTATING_METHODS = /* @__PURE__ */ new Set([
+const KNOWN_MUTATING_METHODS = /* @__PURE__ */ new Set([
 	"add",
 	"clear",
 	"copyWithin",
@@ -1330,14 +1410,36 @@ const MUTATING_METHODS = /* @__PURE__ */ new Set([
 	"unshift"
 ]);
 /**
-* Known navigation hooks.
+* Known mutating hooks.
 */
-const NAVIGATION_HOOKS = /* @__PURE__ */ new Set([
+const KNOWN_MUTATING_HOOKS = /* @__PURE__ */ new Set([
 	"useHistory",
 	"useNavigate",
 	"useNavigation",
 	"useRouter"
 ]);
+function isNodeWithin(node, ancestor) {
+	let current = node;
+	while (current != null) {
+		if (current === ancestor) return true;
+		current = current.parent;
+	}
+	return false;
+}
+function isComponentPropsDefinition(def, components) {
+	if (def.type !== DefinitionType.Parameter) return false;
+	const fn = def.node;
+	if (!Check.isFunction(fn)) return false;
+	const firstParam = fn.params.at(0);
+	if (firstParam == null || !isNodeWithin(def.name, firstParam)) return false;
+	return components.includes(fn);
+}
+function getStateHookName(context, init) {
+	const { additionalStateHooks } = getSettingsFromContext(context);
+	if (core.isUseStateLikeCall(init, additionalStateHooks)) return Extract.getCalleeName(init) ?? "useState";
+	if (core.isUseReducerCall(context, init)) return "useReducer";
+	return null;
+}
 function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set()) {
 	const expr = Extract.unwrap(node);
 	if (Check.isFunction(expr)) return expr;
@@ -1382,7 +1484,7 @@ function isInitializedFromUseRef(context, node) {
 function isKnownNonMutatingMethodCall(context, node) {
 	const callee = Extract.unwrap(node.callee);
 	return Check.isExpression(callee) && isInitializedFromCall(context, callee, (init) => {
-		return NAVIGATION_HOOKS.values().some((hook) => core.isAPICall(hook)(context, init));
+		return KNOWN_MUTATING_HOOKS.values().some((hook) => core.isAPICall(hook)(context, init));
 	});
 }
 function isRefLikeChain(context, node) {
@@ -1427,7 +1529,7 @@ function createImmutabilityCollector() {
 				const callee = Extract.unwrap(node.callee);
 				if (callee.type === AST_NODE_TYPES.MemberExpression) {
 					const method = Extract.getCalleeName(node);
-					if (method != null && MUTATING_METHODS.has(method)) {
+					if (method != null && KNOWN_MUTATING_METHODS.has(method)) {
 						const root = Extract.getIdentifierAt(callee.object, 0);
 						if (root != null) pushMutation("value", node, callee.object, root);
 					}
@@ -1474,6 +1576,66 @@ function createImmutabilityCollector() {
 	};
 }
 
+//#endregion
+//#region src/rules/immutability/origins.ts
+/**
+* Classify whether a variable ultimately holds a value that must be treated as
+* immutable: a component's props, a state value returned from `useState`-like or
+* `useReducer` calls, or a shallow copy (spread literal) of either.
+* @param context The rule context.
+* @param variable The variable to classify.
+* @param components The confirmed function component nodes in the file.
+* @param seen Variables already visited during spread recursion.
+* @returns The frozen origin, or `null` when the variable is not derived from one.
+*/
+function classifyFrozenOrigin(context, variable, components, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(variable)) return null;
+	seen.add(variable);
+	const origin = resolveVariableOrigin(context, variable);
+	const def = origin.defs.length === 1 ? origin.defs[0] : null;
+	if (def == null) return null;
+	if (isComponentPropsDefinition(def, components)) return {
+		kind: "props",
+		name: origin.name
+	};
+	if (def.type !== DefinitionType.Variable) return null;
+	const init = def.node.init == null ? null : Extract.unwrap(def.node.init);
+	if (init == null) return null;
+	switch (init.type) {
+		case AST_NODE_TYPES.CallExpression: {
+			const hook = getStateHookName(context, init);
+			if (hook == null) return null;
+			if (def.node.id.type !== AST_NODE_TYPES.ArrayPattern) return null;
+			const first = def.node.id.elements.at(0);
+			if (first == null || !isNodeWithin(def.name, first)) return null;
+			return {
+				kind: "state",
+				name: origin.name,
+				hook
+			};
+		}
+		case AST_NODE_TYPES.ArrayExpression:
+		case AST_NODE_TYPES.ObjectExpression: {
+			const elements = init.type === AST_NODE_TYPES.ObjectExpression ? init.properties : init.elements;
+			for (const element of elements) {
+				if (element?.type !== AST_NODE_TYPES.SpreadElement) continue;
+				const argument = Extract.unwrap(element.argument);
+				if (!Check.isIdentifier(argument)) continue;
+				const source = findVariable(context.sourceCode.getScope(argument), argument);
+				if (source == null) continue;
+				const inner = classifyFrozenOrigin(context, source, components, seen);
+				if (inner != null) return {
+					kind: "shallow-copy",
+					name: origin.name,
+					original: inner.name
+				};
+			}
+			return null;
+		}
+		default: return null;
+	}
+}
+
 //#endregion
 //#region src/rules/immutability/effects.ts
 function isGlobalOrModuleVariable(variable) {
@@ -1505,6 +1667,47 @@ function inferMutableFunctions(context, mutations) {
 	}
 	return mutableFunctions;
 }
+function getMutatedObject(mutation) {
+	const target = Extract.unwrap(mutation.target);
+	if (mutation.node.type === AST_NODE_TYPES.CallExpression) return target;
+	return target.type === AST_NODE_TYPES.MemberExpression ? Extract.unwrap(target.object) : target;
+}
+function inferDirectMutations(context, mutations, components) {
+	const directMutations = [];
+	for (const mutation of mutations) {
+		if (mutation.kind !== "value") continue;
+		if (mutation.node.type === AST_NODE_TYPES.CallExpression && isKnownNonMutatingMethodCall(context, mutation.node)) continue;
+		if (isRefMutation(context, mutation)) continue;
+		const variable = findVariable(context.sourceCode.getScope(mutation.root), mutation.root);
+		if (variable == null) continue;
+		const origin = classifyFrozenOrigin(context, variable, components);
+		if (origin == null) continue;
+		switch (origin.kind) {
+			case "props":
+				directMutations.push({
+					name: origin.name,
+					detail: "It is a prop of this component and must be treated as immutable.",
+					node: mutation.node
+				});
+				break;
+			case "state":
+				directMutations.push({
+					name: origin.name,
+					detail: `It is a state value returned from '${origin.hook}' and must be treated as immutable.`,
+					node: mutation.node
+				});
+				break;
+			case "shallow-copy":
+				if (getMutatedObject(mutation).type !== AST_NODE_TYPES.MemberExpression) continue;
+				directMutations.push({
+					name: origin.name,
+					detail: `It is a shallow copy of '${origin.original}'; mutating nested values through it mutates '${origin.original}' in place.`,
+					node: mutation.node
+				});
+		}
+	}
+	return directMutations;
+}
 
 //#endregion
 //#region src/rules/immutability/immutability.ts
@@ -1512,9 +1715,10 @@ const RULE_NAME$48 = "immutability";
 var immutability_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Validates against passing functions that mutate captured local variables into frozen contexts such as JSX props, hook arguments, and hook return values." },
+		docs: { description: "Validates against mutating props, state, and other immutable values, including through functions passed into frozen contexts such as JSX props, hook arguments, and hook return values." },
 		messages: {
 			default: "This function may (indirectly) reassign or modify '{{name}}' after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.",
+			direct: "Do not mutate '{{name}}' directly. {{detail}}",
 			mutates: "This modifies '{{name}}'."
 		},
 		schema: []
@@ -1525,31 +1729,48 @@ var immutability_default = createRule({
 });
 function create$48(context) {
 	const hooks = core.getHookCollector(context);
-	const collector = createImmutabilityCollector();
-	return merge(hooks.visitor, collector.visitor, { "Program:exit"(program) {
-		for (const hook of hooks.api.getAllHooks(program)) for (const expression of hook.rets) if (expression != null) collector.facts.sinks.push({
+	const comps = core.getFunctionComponentCollector(context);
+	const immut = createImmutabilityCollector();
+	return merge(hooks.visitor, comps.visitor, immut.visitor, { "Program:exit"(program) {
+		for (const hook of hooks.api.getAllHooks(program)) for (const expression of hook.rets) if (expression != null) immut.facts.sinks.push({
 			kind: "hook-return",
 			expression
 		});
-		const mutableFunctions = inferMutableFunctions(context, collector.facts.mutations);
-		if (mutableFunctions.size === 0) return;
-		const reported = /* @__PURE__ */ new Set();
-		for (const sink of collector.facts.sinks) {
-			const expression = sink.expression;
-			if (reported.has(expression)) continue;
-			const fn = resolveToFunctionNode(context, expression);
-			if (fn == null) continue;
-			const mutation = mutableFunctions.get(fn);
-			if (mutation == null) continue;
-			reported.add(expression);
-			context.report({
-				data: { name: mutation.name },
-				messageId: "default",
-				node: expression
-			});
+		const reportedMutations = /* @__PURE__ */ new Set();
+		const mutableFunctions = inferMutableFunctions(context, immut.facts.mutations);
+		if (mutableFunctions.size > 0) {
+			const reportedSinks = /* @__PURE__ */ new Set();
+			for (const sink of immut.facts.sinks) {
+				const expression = sink.expression;
+				if (reportedSinks.has(expression)) continue;
+				const fn = resolveToFunctionNode(context, expression);
+				if (fn == null) continue;
+				const mutation = mutableFunctions.get(fn);
+				if (mutation == null) continue;
+				reportedSinks.add(expression);
+				reportedMutations.add(mutation.node);
+				context.report({
+					data: { name: mutation.name },
+					messageId: "default",
+					node: expression
+				});
+				context.report({
+					data: { name: mutation.name },
+					messageId: "mutates",
+					node: mutation.node
+				});
+			}
+		}
+		const funcs = comps.api.getAllComponents(program).map((comp) => comp.node);
+		for (const mutation of inferDirectMutations(context, immut.facts.mutations, funcs)) {
+			if (reportedMutations.has(mutation.node)) continue;
+			reportedMutations.add(mutation.node);
 			context.report({
-				data: { name: mutation.name },
-				messageId: "mutates",
+				data: {
+					name: mutation.name,
+					detail: mutation.detail
+				},
+				messageId: "direct",
 				node: mutation.node
 			});
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.18.10",
+  "version": "5.19.1",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -36,17 +36,17 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.18.10",
-    "@eslint-react/core": "5.18.10",
-    "@eslint-react/eslint": "5.18.10",
-    "@eslint-react/jsx": "5.18.10",
-    "@eslint-react/shared": "5.18.10",
-    "@eslint-react/var": "5.18.10",
-    "@typescript-eslint/scope-manager": "^8.69.0",
-    "@typescript-eslint/type-utils": "^8.69.0",
-    "@typescript-eslint/types": "^8.69.0",
-    "@typescript-eslint/typescript-estree": "^8.69.0",
-    "@typescript-eslint/utils": "^8.69.0",
+    "@eslint-react/ast": "5.19.1",
+    "@eslint-react/core": "5.19.1",
+    "@eslint-react/eslint": "5.19.1",
+    "@eslint-react/jsx": "5.19.1",
+    "@eslint-react/shared": "5.19.1",
+    "@eslint-react/var": "5.19.1",
+    "@typescript-eslint/scope-manager": "^8.70.0",
+    "@typescript-eslint/type-utils": "^8.70.0",
+    "@typescript-eslint/types": "^8.70.0",
+    "@typescript-eslint/typescript-estree": "^8.70.0",
+    "@typescript-eslint/utils": "^8.70.0",
     "compare-versions": "^6.1.1",
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.5.0",
@@ -55,12 +55,12 @@
   "devDependencies": {
     "@local/configs": "0.0.0",
     "@local/eff": "0.0.0",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.7",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
     "dedent": "^1.7.2",
     "eslint": "^10.10.0",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "tsdown": "^0.23.0",
     "tsl": "^1.0.30",
     "tsl-dx": "^0.13.3",