eslint-plugin-react-x 5.12.0 → 5.13.0

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.0";
+var version = "5.13.0";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1751,17 +1751,6 @@ function create$47(context) {
 //#endregion
 //#region src/rules/no-array-index-key/lib.ts
 /**
-* Creates a report function for the given rule context.
-* @param context The ESLint rule context.
-* @returns A function that can be used to report violations.
-*/
-function report$2(context) {
-	return (descriptor) => {
-		if (descriptor == null) return;
-		context.report(descriptor);
-	};
-}
-/**
 * Iterator-like methods that pass the item's index to their callback,
 * mapped to the position of the index parameter in the callback's parameter list.
 * `map` and `forEach` also cover `Children.map` and `Children.forEach`,
@@ -1858,7 +1847,7 @@ function create$46(context) {
 	* @param node The key value expression to check.
 	* @returns The report descriptors for the violations found.
 	*/
-	function checkKeyExpression(node) {
+	function visitKeyExpression(node) {
 		switch (node.type) {
 			case AST_NODE_TYPES.Identifier: return isArrayIndex(node) ? [{
 				messageId: "default",
@@ -1872,8 +1861,8 @@ function create$46(context) {
 				messageId: "default",
 				node: identifier
 			}));
-			case AST_NODE_TYPES.ConditionalExpression: return [...checkKeyExpression(node.consequent), ...checkKeyExpression(node.alternate)];
-			case AST_NODE_TYPES.LogicalExpression: return [...checkKeyExpression(node.left), ...checkKeyExpression(node.right)];
+			case AST_NODE_TYPES.ConditionalExpression: return [...visitKeyExpression(node.consequent), ...visitKeyExpression(node.alternate)];
+			case AST_NODE_TYPES.LogicalExpression: return [...visitKeyExpression(node.left), ...visitKeyExpression(node.right)];
 			case AST_NODE_TYPES.CallExpression: {
 				const callee = Extract.unwrap(node.callee);
 				if (callee.type === AST_NODE_TYPES.MemberExpression && Extract.getPropertyName(callee.property) === "toString" && isArrayIndex(callee.object)) return [{
@@ -1898,12 +1887,12 @@ function create$46(context) {
 			for (const property of props.properties) {
 				const value = getKeyPropValue(property);
 				if (value == null) continue;
-				checkKeyExpression(value).forEach(report$2(context));
+				for (const desc of visitKeyExpression(value)) context.report(desc);
 			}
 		},
 		"JSXAttribute[name.name='key']"(node) {
 			if (node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
-			checkKeyExpression(node.value.expression).forEach(report$2(context));
+			for (const desc of visitKeyExpression(node.value.expression)) context.report(desc);
 		}
 	};
 }
@@ -2599,7 +2588,7 @@ function create$28(context) {
 * @param context The ESLint rule context.
 * @returns A function that can be used to report violations.
 */
-function report$1(context) {
+function report(context) {
 	return (descriptor) => {
 		if (descriptor == null) return;
 		context.report(descriptor);
@@ -2643,16 +2632,16 @@ function create$27(context) {
 	* @param seen A set of visited identifier names to prevent infinite recursion.
 	* @returns A report descriptor if a problem is found, otherwise `null`
 	*/
-	function getReportDescriptor(node, seen = /* @__PURE__ */ new Set()) {
+	function visit(node, seen = /* @__PURE__ */ new Set()) {
 		if (node == null) return null;
-		if (Check.is(AST_NODE_TYPES.JSXExpressionContainer)(node)) return getReportDescriptor(node.expression, seen);
+		if (Check.is(AST_NODE_TYPES.JSXExpressionContainer)(node)) return visit(node.expression, seen);
 		if (Check.isJSX(node)) return null;
-		if (Check.isTypeExpression(node)) return getReportDescriptor(node.expression, seen);
+		if (Check.isTypeExpression(node)) return visit(node.expression, seen);
 		return match(node).with({
 			type: AST_NODE_TYPES.LogicalExpression,
 			operator: "&&"
 		}, ({ left, right }) => {
-			if (left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "!") return getReportDescriptor(right, seen);
+			if (left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "!") return visit(right, seen);
 			const initialScope = context.sourceCode.getScope(left);
 			if (Check.isIdentifier(left, "NaN") || getStaticValue(left, initialScope)?.value === "NaN") return {
 				data: { value: context.sourceCode.getText(left) },
@@ -2661,22 +2650,22 @@ function create$27(context) {
 			};
 			const leftType = getConstrainedTypeAtLocation(services, left);
 			const leftTypeVariants = core.getTypeVariants(unionConstituents(leftType));
-			if (Array.from(leftTypeVariants.values()).every((t) => allowedTypeVariants.some((a) => a === t))) return getReportDescriptor(right, seen);
+			if (Array.from(leftTypeVariants.values()).every((t) => allowedTypeVariants.some((a) => a === t))) return visit(right, seen);
 			return {
 				data: { value: context.sourceCode.getText(left) },
 				messageId: "default",
 				node: left
 			};
 		}).with({ type: AST_NODE_TYPES.ConditionalExpression }, ({ alternate, consequent }) => {
-			return getReportDescriptor(consequent, seen) ?? getReportDescriptor(alternate, seen);
+			return visit(consequent, seen) ?? visit(alternate, seen);
 		}).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
 			if (seen.has(n.name)) return null;
 			seen.add(n.name);
 			const variableDefNode = findVariable(context.sourceCode.getScope(n), n.name)?.defs.at(0)?.node;
-			return match(variableDefNode).with({ init: P.select({ type: P.not(AST_NODE_TYPES.VariableDeclaration) }) }, (init) => getReportDescriptor(init, seen)).otherwise(() => null);
+			return match(variableDefNode).with({ init: P.select({ type: P.not(AST_NODE_TYPES.VariableDeclaration) }) }, (init) => visit(init, seen)).otherwise(() => null);
 		}).otherwise(() => null);
 	}
-	return { JSXExpressionContainer: flow(getReportDescriptor, report$1(context)) };
+	return { JSXExpressionContainer: flow(visit, report(context)) };
 }
 
 //#endregion
@@ -2791,17 +2780,6 @@ const INDEX_PARAM_POSITIONS = /* @__PURE__ */ new Map([
 	["map", 0]
 ]);
 /**
-* Creates a report function for the given rule context.
-* @param context The ESLint rule context.
-* @returns A function that can be used to report violations.
-*/
-function report(context) {
-	return (descriptor) => {
-		if (descriptor == null) return;
-		context.report(descriptor);
-	};
-}
-/**
 * Gets the nested return statements in the node that are within the same function
 * @param node The AST node
 * @returns The nested return statements in the node
@@ -2857,7 +2835,7 @@ function create$24(context) {
 	* @param node The expression to check.
 	* @returns The report descriptors for the violations found.
 	*/
-	function checkItemExpression(node) {
+	function visitItemExpression(node) {
 		switch (node.type) {
 			case AST_NODE_TYPES.JSXElement: return hasAttribute(context, node, "key") ? [] : [{
 				messageId: "default",
@@ -2867,8 +2845,8 @@ function create$24(context) {
 				messageId: "unexpectedFragmentSyntax",
 				node
 			}];
-			case AST_NODE_TYPES.ConditionalExpression: return [...checkItemExpression(node.consequent), ...checkItemExpression(node.alternate)];
-			case AST_NODE_TYPES.LogicalExpression: return [...checkItemExpression(node.left), ...checkItemExpression(node.right)];
+			case AST_NODE_TYPES.ConditionalExpression: return [...visitItemExpression(node.consequent), ...visitItemExpression(node.alternate)];
+			case AST_NODE_TYPES.LogicalExpression: return [...visitItemExpression(node.left), ...visitItemExpression(node.right)];
 			default: return [];
 		}
 	}
@@ -2878,16 +2856,16 @@ function create$24(context) {
 	* @param node The callback function to check.
 	* @returns The report descriptors for the violations found.
 	*/
-	function checkIteratorCallback(node) {
-		if (node.body.type !== AST_NODE_TYPES.BlockStatement) return checkItemExpression(node.body);
-		return getNestedReturnStatements$1(node.body).flatMap((stmt) => stmt.argument == null ? [] : checkItemExpression(stmt.argument));
+	function visitIteratorCallback(node) {
+		if (node.body.type !== AST_NODE_TYPES.BlockStatement) return visitItemExpression(node.body);
+		return getNestedReturnStatements$1(node.body).flatMap((stmt) => stmt.argument == null ? [] : visitItemExpression(stmt.argument));
 	}
 	return {
 		ArrayExpression(node) {
 			if (childrenToArrayDepth > 0) return;
 			for (const element of node.elements) {
 				if (element == null || element.type === AST_NODE_TYPES.SpreadElement) continue;
-				checkItemExpression(element).forEach(report(context));
+				for (const desc of visitItemExpression(element)) context.report(desc);
 			}
 		},
 		CallExpression(node) {
@@ -2898,7 +2876,7 @@ function create$24(context) {
 			if (childrenToArrayDepth > 0) return;
 			const callback = getIteratorCallback(node);
 			if (callback == null) return;
-			checkIteratorCallback(callback).forEach(report(context));
+			for (const desc of visitIteratorCallback(callback)) context.report(desc);
 		},
 		"CallExpression:exit"(node) {
 			if (core.isChildrenToArrayCall(context, node)) childrenToArrayDepth -= 1;
@@ -4261,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
@@ -4288,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 ?? []) {
@@ -4356,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
@@ -4400,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;
@@ -4417,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);
@@ -4436,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;
@@ -4462,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
 			});
@@ -4501,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;
 						}
@@ -4530,6 +4557,7 @@ function create$6(context) {
 							case AST_NODE_TYPES.CallExpression: break;
 							default: break findLoop;
 						}
+						prevChild = current;
 						current = current.parent;
 					}
 				}
@@ -4542,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;
 							}
@@ -4570,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.0",
+  "version": "5.13.0",
   "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.0",
-    "@eslint-react/core": "5.12.0",
-    "@eslint-react/eslint": "5.12.0",
-    "@eslint-react/jsx": "5.12.0",
-    "@eslint-react/shared": "5.12.0",
-    "@eslint-react/var": "5.12.0"
+    "@eslint-react/core": "5.13.0",
+    "@eslint-react/ast": "5.13.0",
+    "@eslint-react/eslint": "5.13.0",
+    "@eslint-react/var": "5.13.0",
+    "@eslint-react/jsx": "5.13.0",
+    "@eslint-react/shared": "5.13.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",