oxlint-plugin-react-doctor 0.7.7-dev.79abd71 → 0.7.7-dev.9c612c5

package/dist/index.js

@@ -34,7 +34,7 @@ const REACT_JSX_DIALECT_PACKAGE_PREFIXES = [
 	"preact"
 ];
 const startsWithAny = (source, prefixes) => prefixes.some((prefix) => source === prefix || source.startsWith(`${prefix}/`));
-const collectJsxRuntimeImports = (program) => {
+const collectJsxRuntimeImports$1 = (program) => {
 	let hasNonReactRuntime = false;
 	let hasReactRuntime = false;
 	for (const statement of program.body) {
@@ -53,7 +53,7 @@ const collectJsxRuntimeImports = (program) => {
 	};
 };
 const fileImportsNonReactJsxDialect = (program) => {
-	const runtimeImports = collectJsxRuntimeImports(program);
+	const runtimeImports = collectJsxRuntimeImports$1(program);
 	return runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
 };
 const jsxAttributeIsNonReactDialectMarker = (openingNode) => {
@@ -280,7 +280,7 @@ const wrapCreateForReactJsxOnly = (create) => ((context) => {
 		}
 		if (key === "Program") {
 			wrappedVisitors.Program = (node) => {
-				const runtimeImports = collectJsxRuntimeImports(node);
+				const runtimeImports = collectJsxRuntimeImports$1(node);
 				fileImportsReactRuntime = runtimeImports.hasReactRuntime;
 				fileIsNonReactJsx = runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
 				visitor(node);
@@ -301,7 +301,7 @@ const wrapCreateForReactJsxOnly = (create) => ((context) => {
 		};
 	}
 	if (!("Program" in wrappedVisitors)) wrappedVisitors.Program = (node) => {
-		const runtimeImports = collectJsxRuntimeImports(node);
+		const runtimeImports = collectJsxRuntimeImports$1(node);
 		fileImportsReactRuntime = runtimeImports.hasReactRuntime;
 		fileIsNonReactJsx = runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
 	};
@@ -32786,6 +32786,29 @@ const isReturnOnlyStatement = (node) => {
 	return isNodeOfType(node, "BlockStatement") && (node.body?.length ?? 0) === 1 && isNodeOfType(node.body?.[0], "ReturnStatement");
 };
 const hasEventLikeRemainingStatements = (statements) => statements.some((statement) => !isNodeOfType(statement, "ReturnStatement") && hasEventLikeNode(statement));
+const collectLeadingEarlyReturnGuards = (statements) => {
+	const guardExpressions = [];
+	for (const statement of statements) {
+		if (isNodeOfType(statement, "VariableDeclaration")) continue;
+		if (!isNodeOfType(statement, "IfStatement") || statement.alternate || !isReturnOnlyStatement(statement.consequent)) break;
+		collectGuardExpressions(statement.test, guardExpressions);
+	}
+	return guardExpressions;
+};
+const collectImmutableExpressionOrigins = (expression, scopes) => {
+	const origins = [];
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let currentExpression = stripParenExpression(expression);
+	while (currentExpression) {
+		origins.push(currentExpression);
+		if (!isNodeOfType(currentExpression, "Identifier")) break;
+		const bindingSymbol = scopes.symbolFor(currentExpression);
+		if (!bindingSymbol || bindingSymbol.kind !== "const" || visitedSymbolIds.has(bindingSymbol.id) || !bindingSymbol.initializer) break;
+		visitedSymbolIds.add(bindingSymbol.id);
+		currentExpression = stripParenExpression(bindingSymbol.initializer);
+	}
+	return origins;
+};
 const doesGuardMatchDependency = (guardExpression, dependencyExpression) => {
 	const unwrappedDependencyExpression = unwrapChainExpression$1(dependencyExpression);
 	if (!unwrappedDependencyExpression) return false;
@@ -32793,6 +32816,69 @@ const doesGuardMatchDependency = (guardExpression, dependencyExpression) => {
 	return isNodeOfType(unwrappedDependencyExpression, "Identifier") && unwrappedDependencyExpression.name === guardExpression.rootIdentifierName;
 };
 const hasDependencyMatch = (guardExpression, dependencyExpressions) => dependencyExpressions.some((dependencyExpression) => doesGuardMatchDependency(guardExpression, dependencyExpression));
+const hasAliasedDependencyMatch = (guardExpression, dependencyExpressions, scopes) => {
+	const guardOrigins = collectImmutableExpressionOrigins(guardExpression.expression, scopes);
+	return dependencyExpressions.some((dependencyExpression) => {
+		if (!dependencyExpression) return false;
+		const dependencyOrigins = collectImmutableExpressionOrigins(dependencyExpression, scopes);
+		return guardOrigins.some((guardOrigin) => dependencyOrigins.some((dependencyOrigin) => areExpressionsStructurallyEqual(guardOrigin, dependencyOrigin)));
+	});
+};
+const isStaticallyTrue = (expression, scopes) => collectImmutableExpressionOrigins(expression, scopes).some((origin) => isNodeOfType(origin, "Literal") && origin.value === true);
+const isReactRouterReplacementNavigation = (node, rootIdentifierNames, scopes) => {
+	let didFindNavigation = false;
+	let didFindOtherTriggeredSideEffect = false;
+	walkAst(node, (child) => {
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!(findTriggeredSideEffectCalleeName(child) !== null || hasDocumentClassListMutation(child))) return;
+		const destinationExpression = child.arguments?.[0];
+		const doesDestinationReferenceReconciliationValue = Boolean(destinationExpression && collectImmutableExpressionOrigins(destinationExpression, scopes).some((origin) => doesNodeReferenceAnyRoot(origin, rootIdentifierNames)));
+		if (!isNodeOfType(child.callee, "Identifier") || !doesDestinationReferenceReconciliationValue) {
+			didFindOtherTriggeredSideEffect = true;
+			return;
+		}
+		const navigationSymbol = scopes.symbolFor(child.callee);
+		const navigationInitializer = navigationSymbol?.initializer ? stripParenExpression(navigationSymbol.initializer) : null;
+		if (navigationSymbol?.kind !== "const" || !isNodeOfType(navigationInitializer, "CallExpression") || !isNodeOfType(navigationInitializer.callee, "Identifier")) {
+			didFindOtherTriggeredSideEffect = true;
+			return;
+		}
+		if (scopes.symbolFor(navigationInitializer.callee)?.kind !== "import") {
+			didFindOtherTriggeredSideEffect = true;
+			return;
+		}
+		if ((getImportedNameFromModule(navigationInitializer.callee, navigationInitializer.callee.name, "react-router-dom") ?? getImportedNameFromModule(navigationInitializer.callee, navigationInitializer.callee.name, "react-router")) !== "useNavigate") {
+			didFindOtherTriggeredSideEffect = true;
+			return;
+		}
+		const navigationOptionsArgument = child.arguments?.[1];
+		const navigationOptions = navigationOptionsArgument ? stripParenExpression(navigationOptionsArgument) : null;
+		if (!isNodeOfType(navigationOptions, "ObjectExpression")) {
+			didFindOtherTriggeredSideEffect = true;
+			return;
+		}
+		let isReplacementGuaranteed = false;
+		for (const property of navigationOptions.properties) {
+			if (isNodeOfType(property, "SpreadElement")) {
+				isReplacementGuaranteed = false;
+				continue;
+			}
+			const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+			if (propertyName === null) {
+				isReplacementGuaranteed = false;
+				continue;
+			}
+			if (propertyName !== "replace") continue;
+			isReplacementGuaranteed = isStaticallyTrue(property.value, scopes);
+		}
+		if (isReplacementGuaranteed) {
+			didFindNavigation = true;
+			return;
+		}
+		didFindOtherTriggeredSideEffect = true;
+	});
+	return didFindNavigation && !didFindOtherTriggeredSideEffect;
+};
 const isEqualityToLiteralGuard = (guardExpression) => {
 	const parent = guardExpression.expression.parent;
 	if (!isNodeOfType(parent, "BinaryExpression")) return false;
@@ -32857,18 +32943,35 @@ const noEffectEventHandler = defineRule({
 				if (statements.length === 0) return;
 				const soleStatement = statements[0];
 				if (!isNodeOfType(soleStatement, "IfStatement")) return;
-				const guardExpressions = [];
-				collectGuardExpressions(soleStatement.test, guardExpressions);
-				const matchingPropGuardExpressions = guardExpressions.filter((guardExpression) => hasDependencyMatch(guardExpression, dependencyExpressions) && propStackTracker.isPropName(guardExpression.rootIdentifierName, node));
+				const initialGuardExpressions = [];
+				collectGuardExpressions(soleStatement.test, initialGuardExpressions);
+				const guardExpressions = collectLeadingEarlyReturnGuards(statements);
+				if (guardExpressions.length === 0) guardExpressions.push(...initialGuardExpressions);
+				const matchingPropGuardExpressions = initialGuardExpressions.filter((guardExpression) => hasDependencyMatch(guardExpression, dependencyExpressions) && propStackTracker.isPropName(guardExpression.rootIdentifierName, node));
 				if (matchingPropGuardExpressions.length === 0) return;
 				const isSingleGuardedEventLikeStatement = statements.length === 1 && hasEventLikeNode(soleStatement.consequent);
 				const isEarlyReturnGuardedEventLikeBody = statements.length > 1 && !soleStatement.alternate && isReturnOnlyStatement(soleStatement.consequent) && hasEventLikeRemainingStatements(statements.slice(1));
 				if (!isSingleGuardedEventLikeStatement && !isEarlyReturnGuardedEventLikeBody) return;
 				if (isEarlyReturnGuardedEventLikeBody && !isSingleGuardedEventLikeStatement && matchingPropGuardExpressions.every(isEqualityToLiteralGuard)) return;
-				if (guardExpressions.some((guardExpression) => !matchingPropGuardExpressions.some((matchingGuardExpression) => matchingGuardExpression.expression === guardExpression.expression))) {
+				if (initialGuardExpressions.some((guardExpression) => !matchingPropGuardExpressions.some((matchingGuardExpression) => matchingGuardExpression.expression === guardExpression.expression))) {
 					const matchingPropRootNames = new Set(matchingPropGuardExpressions.map((guardExpression) => guardExpression.rootIdentifierName));
 					if (!(isSingleGuardedEventLikeStatement ? doesEventLikeCallReferenceAnyRoot(soleStatement.consequent, matchingPropRootNames) : doesAnyEventLikeCallReferenceAnyRoot(statements.slice(1), matchingPropRootNames))) return;
 				}
+				if (isEarlyReturnGuardedEventLikeBody) {
+					const reconciliationGuardRootNames = new Set(guardExpressions.filter((guardExpression) => !propStackTracker.isPropName(guardExpression.rootIdentifierName, node) && hasAliasedDependencyMatch(guardExpression, dependencyExpressions, context.scopes) && guardExpressions.some((comparisonGuardExpression) => {
+						if (comparisonGuardExpression.rootIdentifierName !== guardExpression.rootIdentifierName) return false;
+						const comparisonExpression = comparisonGuardExpression.expression.parent;
+						if (!isNodeOfType(comparisonExpression, "BinaryExpression") || comparisonExpression.operator !== "===" && comparisonExpression.operator !== "==") return false;
+						const comparedRootIdentifierName = getRootIdentifierName(comparisonExpression.left === comparisonGuardExpression.expression ? comparisonExpression.right : comparisonExpression.left);
+						return Boolean(comparedRootIdentifierName && propStackTracker.isPropName(comparedRootIdentifierName, node));
+					})).map((guardExpression) => guardExpression.rootIdentifierName));
+					if (reconciliationGuardRootNames.size > 0) {
+						const matchingPropRootNames = new Set(matchingPropGuardExpressions.map((guardExpression) => guardExpression.rootIdentifierName));
+						const eventLikeStatements = statements.slice(1);
+						const triggeredStatements = eventLikeStatements.filter(hasEventLikeNode);
+						if (triggeredStatements.length > 0 && triggeredStatements.every((statement) => isReactRouterReplacementNavigation(statement, reconciliationGuardRootNames, context.scopes)) && !doesAnyEventLikeCallReferenceAnyRoot(eventLikeStatements, matchingPropRootNames)) return;
+					}
+				}
 				context.report({
 					node,
 					message: "This useEffect is simulating an event handler, which costs an extra render & runs late."
@@ -39662,14 +39765,25 @@ const isPropsChildrenLength = (node, scopes) => {
 	const unwrappedNode = stripParenExpression(node);
 	return isNodeOfType(unwrappedNode, "MemberExpression") && !unwrappedNode.computed && isNodeOfType(unwrappedNode.property, "Identifier") && unwrappedNode.property.name === "length" && resolvesToPropsChildren(stripParenExpression(unwrappedNode.object), scopes);
 };
+const resolveStaticNumericValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedNode = stripParenExpression(node);
+	if (isNodeOfType(unwrappedNode, "Literal") && typeof unwrappedNode.value === "number") return Number.isFinite(unwrappedNode.value) ? unwrappedNode.value : null;
+	if (!isNodeOfType(unwrappedNode, "Identifier")) return null;
+	const symbol = scopes.symbolFor(unwrappedNode);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
+	const initializer = getDirectConstInitializer(symbol);
+	if (!initializer) return null;
+	return resolveStaticNumericValue(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id));
+};
 const isLargeTextLengthComparison = (node, scopes) => {
 	const unwrappedNode = stripParenExpression(node);
 	if (!isNodeOfType(unwrappedNode, "BinaryExpression")) return false;
 	const leftIsLength = isPropsChildrenLength(unwrappedNode.left, scopes);
 	const rightIsLength = isPropsChildrenLength(unwrappedNode.right, scopes);
 	const thresholdNode = leftIsLength ? unwrappedNode.right : unwrappedNode.left;
-	if (!leftIsLength && !rightIsLength || !isNodeOfType(thresholdNode, "Literal")) return false;
-	if (typeof thresholdNode.value !== "number" || thresholdNode.value < 1e3) return false;
+	if (!leftIsLength && !rightIsLength) return false;
+	const thresholdValue = resolveStaticNumericValue(thresholdNode, scopes);
+	if (thresholdValue === null || thresholdValue < 1e3) return false;
 	return leftIsLength ? unwrappedNode.operator === ">" || unwrappedNode.operator === ">=" : unwrappedNode.operator === "<" || unwrappedNode.operator === "<=";
 };
 const isLargeStringOptimizationGuard = (comparison, scopes) => {
@@ -58269,6 +58383,26 @@ const stateInConstructor = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/collect-jsx-runtime-imports.ts
+const REACT_RUNTIME_PACKAGE_PREFIXES = ["react", "react-dom"];
+const matchesPackage = (source, packageName) => source === packageName || source.startsWith(`${packageName}/`);
+const collectJsxRuntimeImports = (program) => {
+	let hasReactRuntime = false;
+	let hasSolidRuntime = false;
+	for (const statement of program.body) {
+		if (!isNodeOfType(statement, "ImportDeclaration")) continue;
+		if (isTypeOnlyImport(statement)) continue;
+		const source = statement.source.value;
+		if (typeof source !== "string") continue;
+		if (matchesPackage(source, "solid-js")) hasSolidRuntime = true;
+		if (REACT_RUNTIME_PACKAGE_PREFIXES.some((packageName) => matchesPackage(source, packageName))) hasReactRuntime = true;
+	}
+	return {
+		hasReactRuntime,
+		hasSolidRuntime
+	};
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/style-prop-object.ts
 const MESSAGE$1 = "Your styles don't render because you passed the `style` prop a string instead of an object.";
 const resolveSettings = (settings) => {
@@ -58330,6 +58464,13 @@ const isInvalidStyleExpression = (expression) => {
 	}
 	return false;
 };
+const hasObjectValuedClassList = (openingElement) => openingElement.attributes.some((attribute) => {
+	if (!isNodeOfType(attribute, "JSXAttribute")) return false;
+	if (!isNodeOfType(attribute.name, "JSXIdentifier")) return false;
+	if (attribute.name.name !== "classList") return false;
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return false;
+	return isNodeOfType(attribute.value.expression, "ObjectExpression");
+});
 const stylePropObject = defineRule({
 	id: "style-prop-object",
 	title: "Style prop is not an object",
@@ -58339,8 +58480,21 @@ const stylePropObject = defineRule({
 	create: (context) => {
 		const { allow } = resolveSettings(context.settings);
 		const allowSet = new Set(allow);
+		let fileIsProvenSolidJsx = false;
 		return {
+			Program: (node) => {
+				const runtimeImports = collectJsxRuntimeImports(node);
+				let hasSolidSyntaxMarker = false;
+				if (!runtimeImports.hasReactRuntime && !runtimeImports.hasSolidRuntime) walkAst(node, (descendantNode) => {
+					if (isNodeOfType(descendantNode, "JSXOpeningElement") && hasObjectValuedClassList(descendantNode)) {
+						hasSolidSyntaxMarker = true;
+						return false;
+					}
+				});
+				fileIsProvenSolidJsx = !runtimeImports.hasReactRuntime && (runtimeImports.hasSolidRuntime || hasSolidSyntaxMarker);
+			},
 			JSXOpeningElement(node) {
+				if (fileIsProvenSolidJsx) return;
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
 				const elementName = resolveJsxElementType(node);
 				if (elementName && allowSet.has(elementName)) return;
@@ -58371,6 +58525,7 @@ const stylePropObject = defineRule({
 				}
 			},
 			CallExpression(node) {
+				if (fileIsProvenSolidJsx) return;
 				if (!isCreateElementCall(node)) return;
 				const firstArgument = node.arguments[0];
 				if (!firstArgument) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.7-dev.79abd71",
+  "version": "0.7.7-dev.9c612c5",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",