oxlint-plugin-react-doctor 0.9.2-dev.5dc936e → 0.9.2-dev.5f23826

package/dist/index.js

@@ -29461,11 +29461,6 @@ const jsCacheStorage = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-combine-iterations.ts
-const SMALL_ARRAY_NON_MUTATING_METHODS = new Set([
-	...CHAINABLE_ITERATION_METHODS,
-	"find",
-	"some"
-]);
 const isIteratorProducingCall = (callExpression, generatorNamesInFile) => {
 	const callee = callExpression.callee;
 	if (isNodeOfType(callee, "MemberExpression")) {
@@ -29577,34 +29572,21 @@ const isStringSplitRootedChain = (receiverNode) => {
 	return false;
 };
 const isSmallLiteralArray = (node) => {
-	const arrayNode = stripParenExpression(node);
-	if (!isNodeOfType(arrayNode, "ArrayExpression")) return false;
-	const elements = arrayNode.elements ?? [];
-	if (elements.length === 0 || elements.length > 9) return false;
+	if (!isNodeOfType(node, "ArrayExpression")) return false;
+	const elements = node.elements ?? [];
+	if (elements.length === 0 || elements.length > 8) return false;
 	for (const element of elements) {
 		if (!element) continue;
 		if (isNodeOfType(element, "SpreadElement")) return false;
 	}
 	return true;
 };
-const isNonMutatingSmallArrayMethodReference = (identifier) => {
-	const identifierRoot = findTransparentExpressionRoot(identifier);
-	const memberExpression = identifierRoot.parent;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.object !== identifierRoot || !isNodeOfType(memberExpression.property, "Identifier") || !SMALL_ARRAY_NON_MUTATING_METHODS.has(memberExpression.property.name)) return false;
-	const callExpression = memberExpression.parent;
-	return isNodeOfType(callExpression, "CallExpression") && callExpression.callee === memberExpression;
-};
-const isSmallLiteralArrayRootedChain = (receiverNode, scopes) => {
+const isSmallLiteralArrayRootedChain = (receiverNode, smallConstArrayNames) => {
 	let cursor = receiverNode;
 	while (cursor) {
 		cursor = stripParenExpression(cursor);
 		if (isNodeOfType(cursor, "ArrayExpression")) return isSmallLiteralArray(cursor);
-		if (isNodeOfType(cursor, "Identifier")) {
-			const symbol = scopes.symbolFor(cursor);
-			if (!symbol?.initializer || !isSmallLiteralArray(symbol.initializer)) return false;
-			if (!isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier")) return false;
-			return (symbol.kind === "const" || symbol.kind === "let" || symbol.kind === "var") && symbol.references.every((reference) => reference.flag === "read" && isNonMutatingSmallArrayMethodReference(reference.identifier));
-		}
+		if (isNodeOfType(cursor, "Identifier")) return smallConstArrayNames.has(cursor.name);
 		if (!isNodeOfType(cursor, "CallExpression")) return false;
 		if (!isChainPassThroughCall(cursor)) return false;
 		const nextCallee = cursor.callee;
@@ -29613,6 +29595,22 @@ const isSmallLiteralArrayRootedChain = (receiverNode, scopes) => {
 	}
 	return false;
 };
+const collectSmallConstArrayNames = (programNode) => {
+	const names = /* @__PURE__ */ new Set();
+	const statements = programNode.body ?? [];
+	for (const statement of statements) {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) continue;
+		if (declaration.kind !== "const") continue;
+		for (const declarator of declaration.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			if (!declarator.init || !isSmallLiteralArray(declarator.init)) continue;
+			names.add(declarator.id.name);
+		}
+	}
+	return names;
+};
 const collectGeneratorNames = (programNode) => {
 	const generatorNames = /* @__PURE__ */ new Set();
 	walkAst(programNode, (child) => {
@@ -29633,11 +29631,16 @@ const jsCombineIterations = defineRule({
 	create: (context) => {
 		let programNode = null;
 		let generatorNamesInFile = null;
+		let smallConstArrayNames = null;
 		const coveredChainCalls = /* @__PURE__ */ new WeakSet();
 		const getGeneratorNamesInFile = () => {
 			generatorNamesInFile ??= programNode ? collectGeneratorNames(programNode) : /* @__PURE__ */ new Set();
 			return generatorNamesInFile;
 		};
+		const getSmallConstArrayNames = () => {
+			smallConstArrayNames ??= programNode ? collectSmallConstArrayNames(programNode) : /* @__PURE__ */ new Set();
+			return smallConstArrayNames;
+		};
 		return {
 			Program(node) {
 				programNode = node;
@@ -29667,7 +29670,7 @@ const jsCombineIterations = defineRule({
 					if (isTypePredicateArrow(filterArgument)) return;
 				}
 				if (isReceiverChainIteratorRooted(innerCall.callee.object, getGeneratorNamesInFile())) return;
-				if (isSmallLiteralArrayRootedChain(innerCall.callee.object, context.scopes)) return;
+				if (isSmallLiteralArrayRootedChain(innerCall.callee.object, getSmallConstArrayNames())) return;
 				if (isStringSplitRootedChain(innerCall.callee.object)) return;
 				coveredChainCalls.add(innerCall);
 				context.report({
@@ -56087,13 +56090,9 @@ const isInitialOnlyPropName = (propName) => {
 	return /^initial[A-Z]/.test(propName) || /^default[A-Z]/.test(propName) || /^seed[A-Z]/.test(propName) || /^starting[A-Z]/.test(propName) || /^baseline[A-Z]/.test(propName) || /^preset[A-Z]/.test(propName);
 };
 //#endregion
-//#region src/plugin/utils/nextjs-page-data-export-names.ts
-const NEXTJS_PAGE_DATA_EXPORT_NAMES = new Set(["getServerSideProps", "getStaticProps"]);
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-derived-use-state.ts
 const isInitialOnlySeedName = (propName) => isInitialOnlyPropName(propName) || propName === "initial" || propName === "autoFocus" || propName === "autoPlay" || propName === "startOpen" || /^initially[A-Z]/.test(propName) || /Initial([A-Z]|$)/.test(propName);
 const SNAPSHOT_STATE_NAME_PATTERN = /^(initial|previous|prev|preserved|saved|original|cached|snapshot|prior|debounced|deferred)([A-Z_]|$)/;
-const INTERNAL_STATE_NAME_PATTERN = /^(internal|uncontrolled)([A-Z_]|$)/;
 const getStateSetterName = (useStateCall) => {
 	const declarator = useStateCall.parent;
 	if (!isNodeOfType(declarator, "VariableDeclarator")) return null;
@@ -56247,6 +56246,7 @@ const isDraftCommittedToParent = (componentFunction, stateValueName, isPropName)
 	});
 	return isCommitted;
 };
+const NEXTJS_PAGE_DATA_EXPORT_NAMES = new Set(["getServerSideProps", "getStaticProps"]);
 const isNextjsDataFetchingPage = (node) => {
 	const program = findProgramRoot(node);
 	if (!program) return false;
@@ -56290,48 +56290,6 @@ const isInRenderScope = (node, componentFunction) => {
 	}
 	return true;
 };
-const isReferenceToBinding = (reference, bindingIdentifier, context) => {
-	if (!isNodeOfType(reference, "Identifier")) return false;
-	const bindingSymbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!bindingSymbol) return false;
-	return (context.scopes.referenceFor(reference)?.resolvedSymbol)?.id === bindingSymbol.id;
-};
-const isControlledPropFallbackExpression = (expression, stateBinding, isPropName, context) => {
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		const consequent = unwrapInitializerSeed(expression.consequent);
-		const alternate = unwrapInitializerSeed(expression.alternate);
-		return isReferenceToBinding(consequent, stateBinding, context) && isPropDerivedArgument(alternate, isPropName) || isPropDerivedArgument(consequent, isPropName) && isReferenceToBinding(alternate, stateBinding, context);
-	}
-	return isNodeOfType(expression, "LogicalExpression") && expression.operator === "??" && isPropDerivedArgument(unwrapInitializerSeed(expression.left), isPropName) && isReferenceToBinding(unwrapInitializerSeed(expression.right), stateBinding, context);
-};
-const isUserEditableControlledFallback = (useStateCall, isPropName, context) => {
-	const declarator = useStateCall.parent;
-	if (!isNodeOfType(declarator, "VariableDeclarator")) return false;
-	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
-	const stateBinding = declarator.id.elements?.[0];
-	const setterBinding = declarator.id.elements?.[1];
-	if (!isNodeOfType(stateBinding, "Identifier") || !isNodeOfType(setterBinding, "Identifier")) return false;
-	if (!INTERNAL_STATE_NAME_PATTERN.test(stateBinding.name)) return false;
-	const componentFunction = findEnclosingFunction$1(useStateCall);
-	if (!componentFunction) return false;
-	let hasControlledFallback = false;
-	let hasUserEdit = false;
-	walkAst(componentFunction, (child) => {
-		if (child !== componentFunction && isFunctionLike$1(child)) return false;
-		if (!hasControlledFallback && (isNodeOfType(child, "ConditionalExpression") || isNodeOfType(child, "LogicalExpression")) && isControlledPropFallbackExpression(child, stateBinding, isPropName, context)) hasControlledFallback = true;
-	});
-	walkAst(componentFunction, (child) => {
-		if (hasUserEdit) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (!isReferenceToBinding(child.callee, setterBinding, context)) return;
-		if (!isHandlerShapedReseed(child, componentFunction)) return;
-		const setterArgument = child.arguments?.[0];
-		if (!setterArgument || isPropDerivedArgument(unwrapInitializerSeed(setterArgument), isPropName)) return;
-		hasUserEdit = true;
-		return false;
-	});
-	return hasControlledFallback && hasUserEdit;
-};
 const getStateValueName = (useStateCall) => {
 	const declarator = useStateCall.parent;
 	if (!isNodeOfType(declarator, "VariableDeclarator")) return null;
@@ -56396,7 +56354,6 @@ const noDerivedUseState = defineRule({
 				const reportStalePropCopy = (propName) => {
 					if (isIntentionalSnapshotState(node)) return;
 					if (hasSessionDismissProp(propStackTracker.getCurrentPropNames())) return;
-					if (isUserEditableControlledFallback(node, propStackTracker.isPropName, context)) return;
 					if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
 					if (isEffectDrivenResync(node)) return;
 					if (isNextjsDataFetchingPage(node)) return;
@@ -67234,124 +67191,6 @@ const isInsideSnapshotHelper = (node) => {
 	}
 	return false;
 };
-const findEnclosingNextjsPageDataFunction = (node) => {
-	let outermostFunction = null;
-	let cursor = node.parent;
-	while (cursor) {
-		if (isFunctionLike$1(cursor)) outermostFunction = cursor;
-		if (isNodeOfType(cursor, "Program")) {
-			if (!outermostFunction) return null;
-			for (const exportName of NEXTJS_PAGE_DATA_EXPORT_NAMES) {
-				const exportedValue = findExportedValue(cursor, exportName);
-				if (exportedValue && isAstDescendant(outermostFunction, exportedValue)) return outermostFunction;
-			}
-			return null;
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-const findConditionalReturnExpressionRoot = (node) => {
-	let expressionRoot = findTransparentExpressionRoot(node);
-	while (expressionRoot.parent && isNodeOfType(expressionRoot.parent, "ConditionalExpression") && (expressionRoot.parent.consequent === expressionRoot || expressionRoot.parent.alternate === expressionRoot)) expressionRoot = findTransparentExpressionRoot(expressionRoot.parent);
-	return expressionRoot;
-};
-const isReturnedPageDataResultBinding = (returnExpression, pageDataFunction, context) => {
-	const declarator = returnExpression.parent;
-	if (!isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== returnExpression || !isNodeOfType(declarator.id, "Identifier") || findEnclosingFunction$1(declarator) !== pageDataFunction) return false;
-	const bindingSymbol = context.scopes.symbolFor(declarator.id);
-	if (!bindingSymbol || bindingSymbol.references.length !== 1) return false;
-	const referenceRoot = findTransparentExpressionRoot(bindingSymbol.references[0].identifier);
-	const returnStatement = referenceRoot.parent;
-	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument === referenceRoot && findEnclosingFunction$1(returnStatement) === pageDataFunction;
-};
-const isSameShorthandPropertyValue = (node, property) => property.shorthand && (node === property.key || node === property.value);
-const isValueForwardedThroughLiteralStructure = (node, structure) => {
-	const strippedNode = stripParenExpression(node);
-	const strippedStructure = stripParenExpression(structure);
-	if (strippedNode === strippedStructure) return true;
-	if (isNodeOfType(strippedStructure, "ConditionalExpression")) return isValueForwardedThroughLiteralStructure(strippedNode, strippedStructure.consequent) || isValueForwardedThroughLiteralStructure(strippedNode, strippedStructure.alternate);
-	if (isNodeOfType(strippedStructure, "ArrayExpression")) return strippedStructure.elements.some((element) => element && !isNodeOfType(element, "SpreadElement") && isValueForwardedThroughLiteralStructure(strippedNode, element));
-	if (!isNodeOfType(strippedStructure, "ObjectExpression")) return false;
-	return strippedStructure.properties.some((property) => {
-		if (isNodeOfType(property, "SpreadElement")) return isValueForwardedThroughLiteralStructure(strippedNode, property.argument);
-		if (!isNodeOfType(property, "Property")) return false;
-		if (isValueForwardedThroughLiteralStructure(strippedNode, property.value)) return true;
-		return isSameShorthandPropertyValue(strippedNode, property);
-	});
-};
-const isValueForwardedToPropertyValue = (node, property) => {
-	const directValue = findConditionalReturnExpressionRoot(node);
-	if (isValueForwardedThroughLiteralStructure(directValue, property.value)) return true;
-	return isSameShorthandPropertyValue(directValue, property);
-};
-const isInsideReturnedNextjsProps = (node, pageDataFunction, context) => {
-	let cursor = node.parent;
-	while (cursor && cursor !== pageDataFunction) {
-		if (isNodeOfType(cursor, "Property") && getStaticPropertyKeyName(cursor, { allowComputedString: true }) === "props" && isValueForwardedToPropertyValue(node, cursor)) {
-			const propertyContainer = cursor.parent;
-			if (!propertyContainer) return false;
-			const returnExpression = findConditionalReturnExpressionRoot(propertyContainer);
-			const returnStatement = returnExpression.parent;
-			if (isNodeOfType(returnStatement, "ReturnStatement") && findEnclosingFunction$1(returnStatement) === pageDataFunction) return true;
-			if (isNodeOfType(pageDataFunction, "ArrowFunctionExpression") && !isNodeOfType(pageDataFunction.body, "BlockStatement") && stripParenExpression(pageDataFunction.body) === stripParenExpression(returnExpression)) return true;
-			if (isReturnedPageDataResultBinding(returnExpression, pageDataFunction, context)) return true;
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return false;
-};
-const isExpressionReturnedByFunction = (node, functionNode) => {
-	const returnExpression = findConditionalReturnExpressionRoot(node);
-	if (isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode.body, "BlockStatement")) return stripParenExpression(functionNode.body) === stripParenExpression(returnExpression);
-	const returnStatement = returnExpression.parent;
-	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument === returnExpression && findEnclosingFunction$1(returnStatement) === functionNode;
-};
-const isValueForwardedToBindingInitializer = (node, bindingInitializer) => {
-	if (isValueForwardedThroughLiteralStructure(findConditionalReturnExpressionRoot(node), bindingInitializer)) return true;
-	const initializer = stripParenExpression(bindingInitializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const callee = stripParenExpression(initializer.callee);
-	return isFunctionLike$1(callee) && isExpressionReturnedByFunction(node, callee);
-};
-const findPageDataResultBinding = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isNodeOfType(cursor, "VariableDeclarator")) {
-			if (cursor.init && isNodeOfType(cursor.id, "Identifier") && isValueForwardedToBindingInitializer(node, cursor.init)) return cursor.id;
-			return null;
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-const isUsedToSerializeNextjsPageProps = (node, context) => {
-	if (!isInProjectDirectory(context, "pages") || isInProjectDirectory(context, "pages/api")) return false;
-	const pageDataFunction = findEnclosingNextjsPageDataFunction(node);
-	if (!pageDataFunction) return false;
-	if (isInsideReturnedNextjsProps(node, pageDataFunction, context)) return true;
-	const bindingIdentifier = findPageDataResultBinding(node);
-	const bindingSymbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
-	if (!bindingSymbol) return false;
-	const aliasSymbols = collectConstAliasSymbols(bindingSymbol, context.scopes);
-	const aliasSymbolIds = new Set(aliasSymbols.map((aliasSymbol) => aliasSymbol.id));
-	let hasPagePropsReference = false;
-	for (const aliasSymbol of aliasSymbols) for (const reference of aliasSymbol.references) {
-		if (findEnclosingFunction$1(reference.identifier) !== pageDataFunction) return false;
-		if (isInsideReturnedNextjsProps(reference.identifier, pageDataFunction, context)) {
-			hasPagePropsReference = true;
-			continue;
-		}
-		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-		const declarator = referenceRoot.parent;
-		if (isNodeOfType(declarator, "VariableDeclarator") && declarator.init === referenceRoot && isNodeOfType(declarator.id, "Identifier")) {
-			const aliasSymbolForReference = context.scopes.symbolFor(declarator.id);
-			if (aliasSymbolForReference && aliasSymbolIds.has(aliasSymbolForReference.id)) continue;
-		}
-		return false;
-	}
-	return hasPagePropsReference;
-};
 const noJsonParseStringifyClone = defineRule({
 	id: "no-json-parse-stringify-clone",
 	title: "JSON parse/stringify deep clone",
@@ -67369,7 +67208,6 @@ const noJsonParseStringifyClone = defineRule({
 		if (isInsideSnapshotHelper(node)) return;
 		if (isAssignedToNormalizationBinding(node)) return;
 		if (isCatchParameterRoundTrip(firstArgument)) return;
-		if (isUsedToSerializeNextjsPageProps(node, context)) return;
 		context.report({
 			node,
 			message: MESSAGE$35
@@ -79995,23 +79833,16 @@ const MAX_INITIATOR_RESOLUTION_DEPTH = 3;
 const STATE_DISPATCHER_HOOK_NAMES = new Set(["useState", "useReducer"]);
 const REF_HOOK_NAMES = new Set(["useRef"]);
 const MESSAGE$26 = "This promise chain runs in an effect, ends in a `.then` that sets state or mutates a ref, and has no `.catch` or enclosing try/catch, so a rejection leaves the state unset and surfaces as an unhandled rejection. Add a `.catch` handler on the chain (`.finally` does not count).";
-const isKnownNonRejectingHandlerReturn = (expression, context, visitedBindingIdentifiers = /* @__PURE__ */ new Set()) => {
+const isKnownNonThenableHandlerReturn = (expression, context, visitedBindingIdentifiers = /* @__PURE__ */ new Set()) => {
 	const strippedExpression = stripParenExpression(expression);
 	if (isDefinitelyNonThenableValue(strippedExpression)) return true;
-	if (isNodeOfType(strippedExpression, "CallExpression") && isNodeOfType(strippedExpression.callee, "MemberExpression")) {
-		const receiver = stripParenExpression(strippedExpression.callee.object);
-		if (isNodeOfType(receiver, "Identifier") && receiver.name === "Promise" && context.scopes.isGlobalReference(receiver) && getStaticPropertyName(strippedExpression.callee) === "resolve") {
-			const resolvedValue = strippedExpression.arguments[0];
-			return !resolvedValue || !isNodeOfType(resolvedValue, "SpreadElement") && isKnownNonRejectingHandlerReturn(resolvedValue, context, visitedBindingIdentifiers);
-		}
-	}
 	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
 	if (strippedExpression.name === "undefined" && context.scopes.isGlobalReference(strippedExpression)) return true;
 	const symbol = context.scopes.symbolFor(strippedExpression);
 	if (!symbol || visitedBindingIdentifiers.has(symbol.bindingIdentifier)) return false;
 	visitedBindingIdentifiers.add(symbol.bindingIdentifier);
 	const initializer = getDirectUnreassignedInitializer(symbol);
-	return Boolean(initializer && isKnownNonRejectingHandlerReturn(initializer, context, visitedBindingIdentifiers));
+	return Boolean(initializer && isKnownNonThenableHandlerReturn(initializer, context, visitedBindingIdentifiers));
 };
 const isKnownNonRejectingHandler = (argument, context) => {
 	if (!argument) return false;
@@ -80026,7 +79857,7 @@ const isKnownNonRejectingHandler = (argument, context) => {
 			canReject = true;
 			return false;
 		}
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && !isKnownNonRejectingHandlerReturn(child.argument, context)) {
+		if (isNodeOfType(child, "ReturnStatement") && child.argument && !isKnownNonThenableHandlerReturn(child.argument, context)) {
 			if (!isNodeOfType(stripParenExpression(child.argument), "CallExpression")) {
 				canReject = true;
 				return false;
@@ -80075,28 +79906,6 @@ const handlerHasPotentiallyThrowingMemberRead = (argument, context) => {
 	});
 	return hasPotentiallyThrowingMemberRead;
 };
-const hasRejectionHandler = (chain, argument, context, allowTerminalCatchBlock) => {
-	if (!argument) return false;
-	if (!handlerHasPotentiallyThrowingMemberRead(argument, context) && (chainCarriesRejectionHandler(chain, context.scopes) || isKnownNonRejectingHandler(argument, context))) return true;
-	if (!allowTerminalCatchBlock) return false;
-	const candidate = stripParenExpression(argument);
-	const handler = isNodeOfType(candidate, "Identifier") ? resolveExactLocalFunction(candidate, context.scopes) : candidate;
-	if (!handler || !isFunctionLike$1(handler)) return isNodeOfType(candidate, "MemberExpression") || isNodeOfType(candidate, "Identifier") && candidate.name !== "undefined";
-	if (!isNodeOfType(handler.body, "BlockStatement")) return false;
-	let doesExplicitlyReject = false;
-	walkOwnFunctionScope(handler, (child) => {
-		if (doesExplicitlyReject) return false;
-		if (isNodeOfType(child, "ThrowStatement") || isNodeOfType(child, "AwaitExpression")) {
-			doesExplicitlyReject = true;
-			return false;
-		}
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && !isKnownNonRejectingHandlerReturn(child.argument, context)) {
-			doesExplicitlyReject = true;
-			return false;
-		}
-	});
-	return !doesExplicitlyReject;
-};
 const walkPromiseChain = (chainExpression, context) => {
 	let cursor = stripParenExpression(chainExpression);
 	let hasCatch = false;
@@ -80108,9 +79917,10 @@ const walkPromiseChain = (chainExpression, context) => {
 	while (isNodeOfType(cursor, "CallExpression") && isNodeOfType(cursor.callee, "MemberExpression") && PROMISE_METHOD_NAMES.has(getStaticPropertyName(cursor.callee) ?? "")) {
 		const methodName = getStaticPropertyName(cursor.callee);
 		const rejectionHandlerArgument = methodName === "catch" ? cursor.arguments[0] : cursor.arguments[1];
-		if (!didReachTerminalThen && methodName === "catch" && hasRejectionHandler(cursor, rejectionHandlerArgument, context, true)) hasCatch = true;
+		const hasAbsorbingRejectionHandler = !handlerHasPotentiallyThrowingMemberRead(rejectionHandlerArgument, context) && (chainCarriesRejectionHandler(cursor, context.scopes) || isKnownNonRejectingHandler(rejectionHandlerArgument, context));
+		if (!didReachTerminalThen && methodName === "catch" && hasAbsorbingRejectionHandler) hasCatch = true;
 		if (methodName === "then") {
-			if (!didReachTerminalThen && hasRejectionHandler(cursor, rejectionHandlerArgument, context, false)) hasRejectionHandlerArgument = true;
+			if (!didReachTerminalThen && hasAbsorbingRejectionHandler) hasRejectionHandlerArgument = true;
 			didReachTerminalThen = true;
 			sawThen = true;
 			const callbackArgument = cursor.arguments[0];
@@ -82437,45 +82247,6 @@ const noRefCallbackCleanupBeforeReact19 = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/contains-non-deterministic-source.ts
-const NON_DETERMINISTIC_MEMBER_CALLS = new Set([
-	"Math.random",
-	"Date.now",
-	"performance.now",
-	"crypto.randomUUID",
-	"crypto.getRandomValues"
-]);
-const NON_DETERMINISTIC_ID_GENERATOR_NAMES = new Set([
-	"nanoid",
-	"uuid",
-	"cuid",
-	"ulid",
-	"createId"
-]);
-const isZeroArgDateConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Date" && (node.arguments?.length ?? 0) === 0;
-const containsNonDeterministicSource = (root) => {
-	let found = false;
-	walkAst(root, (child) => {
-		if (found) return false;
-		if (isFunctionLike$1(child)) return false;
-		if (isZeroArgDateConstruction(child)) {
-			found = true;
-			return false;
-		}
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = child.callee;
-		if (isNodeOfType(callee, "Identifier") && NON_DETERMINISTIC_ID_GENERATOR_NAMES.has(callee.name)) {
-			found = true;
-			return false;
-		}
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && NON_DETERMINISTIC_MEMBER_CALLS.has(`${callee.object.name}.${callee.property.name}`)) {
-			found = true;
-			return false;
-		}
-	});
-	return found;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
 const REPEATED_ANCESTOR_TYPES = new Set([
 	"DoWhileStatement",
@@ -82506,75 +82277,45 @@ const resolveImmutableInitializationValue = (node, scopes, visitedSymbolIds = /*
 };
 const isProvablyTruthyInitializationValue = (node, scopes) => {
 	const expression = resolveImmutableInitializationValue(node, scopes);
-	if (!expression) return false;
-	if (isNodeOfType(expression, "CallExpression")) {
-		const callee = stripParenExpression(expression.callee);
-		return isNodeOfType(callee, "Identifier") && callee.name.startsWith("create");
-	}
-	return isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression");
+	return Boolean(expression && (isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression")));
 };
-const getInitializationValueName = (node, scopes) => {
+const getInitializationConstructorName = (node, scopes) => {
 	const expression = resolveImmutableInitializationValue(node, scopes);
 	if (!expression) return null;
-	if (isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "CallExpression")) {
+	if (isNodeOfType(expression, "NewExpression")) {
 		const callee = stripParenExpression(expression.callee);
-		if (!isNodeOfType(callee, "Identifier")) return null;
-		return callee.name.startsWith("create") && callee.name.length > 6 ? callee.name.slice(6) : callee.name;
+		return isNodeOfType(callee, "Identifier") ? callee.name : null;
 	}
 	return null;
 };
-const isMatchingReturnType = (typeNode, initializationValue, scopes) => {
-	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
-	const typeName = typeNode.typeName;
-	if (!isNodeOfType(typeName, "Identifier") || typeName.name !== "ReturnType") return false;
-	const [returnTypeArgument] = typeNode.typeArguments?.params ?? [];
-	if (!returnTypeArgument || !isNodeOfType(returnTypeArgument, "TSTypeQuery")) return false;
-	const queriedName = returnTypeArgument.exprName;
-	const expression = stripParenExpression(initializationValue);
-	if (!isNodeOfType(queriedName, "Identifier") || !isNodeOfType(expression, "CallExpression")) return false;
-	const callee = stripParenExpression(expression.callee);
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	const queriedSymbol = scopes.symbolFor(queriedName);
-	const calleeSymbol = scopes.symbolFor(callee);
-	return queriedSymbol && calleeSymbol ? queriedSymbol.id === calleeSymbol.id : queriedName.name === callee.name;
-};
 const isClosedTruthyTypeDomain = (typeNode, initializationValue, scopes) => {
 	const initializationExpression = stripParenExpression(initializationValue);
 	if (isNodeOfType(typeNode, "TSTypeLiteral")) return isNodeOfType(initializationExpression, "ObjectExpression");
 	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return isNodeOfType(initializationExpression, "ArrayExpression");
 	if (isNodeOfType(typeNode, "TSFunctionType") || isNodeOfType(typeNode, "TSConstructorType")) return isNodeOfType(initializationExpression, "ArrowFunctionExpression") || isNodeOfType(initializationExpression, "FunctionExpression") || isNodeOfType(initializationExpression, "ClassExpression");
 	if (isNodeOfType(typeNode, "TSObjectKeyword")) return true;
-	if (isNodeOfType(typeNode, "TSIndexedAccessType")) return isNodeOfType(initializationExpression, "ObjectExpression");
 	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
 	const typeName = typeNode.typeName;
-	if (isNodeOfType(initializationExpression, "ObjectExpression") || isMatchingReturnType(typeNode, initializationExpression, scopes)) return true;
-	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationValueName(initializationExpression, scopes);
+	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationConstructorName(initializationExpression, scopes);
 };
 const refHasClosedFalsySentinelDomain = (refSymbol, initializationValue, scopes) => {
 	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
 	const [initialValue] = initializer.arguments ?? [];
-	if (initialValue && isNodeOfType(initialValue, "SpreadElement") || initialValue && !isEmptySentinel(initialValue, scopes)) return false;
+	if (!initialValue || isNodeOfType(initialValue, "SpreadElement") || !isEmptySentinel(initialValue, scopes)) return false;
 	const [declaredType] = initializer.typeArguments?.params ?? [];
-	if (!declaredType) return false;
-	const domainTypes = isNodeOfType(declaredType, "TSUnionType") ? declaredType.types : [declaredType];
+	if (!declaredType || !isNodeOfType(declaredType, "TSUnionType")) return false;
+	let hasEmptySentinel = false;
 	let hasTruthyDomain = false;
-	for (const memberType of domainTypes) {
-		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) continue;
+	for (const memberType of declaredType.types ?? []) {
+		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) {
+			hasEmptySentinel = true;
+			continue;
+		}
 		if (!isClosedTruthyTypeDomain(memberType, initializationValue, scopes)) return false;
 		hasTruthyDomain = true;
 	}
-	return hasTruthyDomain;
-};
-const refHasEmptySentinelInitializer = (refSymbol, scopes) => {
-	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	const [initialValue] = initializer.arguments ?? [];
-	return Boolean(!initialValue || !isNodeOfType(initialValue, "SpreadElement") && isEmptySentinel(initialValue, scopes));
-};
-const refHasDeclaredType = (refSymbol) => {
-	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
-	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && (initializer.typeArguments?.params.length ?? 0) > 0);
+	return hasEmptySentinel && hasTruthyDomain;
 };
 const isSafeRefIdentifierUse = (identifier) => {
 	const expressionRoot = findTransparentExpressionRoot(identifier);
@@ -82606,40 +82347,25 @@ const expressionContainsRefCurrent = (expression, refSymbol, scopes) => {
 	});
 	return didFindRefCurrent;
 };
-const isEmptySentinel = (node, scopes) => {
-	const expression = stripParenExpression(node);
-	return isNodeOfType(expression, "Literal") && expression.value === null || isNodeOfType(expression, "Identifier") && expression.name === "undefined" && scopes.isGlobalReference(expression);
-};
-const isInitializationInputIndependent = (node, renderOwner, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	let isInputIndependent = true;
-	walkAst(node, (child) => {
-		if (!isInputIndependent) return false;
-		if (resolveReactRefSymbol(child, scopes)) return false;
-		if (!isNodeOfType(child, "Identifier")) return;
-		const symbol = scopes.symbolFor(child);
-		if (!symbol) return;
-		if (symbol.kind === "import") return false;
-		if (symbol.kind === "let" || symbol.kind === "var" || symbol.kind === "using") {
-			isInputIndependent = false;
-			return false;
+const hasNoCompetingRefCurrentWrite = (branchRoot, assignmentExpression, refSymbol, scopes) => {
+	let writeCount = 0;
+	walkAst(branchRoot, (child) => {
+		if (writeCount > 1) return false;
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
+			return;
 		}
-		if (isOutsideAllFunctions(symbol)) return false;
-		if (symbol.kind === "parameter") {
-			if (symbol.scope.node === renderOwner) isInputIndependent = false;
-			return false;
+		if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
+			if (expressionContainsRefCurrent(child.argument, refSymbol, scopes)) writeCount++;
+			return;
 		}
-		if (!symbol.initializer || symbol.references.some((reference) => reference.flag !== "read")) {
-			isInputIndependent = false;
-			return false;
+		if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) {
+			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
 		}
-		if (visitedSymbolIds.has(symbol.id)) return false;
-		visitedSymbolIds.add(symbol.id);
-		if (!isInitializationInputIndependent(symbol.initializer, renderOwner, scopes, visitedSymbolIds)) isInputIndependent = false;
-		return false;
 	});
-	return isInputIndependent;
+	return writeCount === 1 && expressionContainsRefCurrent(assignmentExpression.left, refSymbol, scopes);
 };
-const isPredictableInitializationValue = (node, refSymbol, renderOwner, scopes, requiresClosedTruthyDomain) => isInitializationInputIndependent(node, renderOwner, scopes) && !containsNonDeterministicSource(node) && (isProvablyTruthyInitializationValue(node, scopes) && (!requiresClosedTruthyDomain || !refHasDeclaredType(refSymbol)) || refHasClosedFalsySentinelDomain(refSymbol, node, scopes));
+const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
 const hasRepeatedExecutionAncestor = (node, stop) => {
 	let ancestor = node.parent;
 	while (ancestor && ancestor !== stop) {
@@ -82669,27 +82395,6 @@ const canExecuteTogether = (firstConstraints, secondConstraints) => {
 	}
 	return true;
 };
-const hasNoCoExecutableCompetingWrite = (assignmentExpression, renderOwner, refSymbol, scopes) => {
-	const assignmentConstraints = getBranchConstraints(assignmentExpression, renderOwner);
-	const synchronouslyInvokedFunctions = collectSynchronouslyEffectInvokedFunctions(renderOwner, scopes);
-	let hasCompetingWrite = false;
-	walkAst(renderOwner, (child) => {
-		if (hasCompetingWrite) return false;
-		let writtenExpression = null;
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			if (child === assignmentExpression) return;
-			writtenExpression = child.left;
-		} else if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") writtenExpression = child.argument;
-		else if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) writtenExpression = child.left;
-		const deferredExecutionBoundary = findDeferredExecutionBoundary(child);
-		const deferredWriteValue = isNodeOfType(child, "AssignmentExpression") && child.operator === "=" ? resolveImmutableInitializationValue(child.right, scopes) : null;
-		const isDeferredTruthyWrite = deferredExecutionBoundary !== null && deferredExecutionBoundary !== renderOwner && !synchronouslyInvokedFunctions.has(deferredExecutionBoundary) && !executesDuringRender(deferredExecutionBoundary, scopes) && deferredWriteValue !== null && !isNodeOfType(deferredWriteValue, "CallExpression") && isProvablyTruthyInitializationValue(deferredWriteValue, scopes);
-		if (!writtenExpression || isDeferredTruthyWrite || !expressionContainsRefCurrent(writtenExpression, refSymbol, scopes) || !canExecuteTogether(assignmentConstraints, getBranchConstraints(child, renderOwner))) return;
-		hasCompetingWrite = true;
-		return false;
-	});
-	return !hasCompetingWrite;
-};
 const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol, scopes) => {
 	const assignmentConstraints = getBranchConstraints(assignmentExpression, branchRoot);
 	const assignmentStart = getRangeStart(assignmentExpression);
@@ -82705,17 +82410,16 @@ const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol
 	});
 	return !hasCoExecutableWrite;
 };
-const isPredictableGuardedInitialization = (assignmentExpression, guardedBranch, renderOwner, refSymbol, scopes, requiresClosedTruthyDomain) => refHasEmptySentinelInitializer(refSymbol, scopes) && isPredictableInitializationValue(assignmentExpression.right, refSymbol, renderOwner, scopes, requiresClosedTruthyDomain) && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && (guardedBranch === renderOwner || !hasRepeatedExecutionAncestor(guardedBranch, renderOwner)) && hasNoPriorCoExecutableWrite(assignmentExpression, renderOwner, refSymbol, scopes) && hasNoCoExecutableCompetingWrite(assignmentExpression, renderOwner, refSymbol, scopes) && refDoesNotEscape(renderOwner, refSymbol, scopes);
 const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
+	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
+	if (assignmentExpression.operator !== "=") return false;
 	const renderOwner = findRenderPhaseComponentOrHook(assignmentExpression, scopes);
 	if (!renderOwner) return false;
-	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return isPredictableGuardedInitialization(assignmentExpression, renderOwner, renderOwner, refSymbol, scopes, assignmentExpression.operator === "||=");
-	if (assignmentExpression.operator !== "=") return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
 		const test = isNodeOfType(ancestor, "IfStatement") ? stripParenExpression(ancestor.test) : null;
-		if (isNodeOfType(ancestor, "IfStatement") && test && isNodeOfType(test, "UnaryExpression") && test.operator === "!" && isSameRefCurrentAlias(test.argument, refSymbol, scopes) && ancestor.consequent === descendant && isPredictableGuardedInitialization(assignmentExpression, ancestor.consequent, renderOwner, refSymbol, scopes, true)) return true;
+		if (isNodeOfType(ancestor, "IfStatement") && test && isNodeOfType(test, "UnaryExpression") && test.operator === "!" && isSameRefCurrentAlias(test.argument, refSymbol, scopes) && ancestor.consequent === descendant && isProvablyTruthyInitializationValue(assignmentExpression.right, scopes) && refHasClosedFalsySentinelDomain(refSymbol, assignmentExpression.right, scopes) && !hasRepeatedExecutionAncestor(assignmentExpression, ancestor.consequent) && !hasRepeatedExecutionAncestor(ancestor, renderOwner) && hasNoPriorCoExecutableWrite(assignmentExpression, ancestor.consequent, refSymbol, scopes) && hasNoCompetingRefCurrentWrite(renderOwner, assignmentExpression, refSymbol, scopes) && refDoesNotEscape(renderOwner, refSymbol, scopes)) return true;
 		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(test, "BinaryExpression") && [
 			"===",
 			"==",
@@ -82725,7 +82429,7 @@ const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes)
 			const { left, right } = test;
 			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
 			const guardedBranch = test.operator === "===" || test.operator === "==" ? ancestor.consequent : ancestor.alternate;
-			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && isPredictableGuardedInitialization(assignmentExpression, guardedBranch, renderOwner, refSymbol, scopes, false)) return true;
+			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && hasNoPriorCoExecutableWrite(assignmentExpression, guardedBranch, refSymbol, scopes)) return true;
 		}
 		descendant = ancestor;
 		ancestor = descendant.parent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.9.2-dev.5dc936e",
+  "version": "0.9.2-dev.5f23826",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",