eslint-plugin-react-x 5.14.2 → 5.14.5

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.5";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1370,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.
@@ -1392,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
@@ -1419,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";
@@ -1437,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.2",
+  "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.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/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",