eslint-plugin-react-x 5.14.2 → 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.2";
+var version = "5.14.6";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1344,81 +1344,176 @@ 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);
+}
+function resolveVariableOrigin(context, variable, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(variable)) return variable;
+	seen.add(variable);
+	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);
+}
+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;
+	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);
 }
-/**
-* 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}.
-* @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);
+	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);
 }
 
+//#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 (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 = 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 && Traverse.findParent(declaration, Check.isFunction) === 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";
@@ -1437,120 +1532,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.2",
+  "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/ast": "5.14.2",
-    "@eslint-react/core": "5.14.2",
-    "@eslint-react/shared": "5.14.2",
-    "@eslint-react/eslint": "5.14.2",
-    "@eslint-react/jsx": "5.14.2",
-    "@eslint-react/var": "5.14.2"
+    "@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": "*",