oxlint-plugin-react-doctor 0.2.17-dev.5614b32 → 0.2.18-dev.08e1d55

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,14 +4606,20 @@ 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) => {
+const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames, options = {}) => {
 	if (!returnedValue) return false;
 	const unwrappedValue = unwrapChainExpression$2(returnedValue);
-	if (isNodeOfType(unwrappedValue, "Identifier")) return knownCleanupFunctionNames.has(unwrappedValue.name);
+	if (isNodeOfType(unwrappedValue, "Literal") && unwrappedValue.value === null) return false;
+	if (isNodeOfType(unwrappedValue, "Identifier")) {
+		if (unwrappedValue.name === "undefined") return false;
+		if (knownCleanupFunctionNames.has(unwrappedValue.name)) return true;
+		return options.allowOpaqueReturn === true && !knownBoundSubscriptionNames.has(unwrappedValue.name);
+	}
 	if (isCleanupReturningSubscribeLikeCallExpression(unwrappedValue)) return true;
+	if (options.allowOpaqueReturn === true && !isSubscribeLikeCallExpression(unwrappedValue)) return true;
 	if (isCleanupFunctionLike(unwrappedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames)) return true;
 	return false;
 };
@@ -4634,12 +4640,14 @@ const findSubscribeLikeUsages = (callback) => {
 		if (isNodeOfType(child.callee, "Identifier") && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(child.callee.name)) {
 			usages.push({
 				kind: "timer",
+				node: child,
 				resourceName: child.callee.name
 			});
 			return;
 		}
 		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name)) usages.push({
 			kind: "subscribe",
+			node: child,
 			resourceName: child.callee.property.name
 		});
 	});
@@ -4686,7 +4694,20 @@ const collectCleanupBindings = (effectCallback) => {
 	});
 	return bindings;
 };
-const effectHasCleanupRelease = (callback) => {
+const getRangeStart = (node) => {
+	const rangeStart = node.range?.[0];
+	return typeof rangeStart === "number" ? rangeStart : null;
+};
+const cleanupReturnRunsAfterUsage = (returnStatement, usages) => {
+	if (returnStatement.argument && isCleanupReturningSubscribeLikeCallExpression(returnStatement.argument)) return true;
+	const returnStart = getRangeStart(returnStatement);
+	if (returnStart === null) return true;
+	return usages.some((usage) => {
+		const usageStart = getRangeStart(usage.node);
+		return usageStart === null || usageStart < returnStart;
+	});
+};
+const effectHasCleanupReturn = (callback, usages) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return isCleanupReturningSubscribeLikeCallExpression(callback.body);
 	const cleanupBindings = collectCleanupBindings(callback);
@@ -4694,7 +4715,8 @@ const effectHasCleanupRelease = (callback) => {
 	walkInsideStatementBlocks(callback.body, (child) => {
 		if (didFindCleanupReturn) return;
 		if (!isNodeOfType(child, "ReturnStatement")) return;
-		if (isCleanupReturn(child.argument, cleanupBindings.cleanupFunctionNames, cleanupBindings.subscriptionNames)) didFindCleanupReturn = true;
+		if (!cleanupReturnRunsAfterUsage(child, usages)) return;
+		if (isCleanupReturn(child.argument, cleanupBindings.cleanupFunctionNames, cleanupBindings.subscriptionNames, { allowOpaqueReturn: true })) didFindCleanupReturn = true;
 	});
 	return didFindCleanupReturn;
 };
@@ -4710,7 +4732,7 @@ const effectNeedsCleanup = defineRule({
 		if (!callback) return;
 		const usages = findSubscribeLikeUsages(callback);
 		if (usages.length === 0) return;
-		if (effectHasCleanupRelease(callback)) return;
+		if (effectHasCleanupReturn(callback, usages)) return;
 		const firstUsage = usages[0];
 		const verb = firstUsage.kind === "timer" ? "schedules" : "subscribes via";
 		context.report({
@@ -4848,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) => {
@@ -5003,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);
@@ -5249,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)) {
@@ -7346,6 +7368,13 @@ const isImportedFromModule = (contextNode, localIdentifierName, moduleSource) =>
 	if (!info) return false;
 	return info.source === moduleSource;
 };
+const isNamespaceImportFromModule = (contextNode, localIdentifierName, moduleSource) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return false;
+	const info = lookup.get(localIdentifierName);
+	if (!info) return false;
+	return info.isNamespace && info.source === moduleSource;
+};
 const getImportedNameFromModule = (contextNode, localIdentifierName, moduleSource) => {
 	const lookup = getImportLookup(contextNode);
 	if (!lookup) return null;
@@ -7362,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;
@@ -7481,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);
@@ -7737,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;
 		}
@@ -8098,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) {
@@ -9696,6 +9725,7 @@ const jsxNoConstructedContextValues = defineRule({
 	title: "Unstable context provider value",
 	tags: ["react-jsx-only"],
 	severity: "warn",
+	disabledBy: ["react-compiler"],
 	recommendation: "Wrap the context value in `useMemo`, or move it outside the component.",
 	category: "Performance",
 	create: (context) => {
@@ -13052,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")) {
@@ -13522,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;
@@ -13615,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);
@@ -13632,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;
@@ -13644,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);
 };
@@ -13994,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);
@@ -14013,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;
@@ -14958,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;
@@ -15641,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);
@@ -15652,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;
@@ -15982,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);
@@ -18239,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;
@@ -18943,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");
 };
@@ -18958,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 ?? []) {
@@ -19002,7 +19032,7 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 				defaultExport = declaration;
 				continue;
 			}
-			if (isFunctionLike(declaration)) {
+			if (isFunctionLike$1(declaration)) {
 				defaultExport = declaration;
 				continue;
 			}
@@ -19163,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
 	};
@@ -19171,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
 	};
@@ -19285,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;
@@ -19394,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;
@@ -20172,6 +20202,12 @@ const getReactDoctorStringSetting = (settings, settingName) => {
 	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 [];
@@ -21237,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;
@@ -23392,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,
@@ -23644,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",
@@ -23653,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;
@@ -24815,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;
@@ -25627,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;
@@ -25970,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;
@@ -25989,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;
@@ -26772,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",
@@ -26810,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({
@@ -26823,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.`
 			});
 		}
 	} })
@@ -27045,9 +27196,13 @@ const LEGACY_EXPO_PACKAGE_REPLACEMENTS = new Map([
 	["expo-av", "expo-audio for audio and expo-video for video"],
 	["expo-permissions", "the permissions API in each module (e.g. Camera.requestPermissionsAsync())"],
 	["expo-app-loading", "expo-splash-screen"],
-	["expo-linear-gradient", "the `backgroundImage` CSS gradient style prop (New Architecture) or expo-linear-gradient's successor"],
 	["react-native-fast-image", "expo-image (drop-in with caching, placeholders, and crossfades)"]
 ]);
+const EXPO_UI_MODULE_SOURCES = new Set([
+	"@expo/ui",
+	"@expo/ui/swift-ui",
+	"@expo/ui/jetpack-compose"
+]);
 const REACT_NATIVE_LIST_COMPONENTS = new Set([
 	"FlatList",
 	"SectionList",
@@ -27195,6 +27350,10 @@ const RECYCLABLE_LIST_PACKAGES = {
 	LegendList: ["@legendapp/list"]
 };
 const SIZING_HINT_ATTRIBUTE_NAMES = new Set(["estimatedItemSize", "estimatedListSize"]);
+const isFlashListV2OrNewer = (context) => {
+	const flashListMajorVersion = getReactDoctorNumberSetting(context.settings, "shopifyFlashListMajorVersion");
+	return flashListMajorVersion !== void 0 && flashListMajorVersion >= 2;
+};
 const isEmptyArrayLiteral = (node) => {
 	if (!isNodeOfType(node.value, "JSXExpressionContainer")) return false;
 	const expression = node.value.expression;
@@ -27216,6 +27375,7 @@ const rnListMissingEstimatedItemSize = defineRule({
 			break;
 		}
 		if (!canonicalRecyclerName) return;
+		if (canonicalRecyclerName === "FlashList" && isFlashListV2OrNewer(context)) return;
 		let hasSizingHint = false;
 		let dataIsEmptyLiteral = false;
 		let hasDataProp = false;
@@ -27859,6 +28019,24 @@ const collectTextWrapperComponents = (programNode, isTextHandlingRoot) => {
 	return wrappers;
 };
 //#endregion
+//#region src/plugin/rules/react-native/utils/is-expo-ui-component-element.ts
+const isNamedImportOf = (contextNode, localName, componentName) => {
+	for (const moduleSource of EXPO_UI_MODULE_SOURCES) if (getImportedNameFromModule(contextNode, localName, moduleSource) === componentName) return true;
+	return false;
+};
+const isExpoUiNamespaceImport = (contextNode, localName) => {
+	for (const moduleSource of EXPO_UI_MODULE_SOURCES) if (isNamespaceImportFromModule(contextNode, localName, moduleSource)) return true;
+	return false;
+};
+const isExpoUiComponentElement = (openingElement, contextNode, componentName) => {
+	if (!openingElement.name) return false;
+	const dottedName = flattenJsxName(openingElement.name);
+	if (!dottedName) return false;
+	const [rootLocalName, secondName] = dottedName.split(".");
+	if (isNamedImportOf(contextNode, rootLocalName, componentName)) return true;
+	return secondName === componentName && isExpoUiNamespaceImport(contextNode, rootLocalName);
+};
+//#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) => {
@@ -27918,6 +28096,7 @@ const rnNoRawText = defineRule({
 				if (isDomComponentFile) return;
 				const elementName = resolveTextBoundaryName(node.openingElement);
 				if (elementName && (isTextHandlingComponent(elementName) || autoDetectedWrappers.has(elementName))) return;
+				if (isExpoUiComponentElement(node.openingElement, node, "ListItem")) return;
 				if (isInsidePlatformOsWebBranch(node)) return;
 				if (isTransparentTextWrapper(elementName) && isInsideTextHandlingComponent(node)) return;
 				for (const child of node.children ?? []) {
@@ -28081,6 +28260,7 @@ const rnNoScrollviewMappedList = defineRule({
 	create: (context) => ({ JSXElement(node) {
 		const elementName = resolveJsxElementName(node.openingElement);
 		if (!elementName || !NON_VIRTUALIZED_SCROLL_CONTAINERS.has(elementName)) return;
+		if (isExpoUiComponentElement(node.openingElement, node, "ScrollView")) return;
 		for (const child of node.children ?? []) {
 			if (!isNodeOfType(child, "JSXExpressionContainer")) continue;
 			const expression = child.expression;
@@ -28138,37 +28318,22 @@ const rnNoSingleElementStyleArray = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/react-native/utils/scrollview_names.ts
-const SCROLLVIEW_NAMES = new Set([
-	"ScrollView",
-	"FlatList",
-	"SectionList",
-	"VirtualizedList",
-	"KeyboardAwareScrollView"
-]);
+//#region src/plugin/utils/define-retired-rule.ts
+const defineRetiredRule = (rule) => defineRule({
+	...rule,
+	defaultEnabled: false,
+	lifecycle: "retired",
+	create: () => ({})
+});
 //#endregion
 //#region src/plugin/rules/react-native/rn-prefer-content-inset-adjustment.ts
-const rnPreferContentInsetAdjustment = defineRule({
+const rnPreferContentInsetAdjustment = defineRetiredRule({
 	id: "rn-prefer-content-inset-adjustment",
-	title: "SafeAreaView instead of contentInsetAdjustment",
+	title: "Manual safe-area inset adjustment",
 	tags: ["test-noise"],
 	requires: ["react-native"],
 	severity: "warn",
-	recommendation: "Drop the SafeAreaView wrapper and set `contentInsetAdjustmentBehavior=\"automatic\"` on the ScrollView so the OS handles the safe area.",
-	create: (context) => ({ JSXElement(node) {
-		if (resolveJsxElementName(node.openingElement) !== "SafeAreaView") return;
-		for (const child of node.children ?? []) {
-			if (!isNodeOfType(child, "JSXElement")) continue;
-			const childName = resolveJsxElementName(child.openingElement);
-			if (!childName || !SCROLLVIEW_NAMES.has(childName)) continue;
-			if (childName === "KeyboardAwareScrollView") continue;
-			context.report({
-				node,
-				message: `Your users render an extra wrapper view from <SafeAreaView> around <${childName}>.`
-			});
-			return;
-		}
-	} })
+	recommendation: "Prefer native content inset adjustment only when it replaces manual inset plumbing; SafeAreaView wrappers are valid and intentionally ignored."
 });
 //#endregion
 //#region src/react-native-dependency-names.ts
@@ -28554,6 +28719,15 @@ const rnPressableSharedValueMutation = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/react-native/utils/scrollview_names.ts
+const SCROLLVIEW_NAMES = new Set([
+	"ScrollView",
+	"FlatList",
+	"SectionList",
+	"VirtualizedList",
+	"KeyboardAwareScrollView"
+]);
+//#endregion
 //#region src/plugin/rules/react-native/rn-scrollview-dynamic-padding.ts
 const rnScrollviewDynamicPadding = defineRule({
 	id: "rn-scrollview-dynamic-padding",
@@ -32249,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;
 		}
@@ -32270,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;
@@ -32608,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;
 	});
@@ -37222,7 +37396,7 @@ const reactDoctorRules = [
 		rule: {
 			...rnAnimateLayoutProperty,
 			framework: "react-native",
-			category: "Bugs",
+			category: "Performance",
 			tags: [...new Set(["react-native", ...rnAnimateLayoutProperty.tags ?? []])]
 		}
 	},
@@ -38087,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;
@@ -38425,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);
 		}
@@ -38442,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;
 		}