oxlint-plugin-react-doctor 0.7.8-dev.ece35b3 → 0.7.9-dev.194cc06

package/dist/index.js

@@ -11674,7 +11674,7 @@ const findRenderPhaseComponentOrHook = (node, scopes) => {
 };
 //#endregion
 //#region src/plugin/utils/get-function-binding-name.ts
-const getFunctionBindingIdentifier = (functionNode) => {
+const getFunctionBindingIdentifier$1 = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
 	const parent = functionNode.parent;
 	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
@@ -11685,7 +11685,7 @@ const getFunctionBindingIdentifier = (functionNode) => {
 	}
 	return null;
 };
-const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(functionNode)?.name ?? null;
+const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier$1(functionNode)?.name ?? null;
 //#endregion
 //#region src/plugin/utils/is-event-handler-attribute.ts
 const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
@@ -12272,7 +12272,7 @@ const findDirectCallForReference = (identifier) => {
 	return isNodeOfType(callNode, "CallExpression") && callNode.callee === expressionRoot ? callNode : null;
 };
 const findSingleDirectInvocation = (functionNode, caller, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier || resolveStableValue(bindingIdentifier, context) !== functionNode) return null;
 	const symbol = context.scopes.symbolFor(bindingIdentifier);
 	if (!symbol) return null;
@@ -12809,7 +12809,7 @@ const isReturnedEffectCleanupFunction = (functionNode) => {
 };
 const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode)) return true;
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) return false;
 	const symbol = context.scopes.symbolFor(bindingIdentifier);
 	if (!symbol) return false;
@@ -13043,7 +13043,7 @@ const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) =
 	return didFindCleanupEffect;
 };
 const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) return false;
 	const visitedSymbolIds = /* @__PURE__ */ new Set();
 	const isSubscribeBinding = (candidateBinding) => {
@@ -21492,7 +21492,7 @@ const namedCallbackIteratorCallCache = /* @__PURE__ */ new WeakMap();
 const findNamedCallbackIteratorCall = (functionNode) => {
 	const cached = namedCallbackIteratorCallCache.get(functionNode);
 	if (cached !== void 0) return cached;
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) {
 		namedCallbackIteratorCallCache.set(functionNode, null);
 		return null;
@@ -22317,7 +22317,7 @@ const isReactSlotType = (typeNode, environment, activeDeclarations) => {
 	}
 	return environment.reactSlotTypeBindings.has(typeName);
 };
-const getPropertyName = (property) => {
+const getPropertyName$1 = (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(member);
+			const propertyName = getPropertyName$1(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);
@@ -31988,17 +31988,611 @@ const noCreateContextInRender = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/collect-function-children-references.ts
+const collectFunctionChildrenReferences = (functionNode, scopes) => {
+	if (!isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "FunctionDeclaration")) return null;
+	const rawPropsParameter = functionNode.params[0];
+	const propsParameter = isNodeOfType(rawPropsParameter, "AssignmentPattern") ? rawPropsParameter.left : rawPropsParameter;
+	if (isNodeOfType(propsParameter, "ObjectPattern")) {
+		const childrenProperty = propsParameter.properties.find((property) => isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "children");
+		if (!childrenProperty || !isNodeOfType(childrenProperty, "Property")) return null;
+		const childrenBinding = isNodeOfType(childrenProperty.value, "AssignmentPattern") ? childrenProperty.value.left : childrenProperty.value;
+		if (!isNodeOfType(childrenBinding, "Identifier")) return null;
+		const childrenSymbol = scopes.symbolFor(childrenBinding);
+		if (!childrenSymbol || childrenSymbol.references.length === 0 || childrenSymbol.references.some((reference) => reference.flag !== "read")) return null;
+		return childrenSymbol.references.map((reference) => reference.identifier);
+	}
+	if (!isNodeOfType(propsParameter, "Identifier")) return null;
+	const propsSymbol = scopes.symbolFor(propsParameter);
+	if (!propsSymbol || propsSymbol.references.length === 0) return null;
+	const childrenReferences = [];
+	for (const reference of propsSymbol.references) {
+		if (reference.flag !== "read") return null;
+		const propertyPath = [];
+		let expression = findTransparentExpressionRoot(reference.identifier);
+		while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) {
+			const propertyName = getStaticPropertyName(expression.parent);
+			if (!propertyName) return null;
+			propertyPath.push(propertyName);
+			expression = findTransparentExpressionRoot(expression.parent);
+		}
+		if (propertyPath[0] !== "children") {
+			if (propertyPath.length === 0) return null;
+			continue;
+		}
+		if (propertyPath.length !== 1) return null;
+		childrenReferences.push(expression);
+	}
+	return childrenReferences.length > 0 ? childrenReferences : null;
+};
+//#endregion
+//#region src/plugin/utils/is-proven-react-class-component.ts
+const REACT_COMPONENT_CLASS_NAMES = new Set(["Component", "PureComponent"]);
+const isReactComponentClassValue = (node, scopes, visitedClassNodes, visitedSymbolIds) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "MemberExpression")) {
+		const propertyName = getStaticPropertyName(expression);
+		const receiver = stripParenExpression(expression.object);
+		return Boolean(propertyName && REACT_COMPONENT_CLASS_NAMES.has(propertyName) && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, expression, scopes) && isReactNamespaceImport(receiver, scopes));
+	}
+	if (isNodeOfType(expression, "ClassExpression")) return isProvenReactClassComponent(expression, scopes, visitedClassNodes, visitedSymbolIds);
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, expression, scopes)) return false;
+	visitedSymbolIds.add(symbol.id);
+	if (isImportedFromReact(symbol)) {
+		const importedName = getImportedName(symbol.declarationNode);
+		return Boolean(importedName && REACT_COMPONENT_CLASS_NAMES.has(importedName));
+	}
+	if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes, visitedClassNodes, visitedSymbolIds);
+	return Boolean(symbol.kind === "const" && symbol.initializer && isReactComponentClassValue(symbol.initializer, scopes, visitedClassNodes, visitedSymbolIds));
+};
+const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @__PURE__ */ new Set(), visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || visitedClassNodes.has(classNode) || !classNode.superClass) return false;
+	visitedClassNodes.add(classNode);
+	return isReactComponentClassValue(classNode.superClass, scopes, visitedClassNodes, visitedSymbolIds);
+};
+//#endregion
+//#region src/plugin/utils/is-proven-intrinsic-jsx-element.ts
+const isProvenIntrinsicJsxElement = (openingElement, scopes) => {
+	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
+	const resolvedElementType = resolveJsxElementType(openingElement);
+	if (resolvedElementType[0] === resolvedElementType[0]?.toLowerCase()) return true;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	const isIntrinsicValue = (node) => {
+		const current = findTransparentExpressionRoot(node);
+		if (isNodeOfType(current, "Literal")) return typeof current.value === "string";
+		if (isNodeOfType(current, "Identifier") || isNodeOfType(current, "JSXIdentifier")) {
+			const symbol = scopes.symbolFor(current);
+			if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
+			visitedSymbolIds.add(symbol.id);
+			const isIntrinsic = isIntrinsicValue(symbol.initializer);
+			visitedSymbolIds.delete(symbol.id);
+			return isIntrinsic;
+		}
+		if (isNodeOfType(current, "ConditionalExpression")) return isIntrinsicValue(current.consequent) && isIntrinsicValue(current.alternate);
+		return false;
+	};
+	return isIntrinsicValue(openingElement.name);
+};
+//#endregion
+//#region src/plugin/rules/react-builtins/is-safe-create-ref-callback-current-write.ts
+const pathStartsWith$1 = (propertyPath, prefix) => prefix.every((propertyName, index) => propertyPath[index] === propertyName);
+const collectMemberExpression = (identifier) => {
+	let expression = findTransparentExpressionRoot(identifier);
+	while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) {
+		if (!getStaticPropertyName(expression.parent)) return null;
+		expression = findTransparentExpressionRoot(expression.parent);
+	}
+	return expression;
+};
+const isInlineIntrinsicRefCallback = (functionNode, scopes) => {
+	const functionExpression = findTransparentExpressionRoot(functionNode);
+	if (!isFunctionLike$1(functionExpression) || functionExpression.async || functionExpression.generator) return false;
+	const container = functionExpression.parent;
+	if (!container || !isNodeOfType(container, "JSXExpressionContainer")) return false;
+	const attribute = container.parent;
+	if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
+	const openingElement = attribute.parent;
+	return Boolean(openingElement && isNodeOfType(openingElement, "JSXOpeningElement") && isProvenIntrinsicJsxElement(openingElement, scopes));
+};
+const isSafeCreateRefCallbackCurrentWrite = (referenceNode, accessedPropertyPath, targetPropertyPath, scopes) => {
+	if (accessedPropertyPath.length !== targetPropertyPath.length + 1 || !pathStartsWith$1(accessedPropertyPath, targetPropertyPath) || accessedPropertyPath[targetPropertyPath.length] !== "current") return false;
+	const memberExpression = collectMemberExpression(referenceNode);
+	const assignment = memberExpression?.parent;
+	if (!memberExpression || !assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== memberExpression) return false;
+	const enclosingFunction = findEnclosingFunction$1(referenceNode);
+	if (!enclosingFunction) return false;
+	if (isInlineIntrinsicRefCallback(enclosingFunction, scopes)) return true;
+	if (!isFunctionLike$1(enclosingFunction) || enclosingFunction.async || enclosingFunction.generator) return false;
+	const callbackFunction = findEnclosingFunction$1(enclosingFunction);
+	if (!callbackFunction || !isInlineIntrinsicRefCallback(callbackFunction, scopes)) return false;
+	const cleanupFunction = findTransparentExpressionRoot(enclosingFunction);
+	const cleanupContainer = cleanupFunction.parent;
+	return Boolean(isNodeOfType(cleanupContainer, "ReturnStatement") && cleanupContainer.argument === cleanupFunction && findEnclosingFunction$1(cleanupContainer) === callbackFunction || isNodeOfType(callbackFunction, "ArrowFunctionExpression") && callbackFunction.body === cleanupFunction);
+};
+//#endregion
+//#region src/plugin/rules/react-builtins/is-value-rendered-in-same-render.ts
+const isValueRenderedFromOwner = (expressionNode, renderOwner, scopes, visitedSymbolIds, options) => {
+	const expression = findTransparentExpressionRoot(expressionNode);
+	const parent = expression.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "ReturnStatement") && parent.argument === expression) return findEnclosingFunction$1(parent) === renderOwner;
+	if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === expression) return parent === renderOwner;
+	if (isNodeOfType(parent, "JSXFragment") && parent.children.some((child) => child === expression)) return isValueRenderedFromOwner(parent, renderOwner, scopes, visitedSymbolIds, options);
+	if (isNodeOfType(parent, "JSXElement") && parent.children.some((child) => child === expression) && (isProvenIntrinsicJsxElement(parent.openingElement, scopes) || isJsxFragmentElement(parent.openingElement, scopes) || options.doesCustomElementRenderChildren?.(parent.openingElement))) return isValueRenderedFromOwner(parent, renderOwner, scopes, visitedSymbolIds, options);
+	if (isNodeOfType(parent, "JSXExpressionContainer") && parent.expression === expression && parent.parent && (isNodeOfType(parent.parent, "JSXFragment") || isNodeOfType(parent.parent, "JSXElement") && (isProvenIntrinsicJsxElement(parent.parent.openingElement, scopes) || isJsxFragmentElement(parent.parent.openingElement, scopes) || options.doesCustomElementRenderChildren?.(parent.parent.openingElement)))) return isValueRenderedFromOwner(parent.parent, renderOwner, scopes, visitedSymbolIds, options);
+	if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === expression || parent.alternate === expression) || isNodeOfType(parent, "LogicalExpression") && (parent.left === expression || parent.right === expression) || isNodeOfType(parent, "ArrayExpression") && parent.elements.some((element) => element === expression)) return isValueRenderedFromOwner(parent, renderOwner, scopes, visitedSymbolIds, options);
+	if (!isNodeOfType(parent, "VariableDeclarator") || parent.init !== expression || !isNodeOfType(parent.id, "Identifier")) return false;
+	const symbol = scopes.symbolFor(parent.id);
+	if (!symbol || symbol.kind !== "const" || symbol.references.length === 0 || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	const isRendered = symbol.references.every((reference) => reference.flag === "read" && isValueRenderedFromOwner(reference.identifier, renderOwner, scopes, visitedSymbolIds, options));
+	visitedSymbolIds.delete(symbol.id);
+	return isRendered;
+};
+const isValueRenderedInSameRender = (expressionNode, scopes, options = {}) => isValueRenderedFromOwner(expressionNode, findEnclosingFunction$1(expressionNode), scopes, /* @__PURE__ */ new Set(), options);
+//#endregion
+//#region src/plugin/rules/react-builtins/is-create-ref-result-write-only.ts
+const pathStartsWith = (propertyPath, prefix) => prefix.every((propertyName, index) => propertyPath[index] === propertyName);
+const pathsOverlap = (firstPath, secondPath) => pathStartsWith(firstPath, secondPath) || pathStartsWith(secondPath, firstPath);
+const isClosedNoopFunction = (node) => isFunctionLike$1(node) && isNodeOfType(node.body, "BlockStatement") && node.body.body.length === 0;
+const isProvenReactCall = (callExpression, expectedName, scopes) => isReactApiCall(callExpression, expectedName, scopes, { resolveNamedAliases: true });
+const objectHasOnlyClosedNoopFunctions = (objectExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!isNodeOfType(objectExpression, "ObjectExpression")) return false;
+	return objectExpression.properties.every((property) => {
+		if (isNodeOfType(property, "SpreadElement")) {
+			const spreadArgument = findTransparentExpressionRoot(property.argument);
+			if (isNodeOfType(spreadArgument, "ObjectExpression")) return objectHasOnlyClosedNoopFunctions(spreadArgument, scopes, visitedSymbolIds);
+			if (!isNodeOfType(spreadArgument, "Identifier")) return false;
+			const symbol = scopes.symbolFor(spreadArgument);
+			if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.initializer, "ObjectExpression")) return false;
+			visitedSymbolIds.add(symbol.id);
+			const isClosed = objectHasOnlyClosedNoopFunctions(symbol.initializer, scopes, visitedSymbolIds);
+			visitedSymbolIds.delete(symbol.id);
+			return isClosed;
+		}
+		if (!isNodeOfType(property, "Property")) return false;
+		return !isFunctionLike$1(property.value) || isClosedNoopFunction(property.value);
+	});
+};
+const getValuePathPropertyName = (memberExpression) => {
+	const propertyName = getStaticPropertyName(memberExpression);
+	if (propertyName) return propertyName;
+	return memberExpression.computed && isNodeOfType(memberExpression.property, "Literal") && typeof memberExpression.property.value === "number" && Number.isSafeInteger(memberExpression.property.value) && memberExpression.property.value >= 0 ? String(memberExpression.property.value) : null;
+};
+const collectMemberAccess = (identifier) => {
+	const propertyPath = [];
+	let expression = findTransparentExpressionRoot(identifier);
+	while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) {
+		const propertyName = getValuePathPropertyName(expression.parent);
+		if (!propertyName) return null;
+		propertyPath.push(propertyName);
+		expression = findTransparentExpressionRoot(expression.parent);
+	}
+	return {
+		expression,
+		propertyPath
+	};
+};
+const getEnvironment = (program, filename, state) => {
+	const cached = state.environmentsByProgram.get(program);
+	if (cached) return cached;
+	const environment = {
+		filename,
+		program,
+		scopes: analyzeScopes(program)
+	};
+	state.environmentsByProgram.set(program, environment);
+	return environment;
+};
+const unwrapProvenReactHocFunction = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!node) return null;
+	const current = findTransparentExpressionRoot(node);
+	if (isFunctionLike$1(current)) return current;
+	if (isNodeOfType(current, "Identifier")) {
+		const symbol = scopes.symbolFor(current);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.initializer || hasSymbolWriteBefore(symbol, current, scopes)) return null;
+		visitedSymbolIds.add(symbol.id);
+		return unwrapProvenReactHocFunction(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(current, "CallExpression")) return null;
+	if (!isProvenReactCall(current, "memo", scopes) && !isProvenReactCall(current, "forwardRef", scopes)) return null;
+	const firstArgument = current.arguments[0];
+	if (!firstArgument || isNodeOfType(firstArgument, "SpreadElement")) return null;
+	return unwrapProvenReactHocFunction(firstArgument, scopes, visitedSymbolIds);
+};
+const isForwardRefValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const current = findTransparentExpressionRoot(node);
+	if (isNodeOfType(current, "Identifier")) {
+		const symbol = scopes.symbolFor(current);
+		if (!symbol || !symbol.initializer || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, current, scopes)) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isForwardRefValue(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(current, "CallExpression")) return false;
+	if (isProvenReactCall(current, "forwardRef", scopes)) return true;
+	if (!isProvenReactCall(current, "memo", scopes)) return false;
+	const firstArgument = current.arguments[0];
+	if (!firstArgument || isNodeOfType(firstArgument, "SpreadElement")) return false;
+	return isForwardRefValue(firstArgument, scopes, visitedSymbolIds);
+};
+const functionFromExport = (resolved, state) => {
+	const environment = getEnvironment(resolved.programNode, resolved.filePath, state);
+	const functionNode = unwrapProvenReactHocFunction(resolved.exportedNode, environment.scopes);
+	if (!functionNode) return null;
+	return {
+		environment,
+		functionNode,
+		isForwardRef: isForwardRefValue(resolved.exportedNode, environment.scopes)
+	};
+};
+const resolveFunctionValue = (identifier, environment, state) => {
+	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
+	const symbol = environment.scopes.symbolFor(identifier);
+	if (symbol && symbol.kind !== "import") {
+		if (hasSymbolWriteBefore(symbol, identifier, environment.scopes)) return null;
+		const functionNode = unwrapProvenReactHocFunction(symbol.initializer, environment.scopes);
+		if (!functionNode) return null;
+		return {
+			environment,
+			functionNode,
+			isForwardRef: Boolean(symbol.initializer && isForwardRefValue(symbol.initializer, environment.scopes))
+		};
+	}
+	const binding = getImportBindingForName(identifier, identifier.name);
+	if (!binding || binding.isNamespace || binding.exportedName === null) return null;
+	const resolved = resolveCrossFileValueExportWithFilePath(environment.filename, binding.source, binding.exportedName);
+	return resolved ? functionFromExport(resolved, state) : null;
+};
+const resolveJsxFunctionValue = (elementName, environment, state) => {
+	if (isNodeOfType(elementName, "JSXIdentifier")) return resolveFunctionValue(elementName, environment, state);
+	if (!isNodeOfType(elementName, "JSXMemberExpression") || !isNodeOfType(elementName.object, "JSXIdentifier")) return null;
+	const namespaceBinding = getImportBindingForName(elementName.object, elementName.object.name);
+	if (!namespaceBinding?.isNamespace) return null;
+	const resolved = resolveCrossFileValueExportWithFilePath(environment.filename, namespaceBinding.source, elementName.property.name);
+	return resolved ? functionFromExport(resolved, state) : null;
+};
+const isProvenReactClassValue = (node, environment, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const current = findTransparentExpressionRoot(node);
+	if (isNodeOfType(current, "Identifier")) {
+		const symbol = environment.scopes.symbolFor(current);
+		if (!symbol || !symbol.initializer || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, current, environment.scopes)) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isProvenReactClassValue(symbol.initializer, environment, visitedSymbolIds);
+	}
+	return isProvenReactClassComponent(current, environment.scopes);
+};
+const isProvenClassComponentIdentifier = (identifier, environment, state) => {
+	if (!isNodeOfType(identifier, "JSXIdentifier")) return false;
+	const symbol = environment.scopes.symbolFor(identifier);
+	if (symbol && symbol.kind !== "import") {
+		if (hasSymbolWriteBefore(symbol, identifier, environment.scopes)) return false;
+		return Boolean(symbol.initializer && isProvenReactClassValue(symbol.initializer, environment));
+	}
+	const binding = getImportBindingForName(identifier, identifier.name);
+	if (!binding || binding.isNamespace || binding.exportedName === null) return false;
+	const resolved = resolveCrossFileValueExportWithFilePath(environment.filename, binding.source, binding.exportedName);
+	if (!resolved) return false;
+	const resolvedEnvironment = getEnvironment(resolved.programNode, resolved.filePath, state);
+	return isProvenReactClassValue(resolved.exportedNode, resolvedEnvironment);
+};
+const resolveClassValue = (node, environment) => {
+	if (!node) return null;
+	const classNode = findTransparentExpressionRoot(node);
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || !isProvenReactClassValue(classNode, environment)) return null;
+	return {
+		classNode,
+		environment
+	};
+};
+const resolveJsxClassValue = (elementName, environment, state) => {
+	if (!isNodeOfType(elementName, "JSXIdentifier")) return null;
+	const symbol = environment.scopes.symbolFor(elementName);
+	if (symbol && symbol.kind !== "import") {
+		if (hasSymbolWriteBefore(symbol, elementName, environment.scopes)) return null;
+		return resolveClassValue(symbol.initializer, environment);
+	}
+	const binding = getImportBindingForName(elementName, elementName.name);
+	if (!binding || binding.isNamespace || binding.exportedName === null) return null;
+	const resolved = resolveCrossFileValueExportWithFilePath(environment.filename, binding.source, binding.exportedName);
+	if (!resolved) return null;
+	const resolvedEnvironment = getEnvironment(resolved.programNode, resolved.filePath, state);
+	return resolveClassValue(resolved.exportedNode, resolvedEnvironment);
+};
+const findOwnedSymbolValue = (expressionNode, initialPropertyPath, environment) => {
+	const propertyPath = [...initialPropertyPath];
+	let expression = findTransparentExpressionRoot(expressionNode);
+	while (expression.parent) {
+		const parent = expression.parent;
+		if (isNodeOfType(parent, "ArrayExpression")) {
+			if (parent.elements.some((element) => element && isNodeOfType(element, "SpreadElement"))) return null;
+			const elementIndex = parent.elements.findIndex((element) => element === expression);
+			if (elementIndex < 0) return null;
+			propertyPath.unshift(String(elementIndex));
+			expression = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "Property") && parent.value === expression) {
+			const propertyName = getStaticPropertyKeyName(parent, { allowComputedString: true });
+			const objectExpression = parent.parent;
+			if (!propertyName || !objectExpression || !objectHasOnlyClosedNoopFunctions(objectExpression, environment.scopes)) return null;
+			propertyPath.unshift(propertyName);
+			expression = findTransparentExpressionRoot(objectExpression);
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === expression || parent.alternate === expression) || isNodeOfType(parent, "LogicalExpression") && (parent.left === expression || parent.right === expression)) {
+			expression = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "VariableDeclarator") && parent.init === expression && isNodeOfType(parent.id, "Identifier")) {
+			const symbol = environment.scopes.symbolFor(parent.id);
+			if (!symbol || symbol.kind !== "const") return null;
+			return {
+				environment,
+				propertyPath,
+				symbol
+			};
+		}
+		if (isNodeOfType(parent, "AssignmentExpression") && parent.operator === "=" && parent.right === expression && isNodeOfType(parent.left, "MemberExpression")) {
+			const assignedPropertyPath = [];
+			let assignedExpression = parent.left;
+			while (isNodeOfType(assignedExpression, "MemberExpression")) {
+				const propertyName = getValuePathPropertyName(assignedExpression);
+				if (!propertyName) return null;
+				assignedPropertyPath.unshift(propertyName);
+				assignedExpression = findTransparentExpressionRoot(assignedExpression.object);
+			}
+			if (!isNodeOfType(assignedExpression, "Identifier")) return null;
+			const symbol = environment.scopes.symbolFor(assignedExpression);
+			if (!symbol || symbol.kind !== "const") return null;
+			return {
+				environment,
+				originWriteReference: assignedExpression,
+				propertyPath: [...assignedPropertyPath, ...propertyPath],
+				symbol
+			};
+		}
+		return null;
+	}
+	return null;
+};
+const analyzePatternPath = (pattern, propertyPath, environment, state, remainingDepth) => {
+	if (isNodeOfType(pattern, "AssignmentPattern")) return analyzePatternPath(pattern.left, propertyPath, environment, state, remainingDepth);
+	if (isNodeOfType(pattern, "Identifier")) {
+		const symbol = environment.scopes.symbolFor(pattern);
+		return Boolean(symbol && analyzeSymbolValuePath({
+			environment,
+			propertyPath,
+			symbol
+		}, state, remainingDepth - 1));
+	}
+	if (!isNodeOfType(pattern, "ObjectPattern") || propertyPath.length === 0) return false;
+	const [firstPropertyName, ...remainingPropertyPath] = propertyPath;
+	for (const property of pattern.properties) {
+		if (!isNodeOfType(property, "Property")) continue;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (!propertyName) return false;
+		if (propertyName !== firstPropertyName) continue;
+		return analyzePatternPath(property.value, remainingPropertyPath, environment, state, remainingDepth);
+	}
+	const restProperty = pattern.properties.find((property) => isNodeOfType(property, "RestElement"));
+	return restProperty ? analyzePatternPath(restProperty.argument, propertyPath, environment, state, remainingDepth) : true;
+};
+const isIntrinsicReactElementFactoryCall = (callExpression, environment) => {
+	const element = callExpression.arguments[0];
+	if (!element || isNodeOfType(element, "SpreadElement")) return false;
+	if (isProvenReactCall(callExpression, "createElement", environment.scopes)) return isNodeOfType(element, "Literal") && typeof element.value === "string";
+	if (!isProvenReactCall(callExpression, "cloneElement", environment.scopes)) return false;
+	if (!isNodeOfType(element, "JSXElement")) return false;
+	return isProvenIntrinsicJsxElement(element.openingElement, environment.scopes);
+};
+const isIntrinsicReactElementRefProperty = (expression, propertyPath, environment, state, remainingDepth) => {
+	if (propertyPath.length > 0) return false;
+	const property = expression.parent;
+	if (!property || !isNodeOfType(property, "Property") || property.value !== expression) return false;
+	if (getStaticPropertyKeyName(property, { allowComputedString: true }) !== "ref") return false;
+	const props = property.parent;
+	if (!props || !isNodeOfType(props, "ObjectExpression")) return false;
+	const callExpression = props.parent;
+	if (!callExpression || !isNodeOfType(callExpression, "CallExpression") || callExpression.arguments[1] !== props || !isIntrinsicReactElementFactoryCall(callExpression, environment) || !isValueRenderedForEnvironment(callExpression, environment, state, remainingDepth)) return false;
+	return true;
+};
+const analyzeFunctionInput = (resolvedFunction, parameterIndex, propertyPath, state, remainingDepth) => {
+	if (remainingDepth <= 0 || !isFunctionLike$1(resolvedFunction.functionNode) || resolvedFunction.functionNode.async || resolvedFunction.functionNode.generator) return false;
+	const parameter = resolvedFunction.functionNode.params[parameterIndex];
+	return Boolean(parameter && analyzePatternPath(parameter, propertyPath, resolvedFunction.environment, state, remainingDepth));
+};
+const isThisPropsChildren = (node) => {
+	if (!isNodeOfType(node, "MemberExpression") || getStaticPropertyName(node) !== "children") return false;
+	const propsMember = findTransparentExpressionRoot(node.object);
+	return Boolean(isNodeOfType(propsMember, "MemberExpression") && getStaticPropertyName(propsMember) === "props" && isNodeOfType(findTransparentExpressionRoot(propsMember.object), "ThisExpression"));
+};
+const isProvenReactContextProvider = (openingElement, environment) => {
+	if (!isNodeOfType(openingElement, "JSXOpeningElement") || !isNodeOfType(openingElement.name, "JSXMemberExpression") || openingElement.name.property.name !== "Provider" || !isNodeOfType(openingElement.name.object, "JSXIdentifier")) return false;
+	const contextSymbol = environment.scopes.symbolFor(openingElement.name.object);
+	return Boolean(contextSymbol?.kind === "const" && contextSymbol.initializer && isNodeOfType(contextSymbol.initializer, "CallExpression") && isProvenReactCall(contextSymbol.initializer, "createContext", environment.scopes));
+};
+const isValueRenderedForEnvironment = (expression, environment, state, remainingDepth) => isValueRenderedInSameRender(expression, environment.scopes, { doesCustomElementRenderChildren: (openingElement) => doesCustomElementRenderChildren(openingElement, environment, state, remainingDepth - 1) });
+const doesFunctionComponentRenderChildren = (resolvedFunction, state, remainingDepth) => {
+	const { functionNode } = resolvedFunction;
+	if (remainingDepth <= 0 || state.activeRenderedChildrenComponents.has(functionNode) || !isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "FunctionDeclaration") || functionNode.async || functionNode.generator) return false;
+	const childrenReferences = collectFunctionChildrenReferences(functionNode, resolvedFunction.environment.scopes);
+	if (!childrenReferences) return false;
+	state.activeRenderedChildrenComponents.add(functionNode);
+	const isRendered = childrenReferences.every((childrenReference) => isValueRenderedForEnvironment(childrenReference, resolvedFunction.environment, state, remainingDepth));
+	state.activeRenderedChildrenComponents.delete(functionNode);
+	return isRendered;
+};
+const doesClassComponentRenderChildren = (resolvedClass, state, remainingDepth) => {
+	const { classNode, environment } = resolvedClass;
+	if (remainingDepth <= 0 || state.activeRenderedChildrenComponents.has(classNode) || !isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression")) return false;
+	const renderMethod = classNode.body.body.find((element) => isNodeOfType(element, "MethodDefinition") && !element.computed && isNodeOfType(element.key, "Identifier") && element.key.name === "render");
+	if (!renderMethod || !isNodeOfType(renderMethod, "MethodDefinition")) return false;
+	const childrenReads = [];
+	walkAst(classNode, (node) => {
+		if (isThisPropsChildren(node)) childrenReads.push(node);
+	});
+	if (childrenReads.length === 0) return false;
+	state.activeRenderedChildrenComponents.add(classNode);
+	const isRendered = childrenReads.every((childrenRead) => findEnclosingFunction$1(childrenRead) === renderMethod.value && isValueRenderedForEnvironment(childrenRead, environment, state, remainingDepth));
+	state.activeRenderedChildrenComponents.delete(classNode);
+	return isRendered;
+};
+const doesCustomElementRenderChildren = (openingElement, environment, state, remainingDepth) => {
+	if (remainingDepth <= 0 || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	if (isProvenReactContextProvider(openingElement, environment)) return true;
+	const resolvedFunction = resolveJsxFunctionValue(openingElement.name, environment, state);
+	if (resolvedFunction) return doesFunctionComponentRenderChildren(resolvedFunction, state, remainingDepth);
+	const resolvedClass = resolveJsxClassValue(openingElement.name, environment, state);
+	return Boolean(resolvedClass && doesClassComponentRenderChildren(resolvedClass, state, remainingDepth));
+};
+const analyzeJsxAttributeUse = (attribute, propertyPath, environment, state, remainingDepth) => {
+	const attributeName = getJsxAttributeName(attribute.name);
+	const openingElement = attribute.parent;
+	if (!attributeName || !openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	const jsxElement = openingElement.parent;
+	if (!jsxElement || !isNodeOfType(jsxElement, "JSXElement") || !isValueRenderedForEnvironment(jsxElement, environment, state, remainingDepth)) return false;
+	if (isProvenIntrinsicJsxElement(openingElement, environment.scopes)) return attributeName === "ref" && propertyPath.length === 0;
+	if (isNodeOfType(openingElement.name, "JSXIdentifier") && attributeName === "ref" && propertyPath.length === 0 && isProvenClassComponentIdentifier(openingElement.name, environment, state)) return true;
+	const resolvedFunction = resolveJsxFunctionValue(openingElement.name, environment, state);
+	if (!resolvedFunction) return false;
+	if (attributeName === "ref" && resolvedFunction.isForwardRef) return analyzeFunctionInput(resolvedFunction, 1, propertyPath, state, remainingDepth);
+	return analyzeFunctionInput(resolvedFunction, 0, [attributeName, ...propertyPath], state, remainingDepth);
+};
+const analyzeCallArgumentUse = (callExpression, argumentExpression, propertyPath, environment, state, remainingDepth) => {
+	const argumentIndex = callExpression.arguments.findIndex((argument) => argument === argumentExpression);
+	if (argumentIndex < 0) return false;
+	if (argumentIndex === 0 && isNodeOfType(callExpression.callee, "Identifier") && callExpression.callee.name === "Boolean" && environment.scopes.isGlobalReference(callExpression.callee)) return true;
+	if (argumentIndex === 0 && isProvenReactCall(callExpression, "useImperativeHandle", environment.scopes)) return propertyPath.length === 0;
+	if (argumentIndex === 1 && propertyPath.length === 1 && propertyPath[0] === "ref" && isIntrinsicReactElementFactoryCall(callExpression, environment) && isValueRenderedForEnvironment(callExpression, environment, state, remainingDepth)) return true;
+	const inlineCallee = findTransparentExpressionRoot(callExpression.callee);
+	if (isFunctionLike$1(inlineCallee)) {
+		if (functionContainsReactRenderOutput(inlineCallee, environment.scopes) && !isValueRenderedForEnvironment(callExpression, environment, state, remainingDepth)) return false;
+		return analyzeFunctionInput({
+			environment,
+			functionNode: inlineCallee,
+			isForwardRef: false
+		}, argumentIndex, propertyPath, state, remainingDepth);
+	}
+	if (!isNodeOfType(callExpression.callee, "Identifier")) return false;
+	const resolvedFunction = resolveFunctionValue(callExpression.callee, environment, state);
+	return Boolean(resolvedFunction && (!functionContainsReactRenderOutput(resolvedFunction.functionNode, resolvedFunction.environment.scopes) || isValueRenderedForEnvironment(callExpression, environment, state, remainingDepth)) && analyzeFunctionInput(resolvedFunction, argumentIndex, propertyPath, state, remainingDepth));
+};
+const isIntrinsicJsxSpreadRefUse = (expression, propertyPath, environment, state, remainingDepth) => {
+	let spreadAttribute;
+	if (propertyPath.length === 1 && propertyPath[0] === "ref") spreadAttribute = expression.parent;
+	else if (propertyPath.length === 0) {
+		const property = expression.parent;
+		if (!property || !isNodeOfType(property, "Property") || property.value !== expression || getStaticPropertyKeyName(property, { allowComputedString: true }) !== "ref") return false;
+		spreadAttribute = property.parent?.parent;
+	}
+	if (!spreadAttribute || !isNodeOfType(spreadAttribute, "JSXSpreadAttribute")) return false;
+	const openingElement = spreadAttribute.parent;
+	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	const jsxElement = openingElement.parent;
+	return Boolean(isProvenIntrinsicJsxElement(openingElement, environment.scopes) && jsxElement && isNodeOfType(jsxElement, "JSXElement") && isValueRenderedForEnvironment(jsxElement, environment, state, remainingDepth));
+};
+const analyzeValueUse = (expressionNode, propertyPath, environment, state, remainingDepth) => {
+	const expression = findTransparentExpressionRoot(expressionNode);
+	const parent = expression.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "ExpressionStatement")) return true;
+	if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void" && parent.argument === expression) return true;
+	if (propertyPath.length === 0 && isNodeOfType(parent, "BinaryExpression") && (parent.operator === "===" || parent.operator === "!==" || parent.operator === "==" || parent.operator === "!=")) {
+		const comparedExpression = parent.left === expression ? parent.right : parent.left;
+		return Boolean(isNodeOfType(expression, "Identifier") && isNodeOfType(comparedExpression, "Identifier") && environment.scopes.symbolFor(expression)?.id === environment.scopes.symbolFor(comparedExpression)?.id);
+	}
+	if (isIntrinsicJsxSpreadRefUse(expression, propertyPath, environment, state, remainingDepth)) return true;
+	if (isIntrinsicReactElementRefProperty(expression, propertyPath, environment, state, remainingDepth)) return true;
+	if (propertyPath.length > 0 && (isNodeOfType(parent, "LogicalExpression") && parent.left === expression || isNodeOfType(parent, "ConditionalExpression") && parent.test === expression || isNodeOfType(parent, "IfStatement") && parent.test === expression || isNodeOfType(parent, "UnaryExpression") && parent.operator === "!" && parent.argument === expression)) return true;
+	if (isNodeOfType(parent, "JSXExpressionContainer") && parent.expression === expression) {
+		const attribute = parent.parent;
+		return Boolean(attribute && isNodeOfType(attribute, "JSXAttribute") && analyzeJsxAttributeUse(attribute, propertyPath, environment, state, remainingDepth));
+	}
+	if (isNodeOfType(parent, "CallExpression")) return analyzeCallArgumentUse(parent, expression, propertyPath, environment, state, remainingDepth);
+	if (isNodeOfType(parent, "VariableDeclarator") && parent.init === expression && !isNodeOfType(parent.id, "Identifier")) return analyzePatternPath(parent.id, propertyPath, environment, state, remainingDepth);
+	const propagatedValue = findOwnedSymbolValue(expression, propertyPath, environment);
+	return Boolean(propagatedValue && analyzeSymbolValuePath(propagatedValue, state, remainingDepth - 1));
+};
+const getFunctionBindingIdentifier = (functionNode) => {
+	const parent = functionNode.parent;
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) return functionNode.id;
+	return null;
+};
+const isSynchronouslyInvokedLocalFunction = (functionNode, callerFunction, scopes) => {
+	if (!functionNode || !callerFunction || !isFunctionLike$1(functionNode) || functionNode.async || functionNode.generator) return false;
+	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	if (!bindingIdentifier) return false;
+	if (((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id === bindingIdentifier ? findEnclosingFunction$1(functionNode) : findEnclosingFunction$1(bindingIdentifier)) !== callerFunction) return false;
+	const symbol = isNodeOfType(functionNode, "FunctionDeclaration") ? scopes.ownScopeFor(callerFunction)?.symbolsByName.get(bindingIdentifier.name) : scopes.symbolFor(bindingIdentifier);
+	return Boolean(symbol && symbol.references.length > 0 && symbol.references.every((reference) => {
+		const referenceExpression = findTransparentExpressionRoot(reference.identifier);
+		const callExpression = referenceExpression.parent;
+		return Boolean(callExpression && isNodeOfType(callExpression, "CallExpression") && callExpression.callee === referenceExpression && findEnclosingFunction$1(callExpression) === callerFunction && isValueRenderedInSameRender(callExpression, scopes));
+	}));
+};
+const analyzeSymbolValuePath = (valuePath, state, remainingDepth) => {
+	if (remainingDepth <= 0) return false;
+	const activePathKey = `${valuePath.environment.filename}:${valuePath.symbol.id}:${valuePath.propertyPath.join(".")}`;
+	if (state.activePaths.has(activePathKey)) return false;
+	state.activePaths.add(activePathKey);
+	const bindingFunction = findEnclosingFunction$1(valuePath.symbol.bindingIdentifier);
+	const result = valuePath.symbol.references.every((reference) => {
+		if (reference.identifier === valuePath.originWriteReference) return true;
+		const referenceParent = reference.identifier.parent;
+		if (referenceParent && isNodeOfType(referenceParent, "Property") && !referenceParent.computed && referenceParent.key === reference.identifier && referenceParent.value !== reference.identifier) return true;
+		const memberAccess = collectMemberAccess(reference.identifier);
+		if (!memberAccess) return false;
+		if (!pathsOverlap(memberAccess.propertyPath, valuePath.propertyPath)) return true;
+		const referenceFunction = findEnclosingFunction$1(reference.identifier);
+		if (referenceFunction !== bindingFunction && !isSynchronouslyInvokedLocalFunction(referenceFunction, bindingFunction, valuePath.environment.scopes)) {
+			if (isSafeCreateRefCallbackCurrentWrite(reference.identifier, memberAccess.propertyPath, valuePath.propertyPath, valuePath.environment.scopes)) return true;
+			return false;
+		}
+		if (reference.flag !== "read") return false;
+		if (pathStartsWith(memberAccess.propertyPath, valuePath.propertyPath)) {
+			if (memberAccess.propertyPath.length > valuePath.propertyPath.length) {
+				const parent = memberAccess.expression.parent;
+				return Boolean(memberAccess.propertyPath.length === valuePath.propertyPath.length + 1 && memberAccess.propertyPath[valuePath.propertyPath.length] === "current" && parent && isNodeOfType(parent, "UnaryExpression") && parent.operator === "void" && parent.argument === memberAccess.expression);
+			}
+			return analyzeValueUse(memberAccess.expression, [], valuePath.environment, state, remainingDepth);
+		}
+		return analyzeValueUse(memberAccess.expression, valuePath.propertyPath.slice(memberAccess.propertyPath.length), valuePath.environment, state, remainingDepth);
+	});
+	state.activePaths.delete(activePathKey);
+	return result;
+};
+const isCreateRefResultWriteOnly = (createRefCall, filename, scopes) => {
+	if (!filename) return false;
+	const program = findProgramRoot(createRefCall);
+	if (!program) return false;
+	const environment = {
+		filename,
+		program,
+		scopes
+	};
+	const state = {
+		activePaths: /* @__PURE__ */ new Set(),
+		activeRenderedChildrenComponents: /* @__PURE__ */ new WeakSet(),
+		environmentsByProgram: new WeakMap([[program, environment]])
+	};
+	const ownedValue = findOwnedSymbolValue(createRefCall, [], environment);
+	return ownedValue ? analyzeSymbolValuePath(ownedValue, state, 12) : analyzeValueUse(createRefCall, [], environment, state, 12);
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/no-create-ref-in-function-component.ts
-const MESSAGE$31 = "`createRef()` in a function component allocates a brand-new ref on every render, so it never holds a value between renders. Use the `useRef()` hook instead.";
-const isUseMemoCallbackArgument = (functionNode) => {
+const MESSAGE$31 = "`createRef()` may escape or be observed beyond the render that created it, so a later render can replace the ref object and detach the observed one. Hoist a `useRef()` call to the component's unconditional top level instead.";
+const isUseMemoCallbackArgument = (functionNode, scopes) => {
 	const parent = functionNode.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
 	if (parent.arguments?.[0] !== functionNode) return false;
-	return isReactFunctionCall(parent, "useMemo");
+	return isReactApiCall(parent, "useMemo", scopes, { resolveNamedAliases: true });
 };
-const findEnclosingRenderFunction = (node) => {
+const findEnclosingRenderFunction = (node, scopes) => {
 	let enclosingFunction = findEnclosingFunction$1(node);
-	while (enclosingFunction && isUseMemoCallbackArgument(enclosingFunction)) enclosingFunction = findEnclosingFunction$1(enclosingFunction);
+	while (enclosingFunction && isUseMemoCallbackArgument(enclosingFunction, scopes)) enclosingFunction = findEnclosingFunction$1(enclosingFunction);
 	return enclosingFunction;
 };
 const noCreateRefInFunctionComponent = defineRule({
@@ -32007,16 +32601,17 @@ const noCreateRefInFunctionComponent = defineRule({
 	severity: "warn",
 	recommendation: "Replace `createRef()` with the `useRef()` hook inside function components and hooks. `createRef` is only for class components.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isReactFunctionCall(node, "createRef")) return;
-		if (isNodeOfType(node.callee, "Identifier")) {
-			const symbol = context.scopes.symbolFor(node.callee);
-			if (symbol && symbol.kind !== "import") return;
-		}
-		const enclosingFunction = findEnclosingRenderFunction(node);
+		if (!isReactApiCall(node, "createRef", context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveNamedAliases: true
+		})) return;
+		const enclosingFunction = findEnclosingRenderFunction(node, context.scopes);
 		if (!enclosingFunction) return;
 		const displayName = componentOrHookDisplayNameForFunction(enclosingFunction);
 		if (!displayName) return;
 		if (!(isReactHookName(displayName) || functionContainsReactRenderOutput(enclosingFunction, context.scopes, context.cfg))) return;
+		if (isCreateRefResultWriteOnly(node, context.filename, context.scopes)) return;
 		context.report({
 			node,
 			message: MESSAGE$31
@@ -38195,33 +38790,6 @@ const noLegacyClassLifecycles = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-proven-react-class-component.ts
-const REACT_COMPONENT_CLASS_NAMES = new Set(["Component", "PureComponent"]);
-const isReactComponentClassValue = (node, scopes, visitedClassNodes, visitedSymbolIds) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "MemberExpression")) {
-		const propertyName = getStaticPropertyName(expression);
-		const receiver = stripParenExpression(expression.object);
-		return Boolean(propertyName && REACT_COMPONENT_CLASS_NAMES.has(propertyName) && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, expression, scopes) && isReactNamespaceImport(receiver, scopes));
-	}
-	if (isNodeOfType(expression, "ClassExpression")) return isProvenReactClassComponent(expression, scopes, visitedClassNodes, visitedSymbolIds);
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, expression, scopes)) return false;
-	visitedSymbolIds.add(symbol.id);
-	if (isImportedFromReact(symbol)) {
-		const importedName = getImportedName(symbol.declarationNode);
-		return Boolean(importedName && REACT_COMPONENT_CLASS_NAMES.has(importedName));
-	}
-	if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes, visitedClassNodes, visitedSymbolIds);
-	return Boolean(symbol.kind === "const" && symbol.initializer && isReactComponentClassValue(symbol.initializer, scopes, visitedClassNodes, visitedSymbolIds));
-};
-const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @__PURE__ */ new Set(), visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || visitedClassNodes.has(classNode) || !classNode.superClass) return false;
-	visitedClassNodes.add(classNode);
-	return isReactComponentClassValue(classNode.superClass, scopes, visitedClassNodes, visitedSymbolIds);
-};
-//#endregion
 //#region src/plugin/utils/function-contains-proven-react-hook-call.ts
 const functionContainsProvenReactHookCall = (functionNode, scopes) => {
 	if (!isFunctionLike$1(functionNode)) return false;
@@ -38685,7 +39253,7 @@ const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, sc
 		}
 		if (isFunctionInvokedBeforeUsage(methodCallFunction, usageNode, usageBoundary, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes))) return true;
 	}
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) return false;
 	const symbol = scopes.symbolFor(bindingIdentifier);
 	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
@@ -42992,6 +43560,31 @@ 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";
@@ -43053,6 +43646,241 @@ 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 getRequiredTruthyConditions = (analysis, context, node, protectedSymbolIds) => {
+	const formula = getBooleanFormula$1(analysis, context, node, protectedSymbolIds);
+	if (formula) return [formula];
+	const expression = stripParenExpression(node);
+	if (!isNodeOfType(expression, "LogicalExpression") || expression.operator !== "&&") return [];
+	return [...getRequiredTruthyConditions(analysis, context, expression.left, protectedSymbolIds), ...getRequiredTruthyConditions(analysis, context, expression.right, protectedSymbolIds)];
+};
+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) {
+			if (parent.operator === "&&") conditions.push(...getRequiredTruthyConditions(analysis, context, parent.left, protectedSymbolIds));
+			if (parent.operator === "||") {
+				const leftFormula = getBooleanFormula$1(analysis, context, parent.left, protectedSymbolIds);
+				if (leftFormula) 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];
@@ -43128,6 +43956,158 @@ 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) || symbol.references.some((reference) => reference.flag !== "read"))) 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;
@@ -43135,6 +44115,8 @@ 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;
 };
@@ -62551,7 +63533,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 			return false;
 		};
 		const isWiredAsEventHandler = (functionNode) => {
-			const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+			const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 			if (!bindingIdentifier) return false;
 			const bindingSymbol = context.scopes.symbolFor(bindingIdentifier);
 			if (!bindingSymbol) return false;
@@ -62571,7 +63553,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 			return false;
 		};
 		const isSynchronouslyInvokedAnonymousWrapper = (functionNode) => {
-			if (getFunctionBindingIdentifier(functionNode)) return false;
+			if (getFunctionBindingIdentifier$1(functionNode)) return false;
 			const parent = functionNode.parent;
 			if (!isNodeOfType(parent, "CallExpression")) return false;
 			return parent.callee === functionNode || (parent.arguments ?? []).some((callArgument) => callArgument === functionNode);
@@ -68503,6 +69485,7 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"no-indeterminate-attribute",
 	"no-locale-format-in-render",
 	"no-match-media-in-state-initializer",
+	"no-create-ref-in-function-component",
 	"no-adjust-state-on-prop-change",
 	"no-derived-state",
 	"no-derived-state-effect",
@@ -68607,6 +69590,18 @@ const collectForwardedHookDependencies = ({ absoluteFilePath, staticImports }) =
 		collectProgramDependencies(resolved.filePath, resolved.programNode, 4);
 	}
 };
+const collectCreateRefDependencies = ({ absoluteFilePath, program }) => {
+	attachParentReferences(program);
+	const scopes = analyzeScopes(program);
+	walkAst(program, (node) => {
+		if (!isNodeOfType(node, "CallExpression") || !isReactApiCall(node, "createRef", scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveNamedAliases: true
+		})) return;
+		isCreateRefResultWriteOnly(node, absoluteFilePath, scopes);
+	});
+};
 const collectMutatingReducerDependencies = ({ absoluteFilePath, sourceText, staticImports, program }) => {
 	const namedUseReducerLocals = /* @__PURE__ */ new Set();
 	const reactObjectLocals = /* @__PURE__ */ new Set();
@@ -68695,6 +69690,7 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["no-indeterminate-attribute", collectNearestManifestDependencies],
 	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-match-media-in-state-initializer", collectNearestManifestDependencies],
+	["no-create-ref-in-function-component", collectCreateRefDependencies],
 	["no-adjust-state-on-prop-change", collectEffectValueHelperDependencies],
 	["no-derived-state", collectEffectValueHelperDependencies],
 	["no-derived-state-effect", collectEffectValueHelperDependencies],

package/package.json

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