oxlint-plugin-react-doctor 0.5.1-dev.b819e5f → 0.5.1-dev.d48e7f1

package/dist/index.js

@@ -1132,6 +1132,15 @@ const isMemberProperty = (node, propertyName) => Boolean(node && isNodeOfType(no
 const NEXTJS_SOURCE_FILE_EXTENSION_GROUP = "(?:tsx?|jsx?|mts|mjs)";
 const PAGE_FILE_PATTERN = new RegExp(`/page\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
 const PAGE_OR_LAYOUT_FILE_PATTERN = new RegExp(`/(page|layout)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
+const LAYOUT_FILE_NAMES = [
+	"layout.tsx",
+	"layout.jsx",
+	"layout.ts",
+	"layout.js",
+	"layout.mts",
+	"layout.mjs"
+];
+const METADATA_EXPORT_NAMES = ["metadata", "generateMetadata"];
 const INTERNAL_PAGE_PATH_PATTERN = /\/(?:(?:\((?:dashboard|admin|settings|account|internal|manage|console|portal|auth|onboarding|app|ee|protected)\))|(?:dashboard|admin|settings|account|internal|manage|console|portal))\//i;
 const PAGES_DIRECTORY_PATTERN = /\/pages\//;
 const NEXTJS_NAVIGATION_FUNCTIONS = new Set([
@@ -12543,6 +12552,64 @@ const nextjsInlineScriptMissingId = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/parse-export-specifiers.ts
+const getSpecifierName = (rawName) => rawName.replace(/^type\s+/, "").trim();
+const parseExportSpecifiers = (specifiersText, declarationIsTypeOnly) => specifiersText.split(",").map((specifierText) => specifierText.trim()).filter(Boolean).map((specifierText) => {
+	const isTypeOnly = declarationIsTypeOnly || specifierText.startsWith("type ");
+	const [rawLocalName, rawExportedName] = specifierText.split(/\s+as\s+/);
+	const localName = getSpecifierName(rawLocalName ?? "");
+	return {
+		localName,
+		exportedName: getSpecifierName(rawExportedName ?? localName),
+		isTypeOnly
+	};
+});
+//#endregion
+//#region src/plugin/utils/strip-js-comments.ts
+const BLOCK_COMMENT_PATTERN = /\/\*[\s\S]*?\*\//g;
+const LINE_COMMENT_PATTERN = /^\s*\/\/.*$/gm;
+const stripJsComments = (sourceText) => sourceText.replace(BLOCK_COMMENT_PATTERN, "").replace(LINE_COMMENT_PATTERN, "");
+//#endregion
+//#region src/plugin/utils/does-module-export-name.ts
+const DEFAULT_EXPORT_DECLARATION_PATTERN = /^\s*export\s+default\b/m;
+const NAMED_EXPORT_DECLARATION_PATTERN = /^\s*export\s+(?:declare\s+)?(?:(?:async\s+)?function|(?:abstract\s+)?class|const|let|var|enum|interface|type)\s+([\w$]+)/gm;
+const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1 = /^\s*export\s+(?:type\s+)?\{([\s\S]*?)\}(?:\s+from\s+["'][^"']+["'])?\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const doesSourceTextExportName = (sourceText, exportedName) => {
+	const strippedSource = stripJsComments(sourceText);
+	if (exportedName === "default" && DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) return true;
+	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1] === exportedName) return true;
+	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1)) if (parseExportSpecifiers(match[1] ?? "", false).map((specifier) => specifier.exportedName).includes(exportedName)) return true;
+	return false;
+};
+const doesModuleExportName = (filePath, exportedName) => {
+	try {
+		return doesSourceTextExportName(fs.readFileSync(filePath, "utf8"), exportedName);
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/plugin/utils/has-ancestor-layout-matching.ts
+const hasAncestorLayoutMatching = (pageFilename, matchesLayout) => {
+	const normalizedPage = pageFilename.replaceAll("\\", "/");
+	let currentDirectory = path.dirname(normalizedPage);
+	for (let level = 0; level < 30; level++) {
+		for (const layoutFileName of LAYOUT_FILE_NAMES) {
+			const layoutPath = path.join(currentDirectory, layoutFileName);
+			if (layoutPath.replaceAll("\\", "/") === normalizedPage) continue;
+			if (matchesLayout(layoutPath)) return true;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (path.basename(currentDirectory) === "app" && path.basename(parentDirectory) !== "app") break;
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/find-ancestor-metadata-layout.ts
+const hasAncestorMetadataLayout = (pageFilename) => hasAncestorLayoutMatching(pageFilename, (layoutPath) => METADATA_EXPORT_NAMES.some((exportName) => doesModuleExportName(layoutPath, exportName)));
+//#endregion
 //#region src/plugin/rules/nextjs/nextjs-missing-metadata.ts
 const nextjsMissingMetadata = defineRule({
 	id: "nextjs-missing-metadata",
@@ -12555,13 +12622,15 @@ const nextjsMissingMetadata = defineRule({
 		const filename = normalizeFilename$1(context.filename ?? "");
 		if (!PAGE_FILE_PATTERN.test(filename)) return;
 		if (INTERNAL_PAGE_PATH_PATTERN.test(filename)) return;
-		if (!programNode.body?.some((statement) => {
+		if (programNode.body?.some((statement) => {
 			if (!isNodeOfType(statement, "ExportNamedDeclaration")) return false;
 			const declaration = statement.declaration;
-			if (isNodeOfType(declaration, "VariableDeclaration")) return declaration.declarations?.some((declarator) => isNodeOfType(declarator.id, "Identifier") && (declarator.id.name === "metadata" || declarator.id.name === "generateMetadata"));
+			if (isNodeOfType(declaration, "VariableDeclaration")) return declaration.declarations?.some((declarator) => isNodeOfType(declarator.id, "Identifier") && METADATA_EXPORT_NAMES.includes(declarator.id.name));
 			if (isNodeOfType(declaration, "FunctionDeclaration")) return declaration.id?.name === "generateMetadata";
-			return false;
-		})) context.report({
+			return (statement.specifiers ?? []).some((specifier) => isNodeOfType(specifier, "ExportSpecifier") && isNodeOfType(specifier.exported, "Identifier") && METADATA_EXPORT_NAMES.includes(specifier.exported.name));
+		})) return;
+		if (hasAncestorMetadataLayout(context.filename ?? "")) return;
+		context.report({
 			node: programNode,
 			message: "This page has no metadata, so search engines and social previews get no title or description."
 		});
@@ -13452,43 +13521,6 @@ const parseSourceFile = (absoluteFilePath) => {
 	return parsedProgram;
 };
 //#endregion
-//#region src/plugin/utils/parse-export-specifiers.ts
-const getSpecifierName = (rawName) => rawName.replace(/^type\s+/, "").trim();
-const parseExportSpecifiers = (specifiersText, declarationIsTypeOnly) => specifiersText.split(",").map((specifierText) => specifierText.trim()).filter(Boolean).map((specifierText) => {
-	const isTypeOnly = declarationIsTypeOnly || specifierText.startsWith("type ");
-	const [rawLocalName, rawExportedName] = specifierText.split(/\s+as\s+/);
-	const localName = getSpecifierName(rawLocalName ?? "");
-	return {
-		localName,
-		exportedName: getSpecifierName(rawExportedName ?? localName),
-		isTypeOnly
-	};
-});
-//#endregion
-//#region src/plugin/utils/strip-js-comments.ts
-const BLOCK_COMMENT_PATTERN = /\/\*[\s\S]*?\*\//g;
-const LINE_COMMENT_PATTERN = /^\s*\/\/.*$/gm;
-const stripJsComments = (sourceText) => sourceText.replace(BLOCK_COMMENT_PATTERN, "").replace(LINE_COMMENT_PATTERN, "");
-//#endregion
-//#region src/plugin/utils/does-module-export-name.ts
-const DEFAULT_EXPORT_DECLARATION_PATTERN = /^\s*export\s+default\b/m;
-const NAMED_EXPORT_DECLARATION_PATTERN = /^\s*export\s+(?:declare\s+)?(?:(?:async\s+)?function|(?:abstract\s+)?class|const|let|var|enum|interface|type)\s+([\w$]+)/gm;
-const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1 = /^\s*export\s+(?:type\s+)?\{([\s\S]*?)\}(?:\s+from\s+["'][^"']+["'])?\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const doesSourceTextExportName = (sourceText, exportedName) => {
-	const strippedSource = stripJsComments(sourceText);
-	if (exportedName === "default" && DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) return true;
-	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1] === exportedName) return true;
-	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1)) if (parseExportSpecifiers(match[1] ?? "", false).map((specifier) => specifier.exportedName).includes(exportedName)) return true;
-	return false;
-};
-const doesModuleExportName = (filePath, exportedName) => {
-	try {
-		return doesSourceTextExportName(fs.readFileSync(filePath, "utf8"), exportedName);
-	} catch {
-		return false;
-	}
-};
-//#endregion
 //#region src/plugin/utils/is-barrel-index-module.ts
 const INDEX_MODULE_FILE_PATTERN = /^index\.(?:[cm]?[jt]sx?|mjs)$/;
 const BINDING_IMPORT_DECLARATION_PATTERN = /^\s*import\s+(type\s+)?(?!["'])([^;]*?)\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
@@ -13972,29 +14004,10 @@ const astMentionsSuspense = (programNode) => {
 };
 //#endregion
 //#region src/plugin/utils/find-ancestor-suspense-layout.ts
-const LAYOUT_FILE_NAMES = [
-	"layout.tsx",
-	"layout.jsx",
-	"layout.ts",
-	"layout.js"
-];
-const hasAncestorSuspenseLayout = (pageFilename) => {
-	const normalizedPage = pageFilename.replaceAll("\\", "/");
-	let currentDirectory = path.dirname(normalizedPage);
-	for (let level = 0; level < 30; level++) {
-		for (const layoutFileName of LAYOUT_FILE_NAMES) {
-			const layoutPath = path.join(currentDirectory, layoutFileName);
-			if (layoutPath.replaceAll("\\", "/") === normalizedPage) continue;
-			const programRoot = parseSourceFile(layoutPath);
-			if (programRoot && astMentionsSuspense(programRoot)) return true;
-		}
-		if (path.basename(currentDirectory) === "app") break;
-		const parentDirectory = path.dirname(currentDirectory);
-		if (parentDirectory === currentDirectory) break;
-		currentDirectory = parentDirectory;
-	}
-	return false;
-};
+const hasAncestorSuspenseLayout = (pageFilename) => hasAncestorLayoutMatching(pageFilename, (layoutPath) => {
+	const programRoot = parseSourceFile(layoutPath);
+	return Boolean(programRoot && astMentionsSuspense(programRoot));
+});
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-no-use-search-params-without-suspense.ts
 const astContainsUseSearchParams = (root) => {
@@ -24344,6 +24357,21 @@ const noZIndex9999 = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/utils/is-framework-route-or-special-filename.ts
+const sourceFileExtensionGroup = NEXTJS_SOURCE_FILE_EXTENSION_GROUP;
+const FRAMEWORK_ROUTE_FILE_PATTERNS = [
+	new RegExp(`^(page|layout|loading|error|not-found|template|default|global-error|route|_app|_document|_error)\\.${sourceFileExtensionGroup}$`),
+	new RegExp(`^(_layout|\\+html|\\+not-found|\\+native-intent)\\.${sourceFileExtensionGroup}$`),
+	new RegExp(`(?:^__root|\\.lazy)\\.${sourceFileExtensionGroup}$`),
+	new RegExp(`^(root|entry\\.client|entry\\.server)\\.${sourceFileExtensionGroup}$`)
+];
+const isFrameworkRouteOrSpecialFilename = (rawFilename) => {
+	if (!rawFilename) return false;
+	if (isNextjsMetadataImageRouteFilename(rawFilename)) return true;
+	const basename = path.basename(rawFilename);
+	return FRAMEWORK_ROUTE_FILE_PATTERNS.some((pattern) => pattern.test(basename));
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/only-export-components-tables.ts
 const NOT_REACT_COMPONENT_EXPRESSION_TYPES = new Set([
 	"ArrayExpression",
@@ -24395,32 +24423,6 @@ const ENTRY_POINT_BASENAMES = new Set([
 	"client.jsx",
 	"server.tsx",
 	"server.jsx",
-	"page.tsx",
-	"page.jsx",
-	"layout.tsx",
-	"layout.jsx",
-	"loading.tsx",
-	"loading.jsx",
-	"error.tsx",
-	"error.jsx",
-	"not-found.tsx",
-	"not-found.jsx",
-	"template.tsx",
-	"template.jsx",
-	"default.tsx",
-	"default.jsx",
-	"global-error.tsx",
-	"global-error.jsx",
-	"route.tsx",
-	"route.jsx",
-	"_layout.tsx",
-	"_layout.jsx",
-	"_app.tsx",
-	"_app.jsx",
-	"_document.tsx",
-	"_document.jsx",
-	"_error.tsx",
-	"_error.jsx",
 	"app.tsx",
 	"app.jsx",
 	"App.tsx",
@@ -24713,6 +24715,7 @@ const isFileNameAllowed = (filename, checkJS) => {
 	if (filename.includes(".test.") || filename.includes(".spec.") || filename.includes(".cy.") || filename.includes(".stories.")) return false;
 	for (const segment of NON_FAST_REFRESH_PATH_SEGMENTS) if (filename.includes(segment)) return false;
 	if (isEntryPointFile(filename)) return false;
+	if (isFrameworkRouteOrSpecialFilename(filename)) return false;
 	if (isAssetOrUtilityFile(filename)) return false;
 	if (filename.endsWith(".tsx") || filename.endsWith(".jsx")) return true;
 	if (checkJS && filename.endsWith(".js")) return true;
@@ -28585,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 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, functionNode, isTextHandlingRoot, wrappers) => {
+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
@@ -28675,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.b819e5f",
+  "version": "0.5.1-dev.d48e7f1",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",
@@ -50,7 +50,7 @@
     "@types/node": "^25.6.0"
   },
   "engines": {
-    "node": "^20.19.0 || >=22.12.0"
+    "node": "^20.19.0 || >=22.13.0"
   },
   "scripts": {
     "dev": "vp pack --watch",