oxlint-plugin-react-doctor 0.6.2-dev.d8628d7 → 0.6.2-dev.fa61c20

package/dist/index.js

@@ -378,18 +378,13 @@ const isBrowserArtifactPath = (relativePath, isGeneratedBundle) => {
 const isConfigOrCiPath = (relativePath) => /(?:^|\/)(?:package\.json|Dockerfile|docker-compose\.ya?ml|\.github\/workflows\/[^/]+\.ya?ml|vercel\.json|next\.config\.[cm]?[jt]s|netlify\.toml)$/i.test(relativePath);
 //#endregion
 //#region src/plugin/rules/security-scan/utils/is-production-file-path.ts
-const classificationCacheByPattern = /* @__PURE__ */ new Map();
 const isProductionFilePath = (relativePath, sourceFilePattern) => {
-	let classificationByPath = classificationCacheByPattern.get(sourceFilePattern);
-	if (!classificationByPath) {
-		classificationByPath = /* @__PURE__ */ new Map();
-		classificationCacheByPattern.set(sourceFilePattern, classificationByPath);
-	}
-	const cached = classificationByPath.get(relativePath);
-	if (cached !== void 0) return cached;
-	const isProduction = sourceFilePattern.test(relativePath) && !TEST_CONTEXT_PATTERN.test(relativePath) && !BUILD_SCRIPT_CONTEXT_PATTERN.test(relativePath) && !DOCUMENTATION_CONTEXT_PATTERN.test(relativePath) && !GENERATED_SOURCE_CONTEXT_PATTERN.test(relativePath);
-	classificationByPath.set(relativePath, isProduction);
-	return isProduction;
+	if (!sourceFilePattern.test(relativePath)) return false;
+	if (TEST_CONTEXT_PATTERN.test(relativePath)) return false;
+	if (BUILD_SCRIPT_CONTEXT_PATTERN.test(relativePath)) return false;
+	if (DOCUMENTATION_CONTEXT_PATTERN.test(relativePath)) return false;
+	if (GENERATED_SOURCE_CONTEXT_PATTERN.test(relativePath)) return false;
+	return true;
 };
 //#endregion
 //#region src/plugin/rules/security-scan/utils/is-production-source-path.ts
@@ -788,6 +783,24 @@ const collectChildComponentNames = (element, into) => {
 		into.add(name);
 	});
 };
+const findSameFileComponentBody = (programRoot, componentName) => {
+	let foundBody = null;
+	walkAst(programRoot, (node) => {
+		if (foundBody) return false;
+		if (isNodeOfType(node, "FunctionDeclaration") && node.id && node.id.name === componentName) {
+			foundBody = node.body;
+			return false;
+		}
+		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.id.name === componentName) {
+			const initializer = node.init;
+			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) {
+				foundBody = initializer.body;
+				return false;
+			}
+		}
+	});
+	return foundBody;
+};
 const countEffectHookCalls = (body) => {
 	if (!body) return 0;
 	let count = 0;
@@ -797,36 +810,6 @@ const countEffectHookCalls = (body) => {
 	});
 	return count;
 };
-const componentEffectIndexCache = /* @__PURE__ */ new WeakMap();
-const getComponentEffectIndex = (programRoot) => {
-	const cached = componentEffectIndexCache.get(programRoot);
-	if (cached) return cached;
-	const bodyByName = /* @__PURE__ */ new Map();
-	walkAst(programRoot, (node) => {
-		if (isNodeOfType(node, "FunctionDeclaration") && node.id && !bodyByName.has(node.id.name)) {
-			bodyByName.set(node.id.name, node.body);
-			return;
-		}
-		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && !bodyByName.has(node.id.name)) {
-			const initializer = node.init;
-			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) bodyByName.set(node.id.name, initializer.body);
-		}
-	});
-	const index = {
-		bodyByName,
-		effectCountByName: /* @__PURE__ */ new Map()
-	};
-	componentEffectIndexCache.set(programRoot, index);
-	return index;
-};
-const getSameFileComponentEffectCount = (programRoot, componentName) => {
-	const index = getComponentEffectIndex(programRoot);
-	const cachedCount = index.effectCountByName.get(componentName);
-	if (cachedCount !== void 0) return cachedCount;
-	const count = countEffectHookCalls(index.bodyByName.get(componentName) ?? null);
-	index.effectCountByName.set(componentName, count);
-	return count;
-};
 const activityWrapsEffectHeavySubtree = defineRule({
 	id: "activity-wraps-effect-heavy-subtree",
 	title: "Activity wraps an effect-heavy subtree",
@@ -883,7 +866,9 @@ const activityWrapsEffectHeavySubtree = defineRule({
 				let totalEffects = 0;
 				const effectfulChildren = [];
 				for (const componentName of childComponentNames) {
-					const effectCount = getSameFileComponentEffectCount(programRoot, componentName);
+					const body = findSameFileComponentBody(programRoot, componentName);
+					if (!body) continue;
+					const effectCount = countEffectHookCalls(body);
 					if (effectCount === 0) continue;
 					totalEffects += effectCount;
 					effectfulChildren.push(`<${componentName}>`);
@@ -1682,7 +1667,7 @@ const isNextjsMetadataImageRouteFilename = (rawFilename) => {
 };
 //#endregion
 //#region src/plugin/utils/normalize-filename.ts
-const normalizeFilename = (filename) => filename.includes("\\") ? filename.replaceAll("\\", "/") : filename;
+const normalizeFilename = (filename) => filename.replaceAll("\\", "/");
 //#endregion
 //#region src/plugin/utils/is-generated-image-render-context.ts
 const IMAGE_RESPONSE_MODULES = ["next/og", "@vercel/og"];
@@ -3647,9 +3632,8 @@ const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 //#endregion
 //#region src/plugin/rules/security-scan/utils/find-suspicious-public-env-secret-name.ts
-const PUBLIC_ENV_SECRET_NAME_GLOBAL_PATTERN = new RegExp(PUBLIC_ENV_SECRET_NAME_PATTERN.source, "gi");
 const findSuspiciousPublicEnvSecretNamePattern = (content) => {
-	for (const match of content.matchAll(PUBLIC_ENV_SECRET_NAME_GLOBAL_PATTERN)) {
+	for (const match of content.matchAll(new RegExp(PUBLIC_ENV_SECRET_NAME_PATTERN.source, "gi"))) {
 		const value = match[0] ?? "";
 		if (!TRUSTED_PUBLIC_SECRET_NAME_PATTERN.test(value)) return new RegExp(escapeRegExp(value));
 	}
@@ -4116,56 +4100,62 @@ const collectPatternIdentifiers = (pattern, target) => {
 		for (const element of pattern.elements ?? []) if (element) collectPatternIdentifiers(element, target);
 	} else if (isNodeOfType(pattern, "AssignmentPattern") && pattern.left) collectPatternIdentifiers(pattern.left, target);
 };
+const collectAssignedIdentifiers = (block) => {
+	const assigned = /* @__PURE__ */ new Set();
+	walkAst(block, (child) => {
+		if (isInlineFunctionExpression(child) || isNodeOfType(child, "FunctionDeclaration")) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && child.left) collectPatternIdentifiers(child.left, assigned);
+	});
+	return assigned;
+};
+const collectAwaitedArgIdentifiers = (block) => {
+	const referenced = /* @__PURE__ */ new Set();
+	walkAst(block, (child) => {
+		if (isInlineFunctionExpression(child) || isNodeOfType(child, "FunctionDeclaration")) return false;
+		if (!isNodeOfType(child, "AwaitExpression") || !child.argument) return;
+		collectReferenceIdentifierNames(child.argument, referenced);
+	});
+	return referenced;
+};
 const ARRAY_MUTATION_METHOD_NAMES = new Set([
 	"push",
 	"unshift",
 	"splice"
 ]);
-const addDerivedBindings = (block, names) => {
-	const declaratorBindings = [];
+const collectMutatedArrayNames = (block) => {
+	const mutated = /* @__PURE__ */ new Set();
 	walkAst(block, (child) => {
 		if (child !== block && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
-		if (!isNodeOfType(child.id, "Identifier")) return;
-		const referencedNames = /* @__PURE__ */ new Set();
-		collectReferenceIdentifierNames(child.init, referencedNames);
-		declaratorBindings.push({
-			declaredName: child.id.name,
-			referencedNames
-		});
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = child.callee;
+		if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && ARRAY_MUTATION_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier")) mutated.add(callee.object.name);
 	});
+	return mutated;
+};
+const addDerivedBindings = (block, names) => {
 	let didGrow = true;
 	while (didGrow) {
 		didGrow = false;
-		for (const { declaredName, referencedNames } of declaratorBindings) {
-			if (names.has(declaredName)) continue;
-			for (const referenced of referencedNames) if (names.has(referenced)) {
-				names.add(declaredName);
+		walkAst(block, (child) => {
+			if (child !== block && isFunctionLike$1(child)) return false;
+			if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
+			if (!isNodeOfType(child.id, "Identifier") || names.has(child.id.name)) return;
+			const initReferences = /* @__PURE__ */ new Set();
+			collectReferenceIdentifierNames(child.init, initReferences);
+			for (const referenced of initReferences) if (names.has(referenced)) {
+				names.add(child.id.name);
 				didGrow = true;
 				break;
 			}
-		}
+		});
 	}
 };
 const hasLoopCarriedDependency = (block) => {
-	const carried = /* @__PURE__ */ new Set();
-	const awaitedReferences = /* @__PURE__ */ new Set();
-	walkAst(block, (child) => {
-		if (child !== block && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "AssignmentExpression") && child.left) {
-			collectPatternIdentifiers(child.left, carried);
-			return;
-		}
-		if (isNodeOfType(child, "AwaitExpression") && child.argument) {
-			collectReferenceIdentifierNames(child.argument, awaitedReferences);
-			return;
-		}
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = child.callee;
-		if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && ARRAY_MUTATION_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier")) carried.add(callee.object.name);
-	});
+	const carried = collectAssignedIdentifiers(block);
+	for (const name of collectMutatedArrayNames(block)) carried.add(name);
 	if (carried.size === 0) return false;
 	addDerivedBindings(block, carried);
+	const awaitedReferences = collectAwaitedArgIdentifiers(block);
 	for (const name of carried) if (awaitedReferences.has(name)) return true;
 	return false;
 };
@@ -5718,20 +5708,12 @@ const getTemplateInterpolations = (valueTail) => {
 	return interpolations === null ? "" : interpolations.join(" ");
 };
 const isInertParseTarget = (target, fileContent) => {
-	const fileHasCreateElement = fileContent.includes("createElement");
-	const fileHasIsolatedDocument = fileContent.includes("createHTMLDocument");
-	if (!fileHasCreateElement && !fileHasIsolatedDocument) return false;
 	const escapedTarget = escapeRegExp(target);
 	const escapedRoot = escapeRegExp(target.split(".")[0] ?? target);
 	if (new RegExp(`\\b${escapedRoot}\\s*=\\s*[^\\n;]*(?:getElementById|querySelector|getElementsBy|\\.current\\b|document\\.(?:body|head|documentElement))`).test(fileContent)) return false;
-	if (fileHasCreateElement) {
-		if (new RegExp(`${escapedTarget}\\s*=\\s*document\\.createElement\\(\\s*["'\`]template["'\`]`).test(fileContent)) return true;
-		if (new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\(\\s*["'\`](?:style|textarea)["'\`]`).test(fileContent)) return true;
-	}
-	if (fileHasIsolatedDocument) {
-		if (new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateHTMLDocument\\s*\\(`).test(fileContent)) return true;
-	}
-	if (!fileHasCreateElement) return false;
+	if (new RegExp(`${escapedTarget}\\s*=\\s*document\\.createElement\\(\\s*["'\`]template["'\`]`).test(fileContent)) return true;
+	if (new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\(\\s*["'\`](?:style|textarea)["'\`]`).test(fileContent)) return true;
+	if (new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateHTMLDocument\\s*\\(`).test(fileContent)) return true;
 	if (!new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\s*\\(`).test(fileContent)) return false;
 	const attachedToLiveTreePattern = new RegExp(`${LIVE_DOM_ATTACH_PATTERN.source}[^)]*\\b${escapedRoot}\\b`);
 	const returnedAsNodePattern = new RegExp(`\\breturn\\b[^\\n]*\\b${escapedRoot}\\b(?!\\s*\\.\\s*(?:textContent|innerText|innerHTML|outerHTML))`);
@@ -5824,9 +5806,10 @@ const dangerousHtmlSink = defineRule({
 				const valueIdentifier = valueExpression.match(/^[\w$]+/)?.[0];
 				if (valueIdentifier !== void 0) {
 					const escapedIdentifier = escapeRegExp(valueIdentifier);
-					if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`, "i").test(file.content)) continue;
-					if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`, "i").test(file.content)) continue;
-					if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${DOM_CONTENT_ASSIGNMENT_PATTERN.source}`).test(file.content)) continue;
+					const fromSerializer = new RegExp(`\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`, "i");
+					const fromSanitizer = new RegExp(`\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`, "i");
+					const fromDomContent = new RegExp(`\\b${escapedIdentifier}\\b\\s*${DOM_CONTENT_ASSIGNMENT_PATTERN.source}`);
+					if (fromSerializer.test(file.content) || fromSanitizer.test(file.content) || fromDomContent.test(file.content)) continue;
 				}
 			}
 			const sinkTargetMatch = INNERHTML_TARGET_PATTERN.exec(line);
@@ -6217,10 +6200,7 @@ const isReactVersionAtLeast$1 = (version, major, minor) => {
 	const actualMinor = Number(match[2]);
 	return actualMajor > major || actualMajor === major && actualMinor >= minor;
 };
-const containsJsxCache = /* @__PURE__ */ new WeakMap();
 const containsJsx$1 = (root) => {
-	const cached = containsJsxCache.get(root);
-	if (cached !== void 0) return cached;
 	let found = false;
 	const visit = (node) => {
 		if (found) return;
@@ -6243,7 +6223,6 @@ const containsJsx$1 = (root) => {
 		}
 	};
 	visit(root);
-	containsJsxCache.set(root, found);
 	return found;
 };
 const getStaticMemberName = (node) => {
@@ -6335,6 +6314,27 @@ const hasDisplayNameMember = (classNode) => {
 	for (const member of members) if ((isNodeOfType(member, "PropertyDefinition") || isNodeOfType(member, "MethodDefinition")) && "static" in member && member.static && isNodeOfType(member.key, "Identifier") && member.key.name === "displayName") return true;
 	return false;
 };
+const hasDisplayNameAssignment = (className, programRoot) => {
+	let found = false;
+	const visit = (node) => {
+		if (found) return;
+		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.object, "Identifier") && node.left.object.name === className && getStaticMemberName(node.left) === "displayName") {
+			found = true;
+			return;
+		}
+		const record = node;
+		for (const key of Object.keys(record)) {
+			if (key === "parent") continue;
+			const child = record[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+			if (found) return;
+		}
+	};
+	visit(programRoot);
+	return found;
+};
 const memberExpressionPath = (node) => {
 	if (isNodeOfType(node, "Identifier")) return [node.name];
 	if (!isNodeOfType(node, "MemberExpression")) return [];
@@ -6342,16 +6342,15 @@ const memberExpressionPath = (node) => {
 	const propertyName = getStaticMemberName(node);
 	return propertyName ? [...objectPath, propertyName] : objectPath;
 };
-const displayNameAssignmentIndexCache = /* @__PURE__ */ new WeakMap();
-const getDisplayNameAssignmentIndex = (programRoot) => {
-	const cached = displayNameAssignmentIndexCache.get(programRoot);
-	if (cached) return cached;
-	const identifierTargets = /* @__PURE__ */ new Set();
-	const memberPathSegments = /* @__PURE__ */ new Set();
+const hasDisplayNameAssignmentForProperty = (propertyName, programRoot) => {
+	let found = false;
 	const visit = (node) => {
+		if (found) return;
 		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName(node.left) === "displayName") {
-			if (isNodeOfType(node.left.object, "Identifier")) identifierTargets.add(node.left.object.name);
-			for (const segment of memberExpressionPath(node.left.object)) memberPathSegments.add(segment);
+			if (memberExpressionPath(node.left.object).includes(propertyName)) {
+				found = true;
+				return;
+			}
 		}
 		const record = node;
 		for (const key of Object.keys(record)) {
@@ -6360,18 +6359,12 @@ const getDisplayNameAssignmentIndex = (programRoot) => {
 			if (Array.isArray(child)) {
 				for (const item of child) if (isAstNode(item)) visit(item);
 			} else if (isAstNode(child)) visit(child);
+			if (found) return;
 		}
 	};
 	visit(programRoot);
-	const index = {
-		identifierTargets,
-		memberPathSegments
-	};
-	displayNameAssignmentIndexCache.set(programRoot, index);
-	return index;
+	return found;
 };
-const hasDisplayNameAssignment = (className, programRoot) => getDisplayNameAssignmentIndex(programRoot).identifierTargets.has(className);
-const hasDisplayNameAssignmentForProperty = (propertyName, programRoot) => getDisplayNameAssignmentIndex(programRoot).memberPathSegments.has(propertyName);
 const displayName = defineRule({
 	id: "display-name",
 	title: "Component missing display name",
@@ -10257,6 +10250,8 @@ const jsCachePropertyAccess = defineRule({
 			walkAst(loopBody, (child) => {
 				if (isNodeOfType(child, "AssignmentExpression")) recordWriteTarget(child.left);
 				if (isNodeOfType(child, "UpdateExpression")) recordWriteTarget(child.argument);
+			});
+			walkAst(loopBody, (child) => {
 				if (!isNodeOfType(child, "MemberExpression")) return;
 				if (child.computed) return;
 				if (isNodeOfType(child.parent, "MemberExpression") && child.parent.object === child) return;
@@ -10807,11 +10802,7 @@ const isSingleFieldEqualityPredicate = (node) => {
 	if (!isNodeOfType(predicate, "BinaryExpression") || predicate.operator !== "===" && predicate.operator !== "==") return false;
 	return referencesParameter(predicate.left, firstParameter.name) || referencesParameter(predicate.right, firstParameter.name);
 };
-const loopBoundNamesCache = /* @__PURE__ */ new WeakMap();
-const getLoopBoundNames = (loop) => {
-	const cached = loopBoundNamesCache.get(loop);
-	if (cached) return cached;
-	const names = /* @__PURE__ */ new Set();
+const collectLoopBoundNames = (loop, names) => {
 	if ((isNodeOfType(loop, "ForOfStatement") || isNodeOfType(loop, "ForInStatement")) && loop.left) walkAst(loop.left, (child) => {
 		if (isNodeOfType(child, "Identifier")) names.add(child.name);
 	});
@@ -10828,8 +10819,6 @@ const getLoopBoundNames = (loop) => {
 			if (targetRoot) names.add(targetRoot);
 		}
 	});
-	loopBoundNamesCache.set(loop, names);
-	return names;
 };
 const hasLoopBoundComputedIndex = (receiver, loopBoundNames) => {
 	let cursor = receiver;
@@ -10855,7 +10844,7 @@ const isLoopVariantReceiver = (node) => {
 	const loopBoundNames = /* @__PURE__ */ new Set();
 	let ancestor = node.parent;
 	while (ancestor) {
-		if (LOOP_TYPES.includes(ancestor.type)) for (const name of getLoopBoundNames(ancestor)) loopBoundNames.add(name);
+		if (LOOP_TYPES.includes(ancestor.type)) collectLoopBoundNames(ancestor, loopBoundNames);
 		ancestor = ancestor.parent;
 	}
 	if (loopBoundNames.has(receiverRoot)) return true;
@@ -15526,30 +15515,16 @@ const stripJsComments = (sourceText) => sourceText.replace(BLOCK_COMMENT_PATTERN
 const DEFAULT_EXPORT_DECLARATION_PATTERN = /^\s*export\s+default\b/m;
 const NAMED_EXPORT_DECLARATION_PATTERN = /^\s*export\s+(?:declare\s+)?(?:(?:async\s+)?function|(?:abstract\s+)?class|const|let|var|enum|interface|type)\s+([\w$]+)/gm;
 const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1 = /^\s*export\s+(?:type\s+)?\{([\s\S]*?)\}(?:\s+from\s+["'][^"']+["'])?\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const collectSourceTextExportNames = (sourceText) => {
+const doesSourceTextExportName = (sourceText, exportedName) => {
 	const strippedSource = stripJsComments(sourceText);
-	const exportedNames = /* @__PURE__ */ new Set();
-	if (DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) exportedNames.add("default");
-	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1]) exportedNames.add(match[1]);
-	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1)) {
-		const specifiersText = match[1] ?? "";
-		for (const specifier of parseExportSpecifiers(specifiersText, false)) exportedNames.add(specifier.exportedName);
-	}
-	return exportedNames;
+	if (exportedName === "default" && DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) return true;
+	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1] === exportedName) return true;
+	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1)) if (parseExportSpecifiers(match[1] ?? "", false).map((specifier) => specifier.exportedName).includes(exportedName)) return true;
+	return false;
 };
-const exportNamesCache = /* @__PURE__ */ new Map();
 const doesModuleExportName = (filePath, exportedName) => {
 	try {
-		const fileStat = fs.statSync(filePath);
-		const cached = exportNamesCache.get(filePath);
-		if (cached && cached.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) return cached.exportedNames.has(exportedName);
-		const exportedNames = collectSourceTextExportNames(fs.readFileSync(filePath, "utf8"));
-		exportNamesCache.set(filePath, {
-			mtimeMs: fileStat.mtimeMs,
-			size: fileStat.size,
-			exportedNames
-		});
-		return exportedNames.has(exportedName);
+		return doesSourceTextExportName(fs.readFileSync(filePath, "utf8"), exportedName);
 	} catch {
 		return false;
 	}
@@ -17432,15 +17407,8 @@ const getProgramAnalysis = (anyNode) => {
 	programToAnalysis.set(programNode, analysis);
 	return analysis;
 };
-const scopeByNodeCache = /* @__PURE__ */ new WeakMap();
 const getScopeForNode = (node, manager) => {
 	if (!node.range) return null;
-	let scopeByNode = scopeByNodeCache.get(manager);
-	if (!scopeByNode) {
-		scopeByNode = /* @__PURE__ */ new WeakMap();
-		scopeByNodeCache.set(manager, scopeByNode);
-	}
-	if (scopeByNode.has(node)) return scopeByNode.get(node) ?? null;
 	let bestScope = null;
 	let bestSize = Infinity;
 	for (const scope of manager.scopes) {
@@ -17453,7 +17421,6 @@ const getScopeForNode = (node, manager) => {
 			bestScope = scope;
 		}
 	}
-	scopeByNode.set(node, bestScope);
 	return bestScope;
 };
 //#endregion
@@ -17488,20 +17455,11 @@ const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
 		} else if (isAstNode(child)) descend(child, visit, visited);
 	}
 };
-const upstreamRefsCache = /* @__PURE__ */ new WeakMap();
 const getUpstreamRefs = (analysis, ref) => {
-	let upstreamByRef = upstreamRefsCache.get(analysis);
-	if (!upstreamByRef) {
-		upstreamByRef = /* @__PURE__ */ new WeakMap();
-		upstreamRefsCache.set(analysis, upstreamByRef);
-	}
-	const cached = upstreamByRef.get(ref);
-	if (cached) return cached;
 	const refs = [];
 	ascend(analysis, ref, (upRef) => {
 		refs.push(upRef);
 	});
-	upstreamByRef.set(ref, refs);
 	return refs;
 };
 const findDownstreamNodes = (topNode, type) => {
@@ -17511,24 +17469,11 @@ const findDownstreamNodes = (topNode, type) => {
 	});
 	return nodes;
 };
-const refByIdentifierCache = /* @__PURE__ */ new WeakMap();
 const getRef = (analysis, identifier) => {
-	let refByIdentifier = refByIdentifierCache.get(analysis);
-	if (!refByIdentifier) {
-		refByIdentifier = /* @__PURE__ */ new WeakMap();
-		refByIdentifierCache.set(analysis, refByIdentifier);
-	}
-	if (refByIdentifier.has(identifier)) return refByIdentifier.get(identifier) ?? null;
-	let resolvedReference = null;
 	const scope = getScopeForNode(identifier, analysis.scopeManager);
-	if (scope) {
-		for (const reference of scope.references) if (reference.identifier === identifier) {
-			resolvedReference = reference;
-			break;
-		}
-	}
-	refByIdentifier.set(identifier, resolvedReference);
-	return resolvedReference;
+	if (!scope) return null;
+	for (const reference of scope.references) if (reference.identifier === identifier) return reference;
+	return null;
 };
 const downstreamRefsCache = /* @__PURE__ */ new WeakMap();
 const getDownstreamRefs = (analysis, node) => {
@@ -17603,6 +17548,22 @@ const isEventualCallTo = (analysis, ref, predicate) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/react.ts
+const getOuterScopeContaining = (analysis, node) => {
+	if (!node.range) return null;
+	let best = null;
+	let bestSize = Infinity;
+	for (const scope of analysis.scopeManager.scopes) {
+		const block = scope.block;
+		if (!block?.range) continue;
+		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
+		const size = block.range[1] - block.range[0];
+		if (size <= bestSize) {
+			bestSize = size;
+			best = scope;
+		}
+	}
+	return best;
+};
 const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
 const isReactFunctionalComponent = (node) => {
@@ -17633,7 +17594,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 	const isWrappedSeparately = () => {
 		if (!isNodeOfType(node.id, "Identifier")) return false;
 		const bindingName = node.id.name;
-		const containingScope = getScopeForNode(node, analysis.scopeManager);
+		const containingScope = getOuterScopeContaining(analysis, node);
 		if (!containingScope) return false;
 		const variable = containingScope.variables.find((v) => v.name === bindingName);
 		if (!variable) return false;
@@ -19912,44 +19873,38 @@ const convertHslToRgb = (hueDegrees, saturationPercent, lightnessPercent) => {
 };
 const parseColorToRgb = (value) => {
 	const trimmed = value.trim().toLowerCase().replace(/_/g, " ");
-	if (trimmed.startsWith("#")) {
-		const hex8Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})[0-9a-f]{2}$/);
-		if (hex8Match) return {
-			red: parseInt(hex8Match[1], 16),
-			green: parseInt(hex8Match[2], 16),
-			blue: parseInt(hex8Match[3], 16)
-		};
-		const hex6Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/);
-		if (hex6Match) return {
-			red: parseInt(hex6Match[1], 16),
-			green: parseInt(hex6Match[2], 16),
-			blue: parseInt(hex6Match[3], 16)
-		};
-		const hex4Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])[0-9a-f]$/);
-		if (hex4Match) return {
-			red: parseInt(hex4Match[1] + hex4Match[1], 16),
-			green: parseInt(hex4Match[2] + hex4Match[2], 16),
-			blue: parseInt(hex4Match[3] + hex4Match[3], 16)
-		};
-		const hex3Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/);
-		if (hex3Match) return {
-			red: parseInt(hex3Match[1] + hex3Match[1], 16),
-			green: parseInt(hex3Match[2] + hex3Match[2], 16),
-			blue: parseInt(hex3Match[3] + hex3Match[3], 16)
-		};
-	}
-	if (trimmed.includes("rgb")) {
-		const rgbMatch = trimmed.match(/rgba?\(\s*(\d+)[\s,]+(\d+)[\s,]+(\d+)/);
-		if (rgbMatch) return {
-			red: parseInt(rgbMatch[1], 10),
-			green: parseInt(rgbMatch[2], 10),
-			blue: parseInt(rgbMatch[3], 10)
-		};
-	}
-	if (trimmed.includes("hsl")) {
-		const hslMatch = trimmed.match(/hsla?\(\s*([\d.]+)(?:deg)?[\s,]+([\d.]+)%[\s,]+([\d.]+)%/);
-		if (hslMatch) return convertHslToRgb(parseFloat(hslMatch[1]), parseFloat(hslMatch[2]), parseFloat(hslMatch[3]));
-	}
+	const hex8Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})[0-9a-f]{2}$/);
+	if (hex8Match) return {
+		red: parseInt(hex8Match[1], 16),
+		green: parseInt(hex8Match[2], 16),
+		blue: parseInt(hex8Match[3], 16)
+	};
+	const hex6Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/);
+	if (hex6Match) return {
+		red: parseInt(hex6Match[1], 16),
+		green: parseInt(hex6Match[2], 16),
+		blue: parseInt(hex6Match[3], 16)
+	};
+	const hex4Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])[0-9a-f]$/);
+	if (hex4Match) return {
+		red: parseInt(hex4Match[1] + hex4Match[1], 16),
+		green: parseInt(hex4Match[2] + hex4Match[2], 16),
+		blue: parseInt(hex4Match[3] + hex4Match[3], 16)
+	};
+	const hex3Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/);
+	if (hex3Match) return {
+		red: parseInt(hex3Match[1] + hex3Match[1], 16),
+		green: parseInt(hex3Match[2] + hex3Match[2], 16),
+		blue: parseInt(hex3Match[3] + hex3Match[3], 16)
+	};
+	const rgbMatch = trimmed.match(/rgba?\(\s*(\d+)[\s,]+(\d+)[\s,]+(\d+)/);
+	if (rgbMatch) return {
+		red: parseInt(rgbMatch[1], 10),
+		green: parseInt(rgbMatch[2], 10),
+		blue: parseInt(rgbMatch[3], 10)
+	};
+	const hslMatch = trimmed.match(/hsla?\(\s*([\d.]+)(?:deg)?[\s,]+([\d.]+)%[\s,]+([\d.]+)%/);
+	if (hslMatch) return convertHslToRgb(parseFloat(hslMatch[1]), parseFloat(hslMatch[2]), parseFloat(hslMatch[3]));
 	return null;
 };
 //#endregion
@@ -19977,18 +19932,9 @@ const extractColorFromShadowLayer = (layer) => {
 	if (hexMatch) return parseColorToRgb(`#${hexMatch[1]}`);
 	return null;
 };
-const RGB_FUNCTION_PATTERN = /rgba?\([^)]*\)/g;
-const HEX_COLOR_PATTERN = /#[0-9a-f]{3,8}\b/gi;
-const NUMERIC_TOKEN_PATTERN = /(\d+(?:\.\d+)?)(px)?/g;
-const SHADOW_BLUR_TOKEN_INDEX = 2;
 const parseShadowLayerBlur = (layer) => {
-	const withoutColors = layer.replace(RGB_FUNCTION_PATTERN, "").replace(HEX_COLOR_PATTERN, "");
-	let tokenIndex = 0;
-	for (const match of withoutColors.matchAll(NUMERIC_TOKEN_PATTERN)) {
-		if (tokenIndex === SHADOW_BLUR_TOKEN_INDEX) return parseFloat(match[1]);
-		tokenIndex += 1;
-	}
-	return 0;
+	const numericTokens = [...layer.replace(/rgba?\([^)]*\)/g, "").replace(/#[0-9a-f]{3,8}\b/gi, "").matchAll(/(\d+(?:\.\d+)?)(px)?/g)].map((match) => parseFloat(match[1]));
+	return numericTokens.length >= 3 ? numericTokens[2] : 0;
 };
 const hasColoredGlowShadow = (shadowValue) => {
 	for (const layer of splitShadowLayers(shadowValue)) {
@@ -20108,10 +20054,7 @@ const isIntrinsicJsxAttribute = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-controlled-prop-mirror.ts
-const componentPropNamesCache = /* @__PURE__ */ new WeakMap();
 const collectComponentPropNames = (componentFunction) => {
-	const cached = componentPropNamesCache.get(componentFunction);
-	if (cached) return cached;
 	const propNames = /* @__PURE__ */ new Set();
 	if (!isFunctionLike$1(componentFunction)) return propNames;
 	const propsObjectParamNames = /* @__PURE__ */ new Set();
@@ -20125,23 +20068,27 @@ const collectComponentPropNames = (componentFunction) => {
 		if (child !== componentBody && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "ObjectPattern") && isNodeOfType(child.init, "Identifier") && propsObjectParamNames.has(child.init.name)) collectPatternNames(child.id, propNames);
 	});
-	componentPropNamesCache.set(componentFunction, propNames);
 	return propNames;
 };
-const ownScopeBoundNamesCache = /* @__PURE__ */ new WeakMap();
-const getOwnScopeBoundNames = (functionNode) => {
-	const cached = ownScopeBoundNamesCache.get(functionNode);
-	if (cached) return cached;
+const declaresBindingNamed = (functionNode, bindingName) => {
 	const boundNames = /* @__PURE__ */ new Set();
 	if (isFunctionLike$1(functionNode)) for (const param of functionNode.params ?? []) collectPatternNames(param, boundNames);
+	if (boundNames.has(bindingName)) return true;
+	let declaresName = false;
 	walkAst(functionNode, (child) => {
+		if (declaresName) return false;
 		if (child !== functionNode && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "VariableDeclarator")) collectPatternNames(child.id, boundNames);
+		if (isNodeOfType(child, "VariableDeclarator")) {
+			const declaratorNames = /* @__PURE__ */ new Set();
+			collectPatternNames(child.id, declaratorNames);
+			if (declaratorNames.has(bindingName)) {
+				declaresName = true;
+				return false;
+			}
+		}
 	});
-	ownScopeBoundNamesCache.set(functionNode, boundNames);
-	return boundNames;
+	return declaresName;
 };
-const declaresBindingNamed = (functionNode, bindingName) => getOwnScopeBoundNames(functionNode).has(bindingName);
 const isPropertyNamePosition = (identifier) => {
 	const parent = identifier.parent;
 	if (!parent) return false;
@@ -20564,28 +20511,36 @@ const isHandlerShapedReseed = (setterCall, componentFunction) => {
 	}
 	return hasNestedFunction;
 };
-const isInRenderScope = (node, componentFunction) => {
-	let cursor = node.parent ?? null;
-	while (cursor && cursor !== componentFunction) {
-		if (isFunctionLike$1(cursor)) return false;
-		cursor = cursor.parent ?? null;
-	}
-	return true;
+const isReseededDraftBuffer = (useStateCall, isPropName) => {
+	const setterName = getStateSetterName(useStateCall);
+	if (!setterName) return false;
+	const componentFunction = findEnclosingFunction(useStateCall);
+	if (!componentFunction) return false;
+	let isReseeded = false;
+	walkAst(componentFunction, (child) => {
+		if (isReseeded) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName && isPropDerivedArgument(child.arguments?.[0], isPropName) && isHandlerShapedReseed(child, componentFunction)) {
+			isReseeded = true;
+			return false;
+		}
+	});
+	return isReseeded;
 };
-const isDraftReseedOrRenderAdjusted = (useStateCall, isPropName) => {
+const isAdjustedDuringRender = (useStateCall, isPropName) => {
 	const setterName = getStateSetterName(useStateCall);
 	if (!setterName) return false;
 	const componentFunction = findEnclosingFunction(useStateCall);
 	if (!componentFunction) return false;
-	let isExempt = false;
+	let isAdjusted = false;
 	walkAst(componentFunction, (child) => {
-		if (isExempt) return false;
-		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName && isPropDerivedArgument(child.arguments?.[0], isPropName) && (isHandlerShapedReseed(child, componentFunction) || isInRenderScope(child, componentFunction))) {
-			isExempt = true;
+		if (isAdjusted) return false;
+		if (child !== componentFunction && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName && isPropDerivedArgument(child.arguments?.[0], isPropName)) {
+			isAdjusted = true;
 			return false;
 		}
 	});
-	return isExempt;
+	return isAdjusted;
 };
 const noDerivedUseState = defineRule({
 	id: "no-derived-useState",
@@ -20602,7 +20557,8 @@ const noDerivedUseState = defineRule({
 				const initializer = node.arguments[0];
 				if (isNodeOfType(initializer, "Identifier") && propStackTracker.isPropName(initializer.name)) {
 					if (isInitialOnlyPropName(initializer.name)) return;
-					if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
+					if (isReseededDraftBuffer(node, propStackTracker.isPropName)) return;
+					if (isAdjustedDuringRender(node, propStackTracker.isPropName)) return;
 					context.report({
 						node,
 						message: `Your users see a stale value when prop "${initializer.name}" changes because useState copies it once.`
@@ -20613,7 +20569,8 @@ const noDerivedUseState = defineRule({
 					const rootIdentifierName = getRootIdentifierName(initializer);
 					if (rootIdentifierName && propStackTracker.isPropName(rootIdentifierName)) {
 						if (isNodeOfType(initializer.property, "Identifier") && isInitialOnlyPropName(initializer.property.name)) return;
-						if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
+						if (isReseededDraftBuffer(node, propStackTracker.isPropName)) return;
+						if (isAdjustedDuringRender(node, propStackTracker.isPropName)) return;
 						context.report({
 							node,
 							message: `Your users see a stale value when prop "${rootIdentifierName}" changes because useState copies it once.`
@@ -22312,20 +22269,20 @@ const getTriggerGuardRootName = (testNode) => {
 	return null;
 };
 const collectHandlerOnlyWriteStateNames = (componentBody, useStateBindings, handlerBindingNames) => {
-	const setterNames = new Set(useStateBindings.map((binding) => binding.setterName));
-	const settersWithAnyCall = /* @__PURE__ */ new Set();
-	const settersWithNonHandlerCall = /* @__PURE__ */ new Set();
-	walkAst(componentBody, (child) => {
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (!isNodeOfType(child.callee, "Identifier")) return;
-		const setterName = child.callee.name;
-		if (!setterNames.has(setterName)) return;
-		settersWithAnyCall.add(setterName);
-		if (settersWithNonHandlerCall.has(setterName)) return;
-		if (!isInsideEventHandler(child, handlerBindingNames)) settersWithNonHandlerCall.add(setterName);
-	});
 	const handlerOnlyWriteStateNames = /* @__PURE__ */ new Set();
-	for (const binding of useStateBindings) if (settersWithAnyCall.has(binding.setterName) && !settersWithNonHandlerCall.has(binding.setterName)) handlerOnlyWriteStateNames.add(binding.valueName);
+	for (const binding of useStateBindings) {
+		let didFindAnySetterCall = false;
+		let areAllSetterCallsInHandlers = true;
+		walkAst(componentBody, (child) => {
+			if (!areAllSetterCallsInHandlers) return false;
+			if (!isNodeOfType(child, "CallExpression")) return;
+			if (!isNodeOfType(child.callee, "Identifier")) return;
+			if (child.callee.name !== binding.setterName) return;
+			didFindAnySetterCall = true;
+			if (!isInsideEventHandler(child, handlerBindingNames)) areAllSetterCallsInHandlers = false;
+		});
+		if (didFindAnySetterCall && areAllSetterCallsInHandlers) handlerOnlyWriteStateNames.add(binding.valueName);
+	}
 	return handlerOnlyWriteStateNames;
 };
 const noEventTriggerState = defineRule({
@@ -22665,10 +22622,6 @@ const COLORED_BG_PATTERN = /^bg-(?:red|orange|amber|yellow|lime|green|emerald|te
 const TEXT_COLOR_PATTERN = /^text-(?:white|black|transparent|current|inherit|\[|(?:gray|slate|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-)/;
 const BG_COLOR_PATTERN = /^bg-(?:white|black|transparent|current|inherit|\[|(?:gray|slate|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-)/;
 const splitVariantScope = (token) => {
-	if (!token.includes(":")) return {
-		scope: "",
-		utility: token.startsWith("!") ? token.slice(1) : token
-	};
 	const segments = token.split(":");
 	const rawUtility = segments[segments.length - 1];
 	return {
@@ -22692,7 +22645,6 @@ const noGrayOnColoredBackground = defineRule({
 		const bgColorScopes = /* @__PURE__ */ new Set();
 		for (const token of classStr.split(/\s+/)) {
 			if (!token) continue;
-			if (!token.includes("text-") && !token.includes("bg-")) continue;
 			const { scope, utility } = splitVariantScope(token);
 			if (TEXT_COLOR_PATTERN.test(utility)) textColorScopes.add(scope);
 			if (BG_COLOR_PATTERN.test(utility)) bgColorScopes.add(scope);
@@ -23422,8 +23374,6 @@ const hasInfiniteIterationCount = (properties) => properties.some((property) =>
 	return isNodeOfType(property, "Property") && isNodeOfType(property.value, "Identifier") && property.value.name === "Infinity";
 });
 const isInfiniteAnimationSegment = (segment) => segment.trim().split(/\s+/).includes("infinite");
-const DURATION_SEGMENT_PATTERN = /^([\d.]+)(m?s)$/;
-const FIRST_TIME_TOKEN_PATTERN = /(?<![a-zA-Z\d])([\d.]+)(m?s)(?![a-zA-Z\d-])/;
 const noLongTransitionDuration = defineRule({
 	id: "no-long-transition-duration",
 	title: "Transition duration too long",
@@ -23447,10 +23397,11 @@ const noLongTransitionDuration = defineRule({
 			if (key === "transitionDuration" || key === "animationDuration") {
 				let longestDurationPropertyMs = 0;
 				for (const segment of value.split(",")) {
-					const durationMatch = segment.trim().match(DURATION_SEGMENT_PATTERN);
-					if (!durationMatch) continue;
-					const segmentDurationMs = durationMatch[2] === "ms" ? parseFloat(durationMatch[1]) : parseFloat(durationMatch[1]) * 1e3;
-					longestDurationPropertyMs = Math.max(longestDurationPropertyMs, segmentDurationMs);
+					const trimmedSegment = segment.trim();
+					const msMatch = trimmedSegment.match(/^([\d.]+)ms$/);
+					const secondsMatch = trimmedSegment.match(/^([\d.]+)s$/);
+					if (msMatch) longestDurationPropertyMs = Math.max(longestDurationPropertyMs, parseFloat(msMatch[1]));
+					else if (secondsMatch) longestDurationPropertyMs = Math.max(longestDurationPropertyMs, parseFloat(secondsMatch[1]) * 1e3);
 				}
 				if (longestDurationPropertyMs > 0) durationMs = longestDurationPropertyMs;
 			}
@@ -23458,7 +23409,7 @@ const noLongTransitionDuration = defineRule({
 				let longestDurationMs = 0;
 				for (const segment of value.split(",")) {
 					if (key === "animation" && isInfiniteAnimationSegment(segment)) continue;
-					const firstTimeMatch = segment.match(FIRST_TIME_TOKEN_PATTERN);
+					const firstTimeMatch = segment.match(/(?<![a-zA-Z\d])([\d.]+)(m?s)(?![a-zA-Z\d-])/);
 					if (!firstTimeMatch) continue;
 					const segmentDurationMs = firstTimeMatch[2] === "ms" ? parseFloat(firstTimeMatch[1]) : parseFloat(firstTimeMatch[1]) * 1e3;
 					longestDurationMs = Math.max(longestDurationMs, segmentDurationMs);
@@ -32284,11 +32235,41 @@ const callsIdentifier = (root, identifierName) => {
 	});
 	return found;
 };
+const setterIsCalledInAsyncContext = (componentBody, setterName) => {
+	if (!componentBody) return false;
+	let found = false;
+	walkAst(componentBody, (child) => {
+		if (found) return;
+		if (!isFunctionLike$1(child)) return;
+		const functionBody = child.body;
+		if (!(Boolean(child.async) || hasOwnAwait(functionBody))) return;
+		if (callsIdentifier(functionBody, setterName)) found = true;
+	});
+	return found;
+};
 const PROMISE_CHAIN_METHOD_NAMES = new Set([
 	"then",
 	"catch",
 	"finally"
 ]);
+const setterIsCalledInPromiseChain = (componentBody, setterName) => {
+	if (!componentBody) return false;
+	let found = false;
+	walkAst(componentBody, (child) => {
+		if (found) return;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = child.callee;
+		if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier") || !PROMISE_CHAIN_METHOD_NAMES.has(callee.property.name)) return;
+		for (const argument of child.arguments ?? []) {
+			if (!isFunctionLike$1(argument)) continue;
+			if (callsIdentifier(argument.body, setterName)) {
+				found = true;
+				return;
+			}
+		}
+	});
+	return found;
+};
 const ASYNC_DATA_CALLEE_NAMES = new Set([
 	"useApolloClient",
 	"useMutation",
@@ -32301,36 +32282,20 @@ const ASYNC_DATA_CALLEE_NAMES = new Set([
 	"fetch",
 	"axios"
 ]);
-const hasAsyncLoadingWork = (fnBody, setterName) => {
+const referencesAsyncDataApi = (body) => {
+	if (!body) return false;
 	let found = false;
-	walkAst(fnBody, (child) => {
-		if (found) return false;
+	walkAst(body, (child) => {
+		if (found) return;
 		if (isNodeOfType(child, "CallExpression")) {
 			const callee = child.callee;
 			if (isNodeOfType(callee, "Identifier") && ASYNC_DATA_CALLEE_NAMES.has(callee.name)) {
 				found = true;
-				return false;
-			}
-			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-				if (ASYNC_DATA_CALLEE_NAMES.has(callee.property.name)) {
-					found = true;
-					return false;
-				}
-				if (setterName !== null && PROMISE_CHAIN_METHOD_NAMES.has(callee.property.name)) for (const argument of child.arguments ?? []) {
-					if (!isFunctionLike$1(argument)) continue;
-					if (callsIdentifier(argument.body, setterName)) {
-						found = true;
-						return false;
-					}
-				}
+				return;
 			}
-			return;
-		}
-		if (setterName !== null && isFunctionLike$1(child)) {
-			const functionBody = child.body;
-			if ((Boolean(child.async) || hasOwnAwait(functionBody)) && callsIdentifier(functionBody, setterName)) {
+			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ASYNC_DATA_CALLEE_NAMES.has(callee.property.name)) {
 				found = true;
-				return false;
+				return;
 			}
 		}
 	});
@@ -32355,7 +32320,7 @@ const renderingUsetransitionLoading = defineRule({
 		const secondBinding = node.id.elements[1];
 		const setterName = isNodeOfType(secondBinding, "Identifier") ? secondBinding.name : null;
 		const fnBody = enclosingFunctionBody(node);
-		if (fnBody && hasAsyncLoadingWork(fnBody, setterName)) return;
+		if (fnBody && (setterName && setterIsCalledInAsyncContext(fnBody, setterName) || setterName && setterIsCalledInPromiseChain(fnBody, setterName) || referencesAsyncDataApi(fnBody))) return;
 		context.report({
 			node: node.init,
 			message: `This adds an extra render because useState for "${stateVariableName}" re-renders just for the loading flag, so if it's a state change & not a data fetch, use useTransition instead`
@@ -33149,17 +33114,17 @@ const rerenderStateOnlyInHandlers = defineRule({
 			const effectTriggerNames = /* @__PURE__ */ new Set();
 			for (const dependencyName of collectDependencyArrayNames(componentBody)) if (!(stateValueNames.has(dependencyName) && effectCallbackReadNames.has(dependencyName))) effectTriggerNames.add(dependencyName);
 			for (const reachableName of expandTransitiveDependencies(effectTriggerNames, dependencyGraph)) renderReachableNames.add(reachableName);
-			const setterNames = new Set(bindings.map((binding) => binding.setterName));
-			const calledSetterNames = /* @__PURE__ */ new Set();
-			walkAst(componentBody, (child) => {
-				if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && setterNames.has(child.callee.name)) calledSetterNames.add(child.callee.name);
-			});
 			for (const binding of bindings) {
 				if (renderReachableNames.has(binding.valueName)) continue;
 				if (binding.valueName === "_" || binding.valueName.startsWith("_")) continue;
 				const setterSuffix = binding.setterName.slice(3);
 				if (/^(TriggerRender|ForceUpdate|Rerender|ForceRender|Tick|Bump|BumpVersion|InvalidateRender|Refresh|Repaint)$/i.test(setterSuffix)) continue;
-				if (!calledSetterNames.has(binding.setterName)) continue;
+				let setterCalled = false;
+				walkAst(componentBody, (child) => {
+					if (setterCalled) return;
+					if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === binding.setterName) setterCalled = true;
+				});
+				if (!setterCalled) continue;
 				if (isSetterCalledDuringRender(componentBody, binding.setterName)) continue;
 				context.report({
 					node: binding.declarator,
@@ -40581,16 +40546,7 @@ const supabaseRlsPolicyRisk = defineRule({
 //#endregion
 //#region src/plugin/rules/security-scan/supabase-table-missing-rls.ts
 const CREATE_PUBLIC_TABLE_PATTERN = /create\s+(?:unlogged\s+)?table\s+(?:if\s+not\s+exists\s+)?(?!(?:auth|storage|realtime|vault|extensions|graphql|graphql_public|pgbouncer|net|supabase_functions|supabase_migrations|cron|pgsodium|pgmq|information_schema|pg_catalog|pg_temp|private|internal)\s*\.)(?:public\s*\.\s*)?["`]?([A-Za-z_][\w$]*)["`]?(?:\s*\(|\s+as\b)/gi;
-const ENABLE_RLS_PATTERN = /alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?(?:public\s*\.\s*)?["`]?([A-Za-z_][\w$]*)["`]?\s+(?:force\s+)?enable\s+row\s+level\s+security/gi;
-const collectLastEnableRlsIndexByTable = (content) => {
-	const lastEnableIndexByTable = /* @__PURE__ */ new Map();
-	for (const match of content.matchAll(ENABLE_RLS_PATTERN)) {
-		const tableName = match[1];
-		if (tableName === void 0) continue;
-		lastEnableIndexByTable.set(tableName.toLowerCase(), match.index);
-	}
-	return lastEnableIndexByTable;
-};
+const enableRlsForTablePattern = (tableName) => new RegExp(`alter\\s+table\\s+(?:if\\s+exists\\s+)?(?:only\\s+)?(?:public\\s*\\.\\s*)?["\`]?${escapeRegExp(tableName)}["\`]?\\s+(?:force\\s+)?enable\\s+row\\s+level\\s+security`, "i");
 const supabaseTableMissingRls = defineRule({
 	id: "supabase-table-missing-rls",
 	title: "Supabase table created without Row Level Security",
@@ -40601,13 +40557,11 @@ const supabaseTableMissingRls = defineRule({
 		const content = sanitizeSqlForScan(file.content);
 		if (!/create\s+(?:unlogged\s+)?table/i.test(content)) return [];
 		const findings = [];
-		const lastEnableIndexByTable = collectLastEnableRlsIndexByTable(content);
 		CREATE_PUBLIC_TABLE_PATTERN.lastIndex = 0;
 		for (let match = CREATE_PUBLIC_TABLE_PATTERN.exec(content); match !== null; match = CREATE_PUBLIC_TABLE_PATTERN.exec(content)) {
 			const tableName = match[1];
 			if (tableName === void 0) continue;
-			const lastEnableIndex = lastEnableIndexByTable.get(tableName.toLowerCase());
-			if (lastEnableIndex !== void 0 && lastEnableIndex >= match.index) continue;
+			if (enableRlsForTablePattern(tableName).test(content.slice(match.index))) continue;
 			const location = getLocationAtIndex(content, match.index);
 			findings.push({
 				message: "Supabase migration creates a public table but never enables Row Level Security, leaving every row exposed to the anon key.",
@@ -41631,14 +41585,7 @@ const getStaticPropertyName = (member) => {
 	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;
-	const importInfo = computeImportInfoForIdentifier(identifier);
-	importInfoCache.set(identifier, importInfo);
-	return importInfo;
-};
-const computeImportInfoForIdentifier = (identifier) => {
 	const specifier = findVariableInitializer(identifier, identifier.name)?.initializer;
 	if (!specifier) return null;
 	const declaration = specifier.parent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.6.2-dev.d8628d7",
+  "version": "0.6.2-dev.fa61c20",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",