oxlint-plugin-react-doctor 0.2.18-dev.5d7b36b → 0.2.18-dev.68a0bef

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: "Performance";
+    readonly category: "Bugs";
     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: "Performance";
+    readonly category: "Bugs";
     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$3 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
+const isFunctionLike$2 = (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$3(child)) return false;
+		if (child !== block && isFunctionLike$2(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$3(descendant)) return false;
+				if (isFunctionLike$2(descendant)) return false;
 				if (isNodeOfType(descendant, "BlockStatement")) inspectStatements(descendant.body ?? []);
 				else if (isNodeOfType(descendant, "SwitchCase")) inspectStatements(descendant.consequent ?? []);
 			});
 		};
 		const enterFunction = (node) => {
-			if (!isFunctionLike$3(node)) return;
+			if (!isFunctionLike$2(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$3(node)) return;
+	if (isFunctionLike$2(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$3(child) && !isIteratorCallbackArgument(child)) return false;
+		if (child !== node && isFunctionLike$2(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$3(node)) return false;
+	if (!isFunctionLike$2(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$3(block.parent);
+	return isFunctionLike$2(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$3(node)) {
+	if (isFunctionLike$2(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$3(node)) {
+		if (node !== functionNode && isFunctionLike$2(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$2 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
+const isFunctionLike$1 = (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$2(reader)) return;
+		if (!isFunctionLike$1(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$3(current)) {
+		if (isFunctionLike$2(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$3(cursor)) {
+			if (isFunctionLike$2(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$3(expression)) return expression.body ? [expression.body] : [];
+	if (isFunctionLike$2(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$3(definitionNode)) return definitionNode;
+		if (definitionNode && isFunctionLike$2(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$3(node)) return true;
+	if (isFunctionLike$2(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$3(definitionNode)) return true;
+		if (definitionNode && isFunctionLike$2(definitionNode)) return true;
 		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
 			const initializer = definitionNode.init;
-			return isFunctionLike$3(initializer);
+			return isFunctionLike$2(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$3(node)) return false;
+	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$2(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$3(fn)) return false;
+	if (!isFunctionLike$2(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$3(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+		if (isFunctionLike$2(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$3(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+		if (isFunctionLike$2(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$3(cursor)) return cursor;
+		if (isFunctionLike$2(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$3(node)) return node;
+	if (isFunctionLike$2(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$3(cursor)) return cursor;
+		if (isFunctionLike$2(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$3(node)) {
+	if (isFunctionLike$2(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$3(current)) return false;
+		if (isFunctionLike$2(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$1 = (node) => {
+const isFunctionLike = (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$1(initializer)) localBindings.set(declarator.id.name, initializer);
+			if (initializer && isFunctionLike(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$1(declaration)) {
+			if (isFunctionLike(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$3(unwrappedNode)) return {
+	if (isFunctionLike$2(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$3(unwrappedInitializer)) return {
+	if (isFunctionLike$2(unwrappedInitializer)) return {
 		functionNode: unwrappedInitializer,
 		crossFileSourceDisplay: null
 	};
@@ -19315,11 +19315,11 @@ const canExpressionReturnOriginalReducerStateReference = (node, state) => {
 	return false;
 };
 const collectReducerStateMutationsInExpressionOrStatement = (node, state) => {
-	if (isFunctionLike$3(node)) return [];
+	if (isFunctionLike$2(node)) return [];
 	const mutations = [];
 	walkAst(node, (child) => {
 		const unwrappedChild = stripParenExpression(child);
-		if (child !== node && isFunctionLike$3(unwrappedChild)) return false;
+		if (child !== node && isFunctionLike$2(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$3(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return;
+	if (!isFunctionLike$2(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$3(currentNode)) {
+		if (isFunctionLike$2(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$3(walker)) {
+		if (isFunctionLike$2(walker)) {
 			const componentName = inferFunctionLikeName(walker);
 			if (componentName && isReactComponentName(componentName) && expressionContainsJsxOrCreateElement(walker)) return {
 				component: walker,
@@ -25694,7 +25694,7 @@ const reduxUseselectorInlineDerivation = defineRule({
 				if (!body) return;
 				const returnedExpressions = [];
 				if (isNodeOfType(body, "BlockStatement")) walkAst(body, (node) => {
-					if (node !== body && isFunctionLike$3(node)) return false;
+					if (node !== body && isFunctionLike$2(node)) return false;
 					if (isNodeOfType(node, "ReturnStatement")) {
 						if (node.argument) returnedExpressions.push(node.argument);
 						return false;
@@ -26037,7 +26037,7 @@ const hasOwnAwait = (functionBody) => {
 	let found = false;
 	walkAst(functionBody, (child) => {
 		if (found) return;
-		if (child !== functionBody && isFunctionLike$3(child)) return false;
+		if (child !== functionBody && isFunctionLike$2(child)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) found = true;
 	});
 	return found;
@@ -26056,7 +26056,7 @@ const setterIsCalledInAsyncContext = (componentBody, setterName) => {
 	let found = false;
 	walkAst(componentBody, (child) => {
 		if (found) return;
-		if (!isFunctionLike$3(child)) return;
+		if (!isFunctionLike$2(child)) return;
 		const functionBody = child.body;
 		if (!(Boolean(child.async) || hasOwnAwait(functionBody))) return;
 		if (callsIdentifier(functionBody, setterName)) found = true;
@@ -26839,8 +26839,7 @@ const rerenderTransitionsScroll = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-animate-layout-property.ts
-const REANIMATED_MODULE = "react-native-reanimated";
-const REANIMATED_LAYOUT_STYLE_PROPERTIES = new Set([
+const REANIMATED_LAYOUT_KEYS = new Set([
 	"width",
 	"height",
 	"top",
@@ -26878,91 +26877,12 @@ const REANIMATED_LAYOUT_STYLE_PROPERTIES = 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 = stripParenExpression(callback.body);
+	const body = callback.body;
 	if (isNodeOfType(body, "ObjectExpression")) return body;
 	if (!isNodeOfType(body, "BlockStatement")) return null;
-	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;
+	for (const stmt of body.body ?? []) if (isNodeOfType(stmt, "ReturnStatement") && isNodeOfType(stmt.argument, "ObjectExpression")) return stmt.argument;
 	return null;
 };
 const rnAnimateLayoutProperty = defineRule({
@@ -26970,25 +26890,21 @@ const rnAnimateLayoutProperty = defineRule({
 	title: "Animating a layout property",
 	tags: ["test-noise"],
 	requires: ["react-native"],
-	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.",
+	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.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isUseAnimatedStyleCallee(node.callee, context)) return;
+		if (!isNodeOfType(node.callee, "Identifier") || node.callee.name !== "useAnimatedStyle") 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;
-			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;
+			if (!isNodeOfType(property.key, "Identifier")) continue;
+			if (!REANIMATED_LAYOUT_KEYS.has(property.key.name)) continue;
 			context.report({
 				node: property,
-				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.`
+				message: `Your users see stutter when useAnimatedStyle animates "${property.key.name}" on the layout thread.`
 			});
 		}
 	} })
@@ -32423,7 +32339,7 @@ const isUseEffectEventSymbol = (symbol) => {
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$3(current)) {
+		if (isFunctionLike$2(current)) {
 			const resolvedName = inferFunctionName(current);
 			if (resolvedName !== null && isReactComponentOrHookName(resolvedName)) return current;
 		}
@@ -32444,7 +32360,7 @@ const isCallbackArgumentForAllowedEffectEventHook = (functionNode, additionalEff
 const isInsideAllowedEffectEventCallback = (node, additionalEffectHooksRegex) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$3(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
+		if (isFunctionLike$2(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
 		current = current.parent ?? null;
 	}
 	return false;
@@ -32782,7 +32698,7 @@ const containsAuthCheck = (rootNodes, allowedFunctionNames, genericMethodNames)
 	let foundAuthCall = false;
 	for (const rootNode of rootNodes) walkAst(rootNode, (child) => {
 		if (foundAuthCall) return;
-		if (isFunctionLike$3(child)) return false;
+		if (isFunctionLike$2(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (getAuthCallName(child, allowedFunctionNames, genericMethodNames)) foundAuthCall = true;
 	});
@@ -37396,7 +37312,7 @@ const reactDoctorRules = [
 		rule: {
 			...rnAnimateLayoutProperty,
 			framework: "react-native",
-			category: "Performance",
+			category: "Bugs",
 			tags: [...new Set(["react-native", ...rnAnimateLayoutProperty.tags ?? []])]
 		}
 	},
@@ -38261,7 +38177,7 @@ const appendNode = (builder, block, node) => {
 };
 const mapDescendantsToBlock = (builder, node, block) => {
 	builder.nodeBlock.set(node, block);
-	if (isFunctionLike$3(node)) return;
+	if (isFunctionLike$2(node)) return;
 	const record = node;
 	for (const key of Object.keys(record)) {
 		if (key === "parent") continue;
@@ -38599,7 +38515,7 @@ const analyzeControlFlow = (program) => {
 		body: program.body
 	});
 	const visit = (node) => {
-		if (isFunctionLike$3(node)) {
+		if (isFunctionLike$2(node)) {
 			const body = node.body;
 			if (body) buildFor(node, body);
 		}
@@ -38616,7 +38532,7 @@ const analyzeControlFlow = (program) => {
 	const enclosingFunction = (node) => {
 		let current = node;
 		while (current) {
-			if (isFunctionLike$3(current)) return current;
+			if (isFunctionLike$2(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.5d7b36b",
+  "version": "0.2.18-dev.68a0bef",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",