eslint-plugin-react-x 5.14.5 → 5.14.6

package/dist/index.js

@@ -144,7 +144,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.14.5";
+var version = "5.14.6";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1344,103 +1344,55 @@ const MUTATING_METHODS = /* @__PURE__ */ new Set([
 	"splice",
 	"unshift"
 ]);
-/**
-* Check if `inner` is fully contained within `outer`'s source range.
-* @param inner The node that may be contained.
-* @param outer The node that may contain it.
-*/
-function isNodeWithin(inner, outer) {
-	return inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
-}
-/**
-* Resolve an expression to the function it ultimately refers to, following
-* simple local aliasing (`const fn2 = fn;`) via scope resolution.
-* @param context The ESLint rule context.
-* @param node The expression to resolve.
-* @param seen Identifiers already visited, to guard against cycles.
-*/
+const isUseRouterCall = core.isAPICall("useRouter");
 function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set()) {
 	const expr = Extract.unwrap(node);
 	if (Check.isFunction(expr)) return expr;
-	if (expr.type !== AST_NODE_TYPES.Identifier) return null;
-	if (seen.has(expr)) return null;
+	if (expr.type !== AST_NODE_TYPES.Identifier || seen.has(expr)) return null;
 	seen.add(expr);
 	const resolved = resolve(context, expr);
-	if (resolved == null) return null;
-	return resolveToFunctionNode(context, resolved, seen);
+	return resolved == null ? null : 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);
+	const def = variable.defs.length === 1 ? variable.defs[0] : null;
+	if (def?.type !== DefinitionType.Variable || def.node.init == null) return variable;
+	const init = Extract.unwrap(def.node.init);
+	if (init.type !== AST_NODE_TYPES.Identifier) return variable;
+	const source = findVariable(context.sourceCode.getScope(init), init);
+	return source == null ? variable : 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.
-*/
 function isRefLikeName$1(name) {
 	return name === "ref" || name.endsWith("Ref");
 }
-/**
-* Check if any identifier or property name in a member-expression chain
-* is ref-like.
-* @param node The AST node to inspect.
-*/
 function hasRefLikeNameInChain(node) {
 	if (node.type === AST_NODE_TYPES.Identifier) return isRefLikeName$1(node.name);
-	if (node.type === AST_NODE_TYPES.MemberExpression) {
-		const propName = Extract.getPropertyName(node.property);
-		if (propName != null && isRefLikeName$1(propName)) return true;
-		return hasRefLikeNameInChain(node.object);
-	}
-	return false;
+	if (node.type !== AST_NODE_TYPES.MemberExpression) return false;
+	const propertyName = Extract.getPropertyName(node.property);
+	return propertyName != null ? isRefLikeName$1(propertyName) || hasRefLikeNameInChain(node.object) : hasRefLikeNameInChain(node.object);
 }
-/**
-* 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) {
+function isInitializedFromCall(context, node, isCall) {
 	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());
+	const origin = resolveVariableOrigin(context, variable);
+	const def = origin.defs.length === 1 ? origin.defs[0] : null;
+	if (def?.type !== DefinitionType.Variable || def.node.init == null) return false;
+	const init = Extract.unwrap(def.node.init);
+	return init.type === AST_NODE_TYPES.CallExpression && isCall(init);
 }
-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);
+function isInitializedFromUseRef(context, node) {
+	return isInitializedFromCall(context, node, (init) => core.isUseRefCall(context, init));
+}
+function isInitializedFromUseRouter(context, node) {
+	return isInitializedFromCall(context, node, (init) => isUseRouterCall(context, init));
+}
+function isKnownNonMutatingMethodCall(context, node) {
+	const callee = Extract.unwrap(node.callee);
+	return Check.isExpression(callee) && isInitializedFromUseRouter(context, callee);
 }
-/**
-* Check if a mutated expression chain should be exempt from immutability
-* checks because it is rooted at a ref: either by naming convention
-* ({@link hasRefLikeNameInChain}) or because it is initialized from a
-* `useRef()` call ({@link isInitializedFromUseRef}).
-* @param context The ESLint rule context.
-* @param node The AST node to inspect (an identifier or member-expression chain).
-*/
 function isRefLikeChain(context, node) {
 	return hasRefLikeNameInChain(node) || isInitializedFromUseRef(context, node);
 }
@@ -1542,6 +1494,7 @@ function isRefMutation(context, mutation) {
 function inferMutableFunctions(context, mutations) {
 	const mutableFunctions = /* @__PURE__ */ new Map();
 	for (const mutation of mutations) {
+		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;
@@ -1550,7 +1503,7 @@ function inferMutableFunctions(context, mutations) {
 		const declaration = origin.identifiers.at(0) ?? null;
 		let current = mutation.enclosingFunction;
 		while (current != null) {
-			if (declaration != null && isNodeWithin(declaration, current)) break;
+			if (declaration != null && Traverse.findParent(declaration, Check.isFunction) === current) break;
 			if (!mutableFunctions.has(current)) mutableFunctions.set(current, {
 				name: origin.name,
 				node: mutation.node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.14.5",
+  "version": "5.14.6",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -45,26 +45,26 @@
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.5.0",
     "ts-pattern": "^5.9.0",
-    "@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"
+    "@eslint-react/ast": "5.14.6",
+    "@eslint-react/core": "5.14.6",
+    "@eslint-react/jsx": "5.14.6",
+    "@eslint-react/eslint": "5.14.6",
+    "@eslint-react/shared": "5.14.6",
+    "@eslint-react/var": "5.14.6"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "dedent": "^1.7.2",
-    "eslint": "^10.6.0",
+    "eslint": "^10.7.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "tsdown": "^0.22.4",
     "tsl": "^1.0.30",
     "tsl-dx": "^0.13.2",
     "typescript": "6.0.3",
-    "@local/eff": "0.0.0",
-    "@local/configs": "0.0.0"
+    "@local/configs": "0.0.0",
+    "@local/eff": "0.0.0"
   },
   "peerDependencies": {
     "eslint": "*",