oxlint-plugin-react-doctor 0.5.1-dev.038aaf7 → 0.5.1-dev.04e72a4

package/dist/index.js

@@ -5839,6 +5839,20 @@ const isReactHookName = (name) => {
 //#region src/plugin/utils/is-react-component-or-hook-name.ts
 const isReactComponentOrHookName = (name) => isReactComponentName(name) || isReactHookName(name);
 //#endregion
+//#region src/plugin/utils/is-react-hoc-callback-argument.ts
+const reactHocCalleeName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier") && callee.object.name === "React" && isNodeOfType(callee.property, "Identifier")) return `React.${callee.property.name}`;
+	return null;
+};
+const isReactHocCallbackArgument = (functionNode) => {
+	const parent = functionNode.parent;
+	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
+	if (parent.arguments[0] !== functionNode) return false;
+	const calleeName = reactHocCalleeName(parent.callee);
+	return calleeName !== null && REACT_HOC_NAMES.has(calleeName);
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-low-level.ts
 /**
 * Lowest-level helpers consumed by both the main `exhaustive-deps`
@@ -6069,6 +6083,7 @@ const findEnclosingComponentOrHookFunction$1 = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isNodeOfType(current, "FunctionDeclaration") || isNodeOfType(current, "FunctionExpression") || isNodeOfType(current, "ArrowFunctionExpression")) {
+			if (isReactHocCallbackArgument(current)) return current;
 			const functionName = inferFunctionName$1(current);
 			if (functionName && isReactComponentOrHookName(functionName)) return current;
 		}
@@ -15337,6 +15352,182 @@ const createRelativeImportSource = (filename, targetFilePath) => {
 	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 };
 //#endregion
+//#region src/react-native-dependency-names.ts
+const EXPO_MANAGED_DEPENDENCY_NAMES = new Set([
+	"expo",
+	"expo-router",
+	"@expo/cli",
+	"@expo/metro-config",
+	"@expo/metro-runtime"
+]);
+const REACT_NATIVE_DEPENDENCY_NAMES = new Set([
+	"react-native",
+	"react-native-tvos",
+	...EXPO_MANAGED_DEPENDENCY_NAMES,
+	"react-native-windows",
+	"react-native-macos"
+]);
+const REACT_NATIVE_DEPENDENCY_PREFIXES = ["@react-native/", "@react-native-"];
+const isExpoManagedDependencyName = (dependencyName) => EXPO_MANAGED_DEPENDENCY_NAMES.has(dependencyName);
+const isReactNativeDependencyName = (dependencyName) => {
+	if (REACT_NATIVE_DEPENDENCY_NAMES.has(dependencyName)) return true;
+	for (const prefix of REACT_NATIVE_DEPENDENCY_PREFIXES) if (dependencyName.startsWith(prefix)) return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/classify-package-platform.ts
+const WEB_FRAMEWORK_DEPENDENCY_NAMES = new Set([
+	"next",
+	"vite",
+	"react-scripts",
+	"gatsby",
+	"@remix-run/react",
+	"@remix-run/node",
+	"@docusaurus/core",
+	"@docusaurus/preset-classic",
+	"@storybook/react",
+	"@storybook/react-vite",
+	"@storybook/react-webpack5",
+	"@storybook/nextjs",
+	"@storybook/web-components",
+	"storybook",
+	"react-dom",
+	"@vitejs/plugin-react",
+	"@vitejs/plugin-react-swc"
+]);
+const cachedPlatformByPackageDirectory = /* @__PURE__ */ new Map();
+const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
+const findNearestPackageDirectory = (filename) => {
+	if (!filename) return null;
+	const fromCache = cachedPackageDirectoryByFilename.get(filename);
+	if (fromCache !== void 0) return fromCache;
+	let currentDirectory = path.dirname(filename);
+	while (true) {
+		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
+		let hasPackageJson = false;
+		try {
+			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
+		} catch {
+			hasPackageJson = false;
+		}
+		if (hasPackageJson) {
+			cachedPackageDirectoryByFilename.set(filename, currentDirectory);
+			return currentDirectory;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) {
+			cachedPackageDirectoryByFilename.set(filename, null);
+			return null;
+		}
+		currentDirectory = parentDirectory;
+	}
+};
+const readPackageJsonSafe = (packageJsonPath) => {
+	let rawContents;
+	try {
+		rawContents = fs.readFileSync(packageJsonPath, "utf-8");
+	} catch {
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(rawContents);
+		if (typeof parsed === "object" && parsed !== null) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+};
+const DEPENDENCY_SECTION_NAMES = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+const iterateDependencyNames = function* (packageJson) {
+	for (const sectionName of DEPENDENCY_SECTION_NAMES) {
+		const section = packageJson[sectionName];
+		if (!section) continue;
+		for (const dependencyName of Object.keys(section)) yield dependencyName;
+	}
+};
+const isReactNativeAware = (packageJson) => {
+	if (typeof packageJson["react-native"] === "string") return true;
+	for (const dependencyName of iterateDependencyNames(packageJson)) if (isReactNativeDependencyName(dependencyName)) return true;
+	return false;
+};
+const isExpoManaged = (packageJson) => {
+	for (const dependencyName of iterateDependencyNames(packageJson)) if (isExpoManagedDependencyName(dependencyName)) return true;
+	return false;
+};
+const isWebFrameworkOnly = (packageJson) => {
+	for (const dependencyName of iterateDependencyNames(packageJson)) if (WEB_FRAMEWORK_DEPENDENCY_NAMES.has(dependencyName)) return true;
+	return false;
+};
+const classifyPackagePlatform = (filename) => {
+	const packageDirectory = findNearestPackageDirectory(filename);
+	if (!packageDirectory) return "unknown";
+	const cached = cachedPlatformByPackageDirectory.get(packageDirectory);
+	if (cached !== void 0) return cached;
+	const packageJson = readPackageJsonSafe(path.join(packageDirectory, "package.json"));
+	if (!packageJson) {
+		cachedPlatformByPackageDirectory.set(packageDirectory, "unknown");
+		return "unknown";
+	}
+	let result;
+	if (isExpoManaged(packageJson)) result = "expo";
+	else if (isReactNativeAware(packageJson)) result = "react-native";
+	else if (isWebFrameworkOnly(packageJson)) result = "web";
+	else result = "unknown";
+	cachedPlatformByPackageDirectory.set(packageDirectory, result);
+	return result;
+};
+//#endregion
+//#region src/plugin/utils/get-react-doctor-setting.ts
+const readReactDoctorSettingsBag = (settings) => {
+	const reactDoctorSettings = settings?.["react-doctor"];
+	if (typeof reactDoctorSettings !== "object" || reactDoctorSettings === null || Array.isArray(reactDoctorSettings)) return null;
+	return reactDoctorSettings;
+};
+const readOwnPropertyValue = (bag, settingName) => Object.getOwnPropertyDescriptor(bag, settingName)?.value;
+const getReactDoctorStringSetting = (settings, settingName) => {
+	const bag = readReactDoctorSettingsBag(settings);
+	if (!bag) return void 0;
+	const settingValue = readOwnPropertyValue(bag, settingName);
+	return typeof settingValue === "string" ? settingValue : void 0;
+};
+const getReactDoctorNumberSetting = (settings, settingName) => {
+	const bag = readReactDoctorSettingsBag(settings);
+	if (!bag) return void 0;
+	const settingValue = readOwnPropertyValue(bag, settingName);
+	return typeof settingValue === "number" && Number.isFinite(settingValue) ? settingValue : void 0;
+};
+const getReactDoctorStringArraySetting = (settings, settingName) => {
+	const bag = readReactDoctorSettingsBag(settings);
+	if (!bag) return [];
+	const settingValue = readOwnPropertyValue(bag, settingName);
+	if (!Array.isArray(settingValue)) return [];
+	return settingValue.filter((entry) => typeof entry === "string" && entry.length > 0);
+};
+//#endregion
+//#region src/plugin/utils/is-react-native-file.ts
+const WEB_FILE_EXTENSION_PATTERN = /\.web\.[cm]?[jt]sx?$/;
+const NATIVE_FILE_EXTENSION_PATTERN = /\.(?:ios|android|native)\.[cm]?[jt]sx?$/;
+const classifyReactNativeFileTarget = (context) => {
+	const rawFilename = context.filename;
+	if (!rawFilename) return "unknown";
+	const filename = normalizeFilename$1(rawFilename);
+	if (NATIVE_FILE_EXTENSION_PATTERN.test(filename)) return "react-native";
+	if (WEB_FILE_EXTENSION_PATTERN.test(filename)) return "web";
+	const packagePlatform = classifyPackagePlatform(filename);
+	if (packagePlatform === "web") return "web";
+	if (packagePlatform === "expo" || packagePlatform === "react-native") return "react-native";
+	const framework = getReactDoctorStringSetting(context.settings, "framework");
+	if (framework === "react-native" || framework === "expo") return "react-native";
+	if (framework === "nextjs" || framework === "vite" || framework === "cra" || framework === "remix" || framework === "gatsby" || framework === "tanstack-start") return "web";
+	return "unknown";
+};
+const isReactNativeFileActive = (context) => classifyReactNativeFileTarget(context) !== "web";
+//#endregion
 //#region src/plugin/rules/bundle-size/no-barrel-import.ts
 const getLiteralName = (node) => {
 	if (node.type === "Identifier" && typeof node.name === "string") return node.name;
@@ -15354,7 +15545,8 @@ const getRuntimeImportRequests = (node) => {
 		return [{ importedName: null }];
 	});
 };
-const buildReportMessage = (filename, barrelFilePath, importRequests) => {
+const buildReportMessage = (filename, barrelFilePath, importRequests, isReactNativeTarget) => {
+	const costSentence = isReactNativeTarget ? "This ships extra code in your app bundle & slows startup." : "This ships extra code to your users & slows page load.";
 	const directImportSources = /* @__PURE__ */ new Set();
 	for (const request of importRequests) {
 		if (!request.importedName) continue;
@@ -15363,9 +15555,9 @@ const buildReportMessage = (filename, barrelFilePath, importRequests) => {
 	}
 	if (directImportSources.size === 1) {
 		const [directImportSource] = directImportSources;
-		return `This ships extra code to your users & slows page load. Import directly from "${directImportSource}".`;
+		return `${costSentence} Import directly from "${directImportSource}".`;
 	}
-	if (directImportSources.size > 1) return `This ships extra code to your users & slows page load. Import directly from: ${[...directImportSources].map((source) => `"${source}"`).join(", ")}.`;
+	if (directImportSources.size > 1) return `${costSentence} Import directly from: ${[...directImportSources].map((source) => `"${source}"`).join(", ")}.`;
 	return "Importing from an index file pulls in extra code. Import directly from the source file instead.";
 };
 const noBarrelImport = defineRule({
@@ -15389,7 +15581,7 @@ const noBarrelImport = defineRule({
 				didReportForFile = true;
 				context.report({
 					node,
-					message: buildReportMessage(filename, resolvedImportPath, importRequests)
+					message: buildReportMessage(filename, resolvedImportPath, importRequests, classifyReactNativeFileTarget(context) === "react-native")
 				});
 			}
 		} };
@@ -20682,33 +20874,6 @@ const noPolymorphicChildren = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/get-react-doctor-setting.ts
-const readReactDoctorSettingsBag = (settings) => {
-	const reactDoctorSettings = settings?.["react-doctor"];
-	if (typeof reactDoctorSettings !== "object" || reactDoctorSettings === null || Array.isArray(reactDoctorSettings)) return null;
-	return reactDoctorSettings;
-};
-const readOwnPropertyValue = (bag, settingName) => Object.getOwnPropertyDescriptor(bag, settingName)?.value;
-const getReactDoctorStringSetting = (settings, settingName) => {
-	const bag = readReactDoctorSettingsBag(settings);
-	if (!bag) return void 0;
-	const settingValue = readOwnPropertyValue(bag, settingName);
-	return typeof settingValue === "string" ? settingValue : void 0;
-};
-const getReactDoctorNumberSetting = (settings, settingName) => {
-	const bag = readReactDoctorSettingsBag(settings);
-	if (!bag) return void 0;
-	const settingValue = readOwnPropertyValue(bag, settingName);
-	return typeof settingValue === "number" && Number.isFinite(settingValue) ? settingValue : void 0;
-};
-const getReactDoctorStringArraySetting = (settings, settingName) => {
-	const bag = readReactDoctorSettingsBag(settings);
-	if (!bag) return [];
-	const settingValue = readOwnPropertyValue(bag, settingName);
-	if (!Array.isArray(settingValue)) return [];
-	return settingValue.filter((entry) => typeof entry === "string" && entry.length > 0);
-};
-//#endregion
 //#region src/plugin/rules/correctness/no-prevent-default.ts
 const PREVENT_DEFAULT_ELEMENTS = new Map([["form", ["onSubmit"]], ["a", ["onClick"]]]);
 const SERVER_CAPABLE_FRAMEWORKS = new Set([
@@ -28588,29 +28753,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
@@ -28678,6 +29050,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;
@@ -28923,136 +29296,6 @@ const rnPreferContentInsetAdjustment = defineRetiredRule({
 	recommendation: "Retired: SafeAreaView wrappers are valid; prefer native content inset adjustment only when manual inset plumbing causes scroll jumps or duplicated safe-area offsets."
 });
 //#endregion
-//#region src/react-native-dependency-names.ts
-const EXPO_MANAGED_DEPENDENCY_NAMES = new Set([
-	"expo",
-	"expo-router",
-	"@expo/cli",
-	"@expo/metro-config",
-	"@expo/metro-runtime"
-]);
-const REACT_NATIVE_DEPENDENCY_NAMES = new Set([
-	"react-native",
-	"react-native-tvos",
-	...EXPO_MANAGED_DEPENDENCY_NAMES,
-	"react-native-windows",
-	"react-native-macos"
-]);
-const REACT_NATIVE_DEPENDENCY_PREFIXES = ["@react-native/", "@react-native-"];
-const isExpoManagedDependencyName = (dependencyName) => EXPO_MANAGED_DEPENDENCY_NAMES.has(dependencyName);
-const isReactNativeDependencyName = (dependencyName) => {
-	if (REACT_NATIVE_DEPENDENCY_NAMES.has(dependencyName)) return true;
-	for (const prefix of REACT_NATIVE_DEPENDENCY_PREFIXES) if (dependencyName.startsWith(prefix)) return true;
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/classify-package-platform.ts
-const WEB_FRAMEWORK_DEPENDENCY_NAMES = new Set([
-	"next",
-	"vite",
-	"react-scripts",
-	"gatsby",
-	"@remix-run/react",
-	"@remix-run/node",
-	"@docusaurus/core",
-	"@docusaurus/preset-classic",
-	"@storybook/react",
-	"@storybook/react-vite",
-	"@storybook/react-webpack5",
-	"@storybook/nextjs",
-	"@storybook/web-components",
-	"storybook",
-	"react-dom",
-	"@vitejs/plugin-react",
-	"@vitejs/plugin-react-swc"
-]);
-const cachedPlatformByPackageDirectory = /* @__PURE__ */ new Map();
-const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
-const findNearestPackageDirectory = (filename) => {
-	if (!filename) return null;
-	const fromCache = cachedPackageDirectoryByFilename.get(filename);
-	if (fromCache !== void 0) return fromCache;
-	let currentDirectory = path.dirname(filename);
-	while (true) {
-		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
-		let hasPackageJson = false;
-		try {
-			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
-		} catch {
-			hasPackageJson = false;
-		}
-		if (hasPackageJson) {
-			cachedPackageDirectoryByFilename.set(filename, currentDirectory);
-			return currentDirectory;
-		}
-		const parentDirectory = path.dirname(currentDirectory);
-		if (parentDirectory === currentDirectory) {
-			cachedPackageDirectoryByFilename.set(filename, null);
-			return null;
-		}
-		currentDirectory = parentDirectory;
-	}
-};
-const readPackageJsonSafe = (packageJsonPath) => {
-	let rawContents;
-	try {
-		rawContents = fs.readFileSync(packageJsonPath, "utf-8");
-	} catch {
-		return null;
-	}
-	try {
-		const parsed = JSON.parse(rawContents);
-		if (typeof parsed === "object" && parsed !== null) return parsed;
-		return null;
-	} catch {
-		return null;
-	}
-};
-const DEPENDENCY_SECTION_NAMES = [
-	"dependencies",
-	"devDependencies",
-	"peerDependencies",
-	"optionalDependencies"
-];
-const iterateDependencyNames = function* (packageJson) {
-	for (const sectionName of DEPENDENCY_SECTION_NAMES) {
-		const section = packageJson[sectionName];
-		if (!section) continue;
-		for (const dependencyName of Object.keys(section)) yield dependencyName;
-	}
-};
-const isReactNativeAware = (packageJson) => {
-	if (typeof packageJson["react-native"] === "string") return true;
-	for (const dependencyName of iterateDependencyNames(packageJson)) if (isReactNativeDependencyName(dependencyName)) return true;
-	return false;
-};
-const isExpoManaged = (packageJson) => {
-	for (const dependencyName of iterateDependencyNames(packageJson)) if (isExpoManagedDependencyName(dependencyName)) return true;
-	return false;
-};
-const isWebFrameworkOnly = (packageJson) => {
-	for (const dependencyName of iterateDependencyNames(packageJson)) if (WEB_FRAMEWORK_DEPENDENCY_NAMES.has(dependencyName)) return true;
-	return false;
-};
-const classifyPackagePlatform = (filename) => {
-	const packageDirectory = findNearestPackageDirectory(filename);
-	if (!packageDirectory) return "unknown";
-	const cached = cachedPlatformByPackageDirectory.get(packageDirectory);
-	if (cached !== void 0) return cached;
-	const packageJson = readPackageJsonSafe(path.join(packageDirectory, "package.json"));
-	if (!packageJson) {
-		cachedPlatformByPackageDirectory.set(packageDirectory, "unknown");
-		return "unknown";
-	}
-	let result;
-	if (isExpoManaged(packageJson)) result = "expo";
-	else if (isReactNativeAware(packageJson)) result = "react-native";
-	else if (isWebFrameworkOnly(packageJson)) result = "web";
-	else result = "unknown";
-	cachedPlatformByPackageDirectory.set(packageDirectory, result);
-	return result;
-};
-//#endregion
 //#region src/plugin/utils/is-expo-managed-file.ts
 const isExpoManagedFileActive = (context) => {
 	const rawFilename = context.filename;
@@ -32952,7 +33195,7 @@ const findEnclosingFunctionInfo = (node) => {
 				name: displayName,
 				hasResolvedName: resolvedName !== null,
 				isAsync: Boolean(current.async),
-				isComponentOrHook: resolvedName === null ? false : isReactComponentOrHookName(displayName)
+				isComponentOrHook: isReactHocCallbackArgument(current) || (resolvedName === null ? false : isReactComponentOrHookName(displayName))
 			};
 		}
 		current = current.parent ?? null;
@@ -33011,6 +33254,7 @@ const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isFunctionLike$2(current)) {
+			if (isReactHocCallbackArgument(current)) return current;
 			const resolvedName = inferFunctionName(current);
 			if (resolvedName !== null && isReactComponentOrHookName(resolvedName)) return current;
 		}
@@ -33110,26 +33354,26 @@ const rulesOfHooks = defineRule({
 					});
 					return;
 				}
-				if (!enclosing.hasResolvedName) {
-					let outerWalker = enclosing.node;
-					let outerIsComponentOrHook = false;
-					while (outerWalker) {
-						const outerInfo = findEnclosingFunctionInfo(outerWalker);
-						if (!outerInfo) break;
-						if (outerInfo.isComponentOrHook) {
-							outerIsComponentOrHook = true;
-							break;
+				if (!enclosing.isComponentOrHook) {
+					if (!enclosing.hasResolvedName) {
+						let outerWalker = enclosing.node;
+						let outerIsComponentOrHook = false;
+						while (outerWalker) {
+							const outerInfo = findEnclosingFunctionInfo(outerWalker);
+							if (!outerInfo) break;
+							if (outerInfo.isComponentOrHook) {
+								outerIsComponentOrHook = true;
+								break;
+							}
+							outerWalker = outerInfo.node;
 						}
-						outerWalker = outerInfo.node;
+						if (!outerIsComponentOrHook) return;
+						context.report({
+							node: node.callee,
+							message: buildConditionalMessage(hookName)
+						});
+						return;
 					}
-					if (!outerIsComponentOrHook) return;
-					context.report({
-						node: node.callee,
-						message: buildConditionalMessage(hookName)
-					});
-					return;
-				}
-				if (!enclosing.isComponentOrHook) {
 					context.report({
 						node: node.callee,
 						message: buildNonComponentMessage(hookName, enclosing.name)
@@ -39088,24 +39332,6 @@ const reactDoctorRules = [
 ];
 const ruleRegistry = Object.fromEntries(reactDoctorRules.map((rule) => [rule.id, rule.rule]));
 //#endregion
-//#region src/plugin/utils/is-react-native-file.ts
-const WEB_FILE_EXTENSION_PATTERN = /\.web\.[cm]?[jt]sx?$/;
-const NATIVE_FILE_EXTENSION_PATTERN = /\.(?:ios|android|native)\.[cm]?[jt]sx?$/;
-const isReactNativeFileActive = (context) => {
-	const rawFilename = context.filename;
-	if (!rawFilename) return true;
-	const filename = normalizeFilename$1(rawFilename);
-	if (NATIVE_FILE_EXTENSION_PATTERN.test(filename)) return true;
-	if (WEB_FILE_EXTENSION_PATTERN.test(filename)) return false;
-	const packagePlatform = classifyPackagePlatform(filename);
-	if (packagePlatform === "web") return false;
-	if (packagePlatform === "expo" || packagePlatform === "react-native") return true;
-	const framework = getReactDoctorStringSetting(context.settings, "framework");
-	if (framework === "react-native" || framework === "expo") return true;
-	if (framework === "nextjs" || framework === "vite" || framework === "cra" || framework === "remix" || framework === "gatsby" || framework === "tanstack-start") return false;
-	return true;
-};
-//#endregion
 //#region src/plugin/utils/wrap-react-native-rule.ts
 const EMPTY_VISITORS = {};
 const wrapReactNativeRule = (rule) => {

package/package.json

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