oxlint-plugin-react-doctor 0.7.5-dev.18e8717 → 0.7.5-dev.20cd922

package/dist/index.js

@@ -23998,6 +23998,26 @@ const STATEFUL_HTML_DESCENDANT_TAGS = new Set([
 	"dialog",
 	"canvas"
 ]);
+const STATEFUL_HTML_ATTRIBUTE_NAMES = new Set([
+	"autofocus",
+	"contenteditable",
+	"draggable",
+	"tabindex"
+]);
+const isStaticallyFalseAttributeValue = (attribute) => {
+	if (!isNodeOfType(attribute, "JSXAttribute") || !attribute.value) return false;
+	const value = isNodeOfType(attribute.value, "JSXExpressionContainer") ? attribute.value.expression : attribute.value;
+	return isNodeOfType(value, "Literal") && (value.value === false || value.value === "false");
+};
+const hasStatefulHtmlAttribute = (openingElement) => {
+	if (!isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	return openingElement.attributes.some((attribute) => {
+		if (!isNodeOfType(attribute, "JSXAttribute") || !isNodeOfType(attribute.name, "JSXIdentifier")) return false;
+		const attributeName = attribute.name.name.toLowerCase();
+		if (!STATEFUL_HTML_ATTRIBUTE_NAMES.has(attributeName)) return false;
+		return attributeName === "tabindex" || !isStaticallyFalseAttributeValue(attribute);
+	});
+};
 const STATEFUL_DESCENDANT_SCAN_BUDGET = 200;
 const rootIdentifierNameOf = (expression) => {
 	let object = expression;
@@ -24015,7 +24035,8 @@ const containsStatefulDescendant = (jsxElement, options = {}) => {
 		budget -= 1;
 		const node = stack.pop();
 		if (isNodeOfType(node, "JSXElement")) {
-			const name = node.openingElement.name;
+			const opening = node.openingElement;
+			const name = opening.name;
 			if (name && isNodeOfType(name, "JSXIdentifier")) {
 				const tagName = name.name;
 				const firstChar = tagName.charCodeAt(0);
@@ -24023,6 +24044,7 @@ const containsStatefulDescendant = (jsxElement, options = {}) => {
 				if (STATEFUL_HTML_DESCENDANT_TAGS.has(tagName)) return true;
 			}
 			if (name && isNodeOfType(name, "JSXMemberExpression")) return true;
+			if (hasStatefulHtmlAttribute(opening)) return true;
 			const children = node.children ?? [];
 			for (const child of children) stack.push(child);
 			continue;
@@ -24582,6 +24604,14 @@ const templateHasOuterMemberIdentity = (template, bindingFunction) => {
 	}
 	return false;
 };
+const findBareItemNamesReferencedByTemplate = (template, itemNames) => {
+	const referencedItemNames = /* @__PURE__ */ new Set();
+	for (const expression of template.expressions ?? []) {
+		const unwrappedExpression = stripParenExpression(expression);
+		if (isNodeOfType(unwrappedExpression, "Identifier") && itemNames.has(unwrappedExpression.name)) referencedItemNames.add(unwrappedExpression.name);
+	}
+	return referencedItemNames;
+};
 const forLoopTestReadsDataLength = (test) => {
 	let didFindLengthRead = false;
 	walkAst(test, (child) => {
@@ -24718,9 +24748,11 @@ const noArrayIndexAsKey = defineRule({
 				} else if (STATELESS_HTML_LEAF_TAGS.has(elementName.name)) {
 					const jsxElement = openingElement.parent;
 					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
+						const isInlineTextRun = INLINE_TEXT_LEAF_TAGS.has(elementName.name);
+						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET;
 						if (!containsStatefulDescendant(jsxElement, {
-							memberRootNames: INLINE_TEXT_LEAF_TAGS.has(elementName.name) ? itemNames : EMPTY_NAME_SET,
-							bareIdentifierNames: derivedNames
+							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET,
+							bareIdentifierNames: primitiveItemNames.size > 0 ? new Set([...derivedNames, ...primitiveItemNames]) : derivedNames
 						})) return;
 					}
 				}
@@ -35247,6 +35279,27 @@ const hasPreviousValueDep = (effectNode, depElements) => {
 	}
 	return false;
 };
+const isStateLikeDependency = (analysis, element, isPropName) => {
+	if (!isNodeOfType(element, "Identifier") || isPropName(element.name)) return false;
+	if (!analysis) return true;
+	const reference = getRef(analysis, element);
+	if (!reference) return true;
+	const upstreamReferences = getUpstreamRefs(analysis, reference);
+	if (upstreamReferences.some((upstreamReference) => isState(analysis, upstreamReference))) return true;
+	return !upstreamReferences.some((upstreamReference) => isProp(analysis, upstreamReference));
+};
+const getRefHeldPropCallbackName = (callExpression, isPropName) => {
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "current") return null;
+	const receiver = stripParenExpression(callee.object);
+	if (!isNodeOfType(receiver, "Identifier")) return null;
+	const binding = findVariableInitializer(callExpression, receiver.name);
+	if (!binding?.initializer || !isNodeOfType(binding.initializer, "CallExpression")) return null;
+	if (getCalleeName$2(binding.initializer) !== "useRef") return null;
+	const callbackArgument = binding.initializer.arguments?.[0];
+	if (!callbackArgument || !isNodeOfType(callbackArgument, "Identifier")) return null;
+	return isPropName(callbackArgument.name) ? callbackArgument.name : null;
+};
 const noPropCallbackInEffect = defineRule({
 	id: "no-prop-callback-in-effect",
 	title: "Parent kept in sync with a callback effect",
@@ -35263,11 +35316,11 @@ const noPropCallbackInEffect = defineRule({
 				if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
 				const depsNode = node.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression") || !depsNode.elements?.length) return;
-				const stateLikeDeps = (depsNode.elements ?? []).filter((element) => isNodeOfType(element, "Identifier") && !propStackTracker.isPropName(element.name));
+				const analysis = getProgramAnalysis(node);
+				const stateLikeDeps = (depsNode.elements ?? []).filter((element) => element && isStateLikeDependency(analysis, element, propStackTracker.isPropName));
 				if (stateLikeDeps.length === 0) return;
 				if (isRefLatchGuardedEffect(callback.body)) return;
 				if (hasPreviousValueDep(node, depsNode.elements ?? [])) return;
-				const analysis = getProgramAnalysis(node);
 				if (analysis) {
 					const stateLikeDepRefs = [];
 					for (const element of stateLikeDeps) {
@@ -35279,9 +35332,9 @@ const noPropCallbackInEffect = defineRule({
 				const reportedNodes = /* @__PURE__ */ new Set();
 				walkInsideStatementBlocks(callback.body, (child) => {
 					if (!isNodeOfType(child, "CallExpression")) return;
-					if (!isNodeOfType(child.callee, "Identifier")) return;
-					const calleeName = child.callee.name;
-					if (!propStackTracker.isPropName(calleeName)) return;
+					const directCallee = stripParenExpression(child.callee);
+					const calleeName = isNodeOfType(directCallee, "Identifier") && propStackTracker.isPropName(directCallee.name) && directCallee.name || getRefHeldPropCallbackName(child, propStackTracker.isPropName);
+					if (!calleeName) return;
 					if (!isResultDiscardedCall(child)) return;
 					if (reportedNodes.has(child)) return;
 					reportedNodes.add(child);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.5-dev.18e8717",
+  "version": "0.7.5-dev.20cd922",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",