oxlint-plugin-react-doctor 0.7.2-dev.2953b25 → 0.7.2-dev.6ae8e46

package/dist/index.d.ts

@@ -5595,29 +5595,6 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/no-stale-timer-ref";
-  readonly id: "no-stale-timer-ref";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Bugs";
-    readonly requires: readonly Capability[];
-    readonly id: string;
-    readonly title?: string;
-    readonly severity: RuleSeverity;
-    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-static-element-interactions";
   readonly id: "no-static-element-interactions";
@@ -14677,29 +14654,6 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/no-stale-timer-ref";
-  readonly id: "no-stale-timer-ref";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Bugs";
-    readonly requires: readonly Capability[];
-    readonly id: string;
-    readonly title?: string;
-    readonly severity: RuleSeverity;
-    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-static-element-interactions";
   readonly id: "no-static-element-interactions";

package/dist/index.js

@@ -7717,12 +7717,6 @@ const enclosingComponentOrHookName = (node) => {
 	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
 };
 //#endregion
-//#region src/plugin/utils/get-range-start.ts
-const getRangeStart = (node) => {
-	const rangeStart = node.range?.[0];
-	return typeof rangeStart === "number" ? rangeStart : null;
-};
-//#endregion
 //#region src/plugin/utils/is-result-discarded-call.ts
 const isResultDiscardedCall = (callExpression) => {
 	let node = callExpression;
@@ -8009,6 +8003,10 @@ const collectCleanupBindings = (effectCallback) => {
 	});
 	return bindings;
 };
+const getRangeStart = (node) => {
+	const rangeStart = node.range?.[0];
+	return typeof rangeStart === "number" ? rangeStart : null;
+};
 const removeSynchronouslyReleasedUsages = (callback, usages) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
@@ -8982,6 +8980,24 @@ const isAstDescendant = (inner, outer) => {
 	return false;
 };
 //#endregion
+//#region src/plugin/utils/is-imported-from-non-react-module.ts
+const isImportedFromNonReactModule = (contextNode, localIdentifierName) => {
+	const importSource = getImportSourceForName(contextNode, localIdentifierName);
+	if (importSource === null) return false;
+	return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
+};
+//#endregion
+//#region src/plugin/utils/is-non-react-effect-event-callee.ts
+const resolvesToLocalNonImportBinding = (identifier, scopes) => {
+	const symbol = scopes.referenceFor(identifier)?.resolvedSymbol;
+	return Boolean(symbol && symbol.kind !== "import");
+};
+const isNonReactEffectEventCallee = (callee, contextNode, scopes) => {
+	if (isNodeOfType(callee, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.name) || resolvesToLocalNonImportBinding(callee, scopes);
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.object.name);
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-symbol-stability.ts
 /**
 * Symbol-stability helpers consumed by the `exhaustive-deps` rule.
@@ -8989,8 +9005,8 @@ const isAstDescendant = (inner, outer) => {
 * One cohesive concept: "given a captured symbol, is its value
 * structurally stable across re-renders (and therefore unnecessary
 * in a deps array)?". The rule reads `symbolHasStableValue` /
-* `symbolHasStableHookOrigin` / `isRecursiveInitializerCapture` at
-* multiple sites — extracting
+* `symbolHasStableHookOrigin` / `symbolHasUseEffectEventOrigin` /
+* `isRecursiveInitializerCapture` at multiple sites — extracting
 * them lets the rule body stay focused on the diff-the-captured-vs-
 * declared logic.
 *
@@ -9046,6 +9062,12 @@ const symbolHasStableHookOrigin = (symbol) => {
 	}
 	return false;
 };
+const symbolHasUseEffectEventOrigin = (symbol, scopes) => {
+	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
+	if (getHookName(initializer.callee) !== "useEffectEvent") return false;
+	return !isNonReactEffectEventCallee(initializer.callee, initializer, scopes);
+};
 const getFunctionValueNode = (symbol) => {
 	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return symbol.declarationNode;
 	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
@@ -9131,37 +9153,6 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 };
 const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
 //#endregion
-//#region src/plugin/utils/is-imported-from-non-react-module.ts
-const isImportedFromNonReactModule = (contextNode, localIdentifierName) => {
-	const importSource = getImportSourceForName(contextNode, localIdentifierName);
-	if (importSource === null) return false;
-	return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
-};
-//#endregion
-//#region src/plugin/utils/is-non-react-effect-event-callee.ts
-const resolvesToLocalNonImportBinding = (identifier, scopes) => {
-	const symbol = scopes.referenceFor(identifier)?.resolvedSymbol;
-	return Boolean(symbol && symbol.kind !== "import");
-};
-const isNonReactEffectEventCallee = (callee, contextNode, scopes) => {
-	if (isNodeOfType(callee, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.name) || resolvesToLocalNonImportBinding(callee, scopes);
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.object.name);
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
-const getUseEffectEventCalleeName = (callee) => {
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
-	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	if (getUseEffectEventCalleeName(initializer.callee) !== "useEffectEvent") return false;
-	return !isNonReactEffectEventCallee(initializer.callee, initializer, scopes);
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps.ts
 const HOOKS_REQUIRING_DEPS_MATCH = new Set([
 	"useEffect",
@@ -9812,7 +9803,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (isLiteralOrEmptyTemplate(stripped)) continue;
 				if (isNodeOfType(stripped, "Identifier")) {
 					const depSymbol = context.scopes.symbolFor(stripped);
-					if (depSymbol && symbolHasReactUseEffectEventOrigin(depSymbol, context.scopes)) {
+					if (depSymbol && symbolHasUseEffectEventOrigin(depSymbol, context.scopes)) {
 						context.report({
 							node: elementNode,
 							message: buildEffectEventDepMessage()
@@ -25762,45 +25753,18 @@ const collectUseStateBindings = (componentBody) => {
 //#region src/plugin/rules/state-and-effects/no-direct-state-mutation.ts
 const PLAIN_DATA_PRODUCER_GLOBAL_NAMES = new Set(["Array", "structuredClone"]);
 const PLAIN_DATA_ARRAY_STATIC_METHODS = new Set(["from", "of"]);
-const PLAIN_DATA_JSON_STATIC_METHODS = new Set(["parse"]);
-const PLAIN_DATA_OBJECT_STATIC_METHODS = new Set([
-	"assign",
-	"entries",
-	"fromEntries",
-	"keys",
-	"values"
-]);
-const ARRAY_COPY_METHOD_NAMES = new Set([
-	"map",
-	"filter",
-	"slice",
-	"concat",
-	"flat",
-	"flatMap",
-	"toSorted",
-	"toReversed",
-	"toSpliced",
-	"with"
-]);
 const isNullOrUndefinedExpression = (expression) => isNodeOfType(expression, "Literal") && expression.value === null || isNodeOfType(expression, "Identifier") && expression.name === "undefined";
 const isPlainDataProducerCall = (expression) => {
 	if (!isNodeOfType(expression, "CallExpression")) return false;
 	const callee = expression.callee;
 	if (isNodeOfType(callee, "Identifier")) return PLAIN_DATA_PRODUCER_GLOBAL_NAMES.has(callee.name);
 	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier")) return false;
-	if (isNodeOfType(callee.object, "Identifier")) {
-		if (callee.object.name === "Array") return PLAIN_DATA_ARRAY_STATIC_METHODS.has(callee.property.name);
-		if (callee.object.name === "JSON") return PLAIN_DATA_JSON_STATIC_METHODS.has(callee.property.name);
-		if (callee.object.name === "Object") return PLAIN_DATA_OBJECT_STATIC_METHODS.has(callee.property.name);
-	}
+	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array") return PLAIN_DATA_ARRAY_STATIC_METHODS.has(callee.property.name);
 	return producesPlainStateValue(callee.object);
 };
-const PLAIN_DATA_CONSTRUCTOR_NAMES = new Set(["Array", "Object"]);
-const isPlainDataNewExpression = (expression) => isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && PLAIN_DATA_CONSTRUCTOR_NAMES.has(expression.callee.name);
 const producesPlainStateValue = (expression) => {
 	const unwrapped = stripParenExpression(expression);
 	if (isNodeOfType(unwrapped, "ObjectExpression") || isNodeOfType(unwrapped, "ArrayExpression")) return true;
-	if (isPlainDataNewExpression(unwrapped)) return true;
 	if (isNullOrUndefinedExpression(unwrapped)) return true;
 	if (isNodeOfType(unwrapped, "MemberExpression") && getRootIdentifierName(unwrapped) === "props") return true;
 	return isPlainDataProducerCall(unwrapped);
@@ -25816,22 +25780,17 @@ const initializerMarksPlainState = (initializerArgument) => {
 	return producesPlainStateValue(unwrapped);
 };
 const producesOpaqueInstanceValue = (expression) => {
-	if (isNodeOfType(expression, "NewExpression")) return !isPlainDataNewExpression(expression);
-	if (!isNodeOfType(expression, "CallExpression")) return false;
-	const callee = expression.callee;
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	if (isPlainDataProducerCall(expression)) return false;
-	if (!callee.computed && isNodeOfType(callee.property, "Identifier") && ARRAY_COPY_METHOD_NAMES.has(callee.property.name)) return false;
-	return true;
+	if (isNodeOfType(expression, "NewExpression")) return true;
+	return isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "MemberExpression") && !isPlainDataProducerCall(expression);
 };
 const collectSetterValueObservations = (componentBody, setterNames) => {
 	const plainFedSetterNames = /* @__PURE__ */ new Set();
 	const opaqueFedSetterNames = /* @__PURE__ */ new Set();
-	walkComponentRespectingShadows(componentBody, /* @__PURE__ */ new Set(), (node, currentlyShadowed) => {
+	walkAst(componentBody, (node) => {
 		if (!isNodeOfType(node, "CallExpression")) return;
 		if (!isNodeOfType(node.callee, "Identifier")) return;
 		const setterName = node.callee.name;
-		if (!setterNames.has(setterName) || currentlyShadowed.has(setterName)) return;
+		if (!setterNames.has(setterName)) return;
 		const argument = node.arguments?.[0];
 		if (!argument) return;
 		const unwrapped = stripParenExpression(argument);
@@ -25841,7 +25800,7 @@ const collectSetterValueObservations = (componentBody, setterNames) => {
 			return;
 		}
 		if (producesOpaqueInstanceValue(unwrapped)) opaqueFedSetterNames.add(setterName);
-	}, true);
+	});
 	return {
 		plainFedSetterNames,
 		opaqueFedSetterNames
@@ -34665,204 +34624,6 @@ const noSideTabBorder = defineRule({
 	})
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-stale-timer-ref.ts
-const GLOBAL_TIMER_RECEIVER_NAMES = new Set([
-	"window",
-	"globalThis",
-	"self"
-]);
-const NULLISH_COMPARISON_OPERATORS = new Set([
-	"==",
-	"===",
-	"!=",
-	"!=="
-]);
-const getGlobalTimerCalleeName = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return null;
-	const callee = stripParenExpression(node.callee);
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) {
-		const receiver = stripParenExpression(callee.object);
-		if (isNodeOfType(receiver, "Identifier") && GLOBAL_TIMER_RECEIVER_NAMES.has(receiver.name)) return callee.property.name;
-	}
-	return null;
-};
-const getRefCurrentReceiverName = (node) => {
-	if (!isNodeOfType(node, "MemberExpression") || node.computed) return null;
-	if (!isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return null;
-	const receiver = stripParenExpression(node.object);
-	return isNodeOfType(receiver, "Identifier") ? receiver.name : null;
-};
-const isRefCurrentMemberOf = (node, refName) => getRefCurrentReceiverName(node) === refName;
-const parseClearCallOnTimerRef = (node) => {
-	const clearCalleeName = getGlobalTimerCalleeName(node);
-	if (clearCalleeName === null || !TIMER_CLEANUP_CALLEE_NAMES.has(clearCalleeName)) return null;
-	if (!isNodeOfType(node, "CallExpression")) return null;
-	const clearedArgument = node.arguments?.[0];
-	if (!clearedArgument) return null;
-	const refName = getRefCurrentReceiverName(stripParenExpression(clearedArgument));
-	return refName === null ? null : {
-		clearCalleeName,
-		refName
-	};
-};
-const isClearCallOnRef = (node, refName) => parseClearCallOnTimerRef(node)?.refName === refName;
-const isNullishResetExpression = (node) => isNullishExpression(stripParenExpression(node));
-const isAssignmentToRefCurrent = (node, refName) => isNodeOfType(node, "AssignmentExpression") && node.operator === "=" && isRefCurrentMemberOf(node.left, refName);
-const isClearGuardIfIdiom = (ifStatement, refName) => {
-	if (ifStatement.alternate) return false;
-	const consequent = ifStatement.consequent;
-	return (isNodeOfType(consequent, "BlockStatement") ? consequent.body ?? [] : [consequent]).every((statement) => {
-		if (!isNodeOfType(statement, "ExpressionStatement")) return false;
-		const expression = stripParenExpression(statement.expression);
-		if (isClearCallOnRef(expression, refName)) return true;
-		return isAssignmentToRefCurrent(expression, refName) && isNullishResetExpression(expression.right);
-	});
-};
-const climbBooleanProjection = (refCurrentMember) => {
-	let cursor = refCurrentMember;
-	const logicalAncestors = [];
-	let didPassBooleanProjection = false;
-	while (cursor.parent) {
-		const parent = cursor.parent;
-		if (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type)) {
-			cursor = parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "!") {
-			didPassBooleanProjection = true;
-			cursor = parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "BinaryExpression") && NULLISH_COMPARISON_OPERATORS.has(parent.operator) && isNullishResetExpression(parent.left === cursor ? parent.right : parent.left)) {
-			didPassBooleanProjection = true;
-			cursor = parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression")) {
-			logicalAncestors.push(parent);
-			cursor = parent;
-			continue;
-		}
-		break;
-	}
-	return {
-		conditionRoot: cursor,
-		logicalAncestors,
-		didPassBooleanProjection
-	};
-};
-const isLogicalClearGuardIdiom = (logicalAncestors, refName) => logicalAncestors.some((logical) => logical.operator === "&&" && isClearCallOnRef(stripParenExpression(logical.right), refName));
-const isPendingSignalRead = (refCurrentMember, refName) => {
-	const { conditionRoot, logicalAncestors, didPassBooleanProjection } = climbBooleanProjection(refCurrentMember);
-	const conditionParent = conditionRoot.parent;
-	if (isNodeOfType(conditionParent, "IfStatement") && conditionParent.test === conditionRoot) return !isClearGuardIfIdiom(conditionParent, refName);
-	if ((isNodeOfType(conditionParent, "ConditionalExpression") || isNodeOfType(conditionParent, "WhileStatement") || isNodeOfType(conditionParent, "DoWhileStatement") || isNodeOfType(conditionParent, "ForStatement")) && conditionParent.test === conditionRoot) return true;
-	if (logicalAncestors.length > 0) return !isLogicalClearGuardIdiom(logicalAncestors, refName);
-	return didPassBooleanProjection;
-};
-const collectTimerRefUsageFacts = (ownerScope, refName) => {
-	const facts = {
-		holdsScheduledTimerId: false,
-		hasPendingSignalRead: false
-	};
-	walkAst(ownerScope, (child) => {
-		if (isAssignmentToRefCurrent(child, refName)) {
-			const assignedCalleeName = getGlobalTimerCalleeName(stripParenExpression(child.right));
-			if (assignedCalleeName !== null && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(assignedCalleeName)) facts.holdsScheduledTimerId = true;
-			return;
-		}
-		if (isRefCurrentMemberOf(child, refName) && isPendingSignalRead(child, refName)) facts.hasPendingSignalRead = true;
-	});
-	return facts;
-};
-const isEffectCallbackFunction = (functionNode) => {
-	const parent = functionNode.parent;
-	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
-	return isHookCall$2(parent, EFFECT_HOOK_NAMES$1) && getEffectCallback(parent) === functionNode;
-};
-const doesEffectCallbackReturnName = (effectCallback, name) => {
-	if (!isFunctionLike$1(effectCallback)) return false;
-	let isReturnedByName = false;
-	walkInsideStatementBlocks(effectCallback.body, (child) => {
-		if (isReturnedByName || !isNodeOfType(child, "ReturnStatement") || !child.argument) return;
-		const returned = stripParenExpression(child.argument);
-		if (isNodeOfType(returned, "Identifier") && returned.name === name) isReturnedByName = true;
-	});
-	return isReturnedByName;
-};
-const isFunctionReturnedFromEffectCallback = (functionNode, effectCallback) => {
-	if (!isFunctionLike$1(effectCallback)) return false;
-	if (isNodeOfType(functionNode.parent, "ReturnStatement")) return true;
-	if (effectCallback.body === functionNode) return true;
-	const cleanupBindingName = getFunctionBindingName$1(functionNode);
-	return cleanupBindingName !== null && doesEffectCallbackReturnName(effectCallback, cleanupBindingName);
-};
-const isReturnedFromAnyEffectInScope = (functionNode, ownerScope) => {
-	const cleanupBindingName = getFunctionBindingName$1(functionNode);
-	if (cleanupBindingName === null) return false;
-	let isReturnedFromEffect = false;
-	walkAst(ownerScope, (child) => {
-		if (isReturnedFromEffect) return false;
-		if (!isNodeOfType(child, "CallExpression") || !isHookCall$2(child, EFFECT_HOOK_NAMES$1)) return;
-		const effectCallback = getEffectCallback(child);
-		if (effectCallback && doesEffectCallbackReturnName(effectCallback, cleanupBindingName)) isReturnedFromEffect = true;
-	});
-	return isReturnedFromEffect;
-};
-const isInsideEffectCleanupReturn = (node, ownerScope) => {
-	let functionNode = findEnclosingFunction(node);
-	while (functionNode) {
-		const outerFunction = findEnclosingFunction(functionNode);
-		if (outerFunction && isEffectCallbackFunction(outerFunction) && isFunctionReturnedFromEffectCallback(functionNode, outerFunction)) return true;
-		if (isReturnedFromAnyEffectInScope(functionNode, ownerScope)) return true;
-		functionNode = outerFunction;
-	}
-	return false;
-};
-const hasRefCurrentReassignmentAfterClear = (clearCall, refName) => {
-	const enclosingFunction = findEnclosingFunction(clearCall);
-	if (!isFunctionLike$1(enclosingFunction)) return false;
-	if (!isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
-	const clearStart = getRangeStart(clearCall);
-	if (clearStart === null) return false;
-	let didFindLaterReassignment = false;
-	walkInsideStatementBlocks(enclosingFunction.body, (child) => {
-		if (didFindLaterReassignment) return;
-		if (!isAssignmentToRefCurrent(child, refName)) return;
-		const assignmentStart = getRangeStart(child);
-		if (assignmentStart !== null && assignmentStart > clearStart) didFindLaterReassignment = true;
-	});
-	return didFindLaterReassignment;
-};
-const isShadowedTimerGlobal = (clearCall) => {
-	const callee = stripParenExpression(clearCall.callee);
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	return findVariableInitializer(callee, callee.name) !== null;
-};
-const noStaleTimerRef = defineRule({
-	id: "no-stale-timer-ref",
-	title: "Cleared timer ref keeps the stale id",
-	severity: "warn",
-	recommendation: "Reset the ref right after clearing (`clearTimeout(ref.current); ref.current = null`) so truthiness checks on the ref keep meaning “timer still pending”.",
-	create: (context) => ({ CallExpression(node) {
-		const clearCall = parseClearCallOnTimerRef(node);
-		if (!clearCall) return;
-		if (isShadowedTimerGlobal(node)) return;
-		const { clearCalleeName, refName } = clearCall;
-		const refBinding = findVariableInitializer(node, refName);
-		if (!refBinding?.initializer || !isHookCall$2(refBinding.initializer, "useRef")) return;
-		const usageFacts = collectTimerRefUsageFacts(refBinding.scopeOwner, refName);
-		if (!usageFacts.holdsScheduledTimerId || !usageFacts.hasPendingSignalRead) return;
-		if (isInsideEffectCleanupReturn(node, refBinding.scopeOwner)) return;
-		if (hasRefCurrentReassignmentAfterClear(node, refName)) return;
-		context.report({
-			node,
-			message: `\`${clearCalleeName}(${refName}.current)\` cancels the timer but leaves the old id in \`${refName}.current\`, and this component reads \`${refName}.current\` as a \u201Ctimer pending\u201D signal — assign \`${refName}.current = null\` right after clearing so a cancelled timer does not look pending.`
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/utils/is-abstract-role.ts
 const isAbstractRole = (openingElement, settings) => {
 	const elementType = getElementType(openingElement, settings);
@@ -37627,7 +37388,7 @@ const isRouteFactoryCall = (expression) => {
 	}
 	return false;
 };
-const isConfigOnlyFactoryCall = (call) => call.arguments.length > 0 && call.arguments.every((argument) => {
+const isConfigOnlyFactoryCall = (call) => call.arguments.every((argument) => {
 	const expression = skipTsExpression(argument);
 	return isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "Literal") || isNodeOfType(expression, "TemplateLiteral");
 });
@@ -48834,6 +48595,16 @@ const isInsideLoop = (descendant, ancestor) => {
 	}
 	return false;
 };
+const isUseEffectEventSymbol = (symbol) => {
+	const initializer = symbol.initializer;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
+	return getHookNameFromCallee(initializer.callee) === "useEffectEvent";
+};
+const isNonReactEffectEventSymbol = (symbol, contextNode, scopes) => {
+	const initializer = symbol.initializer;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
+	return isNonReactEffectEventCallee(initializer.callee, contextNode, scopes);
+};
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
@@ -49023,7 +48794,8 @@ const rulesOfHooks = defineRule({
 			},
 			Identifier(node) {
 				const symbol = context.scopes.referenceFor(node)?.resolvedSymbol;
-				if (!symbol || !symbolHasReactUseEffectEventOrigin(symbol, context.scopes)) return;
+				if (!symbol || !isUseEffectEventSymbol(symbol)) return;
+				if (isNonReactEffectEventSymbol(symbol, node, context.scopes)) return;
 				if (!isSameComponentOrHookScope(symbol, node)) return;
 				if (isInsideAllowedEffectEventCallback(node, additionalEffectHooksRegex)) return;
 				context.report({
@@ -54800,18 +54572,6 @@ const reactDoctorRules = [
 			category: "Maintainability"
 		}
 	},
-	{
-		key: "react-doctor/no-stale-timer-ref",
-		id: "no-stale-timer-ref",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noStaleTimerRef,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noStaleTimerRef.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-static-element-interactions",
 		id: "no-static-element-interactions",
@@ -57260,7 +57020,6 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"nextjs-no-use-search-params-without-suspense",
 	"no-dynamic-import-path",
 	"no-full-lodash-import",
-	"no-locale-format-in-render",
 	"no-mutating-reducer-state",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
@@ -57395,7 +57154,6 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["nextjs-no-use-search-params-without-suspense", collectNextjsSearchParamsDependencies],
 	["no-dynamic-import-path", collectNearestManifestDependencies],
 	["no-full-lodash-import", collectNearestManifestDependencies],
-	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-mutating-reducer-state", collectMutatingReducerDependencies],
 	["prefer-dynamic-import", collectNearestManifestDependencies],
 	["rendering-hydration-mismatch-time", collectNearestManifestDependencies],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.2-dev.2953b25",
+  "version": "0.7.2-dev.6ae8e46",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",