oxlint-plugin-react-doctor 0.7.9-dev.842a55f → 0.7.9-dev.8835214

package/dist/index.js

@@ -13883,6 +13883,7 @@ const walkInsideStatementBlocks = (node, visitor) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-subscribe-like-call-expression.ts
+const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
 const getSubscribeLikeMethodName = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	if (!isNodeOfType(node.callee, "MemberExpression")) return null;
@@ -13893,6 +13894,11 @@ const isSubscribeLikeCallExpression = (node) => {
 	const methodName = getSubscribeLikeMethodName(node);
 	return methodName !== null && SUBSCRIPTION_METHOD_NAMES.has(methodName);
 };
+const getSubscribeOrObserveMethodName = (node) => {
+	const methodName = getSubscribeLikeMethodName(node);
+	return methodName !== null && (SUBSCRIPTION_METHOD_NAMES.has(methodName) || methodName === "observe") ? methodName : null;
+};
+const isSubscribeOrObserveCallExpression = (node) => getSubscribeOrObserveMethodName(node) !== null;
 const isCleanupReturningSubscribeLikeCallExpression = (node) => {
 	const methodName = getSubscribeLikeMethodName(node);
 	if (methodName === null || !CLEANUP_RETURNING_SUBSCRIPTION_METHOD_NAMES.has(methodName)) return false;
@@ -13945,7 +13951,6 @@ const isNodeReachableWithinFunction = (node, context) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
-const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
 const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
 const REPLAYABLE_ITERATOR_COLLECTION_CACHE = /* @__PURE__ */ new WeakMap();
 const REACT_REF_EFFECT_ANALYSIS_CACHE = /* @__PURE__ */ new WeakMap();
@@ -13955,10 +13960,6 @@ const RESOURCE_NOUN_BY_KIND = {
 	socket: "connection"
 };
 const isSocketConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP.has(node.callee.name);
-const isSubscribeOrObserveCall = (node) => {
-	if (isSubscribeLikeCallExpression(node)) return true;
-	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME;
-};
 const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	if (!expression) return null;
 	const unwrappedExpression = stripParenExpression(expression);
@@ -14060,12 +14061,13 @@ const findSubscribeLikeUsages = (callback, context) => {
 			});
 			return;
 		}
-		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) {
+		const subscribeOrObserveMethodName = getSubscribeOrObserveMethodName(child);
+		if (subscribeOrObserveMethodName !== null) {
 			const registrationDetails = getCallRegistrationDetails(child, context);
 			usages.push({
 				kind: "subscribe",
 				node: child,
-				resourceName: child.callee.property.name,
+				resourceName: subscribeOrObserveMethodName,
 				handleKey: findAssignedResourceKey(child, context),
 				...registrationDetails
 			});
@@ -15683,7 +15685,7 @@ const findRetainedFunctionLeak = (retainedFunction, context, options) => {
 				return false;
 			}
 		}
-		if (isSubscribeOrObserveCall(child) && (!doesResourceResultEscape(child, allowReturnedResourceEscape, allowReturnedResourceEscape, context) || options?.requireCallableReturnedResource === true && !isCleanupReturningSubscribeLikeCallExpression(child))) {
+		if (isSubscribeOrObserveCallExpression(child) && (!doesResourceResultEscape(child, allowReturnedResourceEscape, allowReturnedResourceEscape, context) || options?.requireCallableReturnedResource === true && !isCleanupReturningSubscribeLikeCallExpression(child))) {
 			const registrationDetails = getCallRegistrationDetails(child, context);
 			const subscriptionUsage = {
 				kind: "subscribe",
@@ -32270,6 +32272,7 @@ const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFile
 			sourceReferences,
 			isDeferred: frame.isDeferred,
 			isRenderKnownCopy,
+			isSynchronousRenderValue: !frame.isDeferred && !valueEvidence.hasUnknownSource && !valueEvidence.hasDeferredIntroducedValue && !valueEvidence.readsExternalValue,
 			matchesStateInitializer: doesMatchStateInitializer,
 			resetsSourceState: false
 		});
@@ -32285,13 +32288,59 @@ const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFile
 	});
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/has-deferred-or-external-effect-work.ts
+const DEFERRED_MEMBER_NAMES = new Set([
+	"catch",
+	"finally",
+	"then"
+]);
+const hasDeferredOrExternalEffectWork = (analysis, effectNode, scopes) => {
+	const effectFunction = getEffectFn(analysis, effectNode);
+	if (!effectFunction) return false;
+	if (containsFetchCall(effectFunction, { stopAtFunctionBoundary: true })) return true;
+	const effectInvokedFunctions = collectEffectInvokedFunctions(effectFunction);
+	let didFindDeferredOrExternalWork = false;
+	walkAst(effectFunction, (child) => {
+		if (didFindDeferredOrExternalWork) return false;
+		if (child !== effectFunction && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			const assignmentTarget = child.left;
+			if ((isNodeOfType(assignmentTarget, "MemberExpression") ? getStaticPropertyName(assignmentTarget) : null)?.startsWith("on") && isFunctionLike$1(child.right)) {
+				didFindDeferredOrExternalWork = true;
+				return false;
+			}
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (isSubscribeOrObserveCallExpression(child)) {
+			didFindDeferredOrExternalWork = true;
+			return false;
+		}
+		const localFunction = resolveExactLocalFunction(child.callee, scopes);
+		if (isFunctionLike$1(localFunction) && localFunction.async) {
+			didFindDeferredOrExternalWork = true;
+			return false;
+		}
+		const callee = child.callee;
+		if (isNodeOfType(callee, "Identifier") && TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES.has(callee.name)) {
+			didFindDeferredOrExternalWork = true;
+			return false;
+		}
+		const memberName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null;
+		if (memberName && DEFERRED_MEMBER_NAMES.has(memberName)) {
+			didFindDeferredOrExternalWork = true;
+			return false;
+		}
+	});
+	return didFindDeferredOrExternalWork;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-adjust-state-on-prop-change.ts
 const noAdjustStateOnPropChange = defineRule({
 	id: "no-adjust-state-on-prop-change",
-	title: "State synced to a prop inside an effect",
+	title: "State adjusted after a prop changes",
 	severity: "warn",
 	tags: ["test-noise"],
-	recommendation: "Adjust the state inline during render with a `prev`-prop comparison (`if (prop !== prevProp) { setPrevProp(prop); setX(...); }`), or refactor to remove the duplicated state. Routing the adjustment through a useEffect forces an extra render with a stale UI between the two commits. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
+	recommendation: "Remove the adjustment effect by deriving values during render, resetting the component with a key, or updating related state in the event that changes the prop. Avoid tracking the previous prop in more state, which preserves the duplication. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
 	create: (context) => ({ CallExpression(node) {
 		if (!isReactApiCall(node, "useEffect", context.scopes, {
 			allowGlobalReactNamespace: true,
@@ -32304,8 +32353,11 @@ const noAdjustStateOnPropChange = defineRule({
 		const dependencyReferences = getEffectDepsRefs(analysis, node);
 		if (!dependencyReferences) return;
 		if (!dependencyReferences.flatMap((reference) => isState(analysis, reference) ? [] : getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
-			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
+		const facts = collectEffectStateWriteFacts(analysis, context, node, context.filename);
+		if (hasCleanup(analysis, node) || hasDeferredOrExternalEffectWork(analysis, node, context.scopes) || facts.some((fact) => fact.isDeferred)) return;
+		for (const fact of facts) {
+			if (!fact.isSynchronousRenderValue || fact.resetsSourceState) continue;
+			if (fact.sourceReferences.flatMap((reference) => getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) continue;
 			context.report({
 				node: fact.callExpression,
 				message: "This effect adjusts state after a prop changes, so users briefly see the stale value."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.9-dev.842a55f",
+  "version": "0.7.9-dev.8835214",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",