oxlint-plugin-react-doctor 0.2.18-dev.4dc48d7 → 0.2.18-dev.6851a78

package/dist/index.d.ts

@@ -5047,7 +5047,7 @@ declare const REACT_DOCTOR_RULES: readonly [{
   readonly originallyExternal: false;
   readonly rule: {
     readonly framework: "react-native";
-    readonly category: "Bugs";
+    readonly category: "Performance";
     readonly tags: readonly string[];
     readonly id: string;
     readonly title?: string;
@@ -11345,7 +11345,7 @@ declare const RULES: readonly [{
   readonly originallyExternal: false;
   readonly rule: {
     readonly framework: "react-native";
-    readonly category: "Bugs";
+    readonly category: "Performance";
     readonly tags: readonly string[];
     readonly id: string;
     readonly title?: string;

package/dist/index.js

@@ -2574,7 +2574,7 @@ const INTENTIONAL_SEQUENCING_CALLEE_NAMES = new Set([
 * (`FUNCTION_LIKE_TYPES.has(node.type)`) and as a type-guard. The
 * type-guard form covers both shapes without callers paying a cast.
 */
-const isFunctionLike$2 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
+const isFunctionLike$3 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
 //#endregion
 //#region src/plugin/utils/is-inline-function-expression.ts
 /**
@@ -2597,7 +2597,7 @@ const findFirstAwaitOutsideNestedFunctions = (block) => {
 	let firstAwait = null;
 	walkAst(block, (child) => {
 		if (firstAwait) return false;
-		if (child !== block && isFunctionLike$2(child)) return false;
+		if (child !== block && isFunctionLike$3(child)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) firstAwait = child;
 	});
 	return firstAwait;
@@ -3054,13 +3054,13 @@ const asyncDeferAwait = defineRule({
 		const inspectAllStatementBlocks = (functionBody) => {
 			if (!functionBody) return;
 			walkAst(functionBody, (descendant) => {
-				if (isFunctionLike$2(descendant)) return false;
+				if (isFunctionLike$3(descendant)) return false;
 				if (isNodeOfType(descendant, "BlockStatement")) inspectStatements(descendant.body ?? []);
 				else if (isNodeOfType(descendant, "SwitchCase")) inspectStatements(descendant.consequent ?? []);
 			});
 		};
 		const enterFunction = (node) => {
-			if (!isFunctionLike$2(node)) return;
+			if (!isFunctionLike$3(node)) return;
 			if (!node.async) return;
 			if (!isNodeOfType(node.body, "BlockStatement")) return;
 			inspectAllStatementBlocks(node.body);
@@ -4509,7 +4509,7 @@ const displayName = defineRule({
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
-	if (isFunctionLike$2(node)) return;
+	if (isFunctionLike$3(node)) return;
 	visitor(node);
 	const nodeRecord = node;
 	for (const key of Object.keys(nodeRecord)) {
@@ -4597,7 +4597,7 @@ const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubs
 	let didFindRelease = false;
 	walkAst(node, (child) => {
 		if (didFindRelease) return false;
-		if (child !== node && isFunctionLike$2(child) && !isIteratorCallbackArgument(child)) return false;
+		if (child !== node && isFunctionLike$3(child) && !isIteratorCallbackArgument(child)) return false;
 		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
 			didFindRelease = true;
 			return false;
@@ -4606,7 +4606,7 @@ const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubs
 	return didFindRelease;
 };
 const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	if (!isFunctionLike$2(node)) return false;
+	if (!isFunctionLike$3(node)) return false;
 	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
 };
 const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames, options = {}) => {
@@ -4870,7 +4870,7 @@ const recordReference = (state, identifier, flag) => {
 };
 const isFunctionBodyBlock = (block) => {
 	if (!block.parent) return false;
-	return isFunctionLike$2(block.parent);
+	return isFunctionLike$3(block.parent);
 };
 const isCatchClauseBlock = (block) => block.parent !== null && block.parent !== void 0 && block.parent.type === "CatchClause";
 const handleVariableDeclaration = (declaration, state) => {
@@ -5025,7 +5025,7 @@ const walkParameterReferences = (pattern, state) => {
 	if (isNodeOfType(pattern, "RestElement")) walkParameterReferences(pattern.argument, state);
 };
 const walk = (node, state) => {
-	if (isFunctionLike$2(node)) {
+	if (isFunctionLike$3(node)) {
 		if (isNodeOfType(node, "FunctionDeclaration") && node.id) handleFunctionDeclaration(node, state);
 		setNodeScope(node, state);
 		const fnScope = pushScope(node.type === "ArrowFunctionExpression" ? "arrow-function" : "function", node, state);
@@ -5271,7 +5271,7 @@ const closureCaptures = (functionNode, scopes) => {
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (node !== functionNode && isFunctionLike$2(node)) {
+		if (node !== functionNode && isFunctionLike$3(node)) {
 			const innerCaptures = closureCaptures(node, scopes);
 			for (const reference of innerCaptures) if (reference.resolvedSymbol && !isDescendantScope(reference.resolvedSymbol.scope, functionScope)) {
 				if (!seen.has(reference.id)) {
@@ -7391,7 +7391,7 @@ const isAtomFromJotai = (callExpression) => {
 	if (!isImportedFromModule(callExpression, localName, "jotai")) return false;
 	return getImportedNameFromModule(callExpression, localName, "jotai") === "atom";
 };
-const isFunctionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
+const isFunctionLike$2 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
 const getFirstParameterName = (fn) => {
 	const parameters = fn.params ?? [];
 	if (parameters.length !== 1) return null;
@@ -7510,7 +7510,7 @@ const jotaiDerivedAtomReturnsFreshObject = defineRule({
 		const args = node.arguments ?? [];
 		if (args.length === 0) return;
 		const reader = args[0];
-		if (!isFunctionLike$1(reader)) return;
+		if (!isFunctionLike$2(reader)) return;
 		const getParameterName = getFirstParameterName(reader);
 		if (!getParameterName) return;
 		const freshReturn = getFreshReturnForFunction(reader);
@@ -7766,7 +7766,7 @@ const isInsideLoopContext = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isNodeOfType(current, "ForStatement") || isNodeOfType(current, "ForInStatement") || isNodeOfType(current, "ForOfStatement") || isNodeOfType(current, "WhileStatement") || isNodeOfType(current, "DoWhileStatement")) return true;
-		if (isFunctionLike$2(current)) {
+		if (isFunctionLike$3(current)) {
 			if (isIteratorCallback(current)) return true;
 			return false;
 		}
@@ -8127,7 +8127,7 @@ const jsHoistIntl = defineRule({
 		let cursor = node.parent ?? null;
 		let inFunctionBody = false;
 		while (cursor) {
-			if (isFunctionLike$2(cursor)) {
+			if (isFunctionLike$3(cursor)) {
 				inFunctionBody = true;
 				const fnParent = cursor.parent;
 				if (fnParent && isNodeOfType(fnParent, "CallExpression") && fnParent.arguments?.[0] === cursor) {
@@ -13082,7 +13082,7 @@ const collectChainedGetHandlerBodies = (initNode) => {
 };
 const resolveBodiesFromExpression = (expression, resolveBinding, remainingDepth) => {
 	if (remainingDepth <= 0) return [];
-	if (isFunctionLike$2(expression)) return expression.body ? [expression.body] : [];
+	if (isFunctionLike$3(expression)) return expression.body ? [expression.body] : [];
 	if (isNodeOfType(expression, "CallExpression")) {
 		for (const callArgument of expression.arguments ?? []) {
 			if (isNodeOfType(callArgument, "ArrowFunctionExpression") || isNodeOfType(callArgument, "FunctionExpression")) {
@@ -13552,7 +13552,7 @@ const getEffectFn = (analysis, node) => {
 	if (isNodeOfType(fn, "ArrowFunctionExpression") || isNodeOfType(fn, "FunctionExpression")) return fn;
 	if (isNodeOfType(fn, "Identifier")) {
 		const definitionNode = getRef(analysis, fn)?.resolved?.defs[0]?.node;
-		if (definitionNode && isFunctionLike$2(definitionNode)) return definitionNode;
+		if (definitionNode && isFunctionLike$3(definitionNode)) return definitionNode;
 		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
 			const initializer = definitionNode.init;
 			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) return initializer;
@@ -13645,14 +13645,14 @@ const getUseStateDecl = (analysis, ref) => {
 	return node ?? null;
 };
 const isCleanupReturnArgument = (analysis, node) => {
-	if (isFunctionLike$2(node)) return true;
+	if (isFunctionLike$3(node)) return true;
 	if (isNodeOfType(node, "MemberExpression")) return true;
 	if (isNodeOfType(node, "Identifier")) {
 		const definitionNode = getRef(analysis, node)?.resolved?.defs[0]?.node;
-		if (definitionNode && isFunctionLike$2(definitionNode)) return true;
+		if (definitionNode && isFunctionLike$3(definitionNode)) return true;
 		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
 			const initializer = definitionNode.init;
-			return isFunctionLike$2(initializer);
+			return isFunctionLike$3(initializer);
 		}
 	}
 	if (isNodeOfType(node, "ConditionalExpression")) return isCleanupReturnArgument(analysis, node.consequent) || isCleanupReturnArgument(analysis, node.alternate);
@@ -13662,7 +13662,7 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 	if (visited.has(node)) return false;
 	visited.add(node);
 	if (isNodeOfType(node, "ReturnStatement") && node.argument != null) return isCleanupReturnArgument(analysis, node.argument);
-	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$2(node)) return false;
+	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$3(node)) return false;
 	const record = node;
 	for (const [key, value] of Object.entries(record)) {
 		if (key === "parent") continue;
@@ -13674,7 +13674,7 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 };
 const hasCleanup = (analysis, node) => {
 	const fn = getEffectFn(analysis, node);
-	if (!isFunctionLike$2(fn)) return false;
+	if (!isFunctionLike$3(fn)) return false;
 	if (!isNodeOfType(fn.body, "BlockStatement")) return false;
 	return hasCleanupReturn(analysis, fn.body);
 };
@@ -14024,7 +14024,7 @@ const isInsideStaticPlaceholderMap = (node) => {
 	let current = node;
 	while (current.parent) {
 		const parent = current.parent;
-		if (isFunctionLike$2(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+		if (isFunctionLike$3(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
 			const callee = parent.callee;
 			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach")) return isStaticPlaceholderReceiver(callee.object);
 			if (isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current) return isArrayFromLengthObjectCall(parent);
@@ -14043,7 +14043,7 @@ const findIteratorItemName$1 = (node) => {
 	let current = node;
 	while (current.parent) {
 		const parent = current.parent;
-		if (isFunctionLike$2(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+		if (isFunctionLike$3(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
 			const callee = parent.callee;
 			const isIteratorMethodCall = isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach");
 			const isArrayFromCallback = isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current;
@@ -14988,7 +14988,7 @@ const componentOrHookDisplayNameForFunction = (functionNode) => {
 const nearestEnclosingFunction = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
-		if (isFunctionLike$2(cursor)) return cursor;
+		if (isFunctionLike$3(cursor)) return cursor;
 		cursor = cursor.parent ?? null;
 	}
 	return null;
@@ -15671,7 +15671,7 @@ const extractDestructuredPropNames = (params) => {
 };
 const getInlineFunctionNode = (node) => {
 	if (!node) return null;
-	if (isFunctionLike$2(node)) return node;
+	if (isFunctionLike$3(node)) return node;
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	for (const argument of node.arguments ?? []) {
 		const inlineFunctionNode = getInlineFunctionNode(argument);
@@ -15682,7 +15682,7 @@ const getInlineFunctionNode = (node) => {
 const getNearestComponentFunction = (node) => {
 	let cursor = node.parent ?? null;
 	while (cursor) {
-		if (isFunctionLike$2(cursor)) return cursor;
+		if (isFunctionLike$3(cursor)) return cursor;
 		cursor = cursor.parent ?? null;
 	}
 	return null;
@@ -16012,7 +16012,7 @@ const collectFunctionLocalBindings = (functionNode) => {
 const walkComponentRespectingShadows = (node, shadowedStateNames, visit) => {
 	if (!node || typeof node !== "object") return;
 	let nextShadowedStateNames = shadowedStateNames;
-	if (isFunctionLike$2(node)) {
+	if (isFunctionLike$3(node)) {
 		const localBindings = collectFunctionLocalBindings(node);
 		if (localBindings.size > 0) {
 			const merged = new Set(shadowedStateNames);
@@ -18269,7 +18269,7 @@ const isInsideClassBody = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isNodeOfType(current, "ClassBody")) return true;
-		if (isFunctionLike$2(current)) return false;
+		if (isFunctionLike$3(current)) return false;
 		current = current.parent;
 	}
 	return false;
@@ -18973,7 +18973,7 @@ const isLodashMutatorCall = (callExpression) => {
 };
 //#endregion
 //#region src/plugin/utils/find-exported-function-body.ts
-const isFunctionLike = (node) => {
+const isFunctionLike$1 = (node) => {
 	if (!node) return false;
 	return isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
 };
@@ -18988,7 +18988,7 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
 			if (!isNodeOfType(declarator.id, "Identifier")) continue;
 			const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
-			if (initializer && isFunctionLike(initializer)) localBindings.set(declarator.id.name, initializer);
+			if (initializer && isFunctionLike$1(initializer)) localBindings.set(declarator.id.name, initializer);
 		}
 	};
 	for (const statement of programRoot.body ?? []) {
@@ -19032,7 +19032,7 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 				defaultExport = declaration;
 				continue;
 			}
-			if (isFunctionLike(declaration)) {
+			if (isFunctionLike$1(declaration)) {
 				defaultExport = declaration;
 				continue;
 			}
@@ -19193,7 +19193,7 @@ const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
 const resolveReducerFunction = (node, currentFilename) => {
 	if (!node) return null;
 	const unwrappedNode = stripParenExpression(node);
-	if (isFunctionLike$2(unwrappedNode)) return {
+	if (isFunctionLike$3(unwrappedNode)) return {
 		functionNode: unwrappedNode,
 		crossFileSourceDisplay: null
 	};
@@ -19201,7 +19201,7 @@ const resolveReducerFunction = (node, currentFilename) => {
 	const initializer = findVariableInitializer(unwrappedNode, unwrappedNode.name)?.initializer;
 	if (!initializer) return null;
 	const unwrappedInitializer = stripParenExpression(initializer);
-	if (isFunctionLike$2(unwrappedInitializer)) return {
+	if (isFunctionLike$3(unwrappedInitializer)) return {
 		functionNode: unwrappedInitializer,
 		crossFileSourceDisplay: null
 	};
@@ -19315,11 +19315,11 @@ const canExpressionReturnOriginalReducerStateReference = (node, state) => {
 	return false;
 };
 const collectReducerStateMutationsInExpressionOrStatement = (node, state) => {
-	if (isFunctionLike$2(node)) return [];
+	if (isFunctionLike$3(node)) return [];
 	const mutations = [];
 	walkAst(node, (child) => {
 		const unwrappedChild = stripParenExpression(child);
-		if (child !== node && isFunctionLike$2(unwrappedChild)) return false;
+		if (child !== node && isFunctionLike$3(unwrappedChild)) return false;
 		if (isNodeOfType(unwrappedChild, "AssignmentExpression")) {
 			if (isNodeOfType(stripParenExpression(unwrappedChild.left), "MemberExpression") && isExpressionRootedInMutableReducerStateSource(unwrappedChild.left, state)) mutations.push({ node: unwrappedChild });
 			return;
@@ -19424,7 +19424,7 @@ const updateReducerStateIdentityForIdentifierAssignment = (assignment, state) =>
 	if (isExpressionReachableFromOriginalReducerState(assignment.right, state)) state.mutableStateSourceNames.add(name);
 };
 const analyzeReactUseReducerFunctionForStateMutation = (context, functionNode, reportedNodes, options) => {
-	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return;
+	if (!isFunctionLike$3(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return;
 	const firstParam = functionNode.params?.[0];
 	const stateName = isNodeOfType(firstParam, "Identifier") ? firstParam.name : isNodeOfType(firstParam, "AssignmentPattern") && isNodeOfType(firstParam.left, "Identifier") ? firstParam.left.name : null;
 	if (!stateName) return;
@@ -21273,7 +21273,7 @@ const isTanStackServerFnHandler = (node) => {
 const isInsideServerOnlyScope = (node) => {
 	let currentNode = node.parent ?? null;
 	while (currentNode) {
-		if (isFunctionLike$2(currentNode)) {
+		if (isFunctionLike$3(currentNode)) {
 			if (hasUseServerDirective(currentNode) || isTanStackServerFnHandler(currentNode)) return true;
 		}
 		currentNode = currentNode.parent ?? null;
@@ -23428,7 +23428,7 @@ const isReactClassComponent = (classNode) => {
 const findEnclosingComponent = (node) => {
 	let walker = node.parent;
 	while (walker) {
-		if (isFunctionLike$2(walker)) {
+		if (isFunctionLike$3(walker)) {
 			const componentName = inferFunctionLikeName(walker);
 			if (componentName && isReactComponentName(componentName) && expressionContainsJsxOrCreateElement(walker)) return {
 				component: walker,
@@ -23680,6 +23680,35 @@ const noUsememoSimpleExpression = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/design/no-wide-letter-spacing.ts
+const getJsxAttributeStringValue = (attributeValue) => {
+	if (!attributeValue) return null;
+	if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") return attributeValue.value;
+	if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
+		const expression = attributeValue.expression;
+		if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return expression.value;
+	}
+	return null;
+};
+const isTruthyBooleanJsxAttribute = (attributeValue) => {
+	if (attributeValue === null) return true;
+	if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
+		const expression = attributeValue.expression;
+		return isNodeOfType(expression, "Literal") && expression.value === true;
+	}
+	return false;
+};
+const hasUppercaseSiblingProp = (styleAttribute) => {
+	const openingElement = styleAttribute.parent;
+	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	for (const attribute of openingElement.attributes ?? []) {
+		if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+		if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
+		const attributeName = attribute.name.name;
+		if (attributeName === "uppercase" && isTruthyBooleanJsxAttribute(attribute.value)) return true;
+		if (attributeName === "textTransform" && getJsxAttributeStringValue(attribute.value) === "uppercase") return true;
+	}
+	return false;
+};
 const noWideLetterSpacing = defineRule({
 	id: "no-wide-letter-spacing",
 	title: "Wide letter spacing on body text",
@@ -23689,6 +23718,7 @@ const noWideLetterSpacing = defineRule({
 	create: (context) => ({ JSXAttribute(node) {
 		const expression = getInlineStyleExpression(node);
 		if (!expression) return;
+		if (hasUppercaseSiblingProp(node)) return;
 		let isUppercase = false;
 		let letterSpacingProperty = null;
 		let letterSpacingEm = null;
@@ -24851,6 +24881,7 @@ const preferModuleScopeStaticValue = defineRule({
 	tags: ["test-noise"],
 	severity: "warn",
 	category: "Architecture",
+	disabledBy: ["react-compiler"],
 	recommendation: "Move the value above the component, at the top of the file. It doesn't use local state, so rebuilding it each update is wasted and makes it look new every time.",
 	create: (context) => ({ VariableDeclarator(node) {
 		if (!isNodeOfType(node.id, "Identifier")) return;
@@ -25663,7 +25694,7 @@ const reduxUseselectorInlineDerivation = defineRule({
 				if (!body) return;
 				const returnedExpressions = [];
 				if (isNodeOfType(body, "BlockStatement")) walkAst(body, (node) => {
-					if (node !== body && isFunctionLike$2(node)) return false;
+					if (node !== body && isFunctionLike$3(node)) return false;
 					if (isNodeOfType(node, "ReturnStatement")) {
 						if (node.argument) returnedExpressions.push(node.argument);
 						return false;
@@ -26006,7 +26037,7 @@ const hasOwnAwait = (functionBody) => {
 	let found = false;
 	walkAst(functionBody, (child) => {
 		if (found) return;
-		if (child !== functionBody && isFunctionLike$2(child)) return false;
+		if (child !== functionBody && isFunctionLike$3(child)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) found = true;
 	});
 	return found;
@@ -26025,7 +26056,7 @@ const setterIsCalledInAsyncContext = (componentBody, setterName) => {
 	let found = false;
 	walkAst(componentBody, (child) => {
 		if (found) return;
-		if (!isFunctionLike$2(child)) return;
+		if (!isFunctionLike$3(child)) return;
 		const functionBody = child.body;
 		if (!(Boolean(child.async) || hasOwnAwait(functionBody))) return;
 		if (callsIdentifier(functionBody, setterName)) found = true;
@@ -26808,7 +26839,8 @@ const rerenderTransitionsScroll = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-animate-layout-property.ts
-const REANIMATED_LAYOUT_KEYS = new Set([
+const REANIMATED_MODULE = "react-native-reanimated";
+const REANIMATED_LAYOUT_STYLE_PROPERTIES = new Set([
 	"width",
 	"height",
 	"top",
@@ -26846,12 +26878,91 @@ const REANIMATED_LAYOUT_KEYS = new Set([
 	"lineHeight",
 	"letterSpacing"
 ]);
+const REANIMATED_ANIMATION_HELPERS = new Set([
+	"withTiming",
+	"withSpring",
+	"withDecay",
+	"withDelay",
+	"withRepeat",
+	"withSequence",
+	"withClamp"
+]);
+const findImportDeclaration = (symbol) => {
+	let currentNode = symbol.declarationNode.parent;
+	while (currentNode && !isNodeOfType(currentNode, "ImportDeclaration")) currentNode = currentNode.parent ?? null;
+	return currentNode && isNodeOfType(currentNode, "ImportDeclaration") ? currentNode : null;
+};
+const isReanimatedImport = (symbol) => {
+	const importDeclaration = findImportDeclaration(symbol);
+	if (!importDeclaration) return false;
+	return importDeclaration.source.value === REANIMATED_MODULE;
+};
+const getReanimatedNamedImport = (node, context) => {
+	if (!isNodeOfType(node, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(node);
+	if (!symbol || symbol.kind !== "import") return null;
+	if (!isReanimatedImport(symbol)) return null;
+	const declarationNode = symbol.declarationNode;
+	if (!isNodeOfType(declarationNode, "ImportSpecifier")) return null;
+	const importedName = declarationNode.imported;
+	if (isNodeOfType(importedName, "Identifier")) return importedName.name;
+	if (isNodeOfType(importedName, "Literal") && typeof importedName.value === "string") return importedName.value;
+	return null;
+};
+const isReanimatedNamespace = (node, context) => {
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const symbol = context.scopes.symbolFor(node);
+	if (!symbol || symbol.kind !== "import") return false;
+	if (!isReanimatedImport(symbol)) return false;
+	return isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier");
+};
+const isUseAnimatedStyleCallee = (callee, context) => {
+	if (isNodeOfType(callee, "Identifier")) return getReanimatedNamedImport(callee, context) === "useAnimatedStyle";
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
+	if (!isNodeOfType(callee.property, "Identifier")) return false;
+	if (callee.property.name !== "useAnimatedStyle") return false;
+	return isReanimatedNamespace(callee.object, context);
+};
+const isReanimatedAnimationHelperCallee = (callee, context) => {
+	if (isNodeOfType(callee, "Identifier")) {
+		const importedName = getReanimatedNamedImport(callee, context);
+		return importedName !== null && REANIMATED_ANIMATION_HELPERS.has(importedName);
+	}
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
+	if (!isNodeOfType(callee.property, "Identifier")) return false;
+	if (!REANIMATED_ANIMATION_HELPERS.has(callee.property.name)) return false;
+	return isReanimatedNamespace(callee.object, context);
+};
+const isFunctionLike = (node) => isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration");
+const containsReanimatedAnimationHelperCall = (expression, context) => {
+	const rootExpression = stripParenExpression(expression);
+	let didFindAnimationHelper = false;
+	walkAst(rootExpression, (node) => {
+		if (didFindAnimationHelper) return false;
+		if (node !== rootExpression && isFunctionLike(node)) return false;
+		if (isNodeOfType(node, "CallExpression") && isReanimatedAnimationHelperCallee(node.callee, context)) {
+			didFindAnimationHelper = true;
+			return false;
+		}
+	});
+	return didFindAnimationHelper;
+};
 const findReturnedObject = (callback) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return null;
-	const body = callback.body;
+	const body = stripParenExpression(callback.body);
 	if (isNodeOfType(body, "ObjectExpression")) return body;
 	if (!isNodeOfType(body, "BlockStatement")) return null;
-	for (const stmt of body.body ?? []) if (isNodeOfType(stmt, "ReturnStatement") && isNodeOfType(stmt.argument, "ObjectExpression")) return stmt.argument;
+	for (const statement of body.body ?? []) {
+		if (!isNodeOfType(statement, "ReturnStatement")) continue;
+		if (!statement.argument) continue;
+		const returnArgument = stripParenExpression(statement.argument);
+		if (isNodeOfType(returnArgument, "ObjectExpression")) return returnArgument;
+	}
+	return null;
+};
+const getStaticPropertyName$1 = (property) => {
+	if (!property.computed && isNodeOfType(property.key, "Identifier")) return property.key.name;
+	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
 	return null;
 };
 const rnAnimateLayoutProperty = defineRule({
@@ -26859,21 +26970,25 @@ const rnAnimateLayoutProperty = defineRule({
 	title: "Animating a layout property",
 	tags: ["test-noise"],
 	requires: ["react-native"],
-	severity: "error",
-	recommendation: "Animating size or position props runs on the JS thread and can stutter. Animate `transform: [{ translateX/Y }, { scale }]` or `opacity` instead, which run on the GPU.",
+	severity: "warn",
+	category: "Performance",
+	recommendation: "Prefer transform or opacity when a Reanimated animation helper drives purely visual motion; use layout-affecting styles only when the layout itself must change.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isNodeOfType(node.callee, "Identifier") || node.callee.name !== "useAnimatedStyle") return;
+		if (!isUseAnimatedStyleCallee(node.callee, context)) return;
 		const callback = node.arguments?.[0];
 		if (!callback) return;
 		const returnedObject = findReturnedObject(callback);
 		if (!returnedObject) return;
 		for (const property of returnedObject.properties ?? []) {
 			if (!isNodeOfType(property, "Property")) continue;
-			if (!isNodeOfType(property.key, "Identifier")) continue;
-			if (!REANIMATED_LAYOUT_KEYS.has(property.key.name)) continue;
+			const propertyName = getStaticPropertyName$1(property);
+			if (propertyName === null) continue;
+			if (!REANIMATED_LAYOUT_STYLE_PROPERTIES.has(propertyName)) continue;
+			const propertyValue = property.value;
+			if (!containsReanimatedAnimationHelperCall(propertyValue, context)) continue;
 			context.report({
 				node: property,
-				message: `Your users see stutter when useAnimatedStyle animates "${property.key.name}" on the layout thread.`
+				message: `Reanimated can animate "${propertyName}", but this layout-affecting style recalculates layout while the animation runs; prefer transform or opacity when the motion is only visual.`
 			});
 		}
 	} })
@@ -32308,7 +32423,7 @@ const isUseEffectEventSymbol = (symbol) => {
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$2(current)) {
+		if (isFunctionLike$3(current)) {
 			const resolvedName = inferFunctionName(current);
 			if (resolvedName !== null && isReactComponentOrHookName(resolvedName)) return current;
 		}
@@ -32329,7 +32444,7 @@ const isCallbackArgumentForAllowedEffectEventHook = (functionNode, additionalEff
 const isInsideAllowedEffectEventCallback = (node, additionalEffectHooksRegex) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$2(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
+		if (isFunctionLike$3(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
 		current = current.parent ?? null;
 	}
 	return false;
@@ -32667,7 +32782,7 @@ const containsAuthCheck = (rootNodes, allowedFunctionNames, genericMethodNames)
 	let foundAuthCall = false;
 	for (const rootNode of rootNodes) walkAst(rootNode, (child) => {
 		if (foundAuthCall) return;
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$3(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (getAuthCallName(child, allowedFunctionNames, genericMethodNames)) foundAuthCall = true;
 	});
@@ -37281,7 +37396,7 @@ const reactDoctorRules = [
 		rule: {
 			...rnAnimateLayoutProperty,
 			framework: "react-native",
-			category: "Bugs",
+			category: "Performance",
 			tags: [...new Set(["react-native", ...rnAnimateLayoutProperty.tags ?? []])]
 		}
 	},
@@ -38146,7 +38261,7 @@ const appendNode = (builder, block, node) => {
 };
 const mapDescendantsToBlock = (builder, node, block) => {
 	builder.nodeBlock.set(node, block);
-	if (isFunctionLike$2(node)) return;
+	if (isFunctionLike$3(node)) return;
 	const record = node;
 	for (const key of Object.keys(record)) {
 		if (key === "parent") continue;
@@ -38484,7 +38599,7 @@ const analyzeControlFlow = (program) => {
 		body: program.body
 	});
 	const visit = (node) => {
-		if (isFunctionLike$2(node)) {
+		if (isFunctionLike$3(node)) {
 			const body = node.body;
 			if (body) buildFor(node, body);
 		}
@@ -38501,7 +38616,7 @@ const analyzeControlFlow = (program) => {
 	const enclosingFunction = (node) => {
 		let current = node;
 		while (current) {
-			if (isFunctionLike$2(current)) return current;
+			if (isFunctionLike$3(current)) return current;
 			if (isNodeOfType(current, "Program")) return current;
 			current = current.parent ?? null;
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.2.18-dev.4dc48d7",
+  "version": "0.2.18-dev.6851a78",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",