oxlint-plugin-react-doctor 0.7.6-dev.e141d90 → 0.7.6-dev.eb09902

package/dist/index.js

@@ -6296,131 +6296,6 @@ const isGlobalMethodCall = (node, objectName, methodName) => {
 	return isNodeOfType(receiver, "Identifier") && receiver.name === objectName && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
 };
 //#endregion
-//#region src/plugin/utils/collect-safely-validated-local-storage-keys.ts
-const isLocalStorageCall = (node, methodName) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && receiver.name === "localStorage" && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
-};
-const catchReturnsFallback = (tryStatement) => {
-	const handler = tryStatement.handler;
-	if (!handler) return false;
-	let hasReturn = false;
-	let hasThrow = false;
-	walkAst(handler.body, (child) => {
-		if (isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "ReturnStatement")) hasReturn = true;
-		if (isNodeOfType(child, "ThrowStatement")) hasThrow = true;
-	});
-	return hasReturn && !hasThrow;
-};
-const resolveValidatorFunction = (callee, scopes) => {
-	const unwrappedCallee = stripParenExpression(callee);
-	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
-	const symbol = scopes.symbolFor(unwrappedCallee);
-	if (!symbol) return null;
-	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
-	return isFunctionLike$1(candidate) ? candidate : null;
-};
-const validatorChecksPayloadProperties = (validatorFunction, scopes) => {
-	if (!isFunctionLike$1(validatorFunction)) return false;
-	const firstParameter = validatorFunction.params?.[0];
-	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
-	const parameterSymbol = scopes.symbolFor(firstParameter);
-	if (!parameterSymbol) return false;
-	const payloadSymbolIds = new Set([parameterSymbol.id]);
-	let hasPropertyTypeCheck = false;
-	walkAst(validatorFunction.body, (child) => {
-		if (isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init) {
-			const initializer = stripParenExpression(child.init);
-			if (isNodeOfType(initializer, "Identifier")) {
-				const initializerSymbol = scopes.symbolFor(initializer);
-				if (initializerSymbol && payloadSymbolIds.has(initializerSymbol.id)) {
-					const aliasSymbol = scopes.symbolFor(child.id);
-					if (aliasSymbol) payloadSymbolIds.add(aliasSymbol.id);
-				}
-			}
-		}
-		if (!isNodeOfType(child, "UnaryExpression") || child.operator !== "typeof") return;
-		const checkedValue = stripParenExpression(child.argument);
-		if (!isNodeOfType(checkedValue, "MemberExpression")) return;
-		const receiver = stripParenExpression(checkedValue.object);
-		if (!isNodeOfType(receiver, "Identifier")) return;
-		const receiverSymbol = scopes.symbolFor(receiver);
-		if (receiverSymbol && payloadSymbolIds.has(receiverSymbol.id)) hasPropertyTypeCheck = true;
-	});
-	return hasPropertyTypeCheck;
-};
-const incrementCount = (counts, keyValue) => {
-	counts.set(keyValue, (counts.get(keyValue) ?? 0) + 1);
-};
-const isReturnedExpression = (expression) => {
-	const parent = expression.parent;
-	return Boolean(parent && isNodeOfType(parent, "ReturnStatement") && parent.argument === expression);
-};
-const collectSafelyValidatedLocalStorageKeys = ({ programNode, scopes, resolveKey }) => {
-	const readCountsByKey = /* @__PURE__ */ new Map();
-	const safeReadCountsByKey = /* @__PURE__ */ new Map();
-	const safeReadSymbolIds = /* @__PURE__ */ new Set();
-	walkAst(programNode, (child) => {
-		if (!isNodeOfType(child, "CallExpression") || !isLocalStorageCall(child, "getItem")) return;
-		const keyArgument = child.arguments?.[0];
-		if (!keyArgument) return;
-		const keyValue = resolveKey(keyArgument);
-		if (keyValue !== null) incrementCount(readCountsByKey, keyValue);
-	});
-	walkAst(programNode, (child) => {
-		if (!isNodeOfType(child, "TryStatement") || !catchReturnsFallback(child)) return;
-		const rawValueKeys = /* @__PURE__ */ new Map();
-		const parsedValueSources = /* @__PURE__ */ new Map();
-		walkAst(child.block, (tryChild) => {
-			if (isFunctionLike$1(tryChild)) return false;
-			if (isNodeOfType(tryChild, "VariableDeclarator") && isNodeOfType(tryChild.id, "Identifier") && tryChild.init) {
-				const initializer = stripParenExpression(tryChild.init);
-				if (isNodeOfType(initializer, "CallExpression") && isLocalStorageCall(initializer, "getItem")) {
-					const keyArgument = initializer.arguments?.[0];
-					const bindingSymbol = scopes.symbolFor(tryChild.id);
-					if (keyArgument && bindingSymbol) {
-						const keyValue = resolveKey(keyArgument);
-						if (keyValue !== null) rawValueKeys.set(bindingSymbol.id, keyValue);
-					}
-				}
-				if (isNodeOfType(initializer, "CallExpression") && isGlobalMethodCall(initializer, "JSON", "parse")) {
-					const rawValueArgument = initializer.arguments?.[0];
-					const parsedValueSymbol = scopes.symbolFor(tryChild.id);
-					if (rawValueArgument && isNodeOfType(rawValueArgument, "Identifier") && parsedValueSymbol) {
-						const rawValueSymbol = scopes.symbolFor(rawValueArgument);
-						if (rawValueSymbol && rawValueKeys.has(rawValueSymbol.id)) parsedValueSources.set(parsedValueSymbol.id, rawValueSymbol.id);
-					}
-				}
-			}
-			if (!isNodeOfType(tryChild, "ConditionalExpression") || !isReturnedExpression(tryChild)) return;
-			const test = stripParenExpression(tryChild.test);
-			if (!isNodeOfType(test, "CallExpression")) return;
-			const testedValue = test.arguments?.[0];
-			if (!testedValue || !isNodeOfType(testedValue, "Identifier")) return;
-			const parsedValueSymbol = scopes.symbolFor(testedValue);
-			if (!parsedValueSymbol) return;
-			const rawValueSymbolId = parsedValueSources.get(parsedValueSymbol.id);
-			if (rawValueSymbolId === void 0) return;
-			const returnedValue = stripParenExpression(tryChild.consequent);
-			if (!isNodeOfType(returnedValue, "Identifier") || scopes.symbolFor(returnedValue)?.id !== parsedValueSymbol.id) return;
-			const validatorFunction = resolveValidatorFunction(test.callee, scopes);
-			if (!validatorFunction || !validatorChecksPayloadProperties(validatorFunction, scopes)) return;
-			const keyValue = rawValueKeys.get(rawValueSymbolId);
-			if (keyValue === void 0 || safeReadSymbolIds.has(rawValueSymbolId)) return;
-			safeReadSymbolIds.add(rawValueSymbolId);
-			incrementCount(safeReadCountsByKey, keyValue);
-		});
-	});
-	const safeKeys = /* @__PURE__ */ new Set();
-	for (const [keyValue, readCount] of readCountsByKey) if (safeReadCountsByKey.get(keyValue) === readCount) safeKeys.add(keyValue);
-	return safeKeys;
-};
-//#endregion
 //#region src/plugin/rules/client/client-localstorage-no-version.ts
 const VERSIONED_KEY_PATTERN = /(?:[._:-]v\d+|@\d+|\bv\d+\b)/i;
 const CAMEL_CASE_VERSIONED_KEY_PATTERN = /[a-z]V\d+/;
@@ -6442,39 +6317,26 @@ const clientLocalstorageNoVersion = defineRule({
 	severity: "warn",
 	category: "Correctness",
 	recommendation: "Put a version in the storage key (e.g. \"myKey:v1\"). If you change the data shape later, old saved data can be ignored instead of crashing the app.",
-	create: (context) => {
-		let safelyValidatedStorageKeys = /* @__PURE__ */ new Set();
-		return {
-			Program(node) {
-				safelyValidatedStorageKeys = collectSafelyValidatedLocalStorageKeys({
-					programNode: node,
-					scopes: context.scopes,
-					resolveKey: (keyNode) => resolveStringKey(keyNode, context)
-				});
-			},
-			CallExpression(node) {
-				if (!isNodeOfType(node.callee, "MemberExpression")) return;
-				const receiver = stripParenExpression(node.callee.object);
-				if (!isNodeOfType(receiver, "Identifier")) return;
-				if (receiver.name !== "localStorage") return;
-				if (!isNodeOfType(node.callee.property, "Identifier")) return;
-				if (node.callee.property.name !== "setItem") return;
-				const keyArg = node.arguments?.[0];
-				if (!keyArg) return;
-				const keyValue = resolveStringKey(keyArg, context);
-				if (keyValue === null) return;
-				if (isVersionedKey(keyValue)) return;
-				if (safelyValidatedStorageKeys.has(keyValue)) return;
-				const valueArg = node.arguments?.[1];
-				if (!valueArg) return;
-				if (!isJsonStringifyCall(valueArg)) return;
-				context.report({
-					node: keyArg,
-					message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
-				});
-			}
-		};
-	}
+	create: (context) => ({ CallExpression(node) {
+		if (!isNodeOfType(node.callee, "MemberExpression")) return;
+		const receiver = stripParenExpression(node.callee.object);
+		if (!isNodeOfType(receiver, "Identifier")) return;
+		if (receiver.name !== "localStorage") return;
+		if (!isNodeOfType(node.callee.property, "Identifier")) return;
+		if (node.callee.property.name !== "setItem") return;
+		const keyArg = node.arguments?.[0];
+		if (!keyArg) return;
+		const keyValue = resolveStringKey(keyArg, context);
+		if (keyValue === null) return;
+		if (isVersionedKey(keyValue)) return;
+		const valueArg = node.arguments?.[1];
+		if (!valueArg) return;
+		if (!isJsonStringifyCall(valueArg)) return;
+		context.report({
+			node: keyArg,
+			message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
+		});
+	} })
 });
 //#endregion
 //#region src/plugin/rules/client/client-passive-event-listeners.ts
@@ -20533,24 +20395,8 @@ const hasDirective = (programNode, directive) => {
 	return Boolean(programNode.body?.some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === directive));
 };
 //#endregion
-//#region src/plugin/utils/unwrap-object-integrity-expression.ts
-const OBJECT_INTEGRITY_METHOD_NAMES = new Set([
-	"freeze",
-	"seal",
-	"preventExtensions"
-]);
-const OBJECT_FREEZE_OR_SEAL_METHOD_NAMES = new Set(["freeze", "seal"]);
-const unwrapObjectIntegrityExpression = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
-	let expression = stripParenExpression(node);
-	while (isNodeOfType(expression, "CallExpression")) {
-		const callee = stripParenExpression(expression.callee);
-		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || callee.object.name !== "Object" || !scopes.isGlobalReference(callee.object) || !isNodeOfType(callee.property, "Identifier") || !methodNames.has(callee.property.name)) break;
-		const wrappedExpression = expression.arguments[0];
-		if (!wrappedExpression || isNodeOfType(wrappedExpression, "SpreadElement")) break;
-		expression = stripParenExpression(wrappedExpression);
-	}
-	return expression;
-};
+//#region src/plugin/utils/is-component-assignment.ts
+const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-async-client-component.ts
 const nextjsAsyncClientComponent = defineRule({
@@ -20576,10 +20422,10 @@ const nextjsAsyncClientComponent = defineRule({
 			},
 			VariableDeclarator(node) {
 				if (!fileHasUseClient) return;
+				if (!isComponentAssignment(node)) return;
+				if (!isInlineFunctionExpression(node.init)) return;
+				if (!node.init.async) return;
 				if (!isNodeOfType(node.id, "Identifier")) return;
-				if (!isUppercaseName(node.id.name) || !node.init) return;
-				const componentFunction = unwrapObjectIntegrityExpression(node.init, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES);
-				if (!isInlineFunctionExpression(componentFunction) || !componentFunction.async) return;
 				context.report({
 					node,
 					message: `Async client component "${node.id.name}" fails to render because client components can't be async.`
@@ -26315,9 +26161,6 @@ const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	return hasRenderOutput;
 };
 //#endregion
-//#region src/plugin/utils/is-component-assignment.ts
-const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
-//#endregion
 //#region src/plugin/utils/is-component-declaration.ts
 const isComponentDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration") && node.id !== null && Boolean(node.id?.name) && isUppercaseName(node.id.name);
 //#endregion
@@ -32367,12 +32210,11 @@ const isMemoCall = (node) => {
 };
 const isDefaultEquivalentComparator = (comparator) => isNodeOfType(comparator, "Identifier") && (comparator.name === "undefined" || comparator.name === "shallowEqual");
 const hasCustomComparator = (node) => isNodeOfType(node, "CallExpression") && (node.arguments?.length ?? 0) >= 2 && !isDefaultEquivalentComparator(node.arguments?.[1]);
-const isInlineReference = (node, scopes) => {
-	const referenceNode = unwrapObjectIntegrityExpression(node, scopes);
-	if (isNodeOfType(referenceNode, "ArrowFunctionExpression") || isNodeOfType(referenceNode, "FunctionExpression") || isNodeOfType(referenceNode, "CallExpression") && isNodeOfType(referenceNode.callee, "MemberExpression") && isNodeOfType(referenceNode.callee.property, "Identifier") && referenceNode.callee.property.name === "bind") return "functions";
-	if (isNodeOfType(referenceNode, "ObjectExpression")) return "objects";
-	if (isNodeOfType(referenceNode, "ArrayExpression")) return "Arrays";
-	if (isNodeOfType(referenceNode, "JSXElement") || isNodeOfType(referenceNode, "JSXFragment")) return "JSX";
+const isInlineReference = (node) => {
+	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "bind") return "functions";
+	if (isNodeOfType(node, "ObjectExpression")) return "objects";
+	if (isNodeOfType(node, "ArrayExpression")) return "Arrays";
+	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) return "JSX";
 	return null;
 };
 const noInlinePropOnMemoComponent = defineRule({
@@ -32402,7 +32244,7 @@ const noInlinePropOnMemoComponent = defineRule({
 				let elementName = null;
 				if (isNodeOfType(openingElement.name, "JSXIdentifier")) elementName = openingElement.name.name;
 				if (!elementName || !memoizedComponentNames.has(elementName)) return;
-				const propType = isInlineReference(node.value.expression, context.scopes);
+				const propType = isInlineReference(node.value.expression);
 				if (propType) context.report({
 					node: node.value.expression,
 					message: `This redraws ${elementName} on every render because the prop is ${propType} built right here, so memo() can't skip it. Move it to a stable value with useMemo, useCallback, or module scope`
@@ -43850,13 +43692,13 @@ const resolveTanstackQueryHookName = (callExpression) => {
 	}
 	return null;
 };
-const resolveHookNameFromInitializer = (initializer, scopes) => {
+const resolveHookNameFromInitializer = (initializer) => {
 	if (isNodeOfType(initializer, "CallExpression")) return resolveTanstackQueryHookName(initializer);
 	if (!isNodeOfType(initializer, "Identifier")) return null;
-	const resolvedSymbol = resolveConstIdentifierAlias(initializer, scopes);
-	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
-	if (!isNodeOfType(resolvedSymbol.initializer, "CallExpression")) return null;
-	return resolveTanstackQueryHookName(resolvedSymbol.initializer);
+	const binding = findVariableInitializer(initializer, initializer.name);
+	if (!binding?.initializer || !isConstDeclaredBinding(binding)) return null;
+	if (!isNodeOfType(binding.initializer, "CallExpression")) return null;
+	return resolveTanstackQueryHookName(binding.initializer);
 };
 const queryNoRestDestructuring = defineRule({
 	id: "query-no-rest-destructuring",
@@ -43869,7 +43711,7 @@ const queryNoRestDestructuring = defineRule({
 		if (!isNodeOfType(node.id, "ObjectPattern")) return;
 		if (!node.init) return;
 		if (!node.id.properties?.some((property) => isNodeOfType(property, "RestElement"))) return;
-		const hookName = resolveHookNameFromInitializer(node.init, context.scopes);
+		const hookName = resolveHookNameFromInitializer(node.init);
 		if (!hookName) return;
 		context.report({
 			node: node.id,
@@ -45224,7 +45066,7 @@ const DEFERRABLE_HOOK_NAMES = new Set([
 	"useParams",
 	"usePathname"
 ]);
-const findHookCallBindings = (componentBody, scopes) => {
+const findHookCallBindings = (componentBody) => {
 	const bindings = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return bindings;
 	for (const statement of componentBody.body ?? []) {
@@ -45235,10 +45077,8 @@ const findHookCallBindings = (componentBody, scopes) => {
 			const callee = declarator.init.callee;
 			if (!isNodeOfType(callee, "Identifier")) continue;
 			if (!DEFERRABLE_HOOK_NAMES.has(callee.name)) continue;
-			const valueSymbol = scopes.symbolFor(declarator.id);
-			if (!valueSymbol) continue;
 			bindings.push({
-				valueSymbol,
+				valueName: declarator.id.name,
 				hookName: callee.name,
 				declarator
 			});
@@ -45246,49 +45086,6 @@ const findHookCallBindings = (componentBody, scopes) => {
 	}
 	return bindings;
 };
-const collectExactAliasSymbols = (componentBody, sourceSymbol, scopes) => {
-	const symbols = [sourceSymbol];
-	const symbolIds = new Set([sourceSymbol.id]);
-	const aliasSourceIdentifiers = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(componentBody, "BlockStatement")) return {
-		symbols,
-		aliasSourceIdentifiers
-	};
-	let didFindAlias = true;
-	while (didFindAlias) {
-		didFindAlias = false;
-		for (const statement of componentBody.body ?? []) {
-			if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "const") continue;
-			for (const declarator of statement.declarations ?? []) {
-				let aliasIdentifier = null;
-				let sourceIdentifier = null;
-				const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
-				const arrayBinding = isNodeOfType(declarator.id, "ArrayPattern") ? declarator.id.elements[0] : null;
-				const arrayValueNode = isNodeOfType(initializer, "ArrayExpression") ? initializer.elements[0] : null;
-				const arrayValue = arrayValueNode && !isNodeOfType(arrayValueNode, "SpreadElement") ? stripParenExpression(arrayValueNode) : null;
-				if (isNodeOfType(declarator.id, "Identifier") && isNodeOfType(initializer, "Identifier")) {
-					aliasIdentifier = declarator.id;
-					sourceIdentifier = initializer;
-				} else if (isNodeOfType(declarator.id, "ArrayPattern") && declarator.id.elements.length === 1 && isNodeOfType(arrayBinding, "Identifier") && isNodeOfType(initializer, "ArrayExpression") && initializer.elements.length === 1 && isNodeOfType(arrayValue, "Identifier")) {
-					aliasIdentifier = arrayBinding;
-					sourceIdentifier = arrayValue;
-				}
-				if (!aliasIdentifier || !sourceIdentifier) continue;
-				const referencedSymbol = scopes.symbolFor(sourceIdentifier);
-				const aliasSymbol = scopes.symbolFor(aliasIdentifier);
-				if (!referencedSymbol || !symbolIds.has(referencedSymbol.id) || !aliasSymbol || aliasSymbol.kind !== "const" || symbolIds.has(aliasSymbol.id)) continue;
-				symbolIds.add(aliasSymbol.id);
-				symbols.push(aliasSymbol);
-				aliasSourceIdentifiers.add(sourceIdentifier);
-				didFindAlias = true;
-			}
-		}
-	}
-	return {
-		symbols,
-		aliasSourceIdentifiers
-	};
-};
 const rerenderDeferReadsHook = defineRule({
 	id: "rerender-defer-reads-hook",
 	title: "URL hook value only read in handlers",
@@ -45299,13 +45096,15 @@ const rerenderDeferReadsHook = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = findHookCallBindings(componentBody, context.scopes);
+			const bindings = findHookCallBindings(componentBody);
 			if (bindings.length === 0) return;
 			const handlerBindingNames = collectHandlerBindingNames(componentBody);
 			for (const binding of bindings) {
-				const { symbols, aliasSourceIdentifiers } = collectExactAliasSymbols(componentBody, binding.valueSymbol, context.scopes);
 				const referenceLocations = [];
-				for (const symbol of symbols) for (const reference of symbol.references) if (!aliasSourceIdentifiers.has(reference.identifier)) referenceLocations.push(reference.identifier);
+				walkAst(componentBody, (child) => {
+					if (isNodeOfType(binding.declarator, "VariableDeclarator") && child === binding.declarator.id) return;
+					if (isNodeOfType(child, "Identifier") && child.name === binding.valueName) referenceLocations.push(child);
+				});
 				if (referenceLocations.length === 0) continue;
 				if (!referenceLocations.every((ref) => isInsideEventHandler(ref, handlerBindingNames))) continue;
 				context.report({
@@ -53254,8 +53053,7 @@ const serverCacheWithObjectLiteral = defineRule({
 				if (!isNodeOfType(node.callee, "Identifier")) return;
 				if (!cachedFunctionNames.has(node.callee.name)) return;
 				const firstArg = node.arguments?.[0];
-				if (!firstArg || isNodeOfType(firstArg, "SpreadElement")) return;
-				if (!isNodeOfType(unwrapObjectIntegrityExpression(firstArg, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES), "ObjectExpression")) return;
+				if (!isNodeOfType(firstArg, "ObjectExpression")) return;
 				context.report({
 					node,
 					message: `Passing a new object to React.cache() each render misses the cache, so it refetches every request.`

package/package.json

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