oxlint-plugin-react-doctor 0.7.9-dev.093619c → 0.7.9-dev.0ff57fa

package/dist/index.d.ts

@@ -5503,29 +5503,6 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/no-ref-callback-cleanup-before-react-19";
-  readonly id: "no-ref-callback-cleanup-before-react-19";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Bugs";
-    readonly id: string;
-    readonly title?: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<Capability>;
-    readonly disabledWhen?: ReadonlyArray<Capability>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly matchByOccurrence?: boolean;
-    readonly defaultEnabled?: boolean;
-    readonly lifecycle?: "retired";
-    readonly scan?: FileScan;
-    readonly committedFilesOnly?: boolean;
-    readonly recommendation?: string;
-    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
 }, {
   readonly key: "react-doctor/no-ref-current-in-render";
   readonly id: "no-ref-current-in-render";
@@ -14815,29 +14792,6 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/no-ref-callback-cleanup-before-react-19";
-  readonly id: "no-ref-callback-cleanup-before-react-19";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Bugs";
-    readonly id: string;
-    readonly title?: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<Capability>;
-    readonly disabledWhen?: ReadonlyArray<Capability>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly matchByOccurrence?: boolean;
-    readonly defaultEnabled?: boolean;
-    readonly lifecycle?: "retired";
-    readonly scan?: FileScan;
-    readonly committedFilesOnly?: boolean;
-    readonly recommendation?: string;
-    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
 }, {
   readonly key: "react-doctor/no-ref-current-in-render";
   readonly id: "no-ref-current-in-render";

package/dist/index.js

@@ -13652,7 +13652,7 @@ const getPromiseChainCallForCallback = (candidate) => {
 	if (!callbackContainer.arguments?.some((argument) => stripParenExpression(argument) === candidate)) return null;
 	return isPromiseChainCall(stripParenExpression(callbackContainer.callee)) ? callbackContainer : null;
 };
-const collectInvokedFunctions = (effectCallback, includePromiseCallbacks) => {
+const collectEffectInvokedFunctions = (effectCallback) => {
 	const invokedFunctions = new Set([effectCallback]);
 	const localFunctionBindings = /* @__PURE__ */ new Map();
 	const calledBindingNames = /* @__PURE__ */ new Set();
@@ -13686,14 +13686,12 @@ const collectInvokedFunctions = (effectCallback, includePromiseCallbacks) => {
 				calledBindingNames.add(callee.name);
 				return;
 			}
-			if (includePromiseCallbacks && isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
+			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
 		});
 		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
 	}
 	return invokedFunctions;
 };
-const collectEffectInvokedFunctions = (effectCallback) => collectInvokedFunctions(effectCallback, true);
-const collectSynchronouslyEffectInvokedFunctions = (effectCallback) => collectInvokedFunctions(effectCallback, false);
 //#endregion
 //#region src/plugin/utils/is-react-hook-name.ts
 const isReactHookName = (name) => {
@@ -14414,7 +14412,7 @@ const findSingleDirectInvocation = (functionNode, caller, context) => {
 		const callNode = findDirectCallForReference(reference.identifier);
 		return callNode ? [callNode] : [];
 	});
-	if (invocationCalls.length !== 1 || symbol.references.length !== 1) return null;
+	if (invocationCalls.length !== 1) return null;
 	const invocationCall = invocationCalls[0];
 	return findEnclosingFunction$1(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
 };
@@ -14701,108 +14699,7 @@ const hasPotentialInterruptionAfterGuard = (callback, guardState, usageNode, con
 	});
 	return hasPotentialInterruption;
 };
-const getNumericReactRefCurrentKey = (expression, context) => {
-	const refSymbol = resolveReactRefSymbol(stripParenExpression(expression), context.scopes);
-	const initializer = refSymbol?.initializer ? stripParenExpression(refSymbol.initializer) : null;
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	const initialValue = initializer.arguments?.[0] ? stripParenExpression(initializer.arguments[0]) : null;
-	if (!isNodeOfType(initialValue, "Literal") || typeof initialValue.value !== "number") return null;
-	return resolveExpressionKey(expression, context);
-};
-const getBlockingGenerationKey = (expression, context) => {
-	const test = stripParenExpression(expression);
-	if (isNodeOfType(test, "LogicalExpression") && test.operator === "||") return getBlockingGenerationKey(test.left, context) ?? getBlockingGenerationKey(test.right, context);
-	if (!isNodeOfType(test, "BinaryExpression") || test.operator !== "!==" && test.operator !== "!=") return null;
-	const leftKey = getNumericReactRefCurrentKey(test.left, context);
-	const rightKey = getNumericReactRefCurrentKey(test.right, context);
-	const snapshotExpression = leftKey ? stripParenExpression(test.right) : stripParenExpression(test.left);
-	const key = leftKey ?? rightKey;
-	return key && isNodeOfType(snapshotExpression, "Identifier") ? key : null;
-};
-const findGenerationGuardKeyForDeferredUsage = (usageFunction, usageNode, context) => {
-	if (!isFunctionLike$1(usageFunction)) return null;
-	let generationKey = null;
-	walkAst(usageFunction.body, (child) => {
-		if (generationKey) return false;
-		if (child !== usageFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "IfStatement") || child.alternate) return;
-		const key = getBlockingGenerationKey(child.test, context);
-		if (!key || canNodeReachLaterNodeWithinFunction(child.consequent, usageNode, usageFunction, context) || !doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], usageFunction, context)) return;
-		generationKey = key;
-	});
-	return generationKey;
-};
-const isGenerationAdvance = (node, generationKey, context) => {
-	if (isNodeOfType(node, "UpdateExpression") && resolveExpressionKey(node.argument, context) === generationKey) return true;
-	if (!isNodeOfType(node, "AssignmentExpression") || resolveExpressionKey(node.left, context) !== generationKey || node.operator !== "+=" && node.operator !== "-=") return false;
-	const amount = stripParenExpression(node.right);
-	return isNodeOfType(amount, "Literal") && typeof amount.value === "number" && amount.value !== 0;
-};
-const functionAdvancesGeneration = (owner, generationKey, context) => {
-	if (!isFunctionLike$1(owner)) return false;
-	let didAdvanceGeneration = false;
-	walkAst(owner.body, (child) => {
-		if (didAdvanceGeneration) return false;
-		if (child !== owner.body && isFunctionLike$1(child)) return false;
-		if (isGenerationAdvance(child, generationKey, context)) {
-			didAdvanceGeneration = true;
-			return false;
-		}
-	});
-	return didAdvanceGeneration;
-};
-const cleanupReturnsReleaseUsage = (cleanupReturns, usage, context) => cleanupReturns.length > 0 && cleanupReturns.every((cleanupReturn) => {
-	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
-	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
-	return Boolean(cleanupFunction && isFunctionLike$1(cleanupFunction) && doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context));
-});
-const getOwnedFunctionReference = (reference, usageFunction, usageNode, callback, cleanupReturns, context) => {
-	const directCall = findDirectCallForReference(reference);
-	if (directCall) {
-		const referenceOwner = findEnclosingFunction$1(directCall);
-		if (referenceOwner && referenceOwner !== usageFunction && collectSynchronouslyEffectInvokedFunctions(callback).has(referenceOwner)) return { generationKey: null };
-		const generationKey = referenceOwner ? findGenerationGuardKeyForDeferredUsage(referenceOwner, directCall, context) : null;
-		return generationKey ? { generationKey } : null;
-	}
-	const referenceRoot = findTransparentExpressionRoot(reference);
-	const schedulerCall = referenceRoot.parent;
-	if (!isNodeOfType(schedulerCall, "CallExpression") || !schedulerCall.arguments.some((argument) => argument === referenceRoot) || !isNodeOfType(schedulerCall.callee, "Identifier") || schedulerCall.callee.name !== "setTimeout" || !context.scopes.isGlobalReference(schedulerCall.callee)) return null;
-	const schedulerUsage = {
-		kind: "timer",
-		node: schedulerCall,
-		resourceName: schedulerCall.callee.name,
-		handleKey: findAssignedResourceKey(schedulerCall, context),
-		receiverKey: null,
-		registrationVerbName: schedulerCall.callee.name,
-		eventKey: null,
-		handlerKey: null
-	};
-	const generationKey = findGenerationGuardKeyForDeferredUsage(usageFunction, usageNode, context);
-	return schedulerUsage.handleKey !== null && cleanupReturnsReleaseUsage(cleanupReturns, schedulerUsage, context) && generationKey ? { generationKey } : null;
-};
-const hasGuardedRefOwnedNestedCleanup = (callback, usage, cleanupReturns, context) => {
-	const usageFunction = findEnclosingFunction$1(usage.node);
-	const usageExpression = findTransparentExpressionRoot(usage.node);
-	const usageAssignment = usageExpression.parent;
-	if (usage.kind !== "subscribe" && usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !resolveReactRefSymbol(stripParenExpression(usageAssignment.left), context.scopes) || !collectSynchronouslyEffectInvokedFunctions(callback).has(usageFunction) || !cleanupReturnsReleaseUsage(cleanupReturns, usage, context) || !doMatchingNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
-	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
-		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
-		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
-		return cleanupFunction && isFunctionLike$1(cleanupFunction) ? [cleanupFunction] : [];
-	});
-	const bindingIdentifier = getFunctionBindingIdentifier$1(usageFunction);
-	const functionSymbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
-	if (!functionSymbol || functionSymbol.references.length === 0) return false;
-	const ownedReferences = functionSymbol.references.map((reference) => getOwnedFunctionReference(reference.identifier, usageFunction, usage.node, callback, cleanupReturns, context));
-	if (ownedReferences.some((reference) => reference === null)) return false;
-	const generationKeys = new Set(ownedReferences.flatMap((reference) => reference?.generationKey ? [reference.generationKey] : []));
-	if (generationKeys.size !== 1) return false;
-	const generationKey = generationKeys.values().next().value;
-	if (typeof generationKey !== "string") return false;
-	return [...collectSynchronouslyEffectInvokedFunctions(callback), ...cleanupFunctions].some((owner) => functionAdvancesGeneration(owner, generationKey, context));
-};
 const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
-	if (hasGuardedRefOwnedNestedCleanup(callback, usage, cleanupReturns, context)) return true;
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
 	if (usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usage.node, "CallExpression") || !isNodeOfType(usage.node.callee, "Identifier") || !context.scopes.isGlobalReference(usage.node.callee) || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
@@ -15014,7 +14911,6 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
 	if (releaseVerbName === "abort" && isRetainedAbortControllerRefRelease(callee.object, usage, context)) return true;
 	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
-	if (usage.registrationVerbName === "subscribe" && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub") && usage.handleKey !== null && resolveExpressionKey(callNode.arguments?.[0], context) === usage.handleKey) return true;
 	const pairedVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
 	if (!pairedVerbNames || !matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return false;
 	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
@@ -15051,8 +14947,7 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		const releaseHandler = usesUnaryListenerSignature ? callNode.arguments?.[0] : callNode.arguments?.[1];
 		if (!releaseHandler) return releaseVerbName === "off";
 		const expectedHandlerKey = usesUnaryListenerSignature ? usage.eventKey : usage.handlerKey;
-		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignature ? 0 : 1] : null;
-		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
+		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey;
 	}
 	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
 	return true;
@@ -15077,188 +14972,13 @@ const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (!symbol) return false;
 	return symbol.references.some((reference) => findEnclosingFunction$1(reference.identifier) !== functionNode);
 };
-const isJsxRefAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && node.name.name === "ref";
-const isFunctionForwardedToReactRef = (functionNode, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
-	if (!bindingIdentifier) return false;
-	const symbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!symbol) return false;
-	return symbol.references.some((reference) => {
-		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-		const expressionContainer = referenceRoot.parent;
-		return Boolean(isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === referenceRoot && isJsxRefAttribute(expressionContainer.parent));
-	});
-};
-const findRetainedDisposerStorages = (disposerFunction, usage, context) => {
-	if (!isFunctionLike$1(disposerFunction) || disposerFunction.async || disposerFunction.generator) return [];
-	const usageFunction = findEnclosingFunction$1(usage.node);
-	if (!usageFunction || !isFunctionLike$1(usageFunction)) return [];
-	const assignments = /* @__PURE__ */ new Map();
-	const collectAssignment = (expression) => {
-		const expressionRoot = findTransparentExpressionRoot(expression);
-		const assignment = expressionRoot.parent;
-		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.right !== expressionRoot) return;
-		const refSymbol = resolveReactRefSymbol(stripParenExpression(assignment.left), context.scopes);
-		const refCurrentKey = resolveExpressionKey(assignment.left, context);
-		const retainedFunction = findEnclosingFunction$1(assignment);
-		const assignmentStart = getRangeStart(assignment);
-		if (!refSymbol || !refCurrentKey || !retainedFunction || retainedFunction !== usageFunction || assignmentStart === null) return;
-		assignments.set(assignmentStart, {
-			assignmentNode: assignment,
-			refCurrentKey,
-			retainedFunction
-		});
-	};
-	collectAssignment(disposerFunction);
-	const bindingIdentifier = getFunctionBindingIdentifier$1(disposerFunction);
-	const symbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
-	for (const reference of symbol?.references ?? []) collectAssignment(reference.identifier);
-	walkAst(usageFunction.body, (child) => {
-		if (child !== usageFunction.body && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "AssignmentExpression") && resolveStableValue(child.right, context) === disposerFunction) collectAssignment(child.right);
-	});
-	return [...assignments.values()];
-};
-const isRetainedDisposerStorageEstablished = (storage, usage, context) => doMatchingNodesCoverEveryPathBeforeUsage(usage.node, [storage.assignmentNode], storage.retainedFunction, context) || doMatchingNodesCoverEveryPathAfterUsage(usage.node, [storage.assignmentNode], context);
-const hasUnsafeRetainedDisposerOverwrite = (storage, usage, context) => {
-	let hasUnsafeOverwrite = false;
-	walkAst(storage.retainedFunction.body, (child) => {
-		if (hasUnsafeOverwrite) return false;
-		if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "AssignmentExpression") || child === storage.assignmentNode || resolveExpressionKey(child.left, context) !== storage.refCurrentKey || !canNodeReachLaterNodeWithinFunction(usage.node, child, storage.retainedFunction, context)) return;
-		const storedValue = resolveStableValue(child.right, context);
-		if (!storedValue || !isFunctionLike$1(storedValue) || !doesCleanupFunctionReleaseUsage(storedValue, usage, context)) {
-			hasUnsafeOverwrite = true;
-			return false;
-		}
-	});
-	return hasUnsafeOverwrite;
-};
-const hasEffectCleanupInvocation = (storage, usage, context) => {
-	const componentFunction = findEnclosingFunction$1(storage.retainedFunction);
-	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
-	const cleanupFunctionInvokesRef = (cleanupFunction) => {
-		if (!isFunctionLike$1(cleanupFunction)) return false;
-		let didFindCleanupCall = false;
-		walkAst(cleanupFunction.body, (child) => {
-			if (didFindCleanupCall) return false;
-			if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
-			if (isNodeOfType(child, "CallExpression") && resolveExpressionKey(child.callee, context) === storage.refCurrentKey) {
-				const callRoot = findTransparentExpressionRoot(child);
-				const callStatement = callRoot.parent;
-				const isDirectBlockStatement = isNodeOfType(cleanupFunction.body, "BlockStatement") && isNodeOfType(callStatement, "ExpressionStatement") && callStatement.parent === cleanupFunction.body;
-				const isConciseBody = cleanupFunction.body === callRoot;
-				if ((isDirectBlockStatement || isConciseBody) && !hasUnprovenReturnBeforeRefOwnedRelease(cleanupFunction, child, storage.refCurrentKey, context)) {
-					didFindCleanupCall = true;
-					return false;
-				}
-			}
-		});
-		return didFindCleanupCall;
-	};
-	const effectReturnsCleanup = (effectCallback) => {
-		if (!isFunctionLike$1(effectCallback)) return false;
-		if (!isNodeOfType(effectCallback.body, "BlockStatement")) {
-			const cleanupFunction = resolveRefOwnedCleanupFunction(effectCallback.body, context);
-			return Boolean(cleanupFunction && cleanupFunctionInvokesRef(cleanupFunction));
-		}
-		const matchingReturns = [];
-		walkInsideStatementBlocks(effectCallback.body, (child) => {
-			if (!isNodeOfType(child, "ReturnStatement") || !child.argument) return;
-			const cleanupFunction = resolveRefOwnedCleanupFunction(child.argument, context);
-			if (!cleanupFunction || !cleanupFunctionInvokesRef(cleanupFunction)) return;
-			matchingReturns.push(child);
-		});
-		return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
-	};
-	let didFindInvocation = false;
-	walkAst(componentFunction.body, (child) => {
-		if (didFindInvocation) return false;
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
-		const effectCallback = getEffectCallback(child);
-		if (effectCallback && effectReturnsCleanup(effectCallback)) {
-			didFindInvocation = true;
-			return false;
-		}
-	});
-	return didFindInvocation;
-};
-const hasCallbackRefReplacementInvocation = (storage, usage, context) => {
-	const isReturnedCallbackRefShape = () => {
-		if (!isFunctionLike$1(storage.retainedFunction)) return false;
-		const callbackCall = findTransparentExpressionRoot(storage.retainedFunction).parent;
-		if (!isNodeOfType(callbackCall, "CallExpression") || !isReactApiCall(callbackCall, "useCallback", context.scopes)) return false;
-		const nodeParameter = storage.retainedFunction.params?.[0];
-		const nodeParameterKey = resolveExpressionKey(nodeParameter, context);
-		if (!nodeParameterKey || usage.receiverKey !== nodeParameterKey) return false;
-		const bindingIdentifier = getFunctionBindingIdentifier$1(storage.retainedFunction);
-		const symbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
-		if (!Boolean(symbol?.references.some((reference) => {
-			const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-			const property = referenceRoot.parent;
-			if (!isNodeOfType(property, "Property") || property.value !== referenceRoot || !isNodeOfType(property.parent, "ObjectExpression")) return false;
-			const returnedObject = findTransparentExpressionRoot(property.parent);
-			const returnStatement = returnedObject.parent;
-			if (!isNodeOfType(returnStatement, "ReturnStatement") || returnStatement.argument !== returnedObject) return false;
-			const hookFunction = findEnclosingFunction$1(returnStatement);
-			return Boolean(hookFunction && getFunctionBindingIdentifier$1(hookFunction)?.name.startsWith("use"));
-		}))) return false;
-		const usageStart = getRangeStart(usage.node);
-		if (usageStart === null) return false;
-		let hasNullExit = false;
-		walkAst(storage.retainedFunction.body, (child) => {
-			if (hasNullExit) return false;
-			if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
-			if (!isNodeOfType(child, "IfStatement") || (getRangeStart(child) ?? usageStart) >= usageStart) return;
-			const test = stripParenExpression(child.test);
-			if (!isNodeOfType(test, "UnaryExpression") || test.operator !== "!" || resolveExpressionKey(test.argument, context) !== nodeParameterKey) return;
-			const consequent = child.consequent;
-			hasNullExit = isNodeOfType(consequent, "ReturnStatement") || isNodeOfType(consequent, "BlockStatement") && consequent.body.some((statement) => isNodeOfType(statement, "ReturnStatement"));
-			if (hasNullExit) return false;
-		});
-		return hasNullExit;
-	};
-	if (!isFunctionForwardedToReactRef(storage.retainedFunction, context) && !isReturnedCallbackRefShape()) return false;
-	const cleanupCalls = [];
-	walkAst(storage.retainedFunction.body, (child) => {
-		if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "CallExpression") && resolveExpressionKey(child.callee, context) === storage.refCurrentKey) cleanupCalls.push(child);
-	});
-	return doMatchingNodesCoverEveryPathBeforeUsage(usage.node, cleanupCalls, storage.retainedFunction, context);
-};
-const isRetainedDisposerRefRelease = (releaseNode, usage, context) => {
-	const disposerFunction = findEnclosingFunction$1(releaseNode);
-	if (!disposerFunction) return false;
-	return findRetainedDisposerStorages(disposerFunction, usage, context).some((storage) => isRetainedDisposerStorageEstablished(storage, usage, context) && !hasUnsafeRetainedDisposerOverwrite(storage, usage, context) && (hasEffectCleanupInvocation(storage, usage, context) || hasCallbackRefReplacementInvocation(storage, usage, context)));
-};
-const isSelfReleasingListenerRelease = (releaseNode, releaseFunction, usage, context) => {
-	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
-	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
-	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
-	if (!isNodeOfType(releaseCall, "CallExpression")) return false;
-	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
-	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
-	const ownerFunction = findEnclosingFunction$1(releaseFunction);
-	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
-	const triggerRegistrations = [];
-	walkAst(ownerFunction.body, (child) => {
-		if (child !== ownerFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const registrationDetails = getCallRegistrationDetails(child, context);
-		if (registrationDetails.registrationVerbName === "addEventListener" && registrationDetails.receiverKey === usage.receiverKey && resolveStableValue(child.arguments?.[1], context) === releaseFunction) triggerRegistrations.push(child);
-	});
-	if (triggerRegistrations.some((triggerRegistration) => triggerRegistration === usage.node)) return true;
-	return doMatchingNodesCoverEveryPathAfterUsage(usage.node, triggerRegistrations, context) || doMatchingNodesCoverEveryPathBeforeUsage(usage.node, triggerRegistrations, ownerFunction, context);
-};
 const isReleaseReachableForUsage = (releaseNode, usage, context) => {
 	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
 	const releaseFunction = findEnclosingFunction$1(releaseNode);
 	if (!releaseFunction) return true;
 	if (releaseFunction === findEnclosingFunction$1(usage.node)) return true;
-	if (isRetainedDisposerRefRelease(releaseNode, usage, context)) return true;
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	if (usageFunction && isFunctionLike$1(usageFunction) && getAssignedReactRefSymbol(usageFunction, context) && isCleanupFunctionReferencedByReturn(usageFunction, releaseFunction, context)) return isReactRefCallbackCleanupOwnedByEffect(usageFunction, releaseFunction, usage, context);
-	if (isSelfReleasingListenerRelease(releaseNode, releaseFunction, usage, context)) return true;
 	return isPotentiallyReachableFunction(releaseFunction, context);
 };
 const fileContainsReleaseForUsage = (usage, context) => {
@@ -17392,7 +17112,7 @@ const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys, allow
 				keys.add(depKey);
 				continue;
 			}
-			const identitySourceKeys = resolvePureCalledFunctionSourceKeys(reference, symbol, scopes) ?? resolveRenderDerivedMutableSourceKeys(reference, symbol, scopes) ?? resolveReactiveIdentitySourceKeys(symbol, scopes);
+			const identitySourceKeys = resolveReactiveIdentitySourceKeys(symbol, scopes);
 			if (identitySourceKeys) {
 				if (identitySourceKeys.size === 0) stableCapturedNames.add(depKey);
 				for (const identitySourceKey of identitySourceKeys) keys.add(identitySourceKey);
@@ -17475,161 +17195,6 @@ const resolveReactiveIdentitySourceKeys = (symbol, scopes) => {
 	if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || symbol.references.some((reference) => reference.flag !== "read")) return null;
 	return resolveIdentitySourceKeysFromExpression(symbol.initializer, scopes, new Set([symbol.id]));
 };
-const isPureDerivedExpression = (expression) => {
-	const candidate = unwrapExpression$3(expression);
-	if (isNodeOfType(candidate, "Literal") || isNodeOfType(candidate, "Identifier")) return true;
-	if (isNodeOfType(candidate, "MemberExpression")) return isPureDerivedExpression(candidate.object) && (!candidate.computed || isPureDerivedExpression(candidate.property));
-	if (isNodeOfType(candidate, "BinaryExpression") || isNodeOfType(candidate, "LogicalExpression")) return isPureDerivedExpression(candidate.left) && isPureDerivedExpression(candidate.right);
-	if (isNodeOfType(candidate, "UnaryExpression")) return candidate.operator !== "delete" && isPureDerivedExpression(candidate.argument);
-	if (isNodeOfType(candidate, "ConditionalExpression")) return isPureDerivedExpression(candidate.test) && isPureDerivedExpression(candidate.consequent) && isPureDerivedExpression(candidate.alternate);
-	if (isNodeOfType(candidate, "TemplateLiteral")) return candidate.expressions.every((nestedExpression) => isPureDerivedExpression(nestedExpression));
-	return false;
-};
-const isPureDerivedStatement = (statement) => {
-	if (isNodeOfType(statement, "BlockStatement")) return statement.body.every((nestedStatement) => isPureDerivedStatement(nestedStatement));
-	if (isNodeOfType(statement, "ReturnStatement")) return !statement.argument || isPureDerivedExpression(statement.argument);
-	if (isNodeOfType(statement, "IfStatement")) return isPureDerivedExpression(statement.test) && isPureDerivedStatement(statement.consequent) && (!statement.alternate || isPureDerivedStatement(statement.alternate));
-	return false;
-};
-const isPureDerivedFunction = (functionNode) => {
-	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return false;
-	if (functionNode.async || functionNode.generator) return false;
-	return isNodeOfType(functionNode.body, "BlockStatement") ? isPureDerivedStatement(functionNode.body) : isPureDerivedExpression(functionNode.body);
-};
-const resolvePureCalledFunctionSourceKeys = (reference, symbol, scopes) => {
-	if (symbol.references.some((symbolReference) => symbolReference.flag !== "read")) return null;
-	const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-	const callExpression = referenceRoot.parent;
-	if (!isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== referenceRoot) return null;
-	const functionNode = getFunctionValueNode(symbol);
-	if (!functionNode || !isPureDerivedFunction(functionNode)) return null;
-	const sourceKeys = /* @__PURE__ */ new Set();
-	for (const capturedReference of closureCaptures(functionNode, scopes)) {
-		const capturedSymbol = capturedReference.resolvedSymbol;
-		if (!capturedSymbol || capturedSymbol.id === symbol.id) continue;
-		if (isOutsideAllFunctions(capturedSymbol) || symbolHasStableValue(capturedSymbol, scopes)) continue;
-		const capturedKey = computeDepKey(capturedReference);
-		if (!capturedKey) return null;
-		if (capturedKey === capturedSymbol.name) {
-			const nestedSourceKeys = resolveReactiveIdentitySourceKeys(capturedSymbol, scopes);
-			if (nestedSourceKeys) {
-				for (const nestedSourceKey of nestedSourceKeys) sourceKeys.add(nestedSourceKey);
-				continue;
-			}
-		}
-		sourceKeys.add(capturedKey);
-	}
-	return sourceKeys.size > 0 ? sourceKeys : null;
-};
-const mergeDerivedExpressionSourceKeys = (expressions, scopes, visitedSymbolIds) => {
-	const sourceKeys = /* @__PURE__ */ new Set();
-	for (const expression of expressions) {
-		const expressionSourceKeys = resolveDerivedExpressionSourceKeys(expression, scopes, visitedSymbolIds);
-		if (!expressionSourceKeys) return null;
-		for (const expressionSourceKey of expressionSourceKeys) sourceKeys.add(expressionSourceKey);
-	}
-	return sourceKeys;
-};
-const resolveDerivedExpressionSourceKeys = (expression, scopes, visitedSymbolIds) => {
-	const candidate = unwrapExpression$3(expression);
-	if (isNodeOfType(candidate, "Literal")) return /* @__PURE__ */ new Set();
-	if (isNodeOfType(candidate, "Identifier")) {
-		if (scopes.isGlobalReference(candidate)) return /* @__PURE__ */ new Set();
-		const sourceSymbol = scopes.symbolFor(candidate);
-		if (!sourceSymbol) return null;
-		if (isOutsideAllFunctions(sourceSymbol) || symbolHasStableValue(sourceSymbol, scopes)) return /* @__PURE__ */ new Set();
-		if (sourceSymbol.kind === "const" && sourceSymbol.initializer && isNodeOfType(sourceSymbol.declarationNode, "VariableDeclarator") && sourceSymbol.declarationNode.id === sourceSymbol.bindingIdentifier && sourceSymbol.references.every((sourceReference) => sourceReference.flag === "read") && !visitedSymbolIds.has(sourceSymbol.id)) {
-			visitedSymbolIds.add(sourceSymbol.id);
-			const sourceKeys = resolveDerivedExpressionSourceKeys(sourceSymbol.initializer, scopes, visitedSymbolIds);
-			visitedSymbolIds.delete(sourceSymbol.id);
-			if (sourceKeys) return sourceKeys;
-		}
-		return new Set([sourceSymbol.name]);
-	}
-	if (isNodeOfType(candidate, "MemberExpression")) {
-		if (hasComputedMemberExpression(candidate)) return null;
-		const sourceKey = stringifyMemberChain(candidate);
-		const rootIdentifier = getMemberRootIdentifier(candidate);
-		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
-		if (!sourceKey || !rootSymbol) return null;
-		if (isOutsideAllFunctions(rootSymbol) || symbolHasStableValue(rootSymbol, scopes)) return /* @__PURE__ */ new Set();
-		return new Set([sourceKey]);
-	}
-	if (isNodeOfType(candidate, "BinaryExpression") || isNodeOfType(candidate, "LogicalExpression")) return mergeDerivedExpressionSourceKeys([candidate.left, candidate.right], scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator !== "delete") return resolveDerivedExpressionSourceKeys(candidate.argument, scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "ConditionalExpression")) return mergeDerivedExpressionSourceKeys([
-		candidate.test,
-		candidate.consequent,
-		candidate.alternate
-	], scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "TemplateLiteral")) return mergeDerivedExpressionSourceKeys(candidate.expressions, scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "NewExpression")) {
-		const callee = unwrapExpression$3(candidate.callee);
-		if (!isNodeOfType(callee, "Identifier") || callee.name !== "Error" || !scopes.isGlobalReference(callee)) return null;
-		const argumentsToAnalyze = [];
-		for (const argument of candidate.arguments) {
-			if (!isAstNode(argument) || isNodeOfType(argument, "SpreadElement")) return null;
-			argumentsToAnalyze.push(argument);
-		}
-		return mergeDerivedExpressionSourceKeys(argumentsToAnalyze, scopes, visitedSymbolIds);
-	}
-	return null;
-};
-const resolveWriteControlSourceKeys = (assignment, boundaryFunction, scopes) => {
-	const sourceKeys = /* @__PURE__ */ new Set();
-	let currentNode = assignment;
-	while (currentNode.parent && currentNode.parent !== boundaryFunction) {
-		const parentNode = currentNode.parent;
-		if (isNodeOfType(parentNode, "IfStatement")) {
-			if (parentNode.test === currentNode) return null;
-			const testSourceKeys = resolveDerivedExpressionSourceKeys(parentNode.test, scopes, /* @__PURE__ */ new Set());
-			if (!testSourceKeys) return null;
-			for (const testSourceKey of testSourceKeys) sourceKeys.add(testSourceKey);
-		} else if (!isNodeOfType(parentNode, "ExpressionStatement") && !isNodeOfType(parentNode, "BlockStatement")) return null;
-		currentNode = parentNode;
-	}
-	return currentNode.parent === boundaryFunction ? sourceKeys : null;
-};
-const isReadOnlyInitialStateUse = (referenceNode, scopes) => {
-	const referenceRoot = findTransparentExpressionRoot(referenceNode);
-	const callExpression = referenceRoot.parent;
-	return isNodeOfType(callExpression, "CallExpression") && callExpression.arguments.some((argument) => argument === referenceRoot) && isReactApiCall(callExpression, "useState", scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true,
-		resolveNamedAliases: true
-	});
-};
-const resolveRenderDerivedMutableSourceKeys = (capturedReference, symbol, scopes) => {
-	if (symbol.kind !== "let" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-	const boundaryFunction = findEnclosingFunction$1(symbol.bindingIdentifier);
-	if (!boundaryFunction) return null;
-	const capturingFunction = findEnclosingFunction$1(capturedReference.identifier);
-	if (!capturingFunction || capturingFunction === boundaryFunction) return null;
-	const sourceKeys = /* @__PURE__ */ new Set();
-	if (symbol.initializer) {
-		const initializerSourceKeys = resolveDerivedExpressionSourceKeys(symbol.initializer, scopes, new Set([symbol.id]));
-		if (!initializerSourceKeys) return null;
-		for (const initializerSourceKey of initializerSourceKeys) sourceKeys.add(initializerSourceKey);
-	}
-	let writeCount = 0;
-	for (const symbolReference of symbol.references) {
-		if (symbolReference.flag === "read") {
-			if (findEnclosingFunction$1(symbolReference.identifier) !== capturingFunction && !isReadOnlyInitialStateUse(symbolReference.identifier, scopes)) return null;
-			continue;
-		}
-		if (symbolReference.flag !== "write") return null;
-		const referenceRoot = findTransparentExpressionRoot(symbolReference.identifier);
-		const assignment = referenceRoot.parent;
-		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== referenceRoot || findEnclosingFunction$1(referenceRoot) !== boundaryFunction) return null;
-		const assignmentSourceKeys = resolveDerivedExpressionSourceKeys(assignment.right, scopes, new Set([symbol.id]));
-		const controlSourceKeys = resolveWriteControlSourceKeys(assignment, boundaryFunction, scopes);
-		if (!assignmentSourceKeys || !controlSourceKeys) return null;
-		for (const assignmentSourceKey of assignmentSourceKeys) sourceKeys.add(assignmentSourceKey);
-		for (const controlSourceKey of controlSourceKeys) sourceKeys.add(controlSourceKey);
-		writeCount += 1;
-	}
-	return writeCount > 0 && sourceKeys.size > 0 ? sourceKeys : null;
-};
 const isUseCallbackResultDep = (node, scopes) => {
 	const rootSymbol = getRootSymbol(node, scopes);
 	const initializer = rootSymbol?.initializer ? unwrapExpression$3(rootSymbol.initializer) : null;
@@ -42457,8 +42022,7 @@ const noJsxElementType = defineRule({
 	create: (context) => {
 		let isJsxImported = false;
 		const flaggedAnnotations = [];
-		const collectComponentReturnType = (functionNode, returnType) => {
-			if (!(isNodeOfType(functionNode, "TSDeclareFunction") ? Boolean(functionNode.id && isReactComponentName(functionNode.id.name)) : isComponentFunction$1(functionNode))) return;
+		const checkReturnType = (returnType) => {
 			const typeAnnotation = extractReturnTypeAnnotation(returnType);
 			if (!typeAnnotation) return;
 			if (isJsxElementTypeReference(typeAnnotation)) flaggedAnnotations.push(typeAnnotation);
@@ -42468,16 +42032,19 @@ const noJsxElementType = defineRule({
 				if (isJsxImportBinding(node)) isJsxImported = true;
 			},
 			FunctionDeclaration(node) {
-				collectComponentReturnType(node, node.returnType);
+				checkReturnType(node.returnType);
 			},
 			ArrowFunctionExpression(node) {
-				collectComponentReturnType(node, node.returnType);
+				checkReturnType(node.returnType);
 			},
 			FunctionExpression(node) {
-				collectComponentReturnType(node, node.returnType);
+				checkReturnType(node.returnType);
 			},
 			TSDeclareFunction(node) {
-				collectComponentReturnType(node, node.returnType);
+				checkReturnType(node.returnType);
+			},
+			TSMethodSignature(node) {
+				checkReturnType(node.returnType);
 			},
 			"Program:exit"() {
 				if (isJsxImported) return;
@@ -47701,69 +47268,6 @@ const noRedundantShouldComponentUpdate = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/correctness/no-ref-callback-cleanup-before-react-19.ts
-const resolveFunctionExpressions = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isFunctionLike$1(expression)) return expression.async || expression.generator ? [] : [expression];
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		if (isNodeOfType(expression.test, "Literal")) return resolveFunctionExpressions(expression.test.value ? expression.consequent : expression.alternate, scopes, visitedSymbolIds);
-		return [...resolveFunctionExpressions(expression.consequent, scopes, visitedSymbolIds), ...resolveFunctionExpressions(expression.alternate, scopes, visitedSymbolIds)];
-	}
-	if (isNodeOfType(expression, "LogicalExpression")) {
-		if (isNodeOfType(expression.left, "Literal")) {
-			const isLeftTruthy = Boolean(expression.left.value);
-			if (expression.operator === "&&" && !isLeftTruthy) return [];
-			if (expression.operator === "||" && isLeftTruthy) return [];
-			if (expression.operator === "??" && expression.left.value !== null) return [];
-		}
-		if (expression.operator === "&&") return resolveFunctionExpressions(expression.right, scopes, visitedSymbolIds);
-		return [...resolveFunctionExpressions(expression.left, scopes, visitedSymbolIds), ...resolveFunctionExpressions(expression.right, scopes, visitedSymbolIds)];
-	}
-	if (isNodeOfType(expression, "SequenceExpression")) {
-		const finalExpression = expression.expressions.at(-1);
-		return finalExpression ? resolveFunctionExpressions(finalExpression, scopes, visitedSymbolIds) : [];
-	}
-	if (isNodeOfType(expression, "CallExpression")) {
-		if (!isReactApiCall(expression, "useCallback", scopes)) return [];
-		const callback = expression.arguments[0];
-		return callback && !isNodeOfType(callback, "SpreadElement") ? resolveFunctionExpressions(callback, scopes, visitedSymbolIds) : [];
-	}
-	if (!isNodeOfType(expression, "Identifier")) return [];
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return [];
-	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration") && symbol.references.every((reference) => reference.flag === "read")) return resolveFunctionExpressions(symbol.declarationNode, scopes, new Set([...visitedSymbolIds, symbol.id]));
-	const initializer = getDirectConstInitializer(symbol);
-	if (!initializer) return [];
-	return resolveFunctionExpressions(initializer, scopes, new Set([...visitedSymbolIds, symbol.id]));
-};
-const functionReturnsCleanupFunction = (functionExpression, scopes) => {
-	if (!isFunctionLike$1(functionExpression)) return false;
-	if (!isNodeOfType(functionExpression.body, "BlockStatement")) return resolveFunctionExpressions(functionExpression.body, scopes).length > 0;
-	return collectFunctionReturnStatements(functionExpression).some((returnStatement) => Boolean(returnStatement.argument && resolveFunctionExpressions(returnStatement.argument, scopes).length > 0));
-};
-const callbackReturnsCleanupFunction = (callback, scopes) => {
-	return resolveFunctionExpressions(callback, scopes).some((functionExpression) => functionReturnsCleanupFunction(functionExpression, scopes));
-};
-const noRefCallbackCleanupBeforeReact19 = defineRule({
-	id: "no-ref-callback-cleanup-before-react-19",
-	title: "Ref cleanup requires React 19",
-	requires: ["react:18"],
-	disabledWhen: ["react:19"],
-	severity: "warn",
-	recommendation: "React 18 ignores functions returned from ref callbacks. Handle cleanup when React calls the ref with `null`, or require React 19 before returning a cleanup function.",
-	create: (context) => ({ JSXAttribute(node) {
-		if (getJsxAttributeName(node.name) !== "ref") return;
-		if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
-		const callback = node.value.expression;
-		if (!callback || isNodeOfType(callback, "JSXEmptyExpression")) return;
-		if (!callbackReturnsCleanupFunction(callback, context.scopes)) return;
-		context.report({
-			node,
-			message: "This ref callback returns a cleanup function, but React 18 ignores ref cleanup returns, so the cleanup never runs. Handle detachment when React calls the ref with `null`, or require React 19."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
 const REPEATED_ANCESTOR_TYPES = new Set([
 	"DoWhileStatement",
@@ -72531,17 +72035,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRedundantShouldComponentUpdate.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-ref-callback-cleanup-before-react-19",
-		id: "no-ref-callback-cleanup-before-react-19",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noRefCallbackCleanupBeforeReact19,
-			framework: "global",
-			category: "Bugs"
-		}
-	},
 	{
 		key: "react-doctor/no-ref-current-in-render",
 		id: "no-ref-current-in-render",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.9-dev.093619c",
+  "version": "0.7.9-dev.0ff57fa",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",