eslint-plugin-react-x 5.19.0 → 5.20.0

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.19.0";
+var version = "5.20.0";
 
 //#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,9 +1410,9 @@ 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",
@@ -1346,6 +1426,20 @@ function isNodeWithin(node, ancestor) {
 	}
 	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;
@@ -1390,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) {
@@ -1435,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);
 					}
@@ -1484,42 +1578,43 @@ function createImmutabilityCollector() {
 
 //#endregion
 //#region src/rules/immutability/origins.ts
-function isComponentPropsDefinition(context, def) {
-	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 core.isFunctionComponentDefinition(context, fn, core.DEFAULT_COMPONENT_DETECTION_HINT);
-}
-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;
-}
 /**
 * 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.
+* `useReducer` calls, a shallow copy (spread literal) of either, or a `for...of`
+* iterator variable whose iterated collection resolves to one of those.
 * @param context The rule context.
 * @param variable The variable to classify.
-* @param seen Variables already visited during spread recursion.
+* @param components The confirmed function component nodes in the file.
+* @param seen Variables already visited during spread/iterator recursion.
 * @returns The frozen origin, or `null` when the variable is not derived from one.
 */
-function classifyFrozenOrigin(context, variable, seen = /* @__PURE__ */ new Set()) {
+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(context, def)) return {
+	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;
+	if (def.node.init == null) {
+		const loop = def.node.parent.parent;
+		if (loop.type !== AST_NODE_TYPES.ForOfStatement || loop.left !== def.node.parent) return null;
+		const root = Extract.getIdentifierAt(loop.right, 0);
+		if (root == null) return null;
+		const source = findVariable(context.sourceCode.getScope(root), root);
+		if (source == null) return null;
+		const inner = classifyFrozenOrigin(context, source, components, seen);
+		return inner == null ? null : {
+			kind: "iterator",
+			name: origin.name,
+			original: inner.name
+		};
+	}
+	const init = Extract.unwrap(def.node.init);
 	switch (init.type) {
 		case AST_NODE_TYPES.CallExpression: {
 			const hook = getStateHookName(context, init);
@@ -1542,7 +1637,7 @@ function classifyFrozenOrigin(context, variable, seen = /* @__PURE__ */ new Set(
 				if (!Check.isIdentifier(argument)) continue;
 				const source = findVariable(context.sourceCode.getScope(argument), argument);
 				if (source == null) continue;
-				const inner = classifyFrozenOrigin(context, source, seen);
+				const inner = classifyFrozenOrigin(context, source, components, seen);
 				if (inner != null) return {
 					kind: "shallow-copy",
 					name: origin.name,
@@ -1591,7 +1686,7 @@ function getMutatedObject(mutation) {
 	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) {
+function inferDirectMutations(context, mutations, components) {
 	const directMutations = [];
 	for (const mutation of mutations) {
 		if (mutation.kind !== "value") continue;
@@ -1599,7 +1694,7 @@ function inferDirectMutations(context, mutations) {
 		if (isRefMutation(context, mutation)) continue;
 		const variable = findVariable(context.sourceCode.getScope(mutation.root), mutation.root);
 		if (variable == null) continue;
-		const origin = classifyFrozenOrigin(context, variable);
+		const origin = classifyFrozenOrigin(context, variable, components);
 		if (origin == null) continue;
 		switch (origin.kind) {
 			case "props":
@@ -1623,6 +1718,12 @@ function inferDirectMutations(context, mutations) {
 					detail: `It is a shallow copy of '${origin.original}'; mutating nested values through it mutates '${origin.original}' in place.`,
 					node: mutation.node
 				});
+				break;
+			case "iterator": directMutations.push({
+				name: origin.name,
+				detail: `It is an element of '${origin.original}' and must be treated as immutable.`,
+				node: mutation.node
+			});
 		}
 	}
 	return directMutations;
@@ -1648,17 +1749,18 @@ 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 reportedMutations = /* @__PURE__ */ new Set();
-		const mutableFunctions = inferMutableFunctions(context, collector.facts.mutations);
+		const mutableFunctions = inferMutableFunctions(context, immut.facts.mutations);
 		if (mutableFunctions.size > 0) {
 			const reportedSinks = /* @__PURE__ */ new Set();
-			for (const sink of collector.facts.sinks) {
+			for (const sink of immut.facts.sinks) {
 				const expression = sink.expression;
 				if (reportedSinks.has(expression)) continue;
 				const fn = resolveToFunctionNode(context, expression);
@@ -1679,7 +1781,8 @@ function create$48(context) {
 				});
 			}
 		}
-		for (const mutation of inferDirectMutations(context, collector.facts.mutations)) {
+		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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.19.0",
+  "version": "5.20.0",
   "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.19.0",
-    "@eslint-react/core": "5.19.0",
-    "@eslint-react/eslint": "5.19.0",
-    "@eslint-react/jsx": "5.19.0",
-    "@eslint-react/shared": "5.19.0",
-    "@eslint-react/var": "5.19.0",
-    "@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.20.0",
+    "@eslint-react/core": "5.20.0",
+    "@eslint-react/eslint": "5.20.0",
+    "@eslint-react/jsx": "5.20.0",
+    "@eslint-react/shared": "5.20.0",
+    "@eslint-react/var": "5.20.0",
+    "@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,15 +55,15 @@
   "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",
+    "tsl-dx": "^0.13.5",
     "typescript": "6.0.3"
   },
   "peerDependencies": {