oxlint-plugin-react-doctor 0.7.8-dev.4829841 → 0.7.8-dev.ece35b3

package/dist/index.js

@@ -22317,7 +22317,7 @@ const isReactSlotType = (typeNode, environment, activeDeclarations) => {
 	}
 	return environment.reactSlotTypeBindings.has(typeName);
 };
-const getPropertyName$1 = (property) => {
+const getPropertyName = (property) => {
 	if (!isNodeOfType(property, "TSPropertySignature") || property.computed) return null;
 	if (isNodeOfType(property.key, "Identifier")) return property.key.name;
 	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
@@ -22329,7 +22329,7 @@ const collectSlotPropertyNames = (propsType, environment, slotPropertyNames, act
 	if (isNodeOfType(propsType, "TSInterfaceDeclaration")) members = propsType.body.body;
 	if (members) {
 		for (const member of members) {
-			const propertyName = getPropertyName$1(member);
+			const propertyName = getPropertyName(member);
 			if (!propertyName || !isNodeOfType(member, "TSPropertySignature")) continue;
 			const annotation = member.typeAnnotation;
 			if (annotation && isNodeOfType(annotation, "TSTypeAnnotation") && isReactSlotType(annotation.typeAnnotation, environment, /* @__PURE__ */ new Set())) slotPropertyNames.add(propertyName);
@@ -42992,31 +42992,6 @@ const noRenderReturnValue = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.ts
-const SYNCHRONOUS_ARRAY_CALLBACK_METHOD_NAMES = new Set([
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"flatMap",
-	"forEach",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some"
-]);
-const createConstantFormula = (constantValue) => ({
-	kind: "constant",
-	constantValue
-});
-const createNotFormula = (formula) => ({
-	kind: "not",
-	left: formula
-});
-const createBinaryFormula = (kind, left, right) => ({
-	kind,
-	left,
-	right
-});
 const isUndefinedNode = (node) => {
 	if (node === null || node === void 0) return true;
 	return isNodeOfType(node, "Identifier") && node.name === "undefined";
@@ -43078,232 +43053,6 @@ const getLivePropExpressionIdentity = (analysis, context, node, visitedSymbolIds
 	}
 	return null;
 };
-const getLivePropAtomKey = (identity) => `prop:${identity.propSymbolId}:${JSON.stringify(identity.memberPath)}:${identity.booleanNormalization}`;
-const getBooleanFormula$1 = (analysis, context, node, protectedSymbolIds, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "Literal")) return createConstantFormula(Boolean(expression.value));
-	if (isNodeOfType(expression, "Identifier")) {
-		if (expression.name === "undefined" && context.scopes.isGlobalReference(expression)) return createConstantFormula(false);
-		const symbol = context.scopes.symbolFor(expression);
-		if (!symbol) return null;
-		if (!protectedSymbolIds.has(symbol.id) && symbol.kind === "const" && !visitedSymbolIds.has(symbol.id) && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier) {
-			const initializer = getDirectConstInitializer(symbol);
-			if (initializer) {
-				visitedSymbolIds.add(symbol.id);
-				const initializerFormula = getBooleanFormula$1(analysis, context, initializer, protectedSymbolIds, visitedSymbolIds);
-				if (initializerFormula) return initializerFormula;
-			}
-		}
-		return {
-			kind: "atom",
-			atomKey: `symbol:${symbol.id}`
-		};
-	}
-	if (isNodeOfType(expression, "MemberExpression")) {
-		const identity = getLivePropExpressionIdentity(analysis, context, expression);
-		return identity ? {
-			kind: "atom",
-			atomKey: getLivePropAtomKey(identity)
-		} : null;
-	}
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") {
-		const argumentFormula = getBooleanFormula$1(analysis, context, expression.argument, protectedSymbolIds, visitedSymbolIds);
-		return argumentFormula ? createNotFormula(argumentFormula) : null;
-	}
-	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee) && expression.arguments.length === 1 && !isNodeOfType(expression.arguments[0], "SpreadElement")) return getBooleanFormula$1(analysis, context, expression.arguments[0], protectedSymbolIds, visitedSymbolIds);
-	if (isNodeOfType(expression, "LogicalExpression") && (expression.operator === "&&" || expression.operator === "||")) {
-		const leftFormula = getBooleanFormula$1(analysis, context, expression.left, protectedSymbolIds, new Set(visitedSymbolIds));
-		const rightFormula = getBooleanFormula$1(analysis, context, expression.right, protectedSymbolIds, new Set(visitedSymbolIds));
-		if (!leftFormula || !rightFormula) return null;
-		return createBinaryFormula(expression.operator === "&&" ? "and" : "or", leftFormula, rightFormula);
-	}
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		const testFormula = getBooleanFormula$1(analysis, context, expression.test, protectedSymbolIds, new Set(visitedSymbolIds));
-		const consequentFormula = getBooleanFormula$1(analysis, context, expression.consequent, protectedSymbolIds, new Set(visitedSymbolIds));
-		const alternateFormula = getBooleanFormula$1(analysis, context, expression.alternate, protectedSymbolIds, new Set(visitedSymbolIds));
-		if (!testFormula || !consequentFormula || !alternateFormula) return null;
-		return createBinaryFormula("or", createBinaryFormula("and", testFormula, consequentFormula), createBinaryFormula("and", createNotFormula(testFormula), alternateFormula));
-	}
-	if (isNodeOfType(expression, "BinaryExpression") && (expression.operator === "===" || expression.operator === "==" || expression.operator === "!==" || expression.operator === "!=")) {
-		const leftIsBoolean = isNodeOfType(expression.left, "Literal") && typeof expression.left.value === "boolean";
-		if (leftIsBoolean === (isNodeOfType(expression.right, "Literal") && typeof expression.right.value === "boolean")) return null;
-		const booleanLiteral = leftIsBoolean ? expression.left : expression.right;
-		const comparedFormula = getBooleanFormula$1(analysis, context, leftIsBoolean ? expression.right : expression.left, protectedSymbolIds, visitedSymbolIds);
-		if (!comparedFormula || !isNodeOfType(booleanLiteral, "Literal")) return null;
-		return (expression.operator === "===" || expression.operator === "==" ? booleanLiteral.value : !booleanLiteral.value) ? comparedFormula : createNotFormula(comparedFormula);
-	}
-	return null;
-};
-const evaluateBooleanFormula$1 = (formula, assignments) => {
-	if (formula.kind === "constant") return formula.constantValue ?? null;
-	if (formula.kind === "atom") return formula.atomKey === void 0 ? null : assignments.get(formula.atomKey) ?? null;
-	if (formula.kind === "not") {
-		if (!formula.left) return null;
-		const value = evaluateBooleanFormula$1(formula.left, assignments);
-		return value === null ? null : !value;
-	}
-	if (!formula.left || !formula.right) return null;
-	const leftValue = evaluateBooleanFormula$1(formula.left, assignments);
-	const rightValue = evaluateBooleanFormula$1(formula.right, assignments);
-	if (formula.kind === "and") {
-		if (leftValue === false || rightValue === false) return false;
-		return leftValue === true && rightValue === true ? true : null;
-	}
-	if (leftValue === true || rightValue === true) return true;
-	return leftValue === false && rightValue === false ? false : null;
-};
-const assignBooleanFact = (facts, atomKey, value) => {
-	const existingValue = facts.assignments.get(atomKey);
-	if (existingValue === void 0) {
-		facts.assignments.set(atomKey, value);
-		facts.didChange = true;
-	} else if (existingValue !== value) facts.didConflict = true;
-};
-const addRequiredBooleanFacts = (formula, expectedValue, facts) => {
-	const existingValue = evaluateBooleanFormula$1(formula, facts.assignments);
-	if (existingValue !== null) {
-		if (existingValue !== expectedValue) facts.didConflict = true;
-		return;
-	}
-	if (formula.kind === "atom" && formula.atomKey !== void 0) {
-		assignBooleanFact(facts, formula.atomKey, expectedValue);
-		return;
-	}
-	if (formula.kind === "not" && formula.left) {
-		addRequiredBooleanFacts(formula.left, !expectedValue, facts);
-		return;
-	}
-	if (!formula.left || !formula.right) return;
-	if (formula.kind === "and") {
-		if (expectedValue) {
-			addRequiredBooleanFacts(formula.left, true, facts);
-			addRequiredBooleanFacts(formula.right, true, facts);
-			return;
-		}
-		const leftValue = evaluateBooleanFormula$1(formula.left, facts.assignments);
-		const rightValue = evaluateBooleanFormula$1(formula.right, facts.assignments);
-		if (leftValue === true) addRequiredBooleanFacts(formula.right, false, facts);
-		if (rightValue === true) addRequiredBooleanFacts(formula.left, false, facts);
-		return;
-	}
-	if (!expectedValue) {
-		addRequiredBooleanFacts(formula.left, false, facts);
-		addRequiredBooleanFacts(formula.right, false, facts);
-		return;
-	}
-	const leftValue = evaluateBooleanFormula$1(formula.left, facts.assignments);
-	const rightValue = evaluateBooleanFormula$1(formula.right, facts.assignments);
-	if (leftValue === false) addRequiredBooleanFacts(formula.right, true, facts);
-	if (rightValue === false) addRequiredBooleanFacts(formula.left, true, facts);
-};
-const doConditionsImplyFormula = (conditions, target) => {
-	const facts = {
-		assignments: /* @__PURE__ */ new Map(),
-		didConflict: false,
-		didChange: true
-	};
-	while (facts.didChange && !facts.didConflict) {
-		facts.didChange = false;
-		for (const condition of conditions) addRequiredBooleanFacts(condition, true, facts);
-	}
-	return facts.didConflict || evaluateBooleanFormula$1(target, facts.assignments) === true;
-};
-const getFunctionBindingSymbol = (functionNode, scopes) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.id) return scopes.symbolFor(functionNode.id);
-	const parent = functionNode.parent;
-	if ((isNodeOfType(functionNode, "ArrowFunctionExpression") || isNodeOfType(functionNode, "FunctionExpression")) && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return scopes.symbolFor(parent.id);
-	return null;
-};
-const getComponentFunctionNode = (containingNode) => {
-	if (isFunctionLike$1(containingNode)) return containingNode;
-	if (!isNodeOfType(containingNode, "VariableDeclarator") || !containingNode.init) return null;
-	const initializer = stripParenExpression(containingNode.init);
-	if (isFunctionLike$1(initializer)) return initializer;
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	const firstArgument = initializer.arguments[0];
-	return firstArgument && !isNodeOfType(firstArgument, "SpreadElement") && isFunctionLike$1(firstArgument) ? firstArgument : null;
-};
-const isReferenceDirectlyCalled = (identifier) => {
-	const unwrappedIdentifier = stripParenExpression(identifier);
-	const parent = unwrappedIdentifier.parent;
-	return isNodeOfType(parent, "CallExpression") && parent.callee === unwrappedIdentifier ? parent : null;
-};
-const getSynchronousCallbackCall = (functionNode) => {
-	const callExpression = functionNode.parent;
-	if (!isNodeOfType(callExpression, "CallExpression") || !callExpression.arguments.some((argument) => argument === functionNode) || !isNodeOfType(callExpression.callee, "MemberExpression")) return null;
-	const methodName = getStaticMemberPropertyName(callExpression.callee);
-	return methodName && SYNCHRONOUS_ARRAY_CALLBACK_METHOD_NAMES.has(methodName) ? callExpression : null;
-};
-const isNodeEvaluatedDuringRender = (node, componentNode, scopes, visitedFunctionSymbolIds = /* @__PURE__ */ new Set()) => {
-	const functionNode = findEnclosingFunction$1(node);
-	if (!functionNode) return false;
-	if (functionNode === componentNode) return true;
-	const synchronousCallbackCall = getSynchronousCallbackCall(functionNode);
-	if (synchronousCallbackCall) return isNodeEvaluatedDuringRender(synchronousCallbackCall, componentNode, scopes, visitedFunctionSymbolIds);
-	if (executesDuringRender(functionNode, scopes)) return isNodeEvaluatedDuringRender(functionNode.parent ?? functionNode, componentNode, scopes, visitedFunctionSymbolIds);
-	const functionSymbol = getFunctionBindingSymbol(functionNode, scopes);
-	if (!functionSymbol || visitedFunctionSymbolIds.has(functionSymbol.id)) return false;
-	visitedFunctionSymbolIds.add(functionSymbol.id);
-	let callCount = 0;
-	for (const reference of functionSymbol.references) {
-		const callExpression = isReferenceDirectlyCalled(reference.identifier);
-		if (!callExpression) return false;
-		if (!isNodeEvaluatedDuringRender(callExpression, componentNode, scopes, new Set(visitedFunctionSymbolIds))) return false;
-		callCount += 1;
-	}
-	return callCount > 0;
-};
-const isInlineJsxCallback = (functionNode) => {
-	let ancestor = functionNode.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "JSXAttribute")) return true;
-		if (isFunctionLike$1(ancestor) || isNodeOfType(ancestor, "Program")) return false;
-		ancestor = ancestor.parent;
-	}
-	return false;
-};
-const collectExposureConditions = (analysis, context, node, componentNode, protectedSymbolIds) => {
-	const conditions = [];
-	let child = node;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) {
-			const leftFormula = getBooleanFormula$1(analysis, context, parent.left, protectedSymbolIds);
-			if (leftFormula && parent.operator === "&&") conditions.push(leftFormula);
-			if (leftFormula && parent.operator === "||") conditions.push(createNotFormula(leftFormula));
-		} else if (isNodeOfType(parent, "ConditionalExpression")) {
-			const testFormula = getBooleanFormula$1(analysis, context, parent.test, protectedSymbolIds);
-			if (testFormula && parent.consequent === child) conditions.push(testFormula);
-			if (testFormula && parent.alternate === child) conditions.push(createNotFormula(testFormula));
-		} else if (isNodeOfType(parent, "IfStatement")) {
-			const testFormula = getBooleanFormula$1(analysis, context, parent.test, protectedSymbolIds);
-			if (testFormula && parent.consequent === child) conditions.push(testFormula);
-			if (testFormula && parent.alternate === child) conditions.push(createNotFormula(testFormula));
-		}
-		if (parent === componentNode) break;
-		if (isFunctionLike$1(parent) && parent !== componentNode && !isInlineJsxCallback(parent)) {
-			const synchronousCallbackCall = getSynchronousCallbackCall(parent);
-			if (synchronousCallbackCall) {
-				child = synchronousCallbackCall;
-				parent = synchronousCallbackCall.parent;
-				continue;
-			}
-			const functionSymbol = getFunctionBindingSymbol(parent, context.scopes);
-			if (functionSymbol?.references.length === 1) {
-				const callExpression = isReferenceDirectlyCalled(functionSymbol.references[0].identifier);
-				if (callExpression) {
-					child = callExpression;
-					parent = callExpression.parent;
-					continue;
-				}
-			}
-			break;
-		}
-		child = parent;
-		parent = parent.parent;
-	}
-	return conditions;
-};
 const isMountSnapshotInitializer = (context, node) => {
 	if (!isReactApiCall(node, "useMemo", context.scopes, { resolveNamedAliases: true }) || !isNodeOfType(node, "CallExpression")) return false;
 	const dependencies = node.arguments?.[1];
@@ -43379,158 +43128,6 @@ const countUseStates = (analysis, componentNode) => {
 	for (const ref of getDownstreamRefs(analysis, componentNode)) if (isState(analysis, ref)) stateVariables.add(ref.resolved);
 	return stateVariables.size;
 };
-const getStateSymbolForSetter = (analysis, context, setterReference) => {
-	const useStateDeclaration = getUseStateDecl(analysis, setterReference);
-	if (!useStateDeclaration || !isNodeOfType(useStateDeclaration, "VariableDeclarator") || !isNodeOfType(useStateDeclaration.id, "ArrayPattern")) return null;
-	const stateBinding = useStateDeclaration.id.elements[0];
-	return stateBinding && isNodeOfType(stateBinding, "Identifier") ? context.scopes.symbolFor(stateBinding) : null;
-};
-const getPropertyName = (node) => {
-	if (isNodeOfType(node, "Identifier")) return node.name;
-	return isNodeOfType(node, "Literal") && typeof node.value === "string" ? node.value : null;
-};
-const isBooleanTypeNode = (node) => {
-	if (!node) return false;
-	if (isNodeOfType(node, "TSBooleanKeyword")) return true;
-	if (!isNodeOfType(node, "TSUnionType")) return false;
-	return node.types.every((typeNode) => isNodeOfType(typeNode, "TSBooleanKeyword") || isNodeOfType(typeNode, "TSUndefinedKeyword") || isNodeOfType(typeNode, "TSNullKeyword"));
-};
-const getBooleanPropertyType = (typeNode, propertyName, referenceNode) => {
-	const unwrappedType = isNodeOfType(typeNode, "TSTypeAnnotation") ? typeNode.typeAnnotation : typeNode;
-	if (isNodeOfType(unwrappedType, "TSTypeLiteral")) return unwrappedType.members.some((member) => isNodeOfType(member, "TSPropertySignature") && getPropertyName(member.key) === propertyName && isBooleanTypeNode(member.typeAnnotation?.typeAnnotation));
-	if (!isNodeOfType(unwrappedType, "TSTypeReference") || !isNodeOfType(unwrappedType.typeName, "Identifier")) return false;
-	const typeName = unwrappedType.typeName.name;
-	if (hasEnclosingTypeParameterNamed(referenceNode, typeName)) return false;
-	const programNode = findProgramNode(referenceNode);
-	if (!isNodeOfType(programNode, "Program")) return false;
-	const matchingInterfaces = programNode.body.flatMap((statement) => {
-		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
-		return isNodeOfType(declaration, "TSInterfaceDeclaration") && declaration.id.name === typeName ? [declaration] : [];
-	});
-	if (matchingInterfaces.length !== 1) return false;
-	let sameNameTypeBindingCount = 0;
-	walkAst(programNode, (candidate) => {
-		const identifier = isNodeOfType(candidate, "TSInterfaceDeclaration") || isNodeOfType(candidate, "TSTypeAliasDeclaration") || isNodeOfType(candidate, "ClassDeclaration") || isNodeOfType(candidate, "ClassExpression") || isNodeOfType(candidate, "TSEnumDeclaration") ? candidate.id : isNodeOfType(candidate, "TSTypeParameter") ? candidate.name : null;
-		if (isNodeOfType(identifier, "Identifier") && identifier.name === typeName) sameNameTypeBindingCount += 1;
-	});
-	if (sameNameTypeBindingCount !== 1) return false;
-	return matchingInterfaces[0].body.body.some((member) => isNodeOfType(member, "TSPropertySignature") && getPropertyName(member.key) === propertyName && isBooleanTypeNode(member.typeAnnotation?.typeAnnotation));
-};
-const findProgramNode = (node) => {
-	let currentNode = node;
-	while (currentNode.parent) currentNode = currentNode.parent;
-	return currentNode;
-};
-const hasBooleanBindingAnnotation = (symbol, identifier) => {
-	const property = symbol.bindingIdentifier.parent;
-	const objectPattern = property?.parent;
-	if (!isNodeOfType(property, "Property") || !isNodeOfType(objectPattern, "ObjectPattern") || !objectPattern.typeAnnotation) return false;
-	const propertyName = getPropertyName(property.key);
-	return Boolean(propertyName && getBooleanPropertyType(objectPattern.typeAnnotation, propertyName, identifier));
-};
-const isBooleanExpression$1 = (context, node, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "Literal")) return typeof expression.value === "boolean";
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") return true;
-	if (isNodeOfType(expression, "BinaryExpression")) return [
-		"==",
-		"===",
-		"!=",
-		"!==",
-		"<",
-		"<=",
-		">",
-		">="
-	].includes(expression.operator);
-	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee)) return true;
-	if (isNodeOfType(expression, "LogicalExpression")) return isBooleanExpression$1(context, expression.left, new Set(visitedSymbolIds)) && isBooleanExpression$1(context, expression.right, new Set(visitedSymbolIds));
-	if (isNodeOfType(expression, "ConditionalExpression")) return isBooleanExpression$1(context, expression.consequent, new Set(visitedSymbolIds)) && isBooleanExpression$1(context, expression.alternate, new Set(visitedSymbolIds));
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = context.scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	if (hasBooleanBindingAnnotation(symbol, expression)) return true;
-	visitedSymbolIds.add(symbol.id);
-	const initializer = getDirectConstInitializer(symbol);
-	return Boolean(initializer && isBooleanExpression$1(context, initializer, visitedSymbolIds));
-};
-const getPropDerivedDependencySymbols = (analysis, context, dependencyReferences) => {
-	const symbolsById = /* @__PURE__ */ new Map();
-	for (const dependencyReference of dependencyReferences) {
-		if (!getUpstreamRefs(analysis, dependencyReference).some((upstreamReference) => isProp(analysis, upstreamReference))) continue;
-		const symbol = context.scopes.symbolFor(dependencyReference.identifier);
-		if (symbol) symbolsById.set(symbol.id, symbol);
-	}
-	return [...symbolsById.values()];
-};
-const getImpliedDependencyValue = (conditions, dependencyFormulas) => {
-	const impliesTrue = dependencyFormulas.some((dependencyFormula) => doConditionsImplyFormula(conditions, dependencyFormula));
-	if (impliesTrue === dependencyFormulas.some((dependencyFormula) => doConditionsImplyFormula(conditions, createNotFormula(dependencyFormula)))) return null;
-	return impliesTrue;
-};
-const getSetterExposureConditions = (analysis, context, setterReference, componentNode, protectedSymbolIds) => {
-	const functionNode = findEnclosingFunction$1(setterReference.identifier);
-	if (!functionNode) return null;
-	if (isInlineJsxCallback(functionNode)) return [collectExposureConditions(analysis, context, functionNode, componentNode, protectedSymbolIds)];
-	const functionSymbol = getFunctionBindingSymbol(functionNode, context.scopes);
-	if (!functionSymbol || functionSymbol.references.length === 0) return null;
-	const conditionsByReference = [];
-	for (const reference of functionSymbol.references) {
-		if (isReferenceDirectlyCalled(reference.identifier)) return null;
-		let ancestor = reference.identifier.parent;
-		while (ancestor && !isNodeOfType(ancestor, "JSXAttribute") && !isFunctionLike$1(ancestor)) ancestor = ancestor.parent;
-		if (!isNodeOfType(ancestor, "JSXAttribute")) return null;
-		conditionsByReference.push(collectExposureConditions(analysis, context, reference.identifier, componentNode, protectedSymbolIds));
-	}
-	return conditionsByReference;
-};
-const areAllSetterWritesVisibilityGuarded = (analysis, context, componentNode, resetSetterReferences, dependencySymbolIds, dependencyFormulas, visibleDependencyValue) => {
-	const resetIdentifiers = new Set(resetSetterReferences.map((setterReference) => setterReference.identifier));
-	const setterVariables = new Set(resetSetterReferences.map((reference) => reference.resolved));
-	for (const setterVariable of setterVariables) {
-		if (!setterVariable) return false;
-		for (const setterReference of setterVariable.references) {
-			if (setterVariable.identifiers.some((identifier) => identifier === setterReference.identifier)) continue;
-			if (resetIdentifiers.has(setterReference.identifier)) continue;
-			if (!getCallExpr(setterReference)) return false;
-			const conditionsByExposure = getSetterExposureConditions(analysis, context, setterReference, componentNode, dependencySymbolIds);
-			if (!conditionsByExposure || conditionsByExposure.some((conditions) => getImpliedDependencyValue(conditions, dependencyFormulas) !== visibleDependencyValue)) return false;
-		}
-	}
-	return true;
-};
-const areAllResetStateReadsHiddenUntilReset = (analysis, context, componentNode, setterReferences, dependencyReferences) => {
-	if (dependencyReferences.length !== 1) return false;
-	const dependencySymbols = getPropDerivedDependencySymbols(analysis, context, dependencyReferences);
-	if (dependencySymbols.length === 0 || dependencySymbols.some((symbol) => !isBooleanExpression$1(context, symbol.bindingIdentifier))) return false;
-	const dependencySymbolIds = new Set(dependencySymbols.map((symbol) => symbol.id));
-	const dependencyFormulas = dependencySymbols.map((symbol) => ({
-		kind: "atom",
-		atomKey: `symbol:${symbol.id}`
-	}));
-	const resetStateSymbolsById = /* @__PURE__ */ new Map();
-	for (const setterReference of setterReferences) {
-		const stateSymbol = getStateSymbolForSetter(analysis, context, setterReference);
-		if (!stateSymbol) return false;
-		resetStateSymbolsById.set(stateSymbol.id, stateSymbol);
-	}
-	let visibleDependencyValue = null;
-	for (const stateSymbol of resetStateSymbolsById.values()) {
-		let exposedReadCount = 0;
-		for (const reference of stateSymbol.references) {
-			if (reference.flag === "write") continue;
-			const isRenderRead = isNodeEvaluatedDuringRender(reference.identifier, componentNode, context.scopes);
-			const functionNode = findEnclosingFunction$1(reference.identifier);
-			if (!isRenderRead && functionNode && !isInlineJsxCallback(functionNode)) return false;
-			const referenceDependencyValue = getImpliedDependencyValue(collectExposureConditions(analysis, context, reference.identifier, componentNode, dependencySymbolIds), dependencyFormulas);
-			if (referenceDependencyValue === null) return false;
-			if (visibleDependencyValue !== null && visibleDependencyValue !== referenceDependencyValue) return false;
-			visibleDependencyValue = referenceDependencyValue;
-			exposedReadCount += 1;
-		}
-		if (exposedReadCount === 0) return false;
-	}
-	return Boolean(resetStateSymbolsById.size > 0 && visibleDependencyValue !== null && areAllSetterWritesVisibilityGuarded(analysis, context, componentNode, setterReferences, dependencySymbolIds, dependencyFormulas, visibleDependencyValue));
-};
 const findPropUsedToResetAllState = (analysis, context, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
 	const stateSetterRefs = effectFnRefs.filter((ref) => isSyncStateSetterCall(analysis, ref, effectFn));
 	if (stateSetterRefs.length === 0) return null;
@@ -43538,8 +43135,6 @@ const findPropUsedToResetAllState = (analysis, context, effectFnRefs, depsRefs,
 	if (stateSetterRefs.every((setterRef) => effectFnRefs.some((otherRef) => otherRef !== setterRef && otherRef.resolved === setterRef.resolved && Boolean(getCallExpr(otherRef)) && !isSyncStateSetterCall(analysis, otherRef, effectFn)))) return null;
 	const containing = findContainingNode(analysis, useEffectNode);
 	if (new Set(stateSetterRefs.map((setterRef) => setterRef.resolved)).size !== countUseStates(analysis, containing)) return null;
-	const componentFunctionNode = containing ? getComponentFunctionNode(containing) : null;
-	if (componentFunctionNode && areAllResetStateReadsHiddenUntilReset(analysis, context, componentFunctionNode, stateSetterRefs, depsRefs)) return null;
 	for (const depRef of depsRefs) for (const upRef of getUpstreamRefs(analysis, depRef)) if (isProp(analysis, upRef)) return upRef;
 	return null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.8-dev.4829841",
+  "version": "0.7.8-dev.ece35b3",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",