eslint-plugin-react-x 5.14.0 → 5.14.2

package/dist/index.js

@@ -5,9 +5,9 @@ import * as core from "@eslint-react/core";
 import { merge } from "@eslint-react/eslint";
 import { JsxDetectionHint, findParentAttribute, getElementFullType, hasAttribute } from "@eslint-react/jsx";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { computeObjectType, isAssignmentTargetEqual, isInitializedFromReact, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
 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, isMatching, match } from "ts-pattern";
 import { compare } from "compare-versions";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
@@ -144,7 +144,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.14.0";
+var version = "5.14.2";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1157,6 +1157,67 @@ const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
 	"splice",
 	"unshift"
 ]);
+/**
+* Return whether an identifier is an unresolved global or is declared in the
+* global/module scope.
+*/
+function isGlobalVariable(context, node) {
+	const variable = findVariable(context.sourceCode.getScope(node), node);
+	if (variable == null || variable.defs.length === 0) return true;
+	return variable.scope.type === ScopeType.global || variable.scope.type === ScopeType.module;
+}
+/**
+* Resolve an object expression to the global/module binding it aliases.
+*
+* This intentionally follows only stable `const alias = value` declarations.
+* It gives the rule useful Alias effects without pretending to perform full
+* control-flow analysis for reassigned locals.
+*/
+function resolveGlobalOrigin(context, node, seen = /* @__PURE__ */ new Set()) {
+	const expression = Extract.unwrap(node);
+	if (seen.has(expression)) return null;
+	seen.add(expression);
+	if (expression.type === AST_NODE_TYPES.MemberExpression) return resolveGlobalOrigin(context, expression.object, seen);
+	if (expression.type !== AST_NODE_TYPES.Identifier) return null;
+	if (isGlobalVariable(context, expression)) return expression;
+	const variable = findVariable(context.sourceCode.getScope(expression), expression);
+	const definition = variable?.defs.length === 1 ? variable.defs[0] : null;
+	if (definition?.type !== DefinitionType.Variable) return null;
+	if (definition.node.id.type !== AST_NODE_TYPES.Identifier || definition.node.init == null) return null;
+	if (definition.node.parent.kind !== "const") return null;
+	const initializer = Extract.unwrap(definition.node.init);
+	if (initializer.type !== AST_NODE_TYPES.Identifier && initializer.type !== AST_NODE_TYPES.MemberExpression) return null;
+	return resolveGlobalOrigin(context, initializer, seen);
+}
+/**
+* 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 (expression.type !== AST_NODE_TYPES.Identifier || 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/globals.ts
@@ -1179,101 +1240,83 @@ var globals_default = createRule({
 function create$49(context) {
 	const hc = core.getHookCollector(context);
 	const fc = core.getFunctionComponentCollector(context);
-	const violations = [];
-	/**
-	* Return true when `id` refers to a variable defined in the global or module
-	* scope (i.e. outside any function), or when it has no known definition.
-	*/
-	function isGlobalOrModuleVariable(id) {
-		const variable = findVariable(context.sourceCode.getScope(id), id);
-		if (variable == null) return true;
-		if (variable.defs.length === 0) return true;
-		const scopeType = variable.scope.type;
-		return scopeType === ScopeType.global || scopeType === ScopeType.module;
-	}
-	/**
-	* Return the nearest enclosing function for `node`.
-	*/
+	const directEffects = /* @__PURE__ */ new Map();
+	const callGraph = /* @__PURE__ */ new Map();
 	function getEnclosingFunction(node) {
 		return Traverse.findParent(node, Check.isFunction);
 	}
-	/**
-	* Record a violation that will be filtered at Program:exit.
-	*/
-	function recordViolation(node, messageId, data) {
-		const func = getEnclosingFunction(node);
-		if (func == null) return;
-		violations.push({
+	function recordEffect(node, messageId, data) {
+		const enclosing = getEnclosingFunction(node);
+		if (enclosing == null) return;
+		const effects = directEffects.get(enclosing) ?? [];
+		effects.push({
 			data,
-			func,
 			messageId,
 			node
 		});
+		directEffects.set(enclosing, effects);
+	}
+	function recordWrite(node, target) {
+		if (target.type === AST_NODE_TYPES.Identifier) {
+			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, {
-		/**
-		* Detect `renderCount++`, `renderCount--`
-		*/
-		UpdateExpression(node) {
-			const arg = Extract.unwrap(node.argument);
-			if (arg.type === AST_NODE_TYPES.Identifier) {
-				if (!isGlobalOrModuleVariable(arg)) return;
-				recordViolation(node, "mutatingGlobal", { name: arg.name });
-				return;
-			}
-			if (arg.type === AST_NODE_TYPES.MemberExpression) {
-				const rootId = Extract.getRootIdentifier(arg);
-				if (rootId == null) return;
-				if (!isGlobalOrModuleVariable(rootId)) return;
-				recordViolation(node, "mutatingGlobalProperty", { name: context.sourceCode.getText(arg) });
-			}
-		},
-		/**
-		* Detect `renderCount = 1`, `window.currentUser = id`, `cache[id] = value`
-		*/
 		AssignmentExpression(node) {
-			const left = Extract.unwrap(node.left);
-			if (left.type === AST_NODE_TYPES.Identifier) {
-				if (!isGlobalOrModuleVariable(left)) return;
-				recordViolation(node, "mutatingGlobal", { name: left.name });
-				return;
-			}
-			if (left.type === AST_NODE_TYPES.MemberExpression) {
-				const rootId = Extract.getRootIdentifier(left);
-				if (rootId == null) return;
-				if (!isGlobalOrModuleVariable(rootId)) return;
-				recordViolation(node, "mutatingGlobalProperty", { name: context.sourceCode.getText(left) });
-			}
+			for (const target of getAssignmentTargets(node.left)) recordWrite(node, target);
 		},
-		/**
-		* Detect `events.push(event)`, `cache.sort()`, etc.
-		*/
 		CallExpression(node) {
+			recordCallEdge(node);
 			const callee = Extract.unwrap(node.callee);
 			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			const { object, property } = callee;
-			if (property.type !== AST_NODE_TYPES.Identifier) return;
-			if (!MUTATING_ARRAY_METHODS.has(property.name)) return;
-			const rootId = Extract.getRootIdentifier(object);
-			if (rootId == null) return;
-			if (!isGlobalOrModuleVariable(rootId)) return;
-			recordViolation(node, "mutatingGlobalArrayMethod", {
-				name: rootId.name,
-				method: property.name
+			const method = Extract.getPropertyName(callee.property);
+			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
 			});
 		},
-		"Program:exit"(node) {
-			const comps = fc.api.getAllComponents(node);
-			const hooks = hc.api.getAllHooks(node);
-			const funcs = [...comps, ...hooks];
-			for (const { data, func, messageId, node } of violations) {
-				if (!funcs.some((f) => f.node === func)) continue;
-				context.report({
-					data,
-					messageId,
-					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);
 		}
 	});
 }
@@ -7547,9 +7590,9 @@ function create$2(context) {
 			});
 		},
 		"Program:exit"(node) {
-			const components = fc.api.getAllComponents(node);
+			const comps = fc.api.getAllComponents(node);
 			const hooks = hc.api.getAllHooks(node);
-			const funcs = [...components, ...hooks];
+			const funcs = [...comps, ...hooks];
 			for (const { func, node } of evalCalls) {
 				if (!funcs.some((f) => f.node === func)) continue;
 				context.report({

package/package.json

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