eslint-plugin-react-x 5.14.1 → 5.14.5

package/dist/index.js

@@ -5,9 +5,9 @@ import * as core from "@eslint-react/core";
 import { merge } from "@eslint-react/eslint";
 import { JsxDetectionHint, findParentAttribute, getElementFullType, hasAttribute } from "@eslint-react/jsx";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { computeObjectType, isAssignmentTargetEqual, isInitializedFromReact, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
 import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { computeObjectType, isAssignmentTargetEqual, isInitializedFromReact, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
 import { P, isMatching, match } from "ts-pattern";
 import { compare } from "compare-versions";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
@@ -144,7 +144,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.14.1";
+var version = "5.14.5";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1157,6 +1157,67 @@ const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
 	"splice",
 	"unshift"
 ]);
+/**
+* Return whether an identifier is an unresolved global or is declared in the
+* global/module scope.
+*/
+function isGlobalVariable(context, node) {
+	const variable = findVariable(context.sourceCode.getScope(node), node);
+	if (variable == null || variable.defs.length === 0) return true;
+	return variable.scope.type === ScopeType.global || variable.scope.type === ScopeType.module;
+}
+/**
+* Resolve an object expression to the global/module binding it aliases.
+*
+* This intentionally follows only stable `const alias = value` declarations.
+* It gives the rule useful Alias effects without pretending to perform full
+* control-flow analysis for reassigned locals.
+*/
+function resolveGlobalOrigin(context, node, seen = /* @__PURE__ */ new Set()) {
+	const expression = Extract.unwrap(node);
+	if (seen.has(expression)) return null;
+	seen.add(expression);
+	if (expression.type === AST_NODE_TYPES.MemberExpression) return resolveGlobalOrigin(context, expression.object, seen);
+	if (expression.type !== AST_NODE_TYPES.Identifier) return null;
+	if (isGlobalVariable(context, expression)) return expression;
+	const variable = findVariable(context.sourceCode.getScope(expression), expression);
+	const definition = variable?.defs.length === 1 ? variable.defs[0] : null;
+	if (definition?.type !== DefinitionType.Variable) return null;
+	if (definition.node.id.type !== AST_NODE_TYPES.Identifier || definition.node.init == null) return null;
+	if (definition.node.parent.kind !== "const") return null;
+	const initializer = Extract.unwrap(definition.node.init);
+	if (initializer.type !== AST_NODE_TYPES.Identifier && initializer.type !== AST_NODE_TYPES.MemberExpression) return null;
+	return resolveGlobalOrigin(context, initializer, seen);
+}
+/**
+* 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 (expression.type !== AST_NODE_TYPES.Identifier || 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/globals.ts
@@ -1179,101 +1240,83 @@ var globals_default = createRule({
 function create$49(context) {
 	const hc = core.getHookCollector(context);
 	const fc = core.getFunctionComponentCollector(context);
-	const violations = [];
-	/**
-	* Return true when `id` refers to a variable defined in the global or module
-	* scope (i.e. outside any function), or when it has no known definition.
-	*/
-	function isGlobalOrModuleVariable(id) {
-		const variable = findVariable(context.sourceCode.getScope(id), id);
-		if (variable == null) return true;
-		if (variable.defs.length === 0) return true;
-		const scopeType = variable.scope.type;
-		return scopeType === ScopeType.global || scopeType === ScopeType.module;
-	}
-	/**
-	* Return the nearest enclosing function for `node`.
-	*/
+	const directEffects = /* @__PURE__ */ new Map();
+	const callGraph = /* @__PURE__ */ new Map();
 	function getEnclosingFunction(node) {
 		return Traverse.findParent(node, Check.isFunction);
 	}
-	/**
-	* Record a violation that will be filtered at Program:exit.
-	*/
-	function recordViolation(node, messageId, data) {
-		const func = getEnclosingFunction(node);
-		if (func == null) return;
-		violations.push({
+	function recordEffect(node, messageId, data) {
+		const enclosing = getEnclosingFunction(node);
+		if (enclosing == null) return;
+		const effects = directEffects.get(enclosing) ?? [];
+		effects.push({
 			data,
-			func,
 			messageId,
 			node
 		});
+		directEffects.set(enclosing, effects);
+	}
+	function recordWrite(node, target) {
+		if (target.type === AST_NODE_TYPES.Identifier) {
+			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, {
-		/**
-		* Detect `renderCount++`, `renderCount--`
-		*/
-		UpdateExpression(node) {
-			const arg = Extract.unwrap(node.argument);
-			if (arg.type === AST_NODE_TYPES.Identifier) {
-				if (!isGlobalOrModuleVariable(arg)) return;
-				recordViolation(node, "mutatingGlobal", { name: arg.name });
-				return;
-			}
-			if (arg.type === AST_NODE_TYPES.MemberExpression) {
-				const rootId = Extract.getRootIdentifier(arg);
-				if (rootId == null) return;
-				if (!isGlobalOrModuleVariable(rootId)) return;
-				recordViolation(node, "mutatingGlobalProperty", { name: context.sourceCode.getText(arg) });
-			}
-		},
-		/**
-		* Detect `renderCount = 1`, `window.currentUser = id`, `cache[id] = value`
-		*/
 		AssignmentExpression(node) {
-			const left = Extract.unwrap(node.left);
-			if (left.type === AST_NODE_TYPES.Identifier) {
-				if (!isGlobalOrModuleVariable(left)) return;
-				recordViolation(node, "mutatingGlobal", { name: left.name });
-				return;
-			}
-			if (left.type === AST_NODE_TYPES.MemberExpression) {
-				const rootId = Extract.getRootIdentifier(left);
-				if (rootId == null) return;
-				if (!isGlobalOrModuleVariable(rootId)) return;
-				recordViolation(node, "mutatingGlobalProperty", { name: context.sourceCode.getText(left) });
-			}
+			for (const target of getAssignmentTargets(node.left)) recordWrite(node, target);
 		},
-		/**
-		* Detect `events.push(event)`, `cache.sort()`, etc.
-		*/
 		CallExpression(node) {
+			recordCallEdge(node);
 			const callee = Extract.unwrap(node.callee);
 			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			const { object, property } = callee;
-			if (property.type !== AST_NODE_TYPES.Identifier) return;
-			if (!MUTATING_ARRAY_METHODS.has(property.name)) return;
-			const rootId = Extract.getRootIdentifier(object);
-			if (rootId == null) return;
-			if (!isGlobalOrModuleVariable(rootId)) return;
-			recordViolation(node, "mutatingGlobalArrayMethod", {
-				name: rootId.name,
-				method: property.name
+			const method = Extract.getPropertyName(callee.property);
+			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
 			});
 		},
-		"Program:exit"(node) {
-			const comps = fc.api.getAllComponents(node);
-			const hooks = hc.api.getAllHooks(node);
-			const funcs = [...comps, ...hooks];
-			for (const { data, func, messageId, node } of violations) {
-				if (!funcs.some((f) => f.node === func)) continue;
-				context.report({
-					data,
-					messageId,
-					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);
 		}
 	});
 }
@@ -1327,6 +1370,24 @@ function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set())
 	return resolveToFunctionNode(context, resolved, seen);
 }
 /**
+* Follow identifier-only variable-declarator aliases to their originating
+* binding. Assignment aliases are intentionally left for the value-flow phase.
+* @param context The ESLint rule context.
+* @param variable The binding whose initializer aliases should be followed.
+* @param seen Bindings already visited, to guard against cycles.
+*/
+function resolveVariableOrigin(context, variable, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(variable)) return variable;
+	seen.add(variable);
+	const definition = variable.defs.length === 1 ? variable.defs[0] : null;
+	if (definition?.type !== DefinitionType.Variable || definition.node.init == null) return variable;
+	const initializer = Extract.unwrap(definition.node.init);
+	if (initializer.type !== AST_NODE_TYPES.Identifier) return variable;
+	const source = findVariable(context.sourceCode.getScope(initializer), initializer);
+	if (source == null) return variable;
+	return resolveVariableOrigin(context, source, seen);
+}
+/**
 * Check if a name is ref-like ("ref" or ends with "Ref").
 * Refs are mutable by design and exempted from immutability checks.
 * @param name The identifier name to check.
@@ -1349,20 +1410,28 @@ function hasRefLikeNameInChain(node) {
 	return false;
 }
 /**
-* Check if the root identifier of a member-expression chain (or the
-* identifier itself) is initialized directly from a `useRef()` call, e.g.
-* `const mounted = useRef(false); mounted.current = true;`.
-*
-* This catches refs regardless of naming convention, complementing
-* {@link hasRefLikeNameInChain}.
+* Check if the root identifier of a member-expression chain is initialized
+* from a `useRef()` call, following variable-declarator aliases.
 * @param context The ESLint rule context.
 * @param node The AST node to inspect (an identifier or member-expression chain).
 */
 function isInitializedFromUseRef(context, node) {
-	const rootId = node.type === AST_NODE_TYPES.Identifier ? node : Extract.getRootIdentifier(node);
-	if (rootId == null) return false;
-	const initNode = resolve(context, rootId);
-	return initNode != null && initNode.type === AST_NODE_TYPES.CallExpression && core.isUseRefCall(context, initNode);
+	const root = node.type === AST_NODE_TYPES.Identifier ? node : Extract.getRootIdentifier(node);
+	if (root == null) return false;
+	const variable = findVariable(context.sourceCode.getScope(root), root);
+	if (variable == null) return false;
+	return isVariableInitializedFromUseRef(context, variable, /* @__PURE__ */ new Set());
+}
+function isVariableInitializedFromUseRef(context, variable, seen) {
+	if (seen.has(variable)) return false;
+	seen.add(variable);
+	const definition = variable.defs.length === 1 ? variable.defs[0] : null;
+	if (definition?.type !== DefinitionType.Variable || definition.node.init == null) return false;
+	const initializer = Extract.unwrap(definition.node.init);
+	if (initializer.type === AST_NODE_TYPES.CallExpression) return core.isUseRefCall(context, initializer);
+	if (initializer.type !== AST_NODE_TYPES.Identifier) return false;
+	const source = findVariable(context.sourceCode.getScope(initializer), initializer);
+	return source != null && isVariableInitializedFromUseRef(context, source, seen);
 }
 /**
 * Check if a mutated expression chain should be exempt from immutability
@@ -1376,6 +1445,122 @@ function isRefLikeChain(context, node) {
 	return hasRefLikeNameInChain(node) || isInitializedFromUseRef(context, node);
 }
 
+//#endregion
+//#region src/rules/immutability/collect.ts
+function createImmutabilityCollector() {
+	const facts = {
+		mutations: [],
+		sinks: []
+	};
+	function pushMutation(kind, node, target, root) {
+		const enclosingFunction = Traverse.findParent(node, Check.isFunction);
+		if (enclosingFunction == null) return;
+		facts.mutations.push({
+			kind,
+			enclosingFunction,
+			node,
+			root,
+			target
+		});
+	}
+	return {
+		facts,
+		visitor: {
+			AssignmentExpression(node) {
+				const target = Extract.unwrap(node.left);
+				switch (target.type) {
+					case AST_NODE_TYPES.Identifier:
+						pushMutation("binding", node, target, target);
+						return;
+					case AST_NODE_TYPES.MemberExpression: {
+						const root = Extract.getRootIdentifier(target);
+						if (root != null) pushMutation("value", node, target, root);
+						return;
+					}
+				}
+			},
+			CallExpression(node) {
+				const callee = Extract.unwrap(node.callee);
+				if (callee.type === AST_NODE_TYPES.MemberExpression) {
+					const property = Extract.getPropertyName(callee.property);
+					if (property != null && MUTATING_METHODS.has(property)) {
+						const root = Extract.getRootIdentifier(callee.object);
+						if (root != null) pushMutation("value", node, callee.object, root);
+					}
+				}
+				if (!core.isHookCall(node)) return;
+				for (const argument of node.arguments) {
+					if (argument.type === AST_NODE_TYPES.SpreadElement) continue;
+					facts.sinks.push({
+						kind: "hook-argument",
+						expression: argument
+					});
+				}
+			},
+			JSXAttribute(node) {
+				if (node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
+				const expression = node.value.expression;
+				if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) return;
+				facts.sinks.push({
+					kind: "jsx-prop",
+					expression
+				});
+			},
+			UnaryExpression(node) {
+				if (node.operator !== "delete") return;
+				const target = Extract.unwrap(node.argument);
+				if (target.type !== AST_NODE_TYPES.MemberExpression) return;
+				const root = Extract.getRootIdentifier(target);
+				if (root != null) pushMutation("value", node, target, root);
+			},
+			UpdateExpression(node) {
+				const target = Extract.unwrap(node.argument);
+				switch (target.type) {
+					case AST_NODE_TYPES.Identifier:
+						pushMutation("binding", node, target, target);
+						return;
+					case AST_NODE_TYPES.MemberExpression: {
+						const root = Extract.getRootIdentifier(target);
+						if (root != null) pushMutation("value", node, target, root);
+						return;
+					}
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/immutability/effects.ts
+function isGlobalOrModuleVariable(variable) {
+	return variable.defs.length === 0 || variable.scope.type === ScopeType.global || variable.scope.type === ScopeType.module;
+}
+function isRefMutation(context, mutation) {
+	if (mutation.target.type === AST_NODE_TYPES.Identifier) return isRefLikeName$1(mutation.target.name);
+	return isRefLikeChain(context, mutation.target);
+}
+function inferMutableFunctions(context, mutations) {
+	const mutableFunctions = /* @__PURE__ */ new Map();
+	for (const mutation of mutations) {
+		if (isRefMutation(context, mutation)) continue;
+		const variable = findVariable(context.sourceCode.getScope(mutation.root), mutation.root);
+		if (variable == null) continue;
+		const origin = mutation.kind === "binding" ? variable : resolveVariableOrigin(context, variable);
+		if (isGlobalOrModuleVariable(origin)) continue;
+		const declaration = origin.identifiers.at(0) ?? null;
+		let current = mutation.enclosingFunction;
+		while (current != null) {
+			if (declaration != null && isNodeWithin(declaration, current)) break;
+			if (!mutableFunctions.has(current)) mutableFunctions.set(current, {
+				name: origin.name,
+				node: mutation.node
+			});
+			current = Traverse.findParent(current, Check.isFunction);
+		}
+	}
+	return mutableFunctions;
+}
+
 //#endregion
 //#region src/rules/immutability/immutability.ts
 const RULE_NAME$48 = "immutability";
@@ -1394,120 +1579,36 @@ var immutability_default = createRule({
 	defaultOptions: []
 });
 function create$48(context) {
-	const hc = core.getHookCollector(context);
-	const mutationSites = [];
-	const sinkCandidates = [];
-	function pushMutationSite(node, root) {
-		const enclosing = Traverse.findParent(node, Check.isFunction);
-		if (enclosing == null) return;
-		mutationSites.push({
-			enclosing,
-			node,
-			root
+	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({
+			kind: "hook-return",
+			expression
 		});
-	}
-	return merge(hc.visitor, {
-		AssignmentExpression(node) {
-			const left = Extract.unwrap(node.left);
-			switch (left.type) {
-				case AST_NODE_TYPES.Identifier:
-					if (isRefLikeName$1(left.name)) return;
-					pushMutationSite(node, left);
-					return;
-				case AST_NODE_TYPES.MemberExpression: {
-					if (isRefLikeChain(context, left)) return;
-					const rootId = Extract.getRootIdentifier(left);
-					if (rootId == null) return;
-					pushMutationSite(node, rootId);
-					return;
-				}
-			}
-		},
-		CallExpression(node) {
-			const callee = Extract.unwrap(node.callee);
-			if (callee.type === AST_NODE_TYPES.MemberExpression) {
-				const propName = Extract.getPropertyName(callee.property);
-				if (propName != null && MUTATING_METHODS.has(propName) && !isRefLikeChain(context, callee.object)) {
-					const rootId = Extract.getRootIdentifier(callee.object);
-					if (rootId != null) pushMutationSite(node, rootId);
-				}
-			}
-			if (core.isHookCall(node)) for (const arg of node.arguments) {
-				if (arg.type === AST_NODE_TYPES.SpreadElement) continue;
-				sinkCandidates.push(arg);
-			}
-		},
-		JSXAttribute(node) {
-			if (node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
-			const expr = node.value.expression;
-			if (expr.type === AST_NODE_TYPES.JSXEmptyExpression) return;
-			sinkCandidates.push(expr);
-		},
-		"Program:exit"(program) {
-			const mutableFunctions = /* @__PURE__ */ new Map();
-			for (const { enclosing, node, root } of mutationSites) {
-				const variable = findVariable(context.sourceCode.getScope(root), root);
-				if (variable == null) continue;
-				const declId = variable.identifiers.at(0) ?? null;
-				let current = enclosing;
-				while (current != null) {
-					if (declId != null && isNodeWithin(declId, current)) break;
-					if (!mutableFunctions.has(current)) mutableFunctions.set(current, {
-						name: variable.name,
-						node
-					});
-					current = Traverse.findParent(current, Check.isFunction);
-				}
-			}
-			if (mutableFunctions.size === 0) return;
-			const reported = /* @__PURE__ */ new Set();
-			function checkSink(expr) {
-				if (expr == null || reported.has(expr)) return;
-				const fn = resolveToFunctionNode(context, expr);
-				if (fn == null) return;
-				const mutation = mutableFunctions.get(fn);
-				if (mutation == null) return;
-				reported.add(expr);
-				context.report({
-					data: { name: mutation.name },
-					messageId: "default",
-					node: expr
-				});
-				context.report({
-					data: { name: mutation.name },
-					messageId: "mutates",
-					node: mutation.node
-				});
-			}
-			for (const candidate of sinkCandidates) checkSink(candidate);
-			for (const hook of hc.api.getAllHooks(program)) for (const ret of hook.rets) checkSink(ret);
-		},
-		UnaryExpression(node) {
-			if (node.operator !== "delete") return;
-			const arg = Extract.unwrap(node.argument);
-			if (arg.type !== AST_NODE_TYPES.MemberExpression) return;
-			if (isRefLikeChain(context, arg)) return;
-			const rootId = Extract.getRootIdentifier(arg);
-			if (rootId == null) return;
-			pushMutationSite(node, rootId);
-		},
-		UpdateExpression(node) {
-			const arg = Extract.unwrap(node.argument);
-			switch (arg.type) {
-				case AST_NODE_TYPES.Identifier:
-					if (isRefLikeName$1(arg.name)) return;
-					pushMutationSite(node, arg);
-					return;
-				case AST_NODE_TYPES.MemberExpression: {
-					if (isRefLikeChain(context, arg)) return;
-					const rootId = Extract.getRootIdentifier(arg);
-					if (rootId == null) return;
-					pushMutationSite(node, rootId);
-					return;
-				}
-			}
+		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
+			});
+			context.report({
+				data: { name: mutation.name },
+				messageId: "mutates",
+				node: mutation.node
+			});
 		}
-	});
+	} });
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.14.1",
+  "version": "5.14.5",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -45,12 +45,12 @@
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.5.0",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.14.1",
-    "@eslint-react/jsx": "5.14.1",
-    "@eslint-react/core": "5.14.1",
-    "@eslint-react/eslint": "5.14.1",
-    "@eslint-react/shared": "5.14.1",
-    "@eslint-react/var": "5.14.1"
+    "@eslint-react/eslint": "5.14.5",
+    "@eslint-react/ast": "5.14.5",
+    "@eslint-react/core": "5.14.5",
+    "@eslint-react/jsx": "5.14.5",
+    "@eslint-react/shared": "5.14.5",
+    "@eslint-react/var": "5.14.5"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",