eslint-plugin-react-x 5.18.9 → 5.19.0

package/dist/index.js

@@ -145,7 +145,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.18.9";
+var version = "5.19.0";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1338,6 +1338,14 @@ const NAVIGATION_HOOKS = /* @__PURE__ */ new Set([
 	"useNavigation",
 	"useRouter"
 ]);
+function isNodeWithin(node, ancestor) {
+	let current = node;
+	while (current != null) {
+		if (current === ancestor) return true;
+		current = current.parent;
+	}
+	return false;
+}
 function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set()) {
 	const expr = Extract.unwrap(node);
 	if (Check.isFunction(expr)) return expr;
@@ -1474,6 +1482,79 @@ function createImmutabilityCollector() {
 	};
 }
 
+//#endregion
+//#region src/rules/immutability/origins.ts
+function isComponentPropsDefinition(context, def) {
+	if (def.type !== DefinitionType.Parameter) return false;
+	const fn = def.node;
+	if (!Check.isFunction(fn)) return false;
+	const firstParam = fn.params.at(0);
+	if (firstParam == null || !isNodeWithin(def.name, firstParam)) return false;
+	return core.isFunctionComponentDefinition(context, fn, core.DEFAULT_COMPONENT_DETECTION_HINT);
+}
+function getStateHookName(context, init) {
+	const { additionalStateHooks } = getSettingsFromContext(context);
+	if (core.isUseStateLikeCall(init, additionalStateHooks)) return Extract.getCalleeName(init) ?? "useState";
+	if (core.isUseReducerCall(context, init)) return "useReducer";
+	return null;
+}
+/**
+* Classify whether a variable ultimately holds a value that must be treated as
+* immutable: a component's props, a state value returned from `useState`-like or
+* `useReducer` calls, or a shallow copy (spread literal) of either.
+* @param context The rule context.
+* @param variable The variable to classify.
+* @param seen Variables already visited during spread recursion.
+* @returns The frozen origin, or `null` when the variable is not derived from one.
+*/
+function classifyFrozenOrigin(context, variable, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(variable)) return null;
+	seen.add(variable);
+	const origin = resolveVariableOrigin(context, variable);
+	const def = origin.defs.length === 1 ? origin.defs[0] : null;
+	if (def == null) return null;
+	if (isComponentPropsDefinition(context, def)) return {
+		kind: "props",
+		name: origin.name
+	};
+	if (def.type !== DefinitionType.Variable) return null;
+	const init = def.node.init == null ? null : Extract.unwrap(def.node.init);
+	if (init == null) return null;
+	switch (init.type) {
+		case AST_NODE_TYPES.CallExpression: {
+			const hook = getStateHookName(context, init);
+			if (hook == null) return null;
+			if (def.node.id.type !== AST_NODE_TYPES.ArrayPattern) return null;
+			const first = def.node.id.elements.at(0);
+			if (first == null || !isNodeWithin(def.name, first)) return null;
+			return {
+				kind: "state",
+				name: origin.name,
+				hook
+			};
+		}
+		case AST_NODE_TYPES.ArrayExpression:
+		case AST_NODE_TYPES.ObjectExpression: {
+			const elements = init.type === AST_NODE_TYPES.ObjectExpression ? init.properties : init.elements;
+			for (const element of elements) {
+				if (element?.type !== AST_NODE_TYPES.SpreadElement) continue;
+				const argument = Extract.unwrap(element.argument);
+				if (!Check.isIdentifier(argument)) continue;
+				const source = findVariable(context.sourceCode.getScope(argument), argument);
+				if (source == null) continue;
+				const inner = classifyFrozenOrigin(context, source, seen);
+				if (inner != null) return {
+					kind: "shallow-copy",
+					name: origin.name,
+					original: inner.name
+				};
+			}
+			return null;
+		}
+		default: return null;
+	}
+}
+
 //#endregion
 //#region src/rules/immutability/effects.ts
 function isGlobalOrModuleVariable(variable) {
@@ -1505,6 +1586,47 @@ function inferMutableFunctions(context, mutations) {
 	}
 	return mutableFunctions;
 }
+function getMutatedObject(mutation) {
+	const target = Extract.unwrap(mutation.target);
+	if (mutation.node.type === AST_NODE_TYPES.CallExpression) return target;
+	return target.type === AST_NODE_TYPES.MemberExpression ? Extract.unwrap(target.object) : target;
+}
+function inferDirectMutations(context, mutations) {
+	const directMutations = [];
+	for (const mutation of mutations) {
+		if (mutation.kind !== "value") continue;
+		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 = classifyFrozenOrigin(context, variable);
+		if (origin == null) continue;
+		switch (origin.kind) {
+			case "props":
+				directMutations.push({
+					name: origin.name,
+					detail: "It is a prop of this component and must be treated as immutable.",
+					node: mutation.node
+				});
+				break;
+			case "state":
+				directMutations.push({
+					name: origin.name,
+					detail: `It is a state value returned from '${origin.hook}' and must be treated as immutable.`,
+					node: mutation.node
+				});
+				break;
+			case "shallow-copy":
+				if (getMutatedObject(mutation).type !== AST_NODE_TYPES.MemberExpression) continue;
+				directMutations.push({
+					name: origin.name,
+					detail: `It is a shallow copy of '${origin.original}'; mutating nested values through it mutates '${origin.original}' in place.`,
+					node: mutation.node
+				});
+		}
+	}
+	return directMutations;
+}
 
 //#endregion
 //#region src/rules/immutability/immutability.ts
@@ -1512,9 +1634,10 @@ const RULE_NAME$48 = "immutability";
 var immutability_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Validates against passing functions that mutate captured local variables into frozen contexts such as JSX props, hook arguments, and hook return values." },
+		docs: { description: "Validates against mutating props, state, and other immutable values, including through functions passed into frozen contexts such as JSX props, hook arguments, and hook return values." },
 		messages: {
 			default: "This function may (indirectly) reassign or modify '{{name}}' after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.",
+			direct: "Do not mutate '{{name}}' directly. {{detail}}",
 			mutates: "This modifies '{{name}}'."
 		},
 		schema: []
@@ -1531,25 +1654,40 @@ function create$48(context) {
 			kind: "hook-return",
 			expression
 		});
+		const reportedMutations = /* @__PURE__ */ new Set();
 		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
-			});
+		if (mutableFunctions.size > 0) {
+			const reportedSinks = /* @__PURE__ */ new Set();
+			for (const sink of collector.facts.sinks) {
+				const expression = sink.expression;
+				if (reportedSinks.has(expression)) continue;
+				const fn = resolveToFunctionNode(context, expression);
+				if (fn == null) continue;
+				const mutation = mutableFunctions.get(fn);
+				if (mutation == null) continue;
+				reportedSinks.add(expression);
+				reportedMutations.add(mutation.node);
+				context.report({
+					data: { name: mutation.name },
+					messageId: "default",
+					node: expression
+				});
+				context.report({
+					data: { name: mutation.name },
+					messageId: "mutates",
+					node: mutation.node
+				});
+			}
+		}
+		for (const mutation of inferDirectMutations(context, collector.facts.mutations)) {
+			if (reportedMutations.has(mutation.node)) continue;
+			reportedMutations.add(mutation.node);
 			context.report({
-				data: { name: mutation.name },
-				messageId: "mutates",
+				data: {
+					name: mutation.name,
+					detail: mutation.detail
+				},
+				messageId: "direct",
 				node: mutation.node
 			});
 		}
@@ -8594,19 +8732,19 @@ const finalPlugin = {
 		/**
 		* Disable rules in `eslint-plugin-react` that conflict with rules in this plugin
 		*/
-		["disable-conflict-eslint-plugin-react"]: disable_conflict_eslint_plugin_react_exports,
+		["disable-conflict-eslint-plugin-react"]: createConfig(disable_conflict_eslint_plugin_react_exports),
 		/**
 		* Disable rules in `eslint-plugin-react-hooks` that conflict with rules in this plugin
 		*/
-		["disable-conflict-eslint-plugin-react-hooks"]: disable_conflict_eslint_plugin_react_hooks_exports,
+		["disable-conflict-eslint-plugin-react-hooks"]: createConfig(disable_conflict_eslint_plugin_react_hooks_exports),
 		/**
 		* Disable experimental rules that might be subject to change in the future
 		*/
-		["disable-experimental"]: disable_experimental_exports,
+		["disable-experimental"]: createConfig(disable_experimental_exports),
 		/**
 		* Disable rules that can be enforced by TypeScript
 		*/
-		["disable-type-checked"]: disable_type_checked_exports,
+		["disable-type-checked"]: createConfig(disable_type_checked_exports),
 		/**
 		* Enforce rules that are recommended by ESLint React for general purpose React + React DOM projects
 		*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.18.9",
+  "version": "5.19.0",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -36,12 +36,12 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.18.9",
-    "@eslint-react/core": "5.18.9",
-    "@eslint-react/eslint": "5.18.9",
-    "@eslint-react/jsx": "5.18.9",
-    "@eslint-react/shared": "5.18.9",
-    "@eslint-react/var": "5.18.9",
+    "@eslint-react/ast": "5.19.0",
+    "@eslint-react/core": "5.19.0",
+    "@eslint-react/eslint": "5.19.0",
+    "@eslint-react/jsx": "5.19.0",
+    "@eslint-react/shared": "5.19.0",
+    "@eslint-react/var": "5.19.0",
     "@typescript-eslint/scope-manager": "^8.69.0",
     "@typescript-eslint/type-utils": "^8.69.0",
     "@typescript-eslint/types": "^8.69.0",