oxlint-plugin-react-doctor 0.7.5-dev.70eff9a → 0.7.5-dev.8fc5848

package/dist/index.js

@@ -9070,30 +9070,6 @@ const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, conte
 	}
 	return matchingBlocks.size > 0;
 };
-const doMatchingNodesCoverEveryPathFromFunctionEntry = (owner, matchingNodes, context) => {
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return false;
-	const matchingBlocks = new Set(matchingNodes.flatMap((matchingNode) => {
-		if (context.cfg.enclosingFunction(matchingNode) !== owner) return [];
-		const matchingBlock = functionCfg.blockOf(matchingNode);
-		return matchingBlock ? [matchingBlock] : [];
-	}));
-	if (matchingBlocks.size === 0) return false;
-	const visitedBlocks = new Set([functionCfg.entry]);
-	const pendingBlocks = [functionCfg.entry];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		if (matchingBlocks.has(currentBlock)) continue;
-		for (const edge of currentBlock.successors) {
-			if (edge.to === functionCfg.exit) return false;
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return true;
-};
 const removeSynchronouslyReleasedUsages = (callback, usages, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
@@ -9294,83 +9270,6 @@ const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visite
 	});
 	return didCleanupFunctionMatch;
 };
-const doesBoundCleanupReleaseUsage = (expression, usage, context) => {
-	const callExpression = stripParenExpression(expression);
-	if (!isNodeOfType(callExpression, "CallExpression")) return false;
-	const bindCallee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(bindCallee, "MemberExpression") || bindCallee.computed || !isNodeOfType(bindCallee.property, "Identifier") || bindCallee.property.name !== "bind") return false;
-	const releaseMember = stripParenExpression(bindCallee.object);
-	if (!isNodeOfType(releaseMember, "MemberExpression") || releaseMember.computed || !isNodeOfType(releaseMember.property, "Identifier")) return false;
-	const releaseReceiverKey = resolveExpressionKey$1(releaseMember.object, context);
-	if (releaseReceiverKey === null || releaseReceiverKey !== resolveExpressionKey$1(callExpression.arguments?.[0], context)) return false;
-	const releaseVerbName = releaseMember.property.name;
-	if (usage.kind === "socket") return usage.handleKey === releaseReceiverKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
-	return usage.kind === "subscribe" && usage.handleKey === releaseReceiverKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName));
-};
-const callbackReturnsCleanupForUsage = (callback, usage, context) => {
-	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	const doesReturnedValueReleaseUsage = (returnedValue) => {
-		if (doesBoundCleanupReleaseUsage(returnedValue, usage, context)) return true;
-		const cleanupFunction = resolveStableValue(returnedValue, context);
-		if (cleanupFunction && doesBoundCleanupReleaseUsage(cleanupFunction, usage, context)) return true;
-		return Boolean(cleanupFunction && isFunctionLike$1(cleanupFunction) && doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context));
-	};
-	if (!isNodeOfType(callback.body, "BlockStatement")) return doesReturnedValueReleaseUsage(stripParenExpression(callback.body));
-	const matchingCleanupReturns = [];
-	walkInsideStatementBlocks(callback.body, (child) => {
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && doesReturnedValueReleaseUsage(stripParenExpression(child.argument))) matchingCleanupReturns.push(child);
-	});
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
-};
-const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
-	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") || !isNodeOfType(callback.body, "BlockStatement")) return false;
-	const functionCfg = context.cfg.cfgFor(callback);
-	const usageBlock = functionCfg?.blockOf(usage.node);
-	const usageStart = getRangeStart(usage.node);
-	if (!functionCfg || !usageBlock || usageStart === null) return false;
-	const findHandleGuard = (releaseCall) => {
-		if (usage.handleKey === null) return null;
-		let ancestor = releaseCall.parent;
-		while (ancestor && ancestor !== callback.body) {
-			if (isNodeOfType(ancestor, "IfStatement")) return ancestor.alternate === null && resolveExpressionKey$1(ancestor.test, context) === usage.handleKey && getRangeStart(ancestor) !== null && (getRangeStart(ancestor) ?? usageStart) < usageStart ? ancestor : null;
-			ancestor = ancestor.parent;
-		}
-		return null;
-	};
-	const matchingReleaseAnchors = [];
-	walkInsideStatementBlocks(callback.body, (child) => {
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const releaseStart = getRangeStart(child);
-		const handleGuard = findHandleGuard(child);
-		if (releaseStart === null || releaseStart >= usageStart || functionCfg.blockOf(child) !== usageBlock && !handleGuard) return;
-		if (doesReleaseCallMatchUsage(child, usage, context)) {
-			matchingReleaseAnchors.push(handleGuard ?? child);
-			return;
-		}
-		const helperFunction = resolveStableValue(child.callee, context);
-		if (helperFunction && isFunctionLike$1(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context)) matchingReleaseAnchors.push(handleGuard ?? child);
-	});
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
-};
-const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
-	const componentFunction = findEnclosingFunction(callback);
-	if (!componentFunction || !isNodeOfType(componentFunction, "ArrowFunctionExpression") && !isNodeOfType(componentFunction, "FunctionExpression") && !isNodeOfType(componentFunction, "FunctionDeclaration")) return false;
-	let didFindUnmountCleanup = false;
-	walkAst(componentFunction.body, (child) => {
-		if (didFindUnmountCleanup) return false;
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction(child) !== componentFunction) return;
-		if (!isHookCall$2(child, CLEANUP_EFFECT_HOOK_NAMES)) return;
-		const dependencyList = child.arguments?.[1];
-		if (!isNodeOfType(dependencyList, "ArrayExpression") || dependencyList.elements.length > 0) return;
-		const cleanupCallback = getEffectCallback(child);
-		if (cleanupCallback && cleanupCallback !== callback && callbackReturnsCleanupForUsage(cleanupCallback, usage, context)) {
-			didFindUnmountCleanup = true;
-			return false;
-		}
-	});
-	return didFindUnmountCleanup;
-};
-const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasRerunReleaseBeforeUsage(callback, usage, context) && hasStableUnmountCleanupForUsage(callback, usage, context);
 const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
 	if (usage.kind === "subscribe" && findEnclosingFunction(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
@@ -9383,10 +9282,6 @@ const effectHasCleanupForUsage = (callback, usage, context) => {
 		if (returnStart !== null && usageStart !== null && returnStart < usageStart) return;
 		const returnedValue = child.argument ? stripParenExpression(child.argument) : null;
 		if (!returnedValue) return;
-		if (doesBoundCleanupReleaseUsage(returnedValue, usage, context)) {
-			matchingCleanupReturns.push(child);
-			return;
-		}
 		if (usage.kind === "subscribe" && (returnedValue === usage.node || getRangeStart(returnedValue) !== null && getRangeStart(returnedValue) === getRangeStart(usage.node)) && isCleanupReturningSubscribeLikeCallExpression(returnedValue)) {
 			matchingCleanupReturns.push(child);
 			return;
@@ -9402,17 +9297,13 @@ const effectHasCleanupForUsage = (callback, usage, context) => {
 			if (!context.scopes.symbolFor(returnedValue)?.initializer) return;
 		}
 		const cleanupFunction = resolveStableValue(returnedValue, context);
-		if (cleanupFunction && doesBoundCleanupReleaseUsage(cleanupFunction, usage, context)) {
-			matchingCleanupReturns.push(child);
-			return;
-		}
 		if (!cleanupFunction || !isFunctionLike$1(cleanupFunction)) return;
 		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
 	});
 	return doMatchingNodesCoverEveryPathAfterUsage(resolveCleanupPathAnchor(usage.node, callback, context), matchingCleanupReturns, context);
 };
 const findFirstUsageWithoutCleanup = (callback, usages, context) => {
-	for (const usage of usages) if (!effectHasCleanupForUsage(callback, usage, context) && !hasSplitLifecycleCleanup(callback, usage, context)) return usage;
+	for (const usage of usages) if (!effectHasCleanupForUsage(callback, usage, context)) return usage;
 	return null;
 };
 const isLocalAbortControllerExpression = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
@@ -28483,31 +28374,20 @@ const noDocumentStartViewTransition = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/get-static-property-name.ts
-const getStaticPropertyName = (memberExpression) => {
-	const property = memberExpression.property;
-	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
-	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
-	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/js-performance/no-document-write.ts
 const MESSAGE$24 = "`document.write()` blocks parsing, is ignored (or wipes the page) after load, and is flagged by browsers as a performance anti-pattern. Build DOM nodes or set `innerHTML`/`textContent` on a target element instead.";
 const WRITE_METHODS = new Set(["write", "writeln"]);
-const isGlobalDocumentReference = (node, context) => node.name === "document" && context.scopes.isGlobalReference(node);
 const noDocumentWrite = defineRule({
 	id: "no-document-write",
 	title: "document.write/writeln",
 	severity: "warn",
 	recommendation: "Don't use `document.write()`/`document.writeln()`. Append DOM nodes or set `innerHTML`/`textContent` on a specific element instead.",
 	create: (context) => ({ CallExpression(node) {
-		const callee = stripParenExpression(node.callee);
-		if (!isNodeOfType(callee, "MemberExpression")) return;
+		const callee = node.callee;
+		if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return;
 		const receiver = stripParenExpression(callee.object);
-		if (!isNodeOfType(receiver, "Identifier") || !isGlobalDocumentReference(receiver, context)) return;
-		const methodName = getStaticPropertyName(callee);
-		if (methodName === null || !WRITE_METHODS.has(methodName)) return;
+		if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "document") return;
+		if (!isNodeOfType(callee.property, "Identifier") || !WRITE_METHODS.has(callee.property.name)) return;
 		context.report({
 			node,
 			message: MESSAGE$24
@@ -29314,14 +29194,6 @@ const noEffectWithFreshDeps = defineRule({
 //#endregion
 //#region src/plugin/rules/security/no-eval.ts
 const SANDBOX_SURFACE_PATH_PATTERN = /(?:^|[/-])sandbox(?:$|[/-])|(?:^|\/)[\w.]+-sandbox(?:\/|\.[cm]?[jt]sx?$)/i;
-const getExecutableGlobalName = (node, context) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "Identifier")) return context.scopes.isGlobalReference(expression) ? expression.name : null;
-	if (!isNodeOfType(expression, "MemberExpression")) return null;
-	const receiver = stripParenExpression(expression.object);
-	if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "globalThis" || !context.scopes.isGlobalReference(receiver)) return null;
-	return getStaticPropertyName(expression);
-};
 const noEval = defineRule({
 	id: "no-eval",
 	title: "eval() runs untrusted code strings",
@@ -29331,21 +29203,20 @@ const noEval = defineRule({
 		if (SANDBOX_SURFACE_PATH_PATTERN.test(normalizeFilename(context.filename ?? ""))) return {};
 		return {
 			CallExpression(node) {
-				const executableGlobalName = getExecutableGlobalName(node.callee, context);
-				if (executableGlobalName === "eval") {
+				if (isNodeOfType(node.callee, "Identifier") && node.callee.name === "eval") {
 					context.report({
 						node,
 						message: "eval() is a code-injection vulnerability: it runs any string as code."
 					});
 					return;
 				}
-				if ((executableGlobalName === "setTimeout" || executableGlobalName === "setInterval") && isNodeOfType(node.arguments?.[0], "Literal") && typeof node.arguments[0].value === "string") context.report({
+				if (isNodeOfType(node.callee, "Identifier") && (node.callee.name === "setTimeout" || node.callee.name === "setInterval") && isNodeOfType(node.arguments?.[0], "Literal") && typeof node.arguments[0].value === "string") context.report({
 					node,
-					message: `Passing a string to ${executableGlobalName}() is a code-injection vulnerability, since it runs that string as code.`
+					message: `Passing a string to ${node.callee.name}() is a code-injection vulnerability, since it runs that string as code.`
 				});
 			},
 			NewExpression(node) {
-				if (getExecutableGlobalName(node.callee, context) === "Function") {
+				if (isNodeOfType(node.callee, "Identifier") && node.callee.name === "Function") {
 					const onlyArgument = node.arguments.length === 1 ? node.arguments[0] : void 0;
 					if (isNodeOfType(onlyArgument, "Literal") && typeof onlyArgument.value === "string" && onlyArgument.value.trim() === "return this") return;
 					context.report({
@@ -35062,14 +34933,6 @@ const isHandlerBagArgument = (analysis, argument) => {
 };
 const getFunctionalUpdaterDataRefs = (analysis, updater) => getDownstreamRefs(analysis, updater).filter((updaterRef) => !updaterRef.resolved?.defs.some((def) => def.type === "Parameter" && def.node === updater));
 const HOOK_NAME_PATTERN$1 = /^use[A-Z0-9]/;
-const EXTERNAL_SUBSCRIPTION_HOOK_NAMES = new Set([
-	"useIntersectionObserver",
-	"useMatchMedia",
-	"useMediaQuery",
-	"useResizeObserver",
-	"useVisibility",
-	"useWindowSize"
-]);
 const isParentWiredHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
@@ -35092,19 +34955,6 @@ const isParentWiredHookCalleeRef = (analysis, ref) => {
 	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier) return false;
 	return (parent.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isProp(analysis, downstreamRef)));
 };
-const isExternalSubscriptionHookRef = (ref) => {
-	const identifier = ref.identifier;
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	if (EXTERNAL_SUBSCRIPTION_HOOK_NAMES.has(identifier.name) && isCalleePosition(identifier)) return true;
-	return Boolean(ref.resolved?.defs.some((def) => {
-		const node = def.node;
-		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-		const initializer = stripParenExpression(node.init);
-		if (!isNodeOfType(initializer, "CallExpression")) return false;
-		const callee = stripParenExpression(initializer.callee);
-		return isNodeOfType(callee, "Identifier") && EXTERNAL_SUBSCRIPTION_HOOK_NAMES.has(callee.name);
-	}));
-};
 const isImportBindingRef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "ImportBinding"));
 const isCalleePosition = (identifier) => {
 	const parent = identifier.parent;
@@ -35166,11 +35016,10 @@ const noPassDataToParent = defineRule({
 						if (argumentRef && resolveToFunction(argumentRef)) return [];
 					}
 					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => isExternallyDrivenState(analysis, argumentRef) ? [] : getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
+				}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
 				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
 				if (!argsUpstreamRefs.some((argRef) => {
 					if (isUseStateIdentifier(argRef.identifier)) return false;
-					if (isExternalSubscriptionHookRef(argRef)) return false;
 					if (isProp(analysis, argRef)) return false;
 					if (isUseRefIdentifier(argRef.identifier)) return false;
 					if (isRefCurrent(argRef)) return false;
@@ -54928,6 +54777,12 @@ const webhookSignatureRisk = defineRule({
 //#region src/plugin/rules/zod/utils/zod-ast.ts
 const ZOD_MODULE = "zod";
 const ZOD_MODULE_SOURCES = [ZOD_MODULE];
+const getStaticPropertyName = (member) => {
+	const property = member.property;
+	if (!member.computed && isNodeOfType(property, "Identifier")) return property.name;
+	if (member.computed && isNodeOfType(property, "Literal") && typeof property.value === "string") return property.value;
+	return null;
+};
 const importInfoCache = /* @__PURE__ */ new WeakMap();
 const getImportInfoForIdentifier = (identifier) => {
 	if (importInfoCache.has(identifier)) return importInfoCache.get(identifier) ?? null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.5-dev.70eff9a",
+  "version": "0.7.5-dev.8fc5848",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",