oxlint-plugin-react-doctor 0.7.9-dev.2979a9b → 0.7.9-dev.2ba83c3

package/dist/index.js

@@ -8959,7 +8959,7 @@ const isReactNamespaceImport = (identifier, scopes) => {
 	if (!symbol || !isImportedFromReact(symbol)) return false;
 	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier") || getImportedName(symbol.declarationNode) === "default";
 };
-const isReactNamespaceReceiver$1 = (receiver, scopes, options) => {
+const isReactNamespaceReceiver = (receiver, scopes, options) => {
 	if (!isNodeOfType(receiver, "Identifier")) return false;
 	if (isReactNamespaceImport(receiver, scopes)) return true;
 	return Boolean(options.allowGlobalReactNamespace && receiver.name === "React" && scopes.isGlobalReference(receiver));
@@ -8972,7 +8972,7 @@ const isDestructuredReactApiBinding = (identifier, apiNames, scopes, options) =>
 	for (const property of pattern.properties) {
 		if (!isNodeOfType(property, "Property") || property.value !== symbol.bindingIdentifier) continue;
 		const propertyName = getStaticPropertyKeyName(property);
-		return Boolean(propertyName && includesApiName(apiNames, propertyName) && isReactNamespaceReceiver$1(stripParenExpression(symbol.initializer), scopes, options));
+		return Boolean(propertyName && includesApiName(apiNames, propertyName) && isReactNamespaceReceiver(stripParenExpression(symbol.initializer), scopes, options));
 	}
 	return false;
 };
@@ -8996,7 +8996,7 @@ const isReactApiCallee = (rawCallee, apiNames, scopes, options, visitedSymbolIds
 		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
 	}
 	if (!isNodeOfType(callee, "MemberExpression") || !includesApiName(apiNames, getStaticPropertyName(callee) ?? "")) return false;
-	return isReactNamespaceReceiver$1(stripParenExpression(callee.object), scopes, options);
+	return isReactNamespaceReceiver(stripParenExpression(callee.object), scopes, options);
 };
 //#endregion
 //#region src/plugin/utils/is-proven-browser-api-receiver.ts
@@ -30212,12 +30212,6 @@ const isReactNamespaceImportReference = (ref) => Boolean(ref?.resolved?.defs.som
 	const importDeclaration = declarationNode.parent;
 	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
 }));
-const isReactNamespaceReceiver = (analysis, node) => {
-	const receiver = stripParenExpression(node);
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	const namespaceReference = getRef(analysis, receiver);
-	return namespaceReference?.resolved ? isReactNamespaceImportReference(namespaceReference) : receiver.name === "React";
-};
 const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
 	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return false;
 	const callee = stripParenExpression(declarator.init.callee);
@@ -30226,20 +30220,24 @@ const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
 		if (!reference?.resolved) return callee.name === hookName;
 		return isReactNamedImportReference(reference, hookName);
 	}
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
-	return isReactNamespaceReceiver(analysis, callee.object);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
+	const namespaceReference = getRef(analysis, callee.object);
+	if (!namespaceReference?.resolved) return callee.object.name === "React";
+	return isReactNamespaceImportReference(namespaceReference);
 };
 const isHookCallee$1 = (analysis, node, hookName) => {
 	if (!node) return false;
 	if (isNodeOfType(node, "Identifier")) {
 		if (node.name === hookName) return true;
 		if (isReactNamedImportReference(getRef(analysis, node), hookName)) return true;
-		const receiverRoot = findTransparentExpressionRoot(node);
-		const parent = receiverRoot.parent;
-		if (parent && isNodeOfType(parent, "MemberExpression") && parent.object === receiverRoot && isReactNamespaceReceiver(analysis, node) && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
+		const parent = node.parent;
+		if (parent && isNodeOfType(parent, "MemberExpression") && isNodeOfType(parent.object, "Identifier") && parent.object.name === "React" && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
 		return false;
 	}
-	if (isNodeOfType(node, "MemberExpression")) return isReactNamespaceReceiver(analysis, node.object) && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	if (isNodeOfType(node, "MemberExpression")) {
+		const receiver = stripParenExpression(node.object);
+		return isNodeOfType(receiver, "Identifier") && receiver.name === "React" && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	}
 	return false;
 };
 const isUseEffect = (node) => {
@@ -30663,88 +30661,7 @@ const isIndependentWriterIdentifier = (componentFunction, identifier, includeDef
 	if (HANDLER_BINDING_NAME_PATTERN.test(bindingName)) return true;
 	return isSetterWiredToJsxHandler(componentFunction, bindingName);
 };
-const isSynchronousFunction = (functionNode) => {
-	const functionMetadata = functionNode;
-	return functionMetadata.async !== true && functionMetadata.generator !== true;
-};
-const findBindingVariable = (analysis, bindingIdentifier) => {
-	for (const scope of analysis.scopeManager.scopes) for (const variable of scope.variables) if (variable.identifiers.includes(bindingIdentifier)) return variable;
-	return null;
-};
-const getImmutableFunctionVariable = (analysis, componentFunction, functionNode) => {
-	if (!isSynchronousFunction(functionNode) || !isAstDescendant(functionNode, componentFunction)) return null;
-	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
-	if (!bindingIdentifier) return null;
-	const variable = findBindingVariable(analysis, bindingIdentifier);
-	if (!variable || variable.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
-	const definition = variable.defs[0];
-	if (definition.type === "FunctionName") return definition.node === functionNode ? variable : null;
-	if (definition.type !== "Variable") return null;
-	const declarator = definition.node;
-	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.parent, "VariableDeclaration") || declarator.parent.kind !== "const") return null;
-	if (declarator.init === functionNode) return variable;
-	if (isNodeOfType(declarator.init, "CallExpression") && declarator.init.arguments?.[0] === functionNode && isGenuineReactHookDeclarator(analysis, declarator, "useCallback")) return variable;
-	return null;
-};
-const getJsxEventValueAttribute = (identifier) => {
-	const expression = findTransparentExpressionRoot(identifier);
-	const expressionContainer = expression.parent;
-	if (!isNodeOfType(expressionContainer, "JSXExpressionContainer") || expressionContainer.expression !== expression) return null;
-	const attribute = expressionContainer.parent;
-	if (!isNodeOfType(attribute, "JSXAttribute")) return null;
-	const attributeName = getJsxAttributeName(attribute.name);
-	return attributeName && isEventHandlerName(attributeName) ? attribute : null;
-};
-const getInlineJsxEventCallbackAttribute = (callExpression) => {
-	const callbackFunction = findEnclosingFunction$1(callExpression);
-	if (!callbackFunction || !isSynchronousFunction(callbackFunction)) return null;
-	return getJsxEventValueAttribute(callbackFunction);
-};
-const isReactHookDependencyReference = (identifier) => {
-	const expression = findTransparentExpressionRoot(identifier);
-	const dependencyArray = expression.parent;
-	if (!isNodeOfType(dependencyArray, "ArrayExpression") || !(dependencyArray.elements ?? []).includes(expression)) return false;
-	const hookCall = dependencyArray.parent;
-	if (!isNodeOfType(hookCall, "CallExpression") || hookCall.arguments?.[1] !== dependencyArray) return false;
-	const callee = hookCall.callee;
-	if (isNodeOfType(callee, "Identifier")) return /^use[A-Z0-9]/.test(callee.name);
-	return Boolean(isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && /^use[A-Z0-9]/.test(callee.property.name));
-};
-const hasReachableJsxEventCallPath = (analysis, context, componentFunction, functionVariable, visitedVariables) => {
-	if (visitedVariables.has(functionVariable)) return false;
-	const nextVisitedVariables = new Set(visitedVariables).add(functionVariable);
-	const callExpressions = [];
-	let hasDirectJsxEventReference = false;
-	for (const reference of functionVariable.references) {
-		if (reference.init) continue;
-		const identifier = reference.identifier;
-		if (reference.isWrite()) return false;
-		const jsxEventValueAttribute = getJsxEventValueAttribute(identifier);
-		if (jsxEventValueAttribute) {
-			if (isNodeReachableWithinFunction(jsxEventValueAttribute, context)) hasDirectJsxEventReference = true;
-			continue;
-		}
-		if (isReactHookDependencyReference(identifier)) continue;
-		const callExpression = getCallExpr(reference);
-		if (!callExpression) return false;
-		const jsxEventCallbackAttribute = getInlineJsxEventCallbackAttribute(callExpression);
-		if (jsxEventCallbackAttribute) {
-			if (isNodeReachableWithinFunction(callExpression, context) && isNodeReachableWithinFunction(jsxEventCallbackAttribute, context)) hasDirectJsxEventReference = true;
-			continue;
-		}
-		callExpressions.push(callExpression);
-	}
-	if (hasDirectJsxEventReference) return true;
-	for (const callExpression of callExpressions) {
-		if (!isNodeReachableWithinFunction(callExpression, context)) continue;
-		const callerFunction = findEnclosingFunction$1(callExpression);
-		if (!callerFunction || callerFunction === componentFunction) continue;
-		const callerVariable = getImmutableFunctionVariable(analysis, componentFunction, callerFunction);
-		if (callerVariable && hasReachableJsxEventCallPath(analysis, context, componentFunction, callerVariable, nextVisitedVariables)) return true;
-	}
-	return false;
-};
-const hasUserInputSetterWriter = (analysis, context, setterRef, effectNode, includeDeferredWriters = false) => {
+const hasUserInputSetterWriter = (setterRef, effectNode, includeDeferredWriters = false) => {
 	if (!setterRef.resolved) return false;
 	const componentFunction = findEnclosingFunction$1(effectNode);
 	if (!componentFunction) return false;
@@ -30753,11 +30670,6 @@ const hasUserInputSetterWriter = (analysis, context, setterRef, effectNode, incl
 		const identifier = reference.identifier;
 		if (isAstDescendant(identifier, effectNode)) continue;
 		if (isIndependentWriterIdentifier(componentFunction, identifier, includeDeferredWriters)) return true;
-		if (!isNodeReachableWithinFunction(identifier, context)) continue;
-		const writerFunction = findEnclosingFunction$1(identifier);
-		if (!writerFunction || writerFunction === componentFunction) continue;
-		const writerVariable = getImmutableFunctionVariable(analysis, componentFunction, writerFunction);
-		if (writerVariable && hasReachableJsxEventCallPath(analysis, context, componentFunction, writerVariable, /* @__PURE__ */ new Set())) return true;
 	}
 	return false;
 };
@@ -31647,7 +31559,7 @@ const areInMutuallyExclusiveBranches = (leftNode, rightNode) => {
 	}
 	return false;
 };
-const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFilename) => {
+const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) => {
 	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode, currentFilename);
 	if (frames.length === 0) return [];
 	const effectHasCleanup = hasCleanup(analysis, effectNode);
@@ -31677,7 +31589,7 @@ const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFile
 			for (const returnedExpression of returnedExpressions) mergeEvidence(valueEvidence, collectValueEvidence(analysis, returnedExpression, updaterFrame, remainingValueCallFrames));
 		} else valueEvidence = collectValueEvidence(analysis, writtenValue, frame, remainingValueCallFrames);
 		const sourceReferences = [...valueEvidence.sourceReferences].filter((sourceReference) => getUseStateDecl(analysis, sourceReference) !== stateDeclarator);
-		const hasIndependentWriter = hasUserInputSetterWriter(analysis, context, setterReference, effectNode, true);
+		const hasIndependentWriter = hasUserInputSetterWriter(setterReference, effectNode, true);
 		const doesMatchStateInitializer = matchesStateInitializer(analysis, callExpression, stateDeclarator);
 		if (effectHasCleanup && (frame.isDeferred || valueEvidence.hasUnknownSource || valueEvidence.hasDeferredIntroducedValue || valueEvidence.readsExternalValue)) cleanupManagedStateDeclarators.add(stateDeclarator);
 		const isRenderKnownCopy = sourceReferences.length > 0 && !frame.isDeferred && !valueEvidence.hasUnknownSource && !valueEvidence.hasDeferredIntroducedValue && !valueEvidence.readsExternalValue && !hasIndependentWriter;
@@ -31718,7 +31630,7 @@ 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)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			context.report({
 				node: fact.callExpression,
@@ -36292,7 +36204,7 @@ const noDerivedState = defineRule({
 				if (!isUseEffect(node)) return;
 				const analysis = getProgramAnalysis(node);
 				if (!analysis) return;
-				for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
+				for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 					if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 					reportStateWrite(fact.callExpression, fact.stateDeclarator);
 				}
@@ -36312,7 +36224,7 @@ const noDerivedStateEffect = defineRule({
 		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, context, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
 		context.report({
 			node,
 			message: "You pay an extra render for state you can derive from other values."
@@ -41482,7 +41394,7 @@ const noInitializeState = defineRule({
 		if (!dependencies || !isNodeOfType(dependencies, "ArrayExpression") || (dependencies.elements ?? []).length !== 0) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.matchesStateInitializer || fact.resetsSourceState) continue;
 			const stateName = getStateName(fact.stateDeclarator);
 			context.report({
@@ -57047,39 +56959,8 @@ const isUseStateSetterInScope = (node, setterName) => isHookBindingInScope(node,
 	destructureIndex: 1
 });
 //#endregion
-//#region src/plugin/utils/unwrap-return-expression.ts
-const unwrapReturnExpression = (node) => isNodeOfType(node, "ReturnStatement") && node.argument ? node.argument : node;
-//#endregion
 //#region src/plugin/rules/performance/rendering-hydration-no-flicker.ts
 const USE_EFFECT_ONLY = new Set(["useEffect"]);
-const USE_CALLBACK_ONLY = new Set(["useCallback"]);
-const USE_STATE_ONLY = new Set(["useState"]);
-const REACT_API_CALL_OPTIONS = {
-	allowGlobalReactNamespace: true,
-	allowUnboundBareCalls: true,
-	resolveNamedAliases: true
-};
-const expressionReadsDerivedSymbol = (context, expression, stateDerivedSymbolIds) => {
-	let readsDerivedSymbol = false;
-	walkAst(expression, (node) => {
-		if (readsDerivedSymbol) return false;
-		if (node !== expression && isFunctionLike$1(node)) return false;
-		if (isNodeOfType(node, "Identifier") && stateDerivedSymbolIds.has(context.scopes.symbolFor(node)?.id ?? -1)) readsDerivedSymbol = true;
-	});
-	return readsDerivedSymbol;
-};
-const getStaticObjectPropertyName = (property) => {
-	if (!isNodeOfType(property, "Property") || property.computed || property.method || property.kind !== "init") return null;
-	if (isNodeOfType(property.key, "Identifier")) return property.key.name;
-	if (isNodeOfType(property.key, "Literal") && (typeof property.key.value === "string" || typeof property.key.value === "number")) return String(property.key.value);
-	return null;
-};
-const isNonVisibleJsxSpreadProperty = (propertyName) => propertyName === "id" || propertyName.startsWith("aria-") || /^on[A-Z]/.test(propertyName);
-const isTransparentAssignmentTarget = (identifier) => {
-	const expressionRoot = findTransparentExpressionRoot(identifier);
-	const parent = expressionRoot.parent;
-	return Boolean(isNodeOfType(parent, "AssignmentExpression") && parent.left === expressionRoot || isNodeOfType(parent, "UpdateExpression") && parent.argument === expressionRoot || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expressionRoot);
-};
 const argumentsReadRefCurrent = (callArguments) => callArguments.some((argument) => {
 	let readsCurrent = false;
 	walkAst(argument, (child) => {
@@ -57131,166 +57012,6 @@ const isStateUsedOnlyInIdOrAriaAttributes = (setterCall, setterName) => {
 	});
 	return referenceCount > 0 && !nonAriaReferenceFound;
 };
-const isGlobalWindowMember = (context, node, propertyName) => {
-	const member = stripParenExpression(node);
-	if (!isNodeOfType(member, "MemberExpression") || member.computed) return false;
-	const receiver = stripParenExpression(member.object);
-	return isNodeOfType(receiver, "Identifier") && receiver.name === "window" && context.scopes.isGlobalReference(receiver) && isNodeOfType(member.property, "Identifier") && member.property.name === propertyName;
-};
-const getDirectWindowWidthSetter = (context, statement) => {
-	const call = unwrapDiscardedExpression(statement);
-	if (!isNodeOfType(call, "CallExpression") || call.arguments?.length !== 1) return null;
-	if (!isNodeOfType(call.callee, "Identifier") || !isSetterCall(call)) return null;
-	const argument = call.arguments[0];
-	return isGlobalWindowMember(context, argument, "innerWidth") ? call : null;
-};
-const getResizeListenerHandler = (context, statement, methodName) => {
-	const call = unwrapDiscardedExpression(statement);
-	if (!isNodeOfType(call, "CallExpression") || call.arguments?.length !== 2) return null;
-	if (!isGlobalWindowMember(context, call.callee, methodName)) return null;
-	const eventName = call.arguments[0];
-	const handler = call.arguments[1];
-	if (!isNodeOfType(eventName, "Literal") || eventName.value !== "resize") return null;
-	return isNodeOfType(handler, "Identifier") ? handler : null;
-};
-const getCleanupResizeHandler = (context, statement) => {
-	if (!isNodeOfType(statement, "ReturnStatement") || !isFunctionLike$1(statement.argument)) return null;
-	const cleanupStatements = getCallbackStatements(statement.argument);
-	if (cleanupStatements.length !== 1) return null;
-	return getResizeListenerHandler(context, unwrapReturnExpression(cleanupStatements[0]), "removeEventListener");
-};
-const findExactViewportState = (context, componentFunction, setterCall) => {
-	if (!isFunctionLike$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
-	const componentBody = componentFunction.body;
-	if (!isNodeOfType(setterCall.callee, "Identifier")) return null;
-	const setterSymbol = context.scopes.symbolFor(setterCall.callee);
-	if (!setterSymbol || setterSymbol.kind !== "const" || !isNodeOfType(setterSymbol.declarationNode, "VariableDeclarator")) return null;
-	const declarator = setterSymbol.declarationNode;
-	if (!isNodeOfType(declarator.id, "ArrayPattern")) return null;
-	const stateIdentifier = declarator.id.elements?.[0];
-	const setterIdentifier = declarator.id.elements?.[1];
-	if (!isNodeOfType(stateIdentifier, "Identifier") || !isNodeOfType(setterIdentifier, "Identifier") || setterIdentifier !== setterSymbol.bindingIdentifier || !isNodeOfType(declarator.init, "CallExpression") || !isReactApiCall(declarator.init, USE_STATE_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) return null;
-	const initializer = declarator.init.arguments?.[0];
-	if (!isNodeOfType(initializer, "Literal") || initializer.value !== 0) return null;
-	const stateSymbol = context.scopes.symbolFor(stateIdentifier);
-	if (!stateSymbol) return null;
-	const stateDerivedSymbolIds = new Set([stateSymbol.id]);
-	let didAddDerivedSymbol = true;
-	while (didAddDerivedSymbol) {
-		didAddDerivedSymbol = false;
-		for (const statement of componentBody.body ?? []) {
-			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-			for (const candidateDeclarator of statement.declarations ?? []) {
-				if (!isNodeOfType(candidateDeclarator.id, "Identifier") || !candidateDeclarator.init) continue;
-				const candidateInitializer = stripParenExpression(candidateDeclarator.init);
-				if (isFunctionLike$1(candidateInitializer) || isNodeOfType(candidateInitializer, "CallExpression") && isReactApiCall(candidateInitializer, USE_CALLBACK_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) continue;
-				if (!expressionReadsDerivedSymbol(context, candidateInitializer, stateDerivedSymbolIds)) continue;
-				const candidateSymbol = context.scopes.symbolFor(candidateDeclarator.id);
-				if (candidateSymbol?.kind === "const" && candidateSymbol.references.every((reference) => reference.flag === "read" && !isTransparentAssignmentTarget(reference.identifier)) && !stateDerivedSymbolIds.has(candidateSymbol.id)) {
-					stateDerivedSymbolIds.add(candidateSymbol.id);
-					didAddDerivedSymbol = true;
-				}
-			}
-		}
-	}
-	const staticSpreadVisibilityBySymbolId = /* @__PURE__ */ new Map();
-	const hasOnlyStaticObjectReferences = (identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-		const symbol = context.scopes.symbolFor(identifier);
-		if (!symbol) return false;
-		if (visitedSymbolIds.has(symbol.id)) return true;
-		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-		nextVisitedSymbolIds.add(symbol.id);
-		let hasUnknownReference = false;
-		walkAst(componentBody, (node) => {
-			if (hasUnknownReference || !isNodeOfType(node, "Identifier") || context.scopes.symbolFor(node)?.id !== symbol.id || node === symbol.bindingIdentifier) return;
-			const referenceRoot = findTransparentExpressionRoot(node);
-			const parent = referenceRoot.parent;
-			if (isNodeOfType(parent, "JSXSpreadAttribute") && parent.argument === referenceRoot) return;
-			if (isNodeOfType(parent, "VariableDeclarator") && parent.init === referenceRoot && isNodeOfType(parent.id, "Identifier") && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const" && hasOnlyStaticObjectReferences(parent.id, nextVisitedSymbolIds)) return;
-			hasUnknownReference = true;
-			return false;
-		});
-		return !hasUnknownReference;
-	};
-	const classifyStaticSpreadObject = (identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-		const symbol = context.scopes.symbolFor(identifier);
-		if (!symbol || visitedSymbolIds.has(symbol.id)) return "unknown";
-		const cachedVisibility = staticSpreadVisibilityBySymbolId.get(symbol.id);
-		if (cachedVisibility) return cachedVisibility;
-		if (symbol.kind !== "const" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || symbol.declarationNode.id !== symbol.bindingIdentifier || !symbol.declarationNode.init) return "unknown";
-		if (!hasOnlyStaticObjectReferences(identifier)) return "unknown";
-		const initializer = stripParenExpression(symbol.declarationNode.init);
-		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-		nextVisitedSymbolIds.add(symbol.id);
-		if (isNodeOfType(initializer, "Identifier")) {
-			const visibility = classifyStaticSpreadObject(initializer, nextVisitedSymbolIds);
-			staticSpreadVisibilityBySymbolId.set(symbol.id, visibility);
-			return visibility;
-		}
-		if (!isNodeOfType(initializer, "ObjectExpression")) return "unknown";
-		let visibility = "non-visible";
-		for (const property of initializer.properties ?? []) {
-			const propertyName = getStaticObjectPropertyName(property);
-			if (!isNodeOfType(property, "Property") || !propertyName) {
-				visibility = "unknown";
-				break;
-			}
-			if (expressionReadsDerivedSymbol(context, property.value, stateDerivedSymbolIds) && !isNonVisibleJsxSpreadProperty(propertyName)) visibility = "visible";
-		}
-		staticSpreadVisibilityBySymbolId.set(symbol.id, visibility);
-		return visibility;
-	};
-	let hasNonAriaReference = false;
-	walkAst(componentBody, (node) => {
-		if (hasNonAriaReference) return false;
-		if (!isNodeOfType(node, "Identifier") || !stateDerivedSymbolIds.has(context.scopes.symbolFor(node)?.id ?? -1)) return;
-		if (findEnclosingFunction$1(node) !== componentFunction) return;
-		const parent = node.parent;
-		if (parent && (isNodeOfType(parent, "MemberExpression") && parent.property === node && !parent.computed || isNodeOfType(parent, "Property") && parent.key === node && !parent.computed)) return;
-		let cursor = parent;
-		while (cursor && cursor !== componentBody) {
-			if (isFunctionLike$1(cursor)) return;
-			if (isNodeOfType(cursor, "JSXSpreadAttribute")) {
-				if (isNodeOfType(node, "Identifier") && classifyStaticSpreadObject(node) === "visible") hasNonAriaReference = true;
-				return;
-			}
-			if (isNodeOfType(cursor, "JSXAttribute")) {
-				if (isEventHandlerAttribute(cursor)) return;
-				if (!isInsideIdOrAriaAttribute(node)) hasNonAriaReference = true;
-				return;
-			}
-			if (isNodeOfType(cursor, "ReturnStatement")) {
-				hasNonAriaReference = true;
-				return;
-			}
-			cursor = cursor.parent;
-		}
-	});
-	return hasNonAriaReference ? stateIdentifier.name : null;
-};
-const isExactViewportSubscriptionEffect = (context, effectCall, callback) => {
-	if (!isReactApiCall(effectCall, USE_EFFECT_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) return false;
-	if (!isFunctionLike$1(callback) || callback.async || !isNodeOfType(callback.body, "BlockStatement")) return false;
-	const statements = getCallbackStatements(callback);
-	if (statements.length !== 4) return false;
-	const handlerDeclaration = statements[0];
-	if (!isNodeOfType(handlerDeclaration, "VariableDeclaration") || handlerDeclaration.kind !== "const" || handlerDeclaration.declarations?.length !== 1) return false;
-	const handlerDeclarator = handlerDeclaration.declarations[0];
-	if (!isNodeOfType(handlerDeclarator.id, "Identifier") || !isFunctionLike$1(handlerDeclarator.init)) return false;
-	const handlerStatements = getCallbackStatements(handlerDeclarator.init);
-	if (handlerStatements.length !== 1) return false;
-	const handlerSetter = getDirectWindowWidthSetter(context, unwrapReturnExpression(handlerStatements[0]));
-	const subscribedHandler = getResizeListenerHandler(context, statements[1], "addEventListener");
-	const immediateSetter = getDirectWindowWidthSetter(context, statements[2]);
-	const cleanupHandler = getCleanupResizeHandler(context, statements[3]);
-	if (!handlerSetter || !subscribedHandler || !immediateSetter || !cleanupHandler) return false;
-	const handlerSymbol = context.scopes.symbolFor(handlerDeclarator.id);
-	if (!handlerSymbol || context.scopes.symbolFor(subscribedHandler) !== handlerSymbol || context.scopes.symbolFor(cleanupHandler) !== handlerSymbol) return false;
-	if (!isNodeOfType(handlerSetter.callee, "Identifier") || !isNodeOfType(immediateSetter.callee, "Identifier") || context.scopes.symbolFor(handlerSetter.callee) !== context.scopes.symbolFor(immediateSetter.callee)) return false;
-	const componentFunction = findEnclosingFunction$1(effectCall);
-	if (!isFunctionLike$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return false;
-	return findExactViewportState(context, componentFunction, immediateSetter) !== null;
-};
 const renderingHydrationNoFlicker = defineRule({
 	id: "rendering-hydration-no-flicker",
 	title: "useEffect setState flashes on mount",
@@ -57303,14 +57024,7 @@ const renderingHydrationNoFlicker = defineRule({
 		if (!isNodeOfType(depsNode, "ArrayExpression") || depsNode.elements?.length !== 0) return;
 		const callback = getEffectCallback(node);
 		if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
-		if (isExactViewportSubscriptionEffect(context, node, callback)) {
-			context.report({
-				node,
-				message: "This flashes for your users because useEffect(setState, []) runs after the first paint, so use useSyncExternalStore, or add suppressHydrationWarning"
-			});
-			return;
-		}
-		const bodyStatements = getCallbackStatements(callback);
+		const bodyStatements = (isNodeOfType(callback.body, "BlockStatement") ? callback.body.body ?? [] : [callback.body]).filter((statement) => !isNoOpStatement(statement));
 		if (bodyStatements.length !== 1) return;
 		const soleStatement = bodyStatements[0];
 		if (!isNodeOfType(soleStatement, "ExpressionStatement")) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.9-dev.2979a9b",
+  "version": "0.7.9-dev.2ba83c3",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",