oxlint-plugin-react-doctor 0.4.0-dev.fe5f3de → 0.4.1-dev.7d4b996

package/dist/index.d.ts

@@ -4470,6 +4470,25 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/prefer-explicit-variants";
+  readonly id: "prefer-explicit-variants";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Maintainability";
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/prefer-function-component";
   readonly id: "prefer-function-component";
@@ -10939,6 +10958,25 @@ declare const RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/prefer-explicit-variants";
+  readonly id: "prefer-explicit-variants";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Maintainability";
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/prefer-function-component";
   readonly id: "prefer-function-component";

package/dist/index.js

@@ -19168,11 +19168,14 @@ const noLongTransitionDuration = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-boolean-prefixed-prop-name.ts
+const BOOLEAN_PROP_PREFIX_PATTERN = /^(?:is|has|should|can|show|hide|enable|disable|with)[A-Z]/;
+const isBooleanPrefixedPropName = (propName) => BOOLEAN_PROP_PREFIX_PATTERN.test(propName);
+//#endregion
 //#region src/plugin/utils/is-component-declaration.ts
 const isComponentDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration") && node.id !== null && Boolean(node.id?.name) && isUppercaseName(node.id.name);
 //#endregion
 //#region src/plugin/rules/architecture/no-many-boolean-props.ts
-const BOOLEAN_PROP_PREFIX_PATTERN = /^(?:is|has|should|can|show|hide|enable|disable|with)[A-Z]/;
 const collectBooleanLikePropsFromBody = (componentBody, propsParamName) => {
 	const found = /* @__PURE__ */ new Set();
 	if (!componentBody) return found;
@@ -19182,7 +19185,7 @@ const collectBooleanLikePropsFromBody = (componentBody, propsParamName) => {
 		if (!isNodeOfType(child.object, "Identifier")) return;
 		if (child.object.name !== propsParamName) return;
 		if (!isNodeOfType(child.property, "Identifier")) return;
-		if (!BOOLEAN_PROP_PREFIX_PATTERN.test(child.property.name)) return;
+		if (!isBooleanPrefixedPropName(child.property.name)) return;
 		found.add(child.property.name);
 	});
 	return found;
@@ -19208,7 +19211,7 @@ const noManyBooleanProps = defineRule({
 					if (!isNodeOfType(property, "Property")) continue;
 					const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : null;
 					if (!keyName) continue;
-					if (BOOLEAN_PROP_PREFIX_PATTERN.test(keyName)) booleanLikePropNames.push(keyName);
+					if (isBooleanPrefixedPropName(keyName)) booleanLikePropNames.push(keyName);
 				}
 				reportIfMany(booleanLikePropNames, componentName, reportNode);
 				return;
@@ -25204,6 +25207,128 @@ const preferEs6Class = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-jsx-element-or-fragment.ts
+/**
+* Type-guard for the two single-node JSX output forms: `JSXElement`
+* (`<Foo />`) and `JSXFragment` (`<>…</>`). Canonical home for the
+* `isNodeOfType(x, "JSXElement") || isNodeOfType(x, "JSXFragment")` check
+* that many rules otherwise inline. Does NOT unwrap parens / TS wrappers —
+* callers that need the semantic expression should `stripParenExpression`
+* first.
+*/
+const isJsxElementOrFragment = (node) => Boolean(node && (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")));
+//#endregion
+//#region src/plugin/rules/architecture/prefer-explicit-variants.ts
+const resolveBooleanPropTestName = (testNode, booleanPropBindings) => {
+	let identifierNode = stripParenExpression(testNode);
+	if (isNodeOfType(identifierNode, "UnaryExpression") && identifierNode.operator === "!") identifierNode = stripParenExpression(identifierNode.argument);
+	if (!isNodeOfType(identifierNode, "Identifier")) return null;
+	return booleanPropBindings.has(identifierNode.name) ? identifierNode.name : null;
+};
+const CROSS_CUTTING_STATE_BOOLEAN_NAMES = new Set([
+	"isLoading",
+	"isPending",
+	"isFetching",
+	"isRefetching",
+	"isSubmitting",
+	"isError",
+	"isSuccess",
+	"isEmpty",
+	"isReady",
+	"isDirty",
+	"isValid",
+	"isInvalid",
+	"isOpen",
+	"isClosed",
+	"isVisible",
+	"isHidden",
+	"isActive",
+	"isInactive",
+	"isExpanded",
+	"isCollapsed",
+	"isSelected",
+	"isChecked",
+	"isDisabled",
+	"isEnabled",
+	"isFocused",
+	"isHovered",
+	"isDragging",
+	"isFullscreen",
+	"isMobile",
+	"isDesktop",
+	"isTablet",
+	"isOnline",
+	"isOffline",
+	"isLoggedIn",
+	"isAuthenticated",
+	"isAuthorized",
+	"isDark",
+	"isLight"
+]);
+const collectBooleanPropBindings = (param) => {
+	const bindings = /* @__PURE__ */ new Set();
+	if (!param || !isNodeOfType(param, "ObjectPattern")) return bindings;
+	for (const property of param.properties ?? []) {
+		if (!isNodeOfType(property, "Property")) continue;
+		if (property.computed) continue;
+		if (!isNodeOfType(property.key, "Identifier")) continue;
+		if (!isBooleanPrefixedPropName(property.key.name)) continue;
+		if (CROSS_CUTTING_STATE_BOOLEAN_NAMES.has(property.key.name)) continue;
+		const propertyValue = property.value;
+		if (isNodeOfType(propertyValue, "Identifier")) bindings.add(propertyValue.name);
+		else if (isNodeOfType(propertyValue, "AssignmentPattern") && isNodeOfType(propertyValue.left, "Identifier")) bindings.add(propertyValue.left.name);
+	}
+	return bindings;
+};
+const collectVariantBranchProps = (body, booleanPropBindings) => {
+	const variantBranchProps = /* @__PURE__ */ new Set();
+	if (!body) return variantBranchProps;
+	walkAst(body, (current) => {
+		if (isNodeOfType(current, "FunctionDeclaration") || isInlineFunctionExpression(current)) return false;
+		if (!isNodeOfType(current, "ConditionalExpression")) return;
+		const propName = resolveBooleanPropTestName(current.test, booleanPropBindings);
+		if (!propName) return;
+		const consequent = stripParenExpression(current.consequent);
+		const alternate = stripParenExpression(current.alternate);
+		if (!isJsxElementOrFragment(consequent) || !isJsxElementOrFragment(alternate)) return;
+		variantBranchProps.add(propName);
+	});
+	return variantBranchProps;
+};
+const preferExplicitVariants = defineRule({
+	id: "prefer-explicit-variants",
+	title: "Prefer explicit variant components",
+	severity: "warn",
+	tags: ["test-noise", "react-jsx-only"],
+	recommendation: "Replace boolean props that switch whole subtrees with explicit variant components, like `<ThreadComposer />` and `<EditMessageComposer />`, so each variant renders one clear path.",
+	create: (context) => {
+		const checkComponent = (param, body, componentName, reportNode) => {
+			const booleanPropBindings = collectBooleanPropBindings(param);
+			if (booleanPropBindings.size < 2) return;
+			const variantBranchProps = collectVariantBranchProps(body, booleanPropBindings);
+			if (variantBranchProps.size < 2) return;
+			const propList = [...variantBranchProps].slice(0, 3).join(", ");
+			const overflow = variantBranchProps.size > 3 ? "…" : "";
+			context.report({
+				node: reportNode,
+				message: `Component "${componentName}" picks which component to render from ${variantBranchProps.size} boolean props (${propList}${overflow}), which multiplies untestable variants. Split it into explicit variant components so each renders one clear path.`
+			});
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (!isComponentDeclaration(node) || !node.id) return;
+				checkComponent(node.params?.[0], node.body, node.id.name, node.id);
+			},
+			VariableDeclarator(node) {
+				if (!isComponentAssignment(node)) return;
+				if (!isNodeOfType(node.id, "Identifier")) return;
+				if (!isInlineFunctionExpression(node.init)) return;
+				checkComponent(node.init.params?.[0], node.init.body, node.id.name, node.id);
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/rules/react-builtins/prefer-function-component.ts
 const MESSAGE$7 = "This class component is harder to maintain than a function component.";
 const resolveSettings$4 = (settings) => {
@@ -37524,6 +37649,17 @@ const reactDoctorRules = [
 			category: "Maintainability"
 		}
 	},
+	{
+		key: "react-doctor/prefer-explicit-variants",
+		id: "prefer-explicit-variants",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preferExplicitVariants,
+			framework: "global",
+			category: "Maintainability"
+		}
+	},
 	{
 		key: "react-doctor/prefer-function-component",
 		id: "prefer-function-component",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.4.0-dev.fe5f3de",
+  "version": "0.4.1-dev.7d4b996",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",