eslint-plugin-react-x 5.3.0-next.2 → 5.3.1-next.0

package/dist/index.js

@@ -5,9 +5,9 @@ import { merge } from "@eslint-react/eslint";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import { JsxDetectionHint, findParentAttribute, getElementFullType, hasAttribute, isJsxLike } from "@eslint-react/jsx";
+import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { computeObjectType, isAssignmentTargetEqual, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
 import { DefinitionType } from "@typescript-eslint/scope-manager";
-import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { P, isMatching, match } from "ts-pattern";
 import { compare } from "compare-versions";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
@@ -93,6 +93,7 @@ const conflictingRules = [
 	"react-hooks/rules-of-hooks",
 	"react-hooks/component-hook-factories",
 	"react-hooks/error-boundaries",
+	"react-hooks/globals",
 	"react-hooks/immutability",
 	"react-hooks/purity",
 	"react-hooks/refs",
@@ -113,6 +114,7 @@ var disable_experimental_exports = /* @__PURE__ */ __exportAll({
 });
 const name$8 = "react-x/disable-experimental";
 const rules$8 = {
+	"react-x/globals": "off",
 	"react-x/immutability": "off",
 	"react-x/no-duplicate-key": "off",
 	"react-x/no-implicit-children": "off",
@@ -142,7 +144,7 @@ const rules$7 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.3.0-next.2";
+var version = "5.3.1-next.0";
 
 //#endregion
 //#region src/rules/component-hook-factories/lib.ts
@@ -198,7 +200,7 @@ const createRule = ESLintUtils.RuleCreator(getDocsUrl);
 
 //#endregion
 //#region src/rules/component-hook-factories/component-hook-factories.ts
-const RULE_NAME$48 = "component-hook-factories";
+const RULE_NAME$49 = "component-hook-factories";
 var component_hook_factories_default = createRule({
 	meta: {
 		type: "problem",
@@ -209,11 +211,11 @@ var component_hook_factories_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$48,
-	create: create$48,
+	name: RULE_NAME$49,
+	create: create$49,
 	defaultOptions: []
 });
-function create$48(context) {
+function create$49(context) {
 	const hint = core.FunctionComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.FunctionComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.FunctionComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.FunctionComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement | core.FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fc = core.getFunctionComponentCollector(context, { hint });
 	const cc = core.getClassComponentCollector(context);
@@ -264,7 +266,7 @@ function create$48(context) {
 
 //#endregion
 //#region src/rules/error-boundaries/error-boundaries.ts
-const RULE_NAME$47 = "error-boundaries";
+const RULE_NAME$48 = "error-boundaries";
 var error_boundaries_default = createRule({
 	meta: {
 		type: "problem",
@@ -275,11 +277,11 @@ var error_boundaries_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$47,
-	create: create$47,
+	name: RULE_NAME$48,
+	create: create$48,
 	defaultOptions: []
 });
-function create$47(context) {
+function create$48(context) {
 	if (!context.sourceCode.text.includes("try")) return {};
 	const hint = JsxDetectionHint.DoNotIncludeJsxWithNullValue | JsxDetectionHint.DoNotIncludeJsxWithNumberValue | JsxDetectionHint.DoNotIncludeJsxWithBigIntValue | JsxDetectionHint.DoNotIncludeJsxWithStringValue | JsxDetectionHint.DoNotIncludeJsxWithBooleanValue | JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue | JsxDetectionHint.DoNotIncludeJsxWithEmptyArrayValue;
 	const fc = core.getFunctionComponentCollector(context);
@@ -1228,6 +1230,135 @@ function getUnknownDependenciesMessage(reactiveHookName) {
 	return `React Hook ${reactiveHookName} received a function whose dependencies are unknown. Pass an inline function instead.`;
 }
 
+//#endregion
+//#region src/rules/globals/lib.ts
+/**
+* Array methods that mutate the array in place.
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
+*/
+const MUTATING_ARRAY_METHODS$1 = new Set([
+	"copyWithin",
+	"fill",
+	"pop",
+	"push",
+	"reverse",
+	"shift",
+	"sort",
+	"splice",
+	"unshift"
+]);
+
+//#endregion
+//#region src/rules/globals/globals.ts
+const RULE_NAME$47 = "globals";
+var globals_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Validates against assignment/mutation of globals during render, part of ensuring that side effects must run outside of render." },
+		messages: {
+			mutatingGlobal: "Do not mutate '{{name}}' during render. Global variables exist outside React's control and make rendering impure.",
+			mutatingGlobalArrayMethod: "Do not call '{{method}}()' on '{{name}}' during render. Mutating global arrays during render makes rendering impure.",
+			mutatingGlobalProperty: "Do not mutate '{{name}}' during render. Modifying global objects during render makes rendering impure."
+		},
+		schema: []
+	},
+	name: RULE_NAME$47,
+	create: create$47,
+	defaultOptions: []
+});
+function create$47(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 === "global" || scopeType === "module";
+	}
+	/**
+	* Return the nearest enclosing function for `node`.
+	*/
+	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({
+			data,
+			func,
+			messageId,
+			node
+		});
+	}
+	return merge(hc.visitor, fc.visitor, {
+		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) });
+			}
+		},
+		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) });
+			}
+		},
+		CallExpression(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$1.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
+			});
+		},
+		"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
+				});
+			}
+		}
+	});
+}
+
 //#endregion
 //#region src/rules/immutability/lib.ts
 /**
@@ -1323,8 +1454,9 @@ function create$46(context) {
 	}
 	return merge(hc.visitor, fc.visitor, {
 		CallExpression(node) {
-			if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			const { object, property } = node.callee;
+			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);
@@ -1688,7 +1820,7 @@ function getIndexParamPosition(methodName) {
 	}
 }
 function getMapIndexParamName(context, node) {
-	const { callee } = node;
+	const callee = Extract.unwrap(node.callee);
 	if (callee.type !== AST_NODE_TYPES.MemberExpression) return null;
 	if (callee.property.type !== AST_NODE_TYPES.Identifier) return null;
 	const { name } = callee.property;
@@ -3503,10 +3635,12 @@ function collectUsedPropKeysOfIdentifier(context, usedPropKeys, identifier) {
 	return true;
 }
 function collectUsedPropKeysOfReference(context, usedPropKeys, identifier, ref) {
-	const { parent } = ref.identifier;
+	let valueNode = ref.identifier;
+	while (Check.isTypeExpression(valueNode.parent) || valueNode.parent.type === AST_NODE_TYPES.ChainExpression) valueNode = valueNode.parent;
+	const parent = valueNode.parent;
 	switch (parent.type) {
 		case AST_NODE_TYPES.MemberExpression:
-			if (parent.object.type === AST_NODE_TYPES.Identifier && parent.object.name === identifier.name) {
+			if (parent.object === valueNode) {
 				const key = getKeyOfExpression(parent.property);
 				if (key == null) return false;
 				usedPropKeys.add(key);
@@ -3514,7 +3648,7 @@ function collectUsedPropKeysOfReference(context, usedPropKeys, identifier, ref)
 			}
 			break;
 		case AST_NODE_TYPES.VariableDeclarator:
-			if (parent.id.type === AST_NODE_TYPES.ObjectPattern && parent.init === ref.identifier) return collectUsedPropKeysOfObjectPattern(context, usedPropKeys, parent.id);
+			if (parent.id.type === AST_NODE_TYPES.ObjectPattern && parent.init === valueNode) return collectUsedPropKeysOfObjectPattern(context, usedPropKeys, parent.id);
 			break;
 	}
 	return false;
@@ -4012,7 +4146,8 @@ function isRefCurrentNullCheck(test, refName) {
 	const { left, right } = test;
 	const checkSides = (a, b) => {
 		a = Check.isTypeExpression(a) ? Extract.unwrap(a) : a;
-		return a.type === AST_NODE_TYPES.MemberExpression && a.object.type === AST_NODE_TYPES.Identifier && a.object.name === refName && b.type === AST_NODE_TYPES.Literal && b.value == null && Extract.getPropertyName(a.property) === "current";
+		const obj = a.type === AST_NODE_TYPES.MemberExpression ? Extract.unwrap(a.object) : null;
+		return a.type === AST_NODE_TYPES.MemberExpression && obj?.type === AST_NODE_TYPES.Identifier && obj.name === refName && b.type === AST_NODE_TYPES.Literal && b.value == null && Extract.getPropertyName(a.property) === "current";
 	};
 	return checkSides(left, right) || checkSides(right, left);
 }
@@ -4022,7 +4157,11 @@ function isInitializedFromRef$1(context, name, initialScope) {
 		const init = node.init;
 		if (init == null) continue;
 		switch (true) {
-			case init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier && (init.object.name === "ref" || init.object.name.endsWith("Ref")): return true;
+			case init.type === AST_NODE_TYPES.MemberExpression: {
+				const initObj = Extract.unwrap(init.object);
+				if (initObj.type === AST_NODE_TYPES.Identifier && (initObj.name === "ref" || initObj.name.endsWith("Ref"))) return true;
+				break;
+			}
 			case init.type === AST_NODE_TYPES.CallExpression && core.isUseRefCall(context, init): return true;
 		}
 	}
@@ -4054,9 +4193,11 @@ function create$5(context) {
 	return merge(hc.visitor, fc.visitor, {
 		JSXAttribute(node) {
 			switch (true) {
-				case node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === "ref" && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.Identifier:
-					jsxRefIdentifiers.add(node.value.expression.name);
+				case node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === "ref" && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer: {
+					const expr = Extract.unwrap(node.value.expression);
+					if (expr.type === AST_NODE_TYPES.Identifier) jsxRefIdentifiers.add(expr.name);
 					return;
+				}
 			}
 		},
 		MemberExpression(node) {
@@ -4076,7 +4217,7 @@ function create$5(context) {
 			const funcs = new Set([...comps.map((c) => c.node), ...hooks.map((h) => h.node)]);
 			const isCompOrHookFn = (n) => Check.isFunction(n) && funcs.has(n);
 			for (const { isWrite, node } of refAccesses) {
-				const obj = node.object;
+				const obj = Extract.unwrap(node.object);
 				if (obj.type !== AST_NODE_TYPES.Identifier) continue;
 				switch (true) {
 					case obj.name === "ref" || obj.name.endsWith("Ref"):
@@ -5874,9 +6015,10 @@ function isHookName(s) {
 * containing a hook name.
 */
 function isHook(node) {
-	if (node.type === "Identifier") return isHookName(node.name);
-	else if (node.type === "MemberExpression" && !node.computed && isHook(node.property)) {
-		const obj = node.object;
+	const expr = Extract.unwrap(node);
+	if (expr.type === "Identifier") return isHookName(expr.name);
+	else if (expr.type === "MemberExpression" && !expr.computed && isHook(expr.property)) {
+		const obj = expr.object;
 		return obj.type === "Identifier" && /^[A-Z].*/.test(obj.name);
 	} else return false;
 }
@@ -6210,7 +6352,8 @@ const rule = {
 				analyzer.leaveNode(node);
 			},
 			CallExpression(node) {
-				if (isHook(node.callee)) {
+				const callee = Extract.unwrap(node.callee);
+				if (isHook(callee)) {
 					const reactHooksMap = last(codePathReactHooksMapStack);
 					const codePathSegment = last(codePathSegmentStack);
 					let reactHooks = reactHooksMap.get(codePathSegment);
@@ -6218,7 +6361,7 @@ const rule = {
 						reactHooks = [];
 						reactHooksMap.set(codePathSegment, reactHooks);
 					}
-					reactHooks.push(node.callee);
+					reactHooks.push(callee);
 				}
 				const nodeWithoutNamespace = getNodeWithoutReactNamespace(node.callee);
 				if ((isEffectIdentifier(nodeWithoutNamespace, additionalEffectHooks) || isUseEffectEventIdentifier(nodeWithoutNamespace)) && node.arguments.length > 0) lastEffect = node;
@@ -6740,10 +6883,13 @@ function create$3(context) {
 //#endregion
 //#region src/rules/unsupported-syntax/lib.ts
 function isEvalCall(node) {
-	return node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === "eval";
+	const callee = Extract.unwrap(node.callee);
+	return callee.type === AST_NODE_TYPES.Identifier && callee.name === "eval";
 }
 function isIifeCall(node) {
-	return node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node;
+	let parent = node.parent;
+	while (Check.isTypeExpression(parent) || parent.type === AST_NODE_TYPES.ChainExpression) parent = parent.parent;
+	return parent.type === AST_NODE_TYPES.CallExpression && Extract.unwrap(parent.callee) === node;
 }
 
 //#endregion
@@ -6853,9 +6999,10 @@ function create$1(context) {
 		}
 		const [callbackArg] = node.arguments;
 		if (callbackArg == null) return;
-		if (!Check.isFunction(callbackArg)) return;
-		if (callbackArg.type === AST_NODE_TYPES.ArrowFunctionExpression && callbackArg.body.type !== AST_NODE_TYPES.BlockStatement) return;
-		if (callbackArg.body.type !== AST_NODE_TYPES.BlockStatement) return;
+		const callback = Extract.unwrap(callbackArg);
+		if (!Check.isFunction(callback)) return;
+		if (callback.type === AST_NODE_TYPES.ArrowFunctionExpression && callback.body.type !== AST_NODE_TYPES.BlockStatement) return;
+		if (callback.body.type !== AST_NODE_TYPES.BlockStatement) return;
 		const returnStatements = getNestedReturnStatements(callbackArg);
 		if (returnStatements.length === 0) {
 			context.report({
@@ -7041,7 +7188,9 @@ function create(context) {
 				}
 			}
 		}
-		if (node.parent.type !== AST_NODE_TYPES.VariableDeclarator) {
+		let parent = node.parent;
+		while (Check.isTypeExpression(parent)) parent = parent.parent;
+		if (parent.type !== AST_NODE_TYPES.VariableDeclarator) {
 			if (!enforceAssignment) return;
 			context.report({
 				messageId: "invalidAssignment",
@@ -7100,6 +7249,7 @@ const plugin = {
 		"component-hook-factories": component_hook_factories_default,
 		"error-boundaries": error_boundaries_default,
 		"exhaustive-deps": rule$1,
+		globals: globals_default,
 		immutability: immutability_default,
 		"no-access-state-in-setstate": no_access_state_in_setstate_default,
 		"no-array-index-key": no_array_index_key_default,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.3.0-next.2",
+  "version": "5.3.1-next.0",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -46,12 +46,12 @@
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.5.0",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.3.0-next.2",
-    "@eslint-react/jsx": "5.3.0-next.2",
-    "@eslint-react/core": "5.3.0-next.2",
-    "@eslint-react/shared": "5.3.0-next.2",
-    "@eslint-react/eslint": "5.3.0-next.2",
-    "@eslint-react/var": "5.3.0-next.2"
+    "@eslint-react/ast": "5.3.1-next.0",
+    "@eslint-react/eslint": "5.3.1-next.0",
+    "@eslint-react/core": "5.3.1-next.0",
+    "@eslint-react/jsx": "5.3.1-next.0",
+    "@eslint-react/shared": "5.3.1-next.0",
+    "@eslint-react/var": "5.3.1-next.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",