eslint-plugin-react-x 5.10.3 → 5.11.0

package/dist/index.js

@@ -8,7 +8,7 @@ import { AST_NODE_TYPES } from "@typescript-eslint/types";
 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, match } from "ts-pattern";
+import { P, isMatching, match } from "ts-pattern";
 import { compare } from "compare-versions";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
 import { unionConstituents } from "ts-api-utils";
@@ -144,7 +144,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.10.3";
+var version = "5.11.0";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -2692,7 +2692,7 @@ function create$27(context) {
 		}, ({ left, right }) => {
 			if (left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "!") return getReportDescriptor(right, visited);
 			const initialScope = context.sourceCode.getScope(left);
-			if (Check.isIdentifier("NaN")(left) || getStaticValue(left, initialScope)?.value === "NaN") return {
+			if (Check.isIdentifier(left, "NaN") || getStaticValue(left, initialScope)?.value === "NaN") return {
 				data: { value: context.sourceCode.getText(left) },
 				messageId: "default",
 				node: left
@@ -2967,8 +2967,12 @@ function isProcessEnvNodeEnvCompare(context, node, operator, value) {
 	if (node == null) return false;
 	if (node.type !== AST_NODE_TYPES.BinaryExpression) return false;
 	if (node.operator !== operator) return false;
-	if (isProcessEnvNodeEnv(context, node.left) && Check.isStringLiteral(node.right)) return node.right.value === value;
-	if (Check.isStringLiteral(node.left) && isProcessEnvNodeEnv(context, node.right)) return node.left.value === value;
+	const isStringLiteral = isMatching({
+		type: AST_NODE_TYPES.Literal,
+		value: P.string
+	});
+	if (isProcessEnvNodeEnv(context, node.left) && isStringLiteral(node.right)) return node.right.value === value;
+	if (isStringLiteral(node.left) && isProcessEnvNodeEnv(context, node.right)) return node.left.value === value;
 	return false;
 }
 function isDevelopmentOnlyCheck(context, node) {
@@ -3428,7 +3432,7 @@ var no_unstable_context_value_default = createRule({
 function create$13(context) {
 	const { compilationMode, version } = getSettingsFromContext(context);
 	if (compilationMode === "infer" || compilationMode === "all") return {};
-	if (compilationMode === "annotation" && context.sourceCode.ast.body.some(Check.isDirective("use memo"))) return {};
+	if (compilationMode === "annotation" && context.sourceCode.ast.body.some((stmt) => Check.isDirective(stmt, "use memo"))) return {};
 	const isReact18OrBelow = compare(version, "19.0.0", "<");
 	const { api, visitor } = core.getFunctionComponentCollector(context);
 	const constructions = /* @__PURE__ */ new WeakMap();
@@ -3527,7 +3531,7 @@ function extractIdentifier(node) {
 function create$12(context, [options]) {
 	const { compilationMode } = getSettingsFromContext(context);
 	if (compilationMode === "infer" || compilationMode === "all") return {};
-	if (compilationMode === "annotation" && context.sourceCode.ast.body.some(Check.isDirective("use memo"))) return {};
+	if (compilationMode === "annotation" && context.sourceCode.ast.body.some((stmt) => Check.isDirective(stmt, "use memo"))) return {};
 	const { api, visitor } = core.getFunctionComponentCollector(context);
 	const declarators = /* @__PURE__ */ new WeakMap();
 	const { safeDefaultProps = [] } = options;
@@ -4379,6 +4383,7 @@ var refs_default = createRule({
 		type: "problem",
 		docs: { description: "Validates correct usage of refs by checking that 'ref.current' is not read or written during render." },
 		messages: {
+			duplicateRefInit: "Ref is initialized more than once during render. Only a single 'if (ref.current == null)' initialization is allowed; move any additional initialization into an effect or event handler.",
 			readDuringRender: "Do not read 'ref.current' during render. Refs are not available during rendering and their values may be stale or inconsistent. Move this read into an effect or event handler.",
 			refPassedToFunction: "Passing a ref to a function may cause its value to be read during render. Pass 'ref.current' instead if the function only needs the value, or move the call into an effect.",
 			writeDuringRender: "Do not write to 'ref.current' during render. Refs should only be mutated in effects or event handlers. Move this write into an effect or event handler."
@@ -4397,6 +4402,50 @@ function resolveAlias(name, aliases) {
 	}
 	return name;
 }
+function isFunctionExpressionLike(node) {
+	return node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.ArrowFunctionExpression;
+}
+/**
+* Phase 2 (part): compute the set of functions that are "reached" during render for a given
+* component/hook boundary. A function is reached if it is the boundary itself, or if it is
+* directly called (possibly through a simple variable alias, e.g. `const b = a; b();`) from
+* somewhere that is itself reached. This lets us detect ref mutations/reads that happen inside
+* a helper function which is invoked synchronously during render (see "Ref Mutation in Called
+* Function" in refs.spec.md), as opposed to functions that are merely defined and handed off
+* to be called later (e.g. event handlers, effect callbacks).
+*/
+function computeReachedFunctions(boundary, isCompOrHookFn, functionVarBindings, directCallSites, aliases) {
+	const reached = /* @__PURE__ */ new Set([boundary]);
+	const relevantCalls = directCallSites.filter((c) => Traverse.findParent(c.node, isCompOrHookFn) === boundary);
+	let changed = true;
+	for (let iterations = 0; changed && iterations < 50; iterations++) {
+		changed = false;
+		for (const { calleeName, node: callNode } of relevantCalls) {
+			const hostFn = Traverse.findParent(callNode, Check.isFunction) ?? boundary;
+			if (!reached.has(hostFn)) continue;
+			const resolvedName = resolveAlias(calleeName, aliases);
+			const target = functionVarBindings.get(resolvedName);
+			if (target == null || reached.has(target)) continue;
+			if (Traverse.findParent(target, isCompOrHookFn) !== boundary) continue;
+			reached.add(target);
+			changed = true;
+		}
+	}
+	return reached;
+}
+/**
+* Phase 2 (part): determine whether a ref access node is reached unconditionally during render,
+* i.e. every function boundary between the access and the component/hook `boundary` is itself
+* a function that gets invoked during render (see `computeReachedFunctions`).
+*/
+function isReachedDuringRender(node, boundary, reached) {
+	let current = node.parent;
+	while (current != null && current !== boundary) {
+		if (Check.isFunction(current) && !reached.has(current)) return false;
+		current = current.parent;
+	}
+	return true;
+}
 function create$6(context) {
 	const hc = core.getHookCollector(context);
 	const fc = core.getFunctionComponentCollector(context);
@@ -4404,17 +4453,27 @@ function create$6(context) {
 	const jsxRefIdentifiers = /* @__PURE__ */ new Set();
 	const aliases = /* @__PURE__ */ new Map();
 	const refPassedToFunctions = [];
+	const functionVarBindings = /* @__PURE__ */ new Map();
+	const directCallSites = [];
 	return merge(hc.visitor, fc.visitor, {
 		AssignmentExpression(node) {
 			if (node.operator !== "=") return;
 			const left = Extract.unwrap(node.left);
 			const right = Extract.unwrap(node.right);
-			if (left.type !== AST_NODE_TYPES.Identifier || right.type !== AST_NODE_TYPES.Identifier) return;
-			aliases.set(left.name, right.name);
+			if (left.type !== AST_NODE_TYPES.Identifier) return;
+			if (right.type === AST_NODE_TYPES.Identifier) {
+				aliases.set(left.name, right.name);
+				return;
+			}
+			if (isFunctionExpressionLike(right)) functionVarBindings.set(left.name, right);
 		},
 		CallExpression(node) {
 			const callee = Extract.unwrap(node.callee);
 			const calleeName = callee.type === AST_NODE_TYPES.Identifier ? callee.name : callee.type === AST_NODE_TYPES.MemberExpression ? Extract.getPropertyName(callee.property) : null;
+			if (callee.type === AST_NODE_TYPES.Identifier) directCallSites.push({
+				calleeName: callee.name,
+				node
+			});
 			if (calleeName != null && (calleeName.startsWith("use") || calleeName === "mergeRefs")) return;
 			for (const arg of node.arguments) {
 				const unwrapped = Extract.unwrap(arg);
@@ -4451,26 +4510,46 @@ function create$6(context) {
 			const hooks = hc.api.getAllHooks(program);
 			const funcs = /* @__PURE__ */ new Set([...comps.map((c) => c.node), ...hooks.map((h) => h.node)]);
 			const isCompOrHookFn = (n) => Check.isFunction(n) && funcs.has(n);
+			const reachedCache = /* @__PURE__ */ new Map();
+			function getReached(boundary) {
+				let reached = reachedCache.get(boundary);
+				if (reached == null) {
+					reached = computeReachedFunctions(boundary, isCompOrHookFn, functionVarBindings, directCallSites, aliases);
+					reachedCache.set(boundary, reached);
+				}
+				return reached;
+			}
+			const lazyInitSeen = /* @__PURE__ */ new Map();
 			for (const { isWrite, node } of refAccesses) {
 				const obj = Extract.unwrap(node.object);
-				if (obj.type !== AST_NODE_TYPES.Identifier) continue;
-				const resolvedName = resolveAlias(obj.name, aliases);
-				switch (true) {
-					case resolvedName === "ref" || resolvedName.endsWith("Ref"):
-					case jsxRefIdentifiers.has(resolvedName):
-					case isInitializedFromRef$1(context, resolvedName, context.sourceCode.getScope(node.object)): break;
-					default: continue;
-				}
+				let refName = null;
+				if (obj.type === AST_NODE_TYPES.Identifier) {
+					const resolvedName = resolveAlias(obj.name, aliases);
+					switch (true) {
+						case resolvedName === "ref" || resolvedName.endsWith("Ref"):
+						case jsxRefIdentifiers.has(resolvedName):
+						case isInitializedFromRef$1(context, resolvedName, context.sourceCode.getScope(node.object)):
+							refName = resolvedName;
+							break;
+						default: continue;
+					}
+				} else if (obj.type === AST_NODE_TYPES.MemberExpression) {
+					const propName = Extract.getPropertyName(obj.property);
+					if (propName == null || propName !== "ref" && !propName.endsWith("Ref")) continue;
+				} else continue;
 				const boundary = Traverse.findParent(node, isCompOrHookFn);
 				if (boundary == null) continue;
-				if (Traverse.findParent(node, Check.isFunction, (n) => n === boundary) != null) continue;
-				const refName = resolvedName;
-				let isLazyInit = isInNullCheckTest(node);
-				if (!isLazyInit) {
+				if (!isReachedDuringRender(node, boundary, getReached(boundary))) continue;
+				let isLazyInit = refName != null && isInNullCheckTest(node);
+				let matchedGuardIf = false;
+				if (!isLazyInit && refName != null) {
 					let current = node.parent;
 					findIf: for (;;) {
 						if (current.type === AST_NODE_TYPES.IfStatement) {
-							if (isRefCurrentNullCheck(current.test, refName)) isLazyInit = true;
+							if (isRefCurrentNullCheck(current.test, refName)) {
+								isLazyInit = true;
+								matchedGuardIf = true;
+							}
 							break;
 						}
 						switch (current.type) {
@@ -4492,7 +4571,7 @@ function create$6(context) {
 						current = current.parent;
 					}
 				}
-				if (!isLazyInit && isWrite) {
+				if (!isLazyInit && isWrite && refName != null) {
 					let stmt = node;
 					while (stmt.parent != null && stmt.parent.type !== AST_NODE_TYPES.BlockStatement) stmt = stmt.parent;
 					if (stmt.parent?.type === AST_NODE_TYPES.BlockStatement) {
@@ -4508,6 +4587,18 @@ function create$6(context) {
 						}
 					}
 				}
+				if (isLazyInit && matchedGuardIf && isWrite && refName != null) {
+					const seen = lazyInitSeen.get(boundary) ?? /* @__PURE__ */ new Set();
+					lazyInitSeen.set(boundary, seen);
+					if (seen.has(refName)) {
+						context.report({
+							messageId: "duplicateRefInit",
+							node
+						});
+						continue;
+					}
+					seen.add(refName);
+				}
 				if (isLazyInit) continue;
 				context.report({
 					messageId: isWrite ? "writeDuringRender" : "readDuringRender",
@@ -4517,7 +4608,7 @@ function create$6(context) {
 			for (const { node } of refPassedToFunctions) {
 				const boundary = Traverse.findParent(node, isCompOrHookFn);
 				if (boundary == null) continue;
-				if (Traverse.findParent(node, Check.isFunction, (n) => n === boundary) != null) continue;
+				if (!isReachedDuringRender(node, boundary, getReached(boundary))) continue;
 				context.report({
 					messageId: "refPassedToFunction",
 					node
@@ -4527,9 +4618,13 @@ function create$6(context) {
 		VariableDeclarator(node) {
 			if (node.init == null) return;
 			const id = node.id;
+			if (id.type !== AST_NODE_TYPES.Identifier) return;
 			const init = Extract.unwrap(node.init);
-			if (id.type !== AST_NODE_TYPES.Identifier || init.type !== AST_NODE_TYPES.Identifier) return;
-			aliases.set(id.name, init.name);
+			if (init.type === AST_NODE_TYPES.Identifier) {
+				aliases.set(id.name, init.name);
+				return;
+			}
+			if (isFunctionExpressionLike(init)) functionVarBindings.set(id.name, init);
 		}
 	});
 }
@@ -7193,34 +7288,49 @@ function create$4(context) {
 
 //#endregion
 //#region src/rules/static-components/lib.ts
-function resolveDynamicValue(context, node, isInsideRender, seen) {
+/**
+* Expression kinds that always produce a brand-new value on every evaluation, and are
+* therefore considered "dynamically created" when used as a component's value.
+*/
+const DYNAMIC_EXPRESSION_TYPES = /* @__PURE__ */ new Set([
+	AST_NODE_TYPES.ArrowFunctionExpression,
+	AST_NODE_TYPES.CallExpression,
+	AST_NODE_TYPES.ClassExpression,
+	AST_NODE_TYPES.FunctionExpression,
+	AST_NODE_TYPES.NewExpression
+]);
+function findVariableForIdentifier(context, identifier) {
+	return findVariable(context.sourceCode.getScope(identifier), identifier.name);
+}
+/**
+* Resolves an expression down to the node that dynamically created its value, if any.
+* Recurses through identifier references and both branches of ternaries.
+*/
+function findDynamicCreationSite(context, node, isInsideRender, seen) {
 	const expr = Extract.unwrap(node);
+	if (DYNAMIC_EXPRESSION_TYPES.has(expr.type)) return expr;
 	switch (expr.type) {
-		case AST_NODE_TYPES.FunctionExpression:
-		case AST_NODE_TYPES.ArrowFunctionExpression:
-		case AST_NODE_TYPES.NewExpression:
-		case AST_NODE_TYPES.CallExpression:
-		case AST_NODE_TYPES.ClassExpression: return expr;
-		case AST_NODE_TYPES.ConditionalExpression: {
-			const consequent = resolveDynamicValue(context, expr.consequent, isInsideRender, seen);
-			if (consequent != null) return consequent;
-			return resolveDynamicValue(context, expr.alternate, isInsideRender, seen);
-		}
+		case AST_NODE_TYPES.ConditionalExpression: return findDynamicCreationSite(context, expr.consequent, isInsideRender, seen) ?? findDynamicCreationSite(context, expr.alternate, isInsideRender, seen);
 		case AST_NODE_TYPES.Identifier:
 		case AST_NODE_TYPES.JSXIdentifier: {
-			const resolved = findVariableForIdentifier(context, expr);
-			if (resolved == null) return null;
-			return getDynamicComponentSource(context, resolved, isInsideRender, seen).creationNode;
+			const variable = findVariableForIdentifier(context, expr);
+			if (variable == null) return null;
+			return getDynamicComponentSource(context, variable, isInsideRender, seen).creationNode;
 		}
 		default: return null;
 	}
 }
-function findVariableForIdentifier(context, identifier) {
-	let scope = context.sourceCode.getScope(identifier);
-	while (scope != null) {
-		const variable = scope.variables.find((v) => v.name === identifier.name);
-		if (variable != null) return variable;
-		scope = scope.upper;
+/**
+* Looks for a reassignment of `variable` (e.g. `Component = createComponent();`) whose
+* right-hand side is dynamically created.
+*/
+function findReassignmentCreationSite(context, variable, isInsideRender, seen) {
+	for (const ref of variable.references) {
+		if (!ref.isWrite()) continue;
+		const { identifier } = ref;
+		if (identifier.parent.type !== AST_NODE_TYPES.AssignmentExpression || identifier.parent.left !== identifier) continue;
+		const source = findDynamicCreationSite(context, identifier.parent.right, isInsideRender, seen);
+		if (source != null) return source;
 	}
 	return null;
 }
@@ -7233,34 +7343,21 @@ function getDynamicComponentSource(context, variable, isInsideRender, seen = /*
 	for (const def of variable.defs) {
 		const defNode = def.node;
 		if (!isInsideRender(defNode)) continue;
-		if (defNode.type === AST_NODE_TYPES.FunctionDeclaration) return {
+		if (defNode.type === AST_NODE_TYPES.FunctionDeclaration || defNode.type === AST_NODE_TYPES.ClassDeclaration) return {
 			creationNode: defNode,
 			isDynamic: true
 		};
-		if (defNode.type === AST_NODE_TYPES.ClassDeclaration) return {
-			creationNode: defNode,
+		if (defNode.type !== AST_NODE_TYPES.VariableDeclarator) continue;
+		const initSource = defNode.init == null ? null : findDynamicCreationSite(context, defNode.init, isInsideRender, seen);
+		if (initSource != null) return {
+			creationNode: initSource,
+			isDynamic: true
+		};
+		const reassignmentSource = findReassignmentCreationSite(context, variable, isInsideRender, seen);
+		if (reassignmentSource != null) return {
+			creationNode: reassignmentSource,
 			isDynamic: true
 		};
-		if (defNode.type === AST_NODE_TYPES.VariableDeclarator) {
-			if (defNode.init != null) {
-				const source = resolveDynamicValue(context, defNode.init, isInsideRender, seen);
-				if (source != null) return {
-					creationNode: source,
-					isDynamic: true
-				};
-			}
-			for (const ref of variable.references) {
-				if (!ref.isWrite()) continue;
-				const id = ref.identifier;
-				if (id.parent.type === AST_NODE_TYPES.AssignmentExpression && id.parent.left === id) {
-					const source = resolveDynamicValue(context, id.parent.right, isInsideRender, seen);
-					if (source != null) return {
-						creationNode: source,
-						isDynamic: true
-					};
-				}
-			}
-		}
 	}
 	return {
 		creationNode: null,
@@ -7289,52 +7386,52 @@ function create$3(context) {
 	const hint = core.FunctionComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.FunctionComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.FunctionComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fc = core.getFunctionComponentCollector(context, { hint });
 	const cc = core.getClassComponentCollector(context);
-	const jsxCandidates = [];
+	const candidates = [];
 	return merge(fc.visitor, cc.visitor, {
 		JSXOpeningElement(node) {
 			if (node.name.type !== AST_NODE_TYPES.JSXIdentifier) return;
 			const name = node.name.name;
 			if (!core.isFunctionComponentName(name)) return;
-			jsxCandidates.push({
+			candidates.push({
 				name,
-				node
+				identifier: node.name
 			});
 		},
 		"Program:exit"(program) {
-			const fComponents = [...fc.api.getAllComponents(program)];
-			const cComponents = [...cc.api.getAllComponents(program)];
-			function getEnclosingComponent(node) {
-				return Traverse.findParent(node, (n) => {
-					if (Check.isFunction(n)) return fComponents.some((c) => c.node === n);
-					if (Check.isClass(n)) return cComponents.some((c) => c.node === n);
-					return false;
-				});
-			}
-			const isInsideRender = (node) => getEnclosingComponent(node) != null;
-			for (const { name, node: jsxNode } of jsxCandidates) {
-				const jsxName = jsxNode.name;
-				const variable = findVariableForIdentifier(context, jsxName);
-				if (variable == null || variable.defs.length === 0) continue;
-				const def = variable.defs.at(0);
-				if (def == null) continue;
-				const defNode = def.node;
-				if (getEnclosingComponent(defNode) == null) continue;
-				const result = getDynamicComponentSource(context, variable, isInsideRender);
-				if (!result.isDynamic) continue;
-				context.report({
-					data: { name },
-					messageId: "default",
-					node: jsxNode.name
-				});
-				if (result.creationNode != null) context.report({
-					data: { name },
-					messageId: "createdHere",
-					node: result.creationNode
-				});
-			}
+			const isInsideRender = createRenderBoundaryChecker(fc, cc, program);
+			for (const candidate of candidates) reportIfCreatedDuringRender(context, candidate, isInsideRender);
 		}
 	});
 }
+/**
+* Builds a predicate that tells whether a given node lies within the body of a
+* previously-collected function or class component, i.e. whether it is "created during render".
+*/
+function createRenderBoundaryChecker(fc, cc, program) {
+	const componentNodes = new Set([...fc.api.getAllComponents(program), ...cc.api.getAllComponents(program)].map((component) => component.node));
+	const getEnclosingComponent = (node) => Traverse.findParent(node, (n) => (Check.isFunction(n) || Check.isClass(n)) && componentNodes.has(n));
+	return (node) => getEnclosingComponent(node) != null;
+}
+function reportIfCreatedDuringRender(context, candidate, isInsideRender) {
+	const { name, identifier } = candidate;
+	const variable = findVariableForIdentifier(context, identifier);
+	if (variable == null) return;
+	const def = variable.defs.at(0);
+	if (def == null) return;
+	if (!isInsideRender(def.node)) return;
+	const { creationNode, isDynamic } = getDynamicComponentSource(context, variable, isInsideRender);
+	if (!isDynamic) return;
+	context.report({
+		data: { name },
+		messageId: "default",
+		node: identifier
+	});
+	if (creationNode != null) context.report({
+		data: { name },
+		messageId: "createdHere",
+		node: creationNode
+	});
+}
 
 //#endregion
 //#region src/rules/unsupported-syntax/lib.ts
@@ -7343,7 +7440,7 @@ function isEvalCall(node) {
 	switch (callee.type) {
 		case AST_NODE_TYPES.Identifier: return callee.name === "eval";
 		case AST_NODE_TYPES.MemberExpression:
-			if (!Check.isIdentifier("globalThis")(Extract.unwrap(callee.object))) return false;
+			if (!Check.isIdentifier(Extract.unwrap(callee.object), "globalThis")) return false;
 			return Extract.getPropertyName(callee.property, (n) => callee.computed ? null : n.name) === "eval";
 		default: return false;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.10.3",
+  "version": "5.11.0",
   "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.10.3",
-    "@eslint-react/core": "5.10.3",
-    "@eslint-react/shared": "5.10.3",
-    "@eslint-react/jsx": "5.10.3",
-    "@eslint-react/var": "5.10.3",
-    "@eslint-react/eslint": "5.10.3"
+    "@eslint-react/core": "5.11.0",
+    "@eslint-react/ast": "5.11.0",
+    "@eslint-react/jsx": "5.11.0",
+    "@eslint-react/shared": "5.11.0",
+    "@eslint-react/eslint": "5.11.0",
+    "@eslint-react/var": "5.11.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",