oxlint-plugin-react-doctor 0.7.4-dev.11333b9 → 0.7.4-dev.2b5a18e

package/dist/index.js

@@ -10589,6 +10589,19 @@ const isUnstableInitializer = (node) => {
 	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
 	return isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment") || isNodeOfType(stripped, "AssignmentExpression") || isNodeOfType(stripped, "NewExpression");
 };
+const isPotentiallyFreshComparedValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = unwrapExpression$3(node);
+	if (isUnstableInitializer(candidate)) return true;
+	if (isNodeOfType(candidate, "ConditionalExpression")) return isPotentiallyFreshComparedValue(candidate.consequent, scopes, visitedSymbolIds) || isPotentiallyFreshComparedValue(candidate.alternate, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "LogicalExpression")) return isPotentiallyFreshComparedValue(candidate.left, scopes, visitedSymbolIds) || isPotentiallyFreshComparedValue(candidate.right, scopes, visitedSymbolIds);
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	if (symbol.kind === "let" || symbol.kind === "var") return true;
+	if (symbol.kind !== "const" || !symbol.initializer) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isPotentiallyFreshComparedValue(symbol.initializer, scopes, visitedSymbolIds);
+};
 const isExtraDepAllowedForHook = (hookName, node, scopes) => {
 	if (!isExtraReactiveDepAllowed(node, scopes)) return false;
 	if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName)) return true;
@@ -10602,6 +10615,52 @@ const isStableSetterLikeSymbol = (symbol, scopes) => {
 	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
 	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
 };
+const isConvergingFunctionalUpdater = (node, scopes) => {
+	const updater = unwrapExpression$3(node);
+	if (!isNodeOfType(updater, "ArrowFunctionExpression") && !isNodeOfType(updater, "FunctionExpression")) return false;
+	const previousValueParameter = updater.params?.[0];
+	if (!previousValueParameter || !isNodeOfType(previousValueParameter, "Identifier")) return false;
+	let returnedExpression = updater.body;
+	if (isNodeOfType(updater.body, "BlockStatement")) {
+		returnedExpression = null;
+		for (const statement of updater.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) {
+			returnedExpression = statement.argument;
+			break;
+		}
+	}
+	const conditional = returnedExpression ? unwrapExpression$3(returnedExpression) : null;
+	if (!conditional || !isNodeOfType(conditional, "ConditionalExpression")) return false;
+	const test = unwrapExpression$3(conditional.test);
+	if (!isNodeOfType(test, "BinaryExpression") || ![
+		"===",
+		"!==",
+		"==",
+		"!="
+	].includes(test.operator)) return false;
+	const isPreviousValue = (expression) => {
+		const candidate = unwrapExpression$3(expression);
+		return isNodeOfType(candidate, "Identifier") && candidate.name === previousValueParameter.name;
+	};
+	let comparedValue = null;
+	if (isPreviousValue(test.left)) comparedValue = test.right;
+	else if (isPreviousValue(test.right)) comparedValue = test.left;
+	if (!comparedValue) return false;
+	if (isPotentiallyFreshComparedValue(comparedValue, scopes)) return false;
+	const isSameComparedValue = (expression) => {
+		const candidate = unwrapExpression$3(expression);
+		const compared = unwrapExpression$3(comparedValue);
+		if (isNodeOfType(candidate, "Identifier") && isNodeOfType(compared, "Identifier")) return candidate.name === compared.name;
+		if (isNodeOfType(candidate, "Literal") && isNodeOfType(compared, "Literal")) return candidate.value === compared.value;
+		return false;
+	};
+	return test.operator === "===" || test.operator === "==" ? isPreviousValue(conditional.consequent) && isSameComparedValue(conditional.alternate) : isSameComparedValue(conditional.consequent) && isPreviousValue(conditional.alternate);
+};
+const isGuardedStableSetterCall = (identifier, symbol, scopes) => {
+	const parent = identifier.parent;
+	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier || !isStableSetterLikeSymbol(symbol, scopes)) return false;
+	const writtenValue = parent.arguments?.[0];
+	return Boolean(writtenValue && isConvergingFunctionalUpdater(writtenValue, scopes));
+};
 const findStableSetterReference = (node, scopes) => {
 	let setterName = null;
 	const visit = (current) => {
@@ -10609,7 +10668,7 @@ const findStableSetterReference = (node, scopes) => {
 		if (current !== node && (isNodeOfType(current, "FunctionDeclaration") || isNodeOfType(current, "FunctionExpression") || isNodeOfType(current, "ArrowFunctionExpression"))) return;
 		if (isNodeOfType(current, "Identifier")) {
 			const symbol = scopes.referenceFor(current)?.resolvedSymbol;
-			if (symbol && isStableSetterLikeSymbol(symbol, scopes)) {
+			if (symbol && isStableSetterLikeSymbol(symbol, scopes) && !isGuardedStableSetterCall(current, symbol, scopes)) {
 				setterName = symbol.name;
 				return;
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.4-dev.11333b9",
+  "version": "0.7.4-dev.2b5a18e",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",