oxlint-plugin-react-doctor 0.7.6-dev.8528def → 0.7.6-dev.8c9a6c4

package/dist/index.js

@@ -14611,6 +14611,18 @@ const jsHoistRegexp = defineRule({
 	}, { treatIteratorCallbacksAsLoops: true })
 });
 //#endregion
+//#region src/plugin/utils/resolve-first-argument-binding.ts
+const resolveFirstArgumentBinding = (firstParameter) => {
+	if (!firstParameter) return null;
+	if (!isNodeOfType(firstParameter, "RestElement")) return firstParameter;
+	if (!isNodeOfType(firstParameter.argument, "ArrayPattern")) return null;
+	const elements = firstParameter.argument.elements ?? [];
+	if (elements.length !== 1) return null;
+	const firstBinding = elements[0];
+	if (!firstBinding || isNodeOfType(firstBinding, "RestElement")) return null;
+	return firstBinding;
+};
+//#endregion
 //#region src/plugin/rules/js-performance/js-index-maps.ts
 const referencesParameter = (expression, parameterName) => {
 	if (!expression) return false;
@@ -14621,7 +14633,7 @@ const referencesParameter = (expression, parameterName) => {
 const isSingleFieldEqualityPredicate = (node) => {
 	const callback = node.arguments?.[0];
 	if (!isInlineFunctionExpression(callback)) return false;
-	const firstParameter = callback.params?.[0];
+	const firstParameter = resolveFirstArgumentBinding(callback.params?.[0]);
 	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
 	let predicate = null;
 	const body = callback.body;
@@ -23043,10 +23055,15 @@ const isProp = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	if (!declaringNode) return false;
 	return isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(analysis, declaringNode) || isCustomHook(declaringNode);
 }));
+const isWholePropsParameterBinding = (bindingNode) => {
+	if (isFunctionLike$1(bindingNode.parent)) return true;
+	let declaringFunction = bindingNode.parent;
+	while (declaringFunction && !isFunctionLike$1(declaringFunction)) declaringFunction = declaringFunction.parent;
+	return Boolean(declaringFunction && resolveFirstArgumentBinding(declaringFunction.params?.[0]) === bindingNode);
+};
 const isWholePropsObjectReference = (analysis, ref) => isProp(analysis, ref) && Boolean(ref.resolved?.defs.some((def) => {
 	if (def.type !== "Parameter") return false;
-	const bindingParent = def.name.parent;
-	return isFunctionLike$1(bindingParent);
+	return isWholePropsParameterBinding(def.name);
 }));
 const isIdentifierOrMemberExpression = (node) => isNodeOfType(node, "Identifier") || isNodeOfType(node, "MemberExpression");
 const isPropAlias = (analysis, ref) => {
@@ -33028,11 +33045,13 @@ const noManyBooleanProps = defineRule({
 		};
 		const checkComponent = (functionNode, param, body, componentName, reportNode) => {
 			if (!param) return;
+			const propsBinding = resolveFirstArgumentBinding(param);
+			if (!propsBinding) return;
 			if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
-			if (isNodeOfType(param, "ObjectPattern")) {
+			if (isNodeOfType(propsBinding, "ObjectPattern")) {
 				const callbackUsedNames = collectCallbackUsedNames(body, param, context.scopes);
 				const booleanLikePropNames = [];
-				for (const property of param.properties ?? []) {
+				for (const property of propsBinding.properties ?? []) {
 					if (!isNodeOfType(property, "Property")) continue;
 					const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : null;
 					if (!keyName) continue;
@@ -33043,7 +33062,7 @@ const noManyBooleanProps = defineRule({
 				reportIfMany(booleanLikePropNames, componentName, reportNode);
 				return;
 			}
-			if (isNodeOfType(param, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, param.name)], componentName, reportNode);
+			if (isNodeOfType(propsBinding, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, propsBinding.name)], componentName, reportNode);
 		};
 		return {
 			FunctionDeclaration(node) {
@@ -41804,8 +41823,9 @@ const CROSS_CUTTING_STATE_BOOLEAN_NAMES = new Set([
 ]);
 const collectBooleanPropBindings = (param) => {
 	const bindings = /* @__PURE__ */ new Set();
-	if (!param || !isNodeOfType(param, "ObjectPattern")) return bindings;
-	for (const property of param.properties ?? []) {
+	const propsBinding = resolveFirstArgumentBinding(param);
+	if (!isNodeOfType(propsBinding, "ObjectPattern")) return bindings;
+	for (const property of propsBinding.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
 		if (property.computed) continue;
 		if (!isNodeOfType(property.key, "Identifier")) continue;
@@ -45547,8 +45567,11 @@ const collectFromObjectPattern = (pattern, bindings) => {
 const collectDefaultedEmptyBindings = (functionNode) => {
 	const bindings = /* @__PURE__ */ new Map();
 	const params = functionNode.params ?? [];
-	for (const param of params) collectFromObjectPattern(param, bindings);
-	const propsParam = params[0];
+	for (const [parameterIndex, param] of params.entries()) {
+		const parameterBinding = parameterIndex === 0 ? resolveFirstArgumentBinding(param) : param;
+		if (parameterBinding) collectFromObjectPattern(parameterBinding, bindings);
+	}
+	const propsParam = resolveFirstArgumentBinding(params[0]);
 	const body = functionNode.body;
 	if (!propsParam || !isNodeOfType(propsParam, "Identifier") || !body) return bindings;
 	if (!isNodeOfType(body, "BlockStatement")) return bindings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.6-dev.8528def",
+  "version": "0.7.6-dev.8c9a6c4",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",