oxlint-plugin-react-doctor 0.7.6-dev.dfd47a7 → 0.7.6-dev.e026a23

package/dist/index.js

@@ -13653,6 +13653,28 @@ const jsAsyncReduceWithoutAwaitedAcc = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/unwrap-discarded-expression.ts
+const unwrapDiscardedExpression = (node) => {
+	let expression = isNodeOfType(node, "ExpressionStatement") ? node.expression : node;
+	for (;;) {
+		expression = stripParenExpression(expression);
+		if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") {
+			expression = expression.argument;
+			continue;
+		}
+		if (isNodeOfType(expression, "SequenceExpression")) {
+			const expressions = expression.expressions ?? [];
+			const finalExpression = expressions.at(-1);
+			const prefixExpressions = expressions.slice(0, -1);
+			if (finalExpression && prefixExpressions.length > 0 && prefixExpressions.every((prefixExpression) => isNodeOfType(stripParenExpression(prefixExpression), "Literal"))) {
+				expression = finalExpression;
+				continue;
+			}
+		}
+		return expression;
+	}
+};
+//#endregion
 //#region src/plugin/rules/js-performance/js-batch-dom-css.ts
 const ITERATOR_METHOD_NAMES$2 = new Set([
 	"forEach",
@@ -13837,9 +13859,19 @@ const hasAttachmentBefore = (scopeOwner, elementName, beforeStart) => {
 	});
 	return foundAttachment;
 };
+const getStyleAssignment = (node) => {
+	if (!isNodeOfType(node, "ExpressionStatement")) return null;
+	const expression = unwrapDiscardedExpression(node);
+	if (!isNodeOfType(expression, "AssignmentExpression")) return null;
+	if (!isNodeOfType(expression.left, "MemberExpression")) return null;
+	if (!isNodeOfType(expression.left.object, "MemberExpression")) return null;
+	if (!isNodeOfType(expression.left.object.property, "Identifier")) return null;
+	return expression.left.object.property.name === "style" ? expression : null;
+};
 const isProvablyDetachedAtWrite = (styleWriteStatement) => {
-	if (!isNodeOfType(styleWriteStatement, "ExpressionStatement") || !isNodeOfType(styleWriteStatement.expression, "AssignmentExpression") || !isNodeOfType(styleWriteStatement.expression.left, "MemberExpression") || !isNodeOfType(styleWriteStatement.expression.left.object, "MemberExpression")) return false;
-	const elementExpression = styleWriteStatement.expression.left.object.object;
+	const assignment = getStyleAssignment(styleWriteStatement);
+	if (!assignment || !isNodeOfType(assignment.left, "MemberExpression") || !isNodeOfType(assignment.left.object, "MemberExpression")) return false;
+	const elementExpression = assignment.left.object.object;
 	const creationRoot = resolveDetachedCreationRoot(elementExpression, 0);
 	if (!creationRoot) return false;
 	return !hasAttachmentBefore(creationRoot.scopeOwner, creationRoot.rootName, getNodeStart$1(styleWriteStatement));
@@ -13851,15 +13883,17 @@ const jsBatchDomCss = defineRule({
 	severity: "warn",
 	recommendation: "Do all your reads first, then all your writes. Mixing them inside a loop makes the browser recalculate the layout again and again, which is slow",
 	create: (context) => {
-		const isStyleAssignment = (node) => isNodeOfType(node, "ExpressionStatement") && isNodeOfType(node.expression, "AssignmentExpression") && isNodeOfType(node.expression.left, "MemberExpression") && isNodeOfType(node.expression.left.object, "MemberExpression") && isNodeOfType(node.expression.left.object.property, "Identifier") && node.expression.left.object.property.name === "style";
-		const writesLayoutAffectingProperty = (node) => isNodeOfType(node, "ExpressionStatement") && isNodeOfType(node.expression, "AssignmentExpression") && isNodeOfType(node.expression.left, "MemberExpression") && isNodeOfType(node.expression.left.property, "Identifier") && !LAYOUT_NEUTRAL_STYLE_PROPERTY_NAMES.has(node.expression.left.property.name);
+		const writesLayoutAffectingProperty = (node) => {
+			const assignment = getStyleAssignment(node);
+			return assignment !== null && isNodeOfType(assignment.left, "MemberExpression") && isNodeOfType(assignment.left.property, "Identifier") && !LAYOUT_NEUTRAL_STYLE_PROPERTY_NAMES.has(assignment.left.property.name);
+		};
 		return { BlockStatement(node) {
 			const perIterationBody = findEnclosingPerIterationBody(node);
 			if (!perIterationBody) return;
 			const statements = node.body ?? [];
 			let layoutReads = null;
 			for (let statementIndex = 1; statementIndex < statements.length; statementIndex++) {
-				if (!isStyleAssignment(statements[statementIndex]) || !isStyleAssignment(statements[statementIndex - 1])) continue;
+				if (getStyleAssignment(statements[statementIndex]) === null || getStyleAssignment(statements[statementIndex - 1]) === null) continue;
 				if (!writesLayoutAffectingProperty(statements[statementIndex]) && !writesLayoutAffectingProperty(statements[statementIndex - 1])) continue;
 				layoutReads ??= scanPerIterationLayoutReads(perIterationBody);
 				if (!layoutReads.hasUsedLayoutRead || layoutReads.hasDeliberateForcedReflow) return;
@@ -15257,9 +15291,21 @@ const isSmallFixedListMember = (receiver) => {
 };
 const getResolvedInitializer = (receiver) => {
 	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const initializer = findVariableInitializer(receiver, receiver.name)?.initializer ?? null;
-	if (initializer && isNodeOfType(initializer, "Identifier")) return findVariableInitializer(initializer, initializer.name)?.initializer ?? initializer;
-	return initializer;
+	const binding = findVariableInitializer(receiver, receiver.name);
+	const initializer = binding?.initializer ?? null;
+	if (!binding || !initializer) return null;
+	const isDefault = isNodeOfType(binding.bindingIdentifier.parent, "AssignmentPattern");
+	if (isNodeOfType(initializer, "Identifier")) {
+		const aliased = findVariableInitializer(initializer, initializer.name);
+		if (aliased?.initializer) return {
+			initializer: aliased.initializer,
+			isDefault: isDefault || isNodeOfType(aliased.bindingIdentifier.parent, "AssignmentPattern")
+		};
+	}
+	return {
+		initializer,
+		isDefault
+	};
 };
 const isSplitCall = (expression) => {
 	if (!expression) return false;
@@ -15425,8 +15471,8 @@ const isBoundedConstantCollection = (collection) => {
 	if (isScreamingSnakeCaseConstantReceiver(stripped)) return true;
 	if (isSmallInlineLiteralArray(stripped)) return true;
 	if (isNodeOfType(stripped, "Identifier")) {
-		const initializer = getResolvedInitializer(stripped);
-		if (initializer && isSmallInlineLiteralArray(initializer)) return true;
+		const resolved = getResolvedInitializer(stripped);
+		if (resolved && !resolved.isDefault && isSmallInlineLiteralArray(resolved.initializer)) return true;
 	}
 	return false;
 };
@@ -15478,8 +15524,8 @@ const jsSetMapLookups = defineRule({
 			if (isIndexedArrayElementWithStringArgument(receiver, node.arguments?.[0])) return;
 			const resolvedInitializer = getResolvedInitializer(receiver);
 			if (resolvedInitializer) {
-				if (isLikelyStringReceiver(resolvedInitializer)) return;
-				if (isSmallInlineLiteralArray(resolvedInitializer)) return;
+				if (isLikelyStringReceiver(resolvedInitializer.initializer)) return;
+				if (!resolvedInitializer.isDefault && isSmallInlineLiteralArray(resolvedInitializer.initializer)) return;
 			}
 			if (isStringElementOfSplitIteration(receiver)) return;
 			if (isReceiverDeclaredInNearestLoop(receiver, node)) return;
@@ -28875,7 +28921,7 @@ const findTopLevelEffectCalls = (componentBody) => {
 	if (!isNodeOfType(componentBody, "BlockStatement")) return effectCalls;
 	for (const statement of componentBody.body ?? []) {
 		if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-		const expression = statement.expression;
+		const expression = unwrapDiscardedExpression(statement);
 		if (!isNodeOfType(expression, "CallExpression")) continue;
 		if (!isHookCall$2(expression, EFFECT_HOOK_NAMES$1)) continue;
 		effectCalls.push(expression);
@@ -33107,7 +33153,7 @@ const noMirrorPropEffect = defineRule({
 			if (mirrorBindings.length === 0) return;
 			for (const statement of componentBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-				const effectCall = statement.expression;
+				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
@@ -33121,7 +33167,7 @@ const noMirrorPropEffect = defineRule({
 				const bodyStatements = getCallbackStatements(callback);
 				if (bodyStatements.length !== 1) continue;
 				const onlyStatement = bodyStatements[0];
-				const expression = isNodeOfType(onlyStatement, "ExpressionStatement") ? onlyStatement.expression : onlyStatement;
+				const expression = unwrapDiscardedExpression(onlyStatement);
 				if (!isNodeOfType(expression, "CallExpression")) continue;
 				if (!isNodeOfType(expression.callee, "Identifier")) continue;
 				if (!isSetterIdentifier(expression.callee.name)) continue;
@@ -37222,7 +37268,7 @@ const isNonSettlingSetterArgument = (setterCall, stateName) => {
 	return expressionReadsStateValue(argument, stateName);
 };
 const getUnconditionalSetterCall = (statement, setterNames) => {
-	const expression = stripParenExpression(isNodeOfType(statement, "ExpressionStatement") ? statement.expression : statement);
+	const expression = unwrapDiscardedExpression(statement);
 	if (!isNodeOfType(expression, "CallExpression")) return null;
 	if (!isNodeOfType(expression.callee, "Identifier")) return null;
 	if (!setterNames.has(expression.callee.name)) return null;
@@ -37571,7 +37617,7 @@ const noSelfUpdatingEffect = defineRule({
 			const setterNames = new Set(setterNameToStateName.keys());
 			for (const statement of functionBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-				const effectCall = statement.expression;
+				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
@@ -45996,8 +46042,8 @@ const rnAnimationReactionAsDerived = defineRule({
 			if (statements.length !== 1) return;
 			const onlyStatement = statements[0];
 			if (!isNodeOfType(onlyStatement, "ExpressionStatement")) return;
-			singleAssignment = onlyStatement.expression;
-		} else if (body) singleAssignment = body;
+			singleAssignment = unwrapDiscardedExpression(onlyStatement);
+		} else if (body) singleAssignment = unwrapDiscardedExpression(body);
 		if (!singleAssignment) return;
 		const isValueAssignment = isNodeOfType(singleAssignment, "AssignmentExpression") && isNodeOfType(singleAssignment.left, "MemberExpression") && isNodeOfType(singleAssignment.left.object, "Identifier") && isNodeOfType(singleAssignment.left.property, "Identifier") && singleAssignment.left.property.name === "value";
 		const isSetCall = isNodeOfType(singleAssignment, "CallExpression") && isNodeOfType(singleAssignment.callee, "MemberExpression") && isNodeOfType(singleAssignment.callee.property, "Identifier") && singleAssignment.callee.property.name === "set" && (singleAssignment.arguments?.length ?? 0) === 1;

package/package.json

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