eslint-plugin-react-x 5.12.1 → 5.13.1

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.12.1";
+var version = "5.13.1";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -4239,6 +4239,17 @@ function create$7(context) {
 
 //#endregion
 //#region src/rules/refs/lib.ts
+function isFunctionExpressionLike(node) {
+	return node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.ArrowFunctionExpression;
+}
+function resolveAlias(name, aliases) {
+	const seen = /* @__PURE__ */ new Set();
+	while (aliases.has(name) && !seen.has(name)) {
+		seen.add(name);
+		name = aliases.get(name);
+	}
+	return name;
+}
 /**
 * Check if the node is the operand of a `ref.current === null` test inside an IfStatement.
 * @param node The MemberExpression node for ref.current
@@ -4266,37 +4277,62 @@ function isInNullCheckTest(node) {
 	if (parent.type === AST_NODE_TYPES.UnaryExpression && parent.operator === "!") return isIfTest(parent);
 	return false;
 }
+function isBinaryNullCheckOperand(a, b, refName) {
+	a = Check.isTypeExpression(a) ? Extract.unwrap(a) : a;
+	if (a.type !== AST_NODE_TYPES.MemberExpression) return false;
+	if (Extract.getPropertyName(a.property) !== "current") return false;
+	const obj = Extract.unwrap(a.object);
+	return obj.type === AST_NODE_TYPES.Identifier && obj.name === refName && b.type === AST_NODE_TYPES.Literal && b.value == null;
+}
 function isBinaryNullCheck(test, refName) {
 	if (test.type !== AST_NODE_TYPES.BinaryExpression) return false;
 	if (!/^(===|==|!==|!=)$/.test(test.operator)) return false;
 	const { left, right } = test;
-	const checkSides = (a, b) => {
-		a = Check.isTypeExpression(a) ? Extract.unwrap(a) : a;
-		if (a.type !== AST_NODE_TYPES.MemberExpression) return false;
-		if (Extract.getPropertyName(a.property) !== "current") return false;
-		const obj = Extract.unwrap(a.object);
-		return obj.type === AST_NODE_TYPES.Identifier && obj.name === refName && b.type === AST_NODE_TYPES.Literal && b.value == null;
-	};
-	return checkSides(left, right) || checkSides(right, left);
+	return isBinaryNullCheckOperand(left, right, refName) || isBinaryNullCheckOperand(right, left, refName);
 }
 /**
-* Check if a test expression is a null check on `ref.current` for a given ref name.
-* Matches forms like `ref.current === null`, `null === ref.current`, `!ref.current`,
-* `!(ref.current === null)`, and their != variants.
+* Determine which branch of an `if` statement is guaranteed to see `ref.current` as null, given
+* a test expression. Returns `null` if the test isn't a recognized null check on `refName`.
 * @param test The test expression to check.
 * @param refName The name of the ref variable.
 */
-function isRefCurrentNullCheck(test, refName) {
-	if (isBinaryNullCheck(test, refName)) return true;
+function getRefCurrentNullCheckBranch(test, refName) {
+	if (isBinaryNullCheck(test, refName)) return test.operator === "===" || test.operator === "==" ? "consequent" : "alternate";
 	if (test.type === AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
 		const arg = Extract.unwrap(test.argument);
 		if (arg.type === AST_NODE_TYPES.MemberExpression) {
 			const obj = Extract.unwrap(arg.object);
-			return obj.type === AST_NODE_TYPES.Identifier && obj.name === refName && Extract.getPropertyName(arg.property) === "current";
+			return obj.type === AST_NODE_TYPES.Identifier && obj.name === refName && Extract.getPropertyName(arg.property) === "current" ? "consequent" : null;
+		}
+		if (arg.type === AST_NODE_TYPES.BinaryExpression) {
+			const inner = getRefCurrentNullCheckBranch(arg, refName);
+			if (inner === "consequent") return "alternate";
+			if (inner === "alternate") return "consequent";
 		}
-		return isBinaryNullCheck(arg, refName);
 	}
-	return false;
+	return null;
+}
+/**
+* Check whether `node` (a `ref.current` MemberExpression) is being written to indirectly through
+* a nested property write, e.g. `ref.current.inner = value` or `ref.current.inner++`.
+* @param node The MemberExpression node for ref.current
+*/
+function isNestedRefCurrentWrite(node) {
+	let outer = node;
+	let sawNesting = false;
+	while (true) {
+		let parent = outer.parent;
+		while (Check.isTypeExpression(parent)) parent = parent.parent;
+		if (parent.type === AST_NODE_TYPES.MemberExpression && (parent.object === outer || Extract.unwrap(parent.object) === outer)) {
+			outer = parent;
+			sawNesting = true;
+			continue;
+		}
+		if (!sawNesting) return false;
+		if (parent.type === AST_NODE_TYPES.AssignmentExpression) return parent.left === outer || Extract.unwrap(parent.left) === outer;
+		if (parent.type === AST_NODE_TYPES.UpdateExpression) return parent.argument === outer || Extract.unwrap(parent.argument) === outer;
+		return false;
+	}
 }
 function isInitializedFromRef$1(context, name, initialScope) {
 	for (const { node } of findVariable(initialScope, name)?.defs ?? []) {
@@ -4324,9 +4360,9 @@ var refs_default = createRule({
 		docs: { description: "Validates correct usage of refs by checking that 'ref.current' is not read or written during render." },
 		messages: {
 			duplicateRefInit: "Ref is initialized more than once during render. Only a single 'if (ref.current == null)' initialization is allowed; move any additional initialization into an effect or event handler.",
-			readDuringRender: "Do not read 'ref.current' during render. Refs are not available during rendering and their values may be stale or inconsistent. Move this read into an effect or event handler.",
-			refPassedToFunction: "Passing a ref to a function may cause its value to be read during render. Pass 'ref.current' instead if the function only needs the value, or move the call into an effect.",
-			writeDuringRender: "Do not write to 'ref.current' during render. Refs should only be mutated in effects or event handlers. Move this write into an effect or event handler."
+			readDuringRender: "Cannot access refs during render",
+			refPassedToFunction: "Passing a ref to a function may read its value during render",
+			writeDuringRender: "Cannot update ref during render"
 		},
 		schema: []
 	},
@@ -4334,17 +4370,6 @@ var refs_default = createRule({
 	create: create$6,
 	defaultOptions: []
 });
-function resolveAlias(name, aliases) {
-	const seen = /* @__PURE__ */ new Set();
-	while (aliases.has(name) && !seen.has(name)) {
-		seen.add(name);
-		name = aliases.get(name);
-	}
-	return name;
-}
-function isFunctionExpressionLike(node) {
-	return node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.ArrowFunctionExpression;
-}
 /**
 * Phase 2 (part): compute the set of functions that are "reached" during render for a given
 * component/hook boundary. A function is reached if it is the boundary itself, or if it is
@@ -4378,10 +4403,10 @@ function computeReachedFunctions(boundary, isCompOrHookFn, functionVarBindings,
 * i.e. every function boundary between the access and the component/hook `boundary` is itself
 * a function that gets invoked during render (see `computeReachedFunctions`).
 */
-function isReachedDuringRender(node, boundary, reached) {
+function isReachedDuringRender(node, boundary, reached, alwaysReached) {
 	let current = node.parent;
 	while (current != null && current !== boundary) {
-		if (Check.isFunction(current) && !reached.has(current)) return false;
+		if (Check.isFunction(current) && !reached.has(current) && !alwaysReached.has(current)) return false;
 		current = current.parent;
 	}
 	return true;
@@ -4395,11 +4420,18 @@ function create$6(context) {
 	const refPassedToFunctions = [];
 	const functionVarBindings = /* @__PURE__ */ new Map();
 	const directCallSites = [];
+	const stateInitializerFunctions = /* @__PURE__ */ new Set();
 	return merge(hc.visitor, fc.visitor, {
 		AssignmentExpression(node) {
 			if (node.operator !== "=") return;
 			const left = Extract.unwrap(node.left);
 			const right = Extract.unwrap(node.right);
+			if (left.type === AST_NODE_TYPES.MemberExpression) {
+				const leftObj = Extract.unwrap(left.object);
+				const propName = Extract.getPropertyName(left.property);
+				if (leftObj.type === AST_NODE_TYPES.Identifier && propName != null && isFunctionExpressionLike(right)) functionVarBindings.set(`${leftObj.name}.${propName}`, right);
+				return;
+			}
 			if (left.type !== AST_NODE_TYPES.Identifier) return;
 			if (right.type === AST_NODE_TYPES.Identifier) {
 				aliases.set(left.name, right.name);
@@ -4414,7 +4446,21 @@ function create$6(context) {
 				calleeName: callee.name,
 				node
 			});
-			if (calleeName != null && (calleeName.startsWith("use") || calleeName === "mergeRefs")) return;
+			else if (callee.type === AST_NODE_TYPES.MemberExpression) {
+				const calleeObj = Extract.unwrap(callee.object);
+				if (calleeObj.type === AST_NODE_TYPES.Identifier && calleeName != null) directCallSites.push({
+					calleeName: `${calleeObj.name}.${calleeName}`,
+					node
+				});
+			}
+			if (calleeName === "useState") {
+				const [firstArg] = node.arguments;
+				if (firstArg != null) {
+					const unwrappedFirstArg = Extract.unwrap(firstArg);
+					if (isFunctionExpressionLike(unwrappedFirstArg)) stateInitializerFunctions.add(unwrappedFirstArg);
+				}
+			}
+			if (calleeName != null && (calleeName.startsWith("use") || calleeName === "mergeRefs" || calleeName === "render")) return;
 			for (const arg of node.arguments) {
 				const unwrapped = Extract.unwrap(arg);
 				if (unwrapped.type !== AST_NODE_TYPES.Identifier) continue;
@@ -4440,7 +4486,7 @@ function create$6(context) {
 				isWrite: (() => {
 					let parent = node.parent;
 					while (Check.isTypeExpression(parent)) parent = parent.parent;
-					return match(parent).with({ type: AST_NODE_TYPES.AssignmentExpression }, (p) => p.left === node || Extract.unwrap(p.left) === node).with({ type: AST_NODE_TYPES.UpdateExpression }, (p) => p.argument === node || Extract.unwrap(p.argument) === node).otherwise(() => false);
+					return match(parent).with({ type: AST_NODE_TYPES.AssignmentExpression }, (p) => p.left === node || Extract.unwrap(p.left) === node).with({ type: AST_NODE_TYPES.UpdateExpression }, (p) => p.argument === node || Extract.unwrap(p.argument) === node).otherwise(() => false) || isNestedRefCurrentWrite(node);
 				})(),
 				node
 			});
@@ -4479,16 +4525,19 @@ function create$6(context) {
 				} else continue;
 				const boundary = Traverse.findParent(node, isCompOrHookFn);
 				if (boundary == null) continue;
-				if (!isReachedDuringRender(node, boundary, getReached(boundary))) continue;
+				if (!isReachedDuringRender(node, boundary, getReached(boundary), stateInitializerFunctions)) continue;
 				let isLazyInit = refName != null && isInNullCheckTest(node);
 				let matchedGuardIf = false;
 				if (!isLazyInit && refName != null) {
 					let current = node.parent;
+					let prevChild = node;
 					findLoop: while (true) {
 						if (current.type === AST_NODE_TYPES.IfStatement) {
-							if (isRefCurrentNullCheck(current.test, refName)) {
-								isLazyInit = true;
+							const nullBranch = getRefCurrentNullCheckBranch(current.test, refName);
+							const actualBranch = current.consequent === prevChild ? "consequent" : current.alternate === prevChild ? "alternate" : null;
+							if (nullBranch != null && actualBranch != null) {
 								matchedGuardIf = true;
+								isLazyInit = actualBranch === nullBranch ? isWrite : !isWrite;
 							}
 							break;
 						}
@@ -4508,6 +4557,7 @@ function create$6(context) {
 							case AST_NODE_TYPES.CallExpression: break;
 							default: break findLoop;
 						}
+						prevChild = current;
 						current = current.parent;
 					}
 				}
@@ -4520,7 +4570,7 @@ function create$6(context) {
 						if (stmtIdx >= 0) for (let i = stmtIdx - 1; i >= 0; i--) {
 							const sibling = block.body[i];
 							if (sibling == null) continue;
-							if (sibling.type === AST_NODE_TYPES.IfStatement && isRefCurrentNullCheck(sibling.test, refName)) {
+							if (sibling.type === AST_NODE_TYPES.IfStatement && getRefCurrentNullCheckBranch(sibling.test, refName) === "alternate") {
 								isLazyInit = true;
 								break;
 							}
@@ -4548,7 +4598,7 @@ function create$6(context) {
 			for (const { node } of refPassedToFunctions) {
 				const boundary = Traverse.findParent(node, isCompOrHookFn);
 				if (boundary == null) continue;
-				if (!isReachedDuringRender(node, boundary, getReached(boundary))) continue;
+				if (!isReachedDuringRender(node, boundary, getReached(boundary), stateInitializerFunctions)) continue;
 				context.report({
 					messageId: "refPassedToFunction",
 					node

package/package.json

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