oxlint-plugin-react-doctor 0.2.14-dev.8b313ba → 0.2.14-dev.938376

package/dist/index.js

@@ -9111,6 +9111,25 @@ const findEnclosingIteratorContext = (jsxNode) => {
 	}
 	return null;
 };
+const resolveIterationItemName = (callExpression) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return null;
+	const callee = callExpression.callee;
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	if (!isNodeOfType(callee.property, "Identifier")) return null;
+	const targetArgIndex = callee.property.name === "from" ? 1 : 0;
+	const callback = callExpression.arguments[targetArgIndex];
+	if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return null;
+	const firstParam = callback.params[0];
+	return firstParam && isNodeOfType(firstParam, "Identifier") ? firstParam.name : null;
+};
+const spreadsIterationItem = (openingElement, iterationItemName) => {
+	for (const attribute of openingElement.attributes) {
+		if (!isNodeOfType(attribute, "JSXSpreadAttribute")) continue;
+		const argument = attribute.argument;
+		if (isNodeOfType(argument, "Identifier") && argument.name === iterationItemName) return true;
+	}
+	return false;
+};
 const isWithinChildrenToArray = (jsxNode) => {
 	let current = jsxNode.parent;
 	while (current) {
@@ -9209,6 +9228,10 @@ const jsxKey = defineRule({
 				if (!enclosingContext) return;
 				if (isWithinChildrenToArray(node)) return;
 				if (hasJsxKeyAttribute(openingElement)) return;
+				if (enclosingContext.kind === "iterator") {
+					const iterationItemName = resolveIterationItemName(enclosingContext.callExpression);
+					if (iterationItemName && spreadsIterationItem(openingElement, iterationItemName)) return;
+				}
 				context.report({
 					node: openingElement,
 					message: enclosingContext.kind === "array" ? MISSING_KEY_ARRAY : MISSING_KEY_ITERATOR
@@ -25401,7 +25424,7 @@ const resolveRemovalMessageForCallee = (callee) => {
 const reactCompilerNoManualMemoization = defineRule({
 	id: "react-compiler-no-manual-memoization",
 	title: "Redundant manual memoization",
-	severity: "error",
+	severity: "warn",
 	requires: ["react-compiler"],
 	recommendation: "Delete the `useMemo` / `useCallback` / `memo` call and use the plain value or component. React Compiler caches it for you.",
 	create: (context) => ({ CallExpression(node) {
@@ -27533,6 +27556,34 @@ const isInsidePlatformOsWebBranch = (node) => {
 	return false;
 };
 //#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 { 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);
+	}
+	return null;
+};
+const recordWrapperFromDeclaration = (componentName, functionNode, isTextHandlingRoot, wrappers) => {
+	if (!componentName || !isReactComponentName(componentName)) return;
+	if (!functionNode || !isFunctionNode(functionNode)) return;
+	const rootName = resolveReturnedRootElementName(functionNode);
+	if (rootName && isTextHandlingRoot(rootName)) wrappers.add(componentName);
+};
+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);
+	});
+	return wrappers;
+};
+//#endregion
 //#region src/plugin/rules/react-native/rn-no-raw-text.ts
 const truncateText = (text) => text.length > 30 ? `${text.slice(0, 30)}...` : text;
 const isRawTextContent = (child) => {
@@ -27582,14 +27633,16 @@ const rnNoRawText = defineRule({
 	recommendation: "Text outside a `<Text>` component crashes on React Native. Wrap it like `<Text>{value}</Text>`.",
 	create: (context) => {
 		let isDomComponentFile = false;
+		let autoDetectedWrappers = /* @__PURE__ */ new Set();
 		return {
 			Program(programNode) {
 				isDomComponentFile = hasDirective(programNode, "use dom");
+				autoDetectedWrappers = collectTextWrapperComponents(programNode, isTextHandlingComponent);
 			},
 			JSXElement(node) {
 				if (isDomComponentFile) return;
 				const elementName = resolveTextBoundaryName(node.openingElement);
-				if (elementName && isTextHandlingComponent(elementName)) return;
+				if (elementName && (isTextHandlingComponent(elementName) || autoDetectedWrappers.has(elementName))) return;
 				if (isInsidePlatformOsWebBranch(node)) return;
 				if (isTransparentTextWrapper(elementName) && isInsideTextHandlingComponent(node)) return;
 				for (const child of node.children ?? []) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.2.14-dev.8b313ba",
+  "version": "0.2.14-dev.0938376",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",