oxlint-plugin-react-doctor 0.5.1-dev.038aaf7 → 0.5.1-dev.19d99ee

package/dist/index.js

@@ -28588,29 +28588,236 @@ const isInsidePlatformOsWebBranch = (node) => {
 //#endregion
 //#region src/plugin/rules/react-native/utils/collect-text-wrapper-components.ts
 const isFunctionNode = (node) => isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration");
-const resolveReturnedRootElementName = (functionNode) => {
+const COMPONENT_WRAPPER_CALLEE_NAMES = new Set(["memo", "forwardRef"]);
+const resolveCalleeName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+const unwrapComponentDefinition = (node) => {
+	let current = stripParenExpression(node);
+	while (isNodeOfType(current, "CallExpression")) {
+		const calleeName = resolveCalleeName(current.callee);
+		const firstArgument = current.arguments?.[0];
+		if (!calleeName || !COMPONENT_WRAPPER_CALLEE_NAMES.has(calleeName) || !firstArgument) break;
+		current = stripParenExpression(firstArgument);
+	}
+	return current;
+};
+const resolveChildrenPropertyLocalName = (property) => {
+	if (!isNodeOfType(property, "Property")) return null;
+	if (!isNodeOfType(property.key, "Identifier") || property.key.name !== "children") return null;
+	const value = property.value;
+	if (isNodeOfType(value, "Identifier")) return value.name;
+	if (isNodeOfType(value, "AssignmentPattern") && isNodeOfType(value.left, "Identifier")) return value.left.name;
+	return null;
+};
+const resolveParamChildrenBindings = (functionNode) => {
+	const bindings = {
+		childrenNames: /* @__PURE__ */ new Set(),
+		propsObjectNames: /* @__PURE__ */ new Set()
+	};
+	const firstParam = functionNode.params?.[0];
+	if (!firstParam) return bindings;
+	if (isNodeOfType(firstParam, "Identifier")) {
+		bindings.propsObjectNames.add(firstParam.name);
+		return bindings;
+	}
+	if (!isNodeOfType(firstParam, "ObjectPattern")) return bindings;
+	let didDestructureChildren = false;
+	let restName = null;
+	for (const property of firstParam.properties ?? []) {
+		if (isNodeOfType(property, "RestElement") && isNodeOfType(property.argument, "Identifier")) {
+			restName = property.argument.name;
+			continue;
+		}
+		const localName = resolveChildrenPropertyLocalName(property);
+		if (localName) {
+			didDestructureChildren = true;
+			bindings.childrenNames.add(localName);
+		}
+	}
+	if (restName && !didDestructureChildren) bindings.propsObjectNames.add(restName);
+	return bindings;
+};
+const MAX_CHILDREN_ALIAS_PASSES = 3;
+const isPropsObjectExpression = (expression, bindings) => {
+	if (!expression) return false;
+	const value = stripParenExpression(expression);
+	if (isNodeOfType(value, "Identifier")) return bindings.propsObjectNames.has(value.name);
+	return isNodeOfType(value, "MemberExpression") && isNodeOfType(value.object, "ThisExpression") && isNodeOfType(value.property, "Identifier") && value.property.name === "props";
+};
+const isChildrenValueExpression = (expression, bindings) => {
+	if (!expression) return false;
+	const value = stripParenExpression(expression);
+	if (isNodeOfType(value, "Identifier")) return bindings.childrenNames.has(value.name);
+	return isNodeOfType(value, "MemberExpression") && isNodeOfType(value.property, "Identifier") && value.property.name === "children" && isPropsObjectExpression(value.object, bindings);
+};
+const collectChildrenAliases = (functionNode, bindings) => {
 	const { body } = functionNode;
-	if (!body) return null;
-	if (!isNodeOfType(body, "BlockStatement")) return isNodeOfType(body, "JSXElement") ? resolveJsxElementName(body.openingElement) : null;
-	for (const statement of body.body) {
-		if (!isNodeOfType(statement, "ReturnStatement")) continue;
-		const argument = statement.argument;
-		if (argument && isNodeOfType(argument, "JSXElement")) return resolveJsxElementName(argument.openingElement);
+	if (!body || !isNodeOfType(body, "BlockStatement")) return;
+	for (let pass = 0; pass < MAX_CHILDREN_ALIAS_PASSES; pass += 1) {
+		const sizeBeforePass = bindings.childrenNames.size;
+		walkAst(body, (node) => {
+			if (isFunctionNode(node)) return false;
+			if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return void 0;
+			if (isNodeOfType(node.id, "Identifier")) {
+				if (isChildrenValueExpression(node.init, bindings)) bindings.childrenNames.add(node.id.name);
+				return;
+			}
+			if (isNodeOfType(node.id, "ObjectPattern") && isPropsObjectExpression(node.init, bindings)) for (const property of node.id.properties ?? []) {
+				const localName = resolveChildrenPropertyLocalName(property);
+				if (localName) bindings.childrenNames.add(localName);
+			}
+		});
+		if (bindings.childrenNames.size === sizeBeforePass) break;
+	}
+};
+const collectJsxRootsFromExpression = (expression, roots) => {
+	const value = stripParenExpression(expression);
+	if (isNodeOfType(value, "JSXElement") || isNodeOfType(value, "JSXFragment")) {
+		roots.push(value);
+		return;
+	}
+	if (isNodeOfType(value, "ConditionalExpression")) {
+		if (value.consequent) collectJsxRootsFromExpression(value.consequent, roots);
+		if (value.alternate) collectJsxRootsFromExpression(value.alternate, roots);
+		return;
+	}
+	if (isNodeOfType(value, "LogicalExpression")) {
+		if (value.left) collectJsxRootsFromExpression(value.left, roots);
+		if (value.right) collectJsxRootsFromExpression(value.right, roots);
+	}
+};
+const collectReturnedJsxRoots = (functionNode) => {
+	const roots = [];
+	const { body } = functionNode;
+	if (!body) return roots;
+	if (!isNodeOfType(body, "BlockStatement")) {
+		collectJsxRootsFromExpression(body, roots);
+		return roots;
+	}
+	walkAst(body, (node) => {
+		if (isFunctionNode(node) && node !== functionNode) return false;
+		if (isNodeOfType(node, "ReturnStatement") && node.argument) {
+			collectJsxRootsFromExpression(node.argument, roots);
+			return false;
+		}
+	});
+	return roots;
+};
+const isChildrenForwardingJsxChild = (child, bindings) => isNodeOfType(child, "JSXExpressionContainer") && isChildrenValueExpression(child.expression, bindings);
+const isChildrenForwardingAttribute = (attribute, bindings) => {
+	if (isNodeOfType(attribute, "JSXSpreadAttribute")) return isPropsObjectExpression(attribute.argument, bindings);
+	return isNodeOfType(attribute, "JSXAttribute") && isNodeOfType(attribute.name, "JSXIdentifier") && attribute.name.name === "children" && isNodeOfType(attribute.value, "JSXExpressionContainer") && isChildrenValueExpression(attribute.value.expression, bindings);
+};
+const jsxRootForwardsChildrenIntoText = (jsxRoot, bindings, isTextHandlingElement) => {
+	let didForwardIntoText = false;
+	walkAst(jsxRoot, (node) => {
+		if (didForwardIntoText || isFunctionNode(node)) return false;
+		if (!isNodeOfType(node, "JSXElement")) return void 0;
+		const elementName = resolveJsxElementName(node.openingElement);
+		if (!elementName || !isTextHandlingElement(elementName)) return;
+		didForwardIntoText = (node.children ?? []).some((child) => isChildrenForwardingJsxChild(child, bindings)) || (node.openingElement.attributes ?? []).some((attribute) => isChildrenForwardingAttribute(attribute, bindings));
+	});
+	return didForwardIntoText;
+};
+const isMeaningfulJsxChild = (child) => !isNodeOfType(child, "JSXText") || Boolean(child.value?.trim());
+const jsxRootRendersChildrenOutsideText = (jsxRoot, bindings, isTextHandlingElement) => {
+	let didRenderOutsideText = false;
+	walkAst(jsxRoot, (node) => {
+		if (didRenderOutsideText || isFunctionNode(node)) return false;
+		if (!isNodeOfType(node, "JSXElement") && !isNodeOfType(node, "JSXFragment")) return;
+		if (isNodeOfType(node, "JSXElement")) {
+			const elementName = resolveJsxElementName(node.openingElement);
+			if (elementName && isTextHandlingElement(elementName)) return false;
+			if (!(node.children ?? []).some(isMeaningfulJsxChild) && (node.openingElement.attributes ?? []).some((attribute) => isChildrenForwardingAttribute(attribute, bindings))) {
+				didRenderOutsideText = true;
+				return;
+			}
+		}
+		didRenderOutsideText = (node.children ?? []).some((child) => isChildrenForwardingJsxChild(child, bindings));
+	});
+	return didRenderOutsideText;
+};
+const resolveStyledFactoryBaseName = (definitionNode) => {
+	let current = stripParenExpression(definitionNode);
+	while (current) {
+		if (isNodeOfType(current, "TaggedTemplateExpression")) {
+			current = stripParenExpression(current.tag);
+			continue;
+		}
+		if (isNodeOfType(current, "CallExpression")) {
+			const callee = stripParenExpression(current.callee);
+			if (isNodeOfType(callee, "Identifier") && callee.name === "styled") {
+				const baseArgument = current.arguments?.[0];
+				if (!baseArgument) return null;
+				const base = stripParenExpression(baseArgument);
+				return isNodeOfType(base, "Identifier") ? base.name : null;
+			}
+			current = callee;
+			continue;
+		}
+		if (isNodeOfType(current, "MemberExpression")) {
+			if (isNodeOfType(current.object, "Identifier") && current.object.name === "styled" && isNodeOfType(current.property, "Identifier")) return current.property.name;
+			current = stripParenExpression(current.object);
+			continue;
+		}
+		return null;
 	}
 	return null;
 };
-const recordWrapperFromDeclaration = (componentName, functionNode, isTextHandlingRoot, wrappers) => {
+const resolveClassRenderFunction = (classNode) => {
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression")) return null;
+	for (const member of classNode.body?.body ?? []) {
+		if (!isNodeOfType(member, "MethodDefinition")) continue;
+		if (!isNodeOfType(member.key, "Identifier") || member.key.name !== "render") continue;
+		return member.value && isFunctionNode(member.value) ? member.value : null;
+	}
+	return null;
+};
+const recordWrapperFromDeclaration = (componentName, definitionNode, isTextHandlingElement, wrappers) => {
 	if (!componentName || !isReactComponentName(componentName)) return;
-	if (!functionNode || !isFunctionNode(functionNode)) return;
-	const rootName = resolveReturnedRootElementName(functionNode);
-	if (rootName && isTextHandlingRoot(rootName)) wrappers.add(componentName);
+	if (wrappers.has(componentName)) return;
+	if (!definitionNode) return;
+	const unwrapped = unwrapComponentDefinition(definitionNode);
+	const styledBaseName = resolveStyledFactoryBaseName(unwrapped);
+	if (styledBaseName && isTextHandlingElement(styledBaseName)) {
+		wrappers.add(componentName);
+		return;
+	}
+	const functionNode = resolveClassRenderFunction(unwrapped) ?? (isFunctionNode(unwrapped) ? unwrapped : null);
+	if (!functionNode) return;
+	const bindings = resolveParamChildrenBindings(functionNode);
+	collectChildrenAliases(functionNode, bindings);
+	const jsxRoots = collectReturnedJsxRoots(functionNode);
+	if (jsxRoots.some((jsxRoot) => jsxRootRendersChildrenOutsideText(jsxRoot, bindings, isTextHandlingElement))) return;
+	for (const jsxRoot of jsxRoots) {
+		if (isNodeOfType(jsxRoot, "JSXElement")) {
+			const rootName = resolveJsxElementName(jsxRoot.openingElement);
+			if (rootName && isTextHandlingElement(rootName)) {
+				wrappers.add(componentName);
+				return;
+			}
+		}
+		if (jsxRootForwardsChildrenIntoText(jsxRoot, bindings, isTextHandlingElement)) {
+			wrappers.add(componentName);
+			return;
+		}
+	}
 };
+const MAX_TRANSITIVE_WRAPPER_PASSES = 3;
 const collectTextWrapperComponents = (programNode, isTextHandlingRoot) => {
 	const wrappers = /* @__PURE__ */ new Set();
-	walkAst(programNode, (node) => {
-		if (isNodeOfType(node, "VariableDeclarator")) recordWrapperFromDeclaration(node.id && isNodeOfType(node.id, "Identifier") ? node.id.name : null, node.init, isTextHandlingRoot, wrappers);
-		else if (isNodeOfType(node, "FunctionDeclaration")) recordWrapperFromDeclaration(node.id && isNodeOfType(node.id, "Identifier") ? node.id.name : null, node, isTextHandlingRoot, wrappers);
-	});
+	const isTextHandlingElement = (elementName) => isTextHandlingRoot(elementName) || wrappers.has(elementName);
+	for (let pass = 0; pass < MAX_TRANSITIVE_WRAPPER_PASSES; pass += 1) {
+		const sizeBeforePass = wrappers.size;
+		walkAst(programNode, (node) => {
+			if (isNodeOfType(node, "VariableDeclarator")) recordWrapperFromDeclaration(node.id && isNodeOfType(node.id, "Identifier") ? node.id.name : null, node.init, isTextHandlingElement, wrappers);
+			else if (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "ClassDeclaration")) recordWrapperFromDeclaration(node.id && isNodeOfType(node.id, "Identifier") ? node.id.name : null, node, isTextHandlingElement, wrappers);
+		});
+		if (wrappers.size === sizeBeforePass) break;
+	}
 	return wrappers;
 };
 //#endregion
@@ -28678,6 +28885,7 @@ const rnNoRawText = defineRule({
 	title: "Raw text outside a Text component",
 	requires: ["react-native"],
 	severity: "error",
+	tags: ["test-noise"],
 	recommendation: "Text outside a `<Text>` component crashes on React Native. Wrap it like `<Text>{value}</Text>`.",
 	create: (context) => {
 		let isDomComponentFile = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.5.1-dev.038aaf7",
+  "version": "0.5.1-dev.19d99ee",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",