oxlint-plugin-react-doctor 0.7.2-dev.e872767 → 0.7.2-dev.f10f9ca

package/dist/index.js

@@ -8987,8 +8987,8 @@ const isAstDescendant = (inner, outer) => {
 * One cohesive concept: "given a captured symbol, is its value
 * structurally stable across re-renders (and therefore unnecessary
 * in a deps array)?". The rule reads `symbolHasStableValue` /
-* `symbolHasStableHookOrigin` / `symbolHasUseEffectEventOrigin` /
-* `isRecursiveInitializerCapture` at multiple sites — extracting
+* `symbolHasStableHookOrigin` / `isRecursiveInitializerCapture` at
+* multiple sites — extracting
 * them lets the rule body stay focused on the diff-the-captured-vs-
 * declared logic.
 *
@@ -9044,11 +9044,6 @@ const symbolHasStableHookOrigin = (symbol) => {
 	}
 	return false;
 };
-const symbolHasUseEffectEventOrigin = (symbol) => {
-	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	return getHookName(initializer.callee) === "useEffectEvent";
-};
 const getFunctionValueNode = (symbol) => {
 	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return symbol.declarationNode;
 	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
@@ -9134,6 +9129,37 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 };
 const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
 //#endregion
+//#region src/plugin/utils/is-imported-from-non-react-module.ts
+const isImportedFromNonReactModule = (contextNode, localIdentifierName) => {
+	const importSource = getImportSourceForName(contextNode, localIdentifierName);
+	if (importSource === null) return false;
+	return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
+};
+//#endregion
+//#region src/plugin/utils/is-non-react-effect-event-callee.ts
+const resolvesToLocalNonImportBinding = (identifier, scopes) => {
+	const symbol = scopes.referenceFor(identifier)?.resolvedSymbol;
+	return Boolean(symbol && symbol.kind !== "import");
+};
+const isNonReactEffectEventCallee = (callee, contextNode, scopes) => {
+	if (isNodeOfType(callee, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.name) || resolvesToLocalNonImportBinding(callee, scopes);
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.object.name);
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
+const getUseEffectEventCalleeName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
+	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
+	if (getUseEffectEventCalleeName(initializer.callee) !== "useEffectEvent") return false;
+	return !isNonReactEffectEventCallee(initializer.callee, initializer, scopes);
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps.ts
 const HOOKS_REQUIRING_DEPS_MATCH = new Set([
 	"useEffect",
@@ -9784,7 +9810,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (isLiteralOrEmptyTemplate(stripped)) continue;
 				if (isNodeOfType(stripped, "Identifier")) {
 					const depSymbol = context.scopes.symbolFor(stripped);
-					if (depSymbol && symbolHasUseEffectEventOrigin(depSymbol)) {
+					if (depSymbol && symbolHasReactUseEffectEventOrigin(depSymbol, context.scopes)) {
 						context.report({
 							node: elementNode,
 							message: buildEffectEventDepMessage()
@@ -25734,18 +25760,45 @@ const collectUseStateBindings = (componentBody) => {
 //#region src/plugin/rules/state-and-effects/no-direct-state-mutation.ts
 const PLAIN_DATA_PRODUCER_GLOBAL_NAMES = new Set(["Array", "structuredClone"]);
 const PLAIN_DATA_ARRAY_STATIC_METHODS = new Set(["from", "of"]);
+const PLAIN_DATA_JSON_STATIC_METHODS = new Set(["parse"]);
+const PLAIN_DATA_OBJECT_STATIC_METHODS = new Set([
+	"assign",
+	"entries",
+	"fromEntries",
+	"keys",
+	"values"
+]);
+const ARRAY_COPY_METHOD_NAMES = new Set([
+	"map",
+	"filter",
+	"slice",
+	"concat",
+	"flat",
+	"flatMap",
+	"toSorted",
+	"toReversed",
+	"toSpliced",
+	"with"
+]);
 const isNullOrUndefinedExpression = (expression) => isNodeOfType(expression, "Literal") && expression.value === null || isNodeOfType(expression, "Identifier") && expression.name === "undefined";
 const isPlainDataProducerCall = (expression) => {
 	if (!isNodeOfType(expression, "CallExpression")) return false;
 	const callee = expression.callee;
 	if (isNodeOfType(callee, "Identifier")) return PLAIN_DATA_PRODUCER_GLOBAL_NAMES.has(callee.name);
 	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier")) return false;
-	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array") return PLAIN_DATA_ARRAY_STATIC_METHODS.has(callee.property.name);
+	if (isNodeOfType(callee.object, "Identifier")) {
+		if (callee.object.name === "Array") return PLAIN_DATA_ARRAY_STATIC_METHODS.has(callee.property.name);
+		if (callee.object.name === "JSON") return PLAIN_DATA_JSON_STATIC_METHODS.has(callee.property.name);
+		if (callee.object.name === "Object") return PLAIN_DATA_OBJECT_STATIC_METHODS.has(callee.property.name);
+	}
 	return producesPlainStateValue(callee.object);
 };
+const PLAIN_DATA_CONSTRUCTOR_NAMES = new Set(["Array", "Object"]);
+const isPlainDataNewExpression = (expression) => isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && PLAIN_DATA_CONSTRUCTOR_NAMES.has(expression.callee.name);
 const producesPlainStateValue = (expression) => {
 	const unwrapped = stripParenExpression(expression);
 	if (isNodeOfType(unwrapped, "ObjectExpression") || isNodeOfType(unwrapped, "ArrayExpression")) return true;
+	if (isPlainDataNewExpression(unwrapped)) return true;
 	if (isNullOrUndefinedExpression(unwrapped)) return true;
 	if (isNodeOfType(unwrapped, "MemberExpression") && getRootIdentifierName(unwrapped) === "props") return true;
 	return isPlainDataProducerCall(unwrapped);
@@ -25760,6 +25813,38 @@ const initializerMarksPlainState = (initializerArgument) => {
 	}
 	return producesPlainStateValue(unwrapped);
 };
+const producesOpaqueInstanceValue = (expression) => {
+	if (isNodeOfType(expression, "NewExpression")) return !isPlainDataNewExpression(expression);
+	if (!isNodeOfType(expression, "CallExpression")) return false;
+	const callee = expression.callee;
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	if (isPlainDataProducerCall(expression)) return false;
+	if (!callee.computed && isNodeOfType(callee.property, "Identifier") && ARRAY_COPY_METHOD_NAMES.has(callee.property.name)) return false;
+	return true;
+};
+const collectSetterValueObservations = (componentBody, setterNames) => {
+	const plainFedSetterNames = /* @__PURE__ */ new Set();
+	const opaqueFedSetterNames = /* @__PURE__ */ new Set();
+	walkComponentRespectingShadows(componentBody, /* @__PURE__ */ new Set(), (node, currentlyShadowed) => {
+		if (!isNodeOfType(node, "CallExpression")) return;
+		if (!isNodeOfType(node.callee, "Identifier")) return;
+		const setterName = node.callee.name;
+		if (!setterNames.has(setterName) || currentlyShadowed.has(setterName)) return;
+		const argument = node.arguments?.[0];
+		if (!argument) return;
+		const unwrapped = stripParenExpression(argument);
+		if (isNullOrUndefinedExpression(unwrapped)) return;
+		if (producesPlainStateValue(unwrapped)) {
+			plainFedSetterNames.add(setterName);
+			return;
+		}
+		if (producesOpaqueInstanceValue(unwrapped)) opaqueFedSetterNames.add(setterName);
+	}, true);
+	return {
+		plainFedSetterNames,
+		opaqueFedSetterNames
+	};
+};
 const collectCallbackRefSetterNames = (componentBody) => {
 	const callbackRefSetterNames = /* @__PURE__ */ new Set();
 	walkAst(componentBody, (node) => {
@@ -25829,11 +25914,15 @@ const noDirectStateMutation = defineRule({
 			if (bindings.length === 0) return;
 			const stateValueToSetter = new Map(bindings.map((binding) => [binding.valueName, binding.setterName]));
 			const callbackRefSetterNames = collectCallbackRefSetterNames(componentBody);
+			const setterValueObservations = collectSetterValueObservations(componentBody, new Set(bindings.map((binding) => binding.setterName)));
 			const plainObjectStateValueNames = /* @__PURE__ */ new Set();
 			for (const binding of bindings) {
 				if (callbackRefSetterNames.has(binding.setterName)) continue;
 				if (!isNodeOfType(binding.declarator.init, "CallExpression")) continue;
-				if (initializerMarksPlainState(binding.declarator.init.arguments?.[0])) plainObjectStateValueNames.add(binding.valueName);
+				const initializerArgument = binding.declarator.init.arguments?.[0];
+				if (!initializerMarksPlainState(initializerArgument)) continue;
+				if ((!initializerArgument || isNullOrUndefinedExpression(stripParenExpression(initializerArgument))) && setterValueObservations.opaqueFedSetterNames.has(binding.setterName) && !setterValueObservations.plainFedSetterNames.has(binding.setterName)) continue;
+				plainObjectStateValueNames.add(binding.valueName);
 			}
 			const visitMutationCandidate = (child, currentlyShadowed) => {
 				if (isNodeOfType(child, "AssignmentExpression")) {
@@ -26614,13 +26703,6 @@ const noEffectEventHandler = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-imported-from-non-react-module.ts
-const isImportedFromNonReactModule = (contextNode, localIdentifierName) => {
-	const importSource = getImportSourceForName(contextNode, localIdentifierName);
-	if (importSource === null) return false;
-	return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-effect-event-in-deps.ts
 const createComponentBindingStackTracker = (callbacks) => {
 	const componentBindingStack = [];
@@ -26674,12 +26756,7 @@ const noEffectEventInDeps = defineRule({
 			const initializer = declaratorNode.init;
 			if (!initializer || !isNodeOfType(initializer, "CallExpression")) return;
 			if (!isHookCall$2(initializer, "useEffectEvent")) return;
-			if (isNodeOfType(initializer.callee, "Identifier")) {
-				if (isImportedFromNonReactModule(declaratorNode, initializer.callee.name)) return;
-				const calleeSymbol = context.scopes.referenceFor(initializer.callee)?.resolvedSymbol;
-				if (calleeSymbol && calleeSymbol.kind !== "import") return;
-			}
-			if (isNodeOfType(initializer.callee, "MemberExpression") && !initializer.callee.computed && isNodeOfType(initializer.callee.object, "Identifier") && isImportedFromNonReactModule(declaratorNode, initializer.callee.object.name)) return;
+			if (isNonReactEffectEventCallee(initializer.callee, declaratorNode, context.scopes)) return;
 			componentBindings.addBindingToCurrentFrame(declaratorNode.id.name);
 		} });
 		return {
@@ -37350,6 +37427,10 @@ const isRouteFactoryCall = (expression) => {
 	}
 	return false;
 };
+const isConfigOnlyFactoryCall = (call) => call.arguments.length > 0 && call.arguments.every((argument) => {
+	const expression = skipTsExpression(argument);
+	return isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "Literal") || isNodeOfType(expression, "TemplateLiteral");
+});
 const isReactHocName = (name, state) => state.customHocs.has(name);
 const isHocCallee = (callee, state) => {
 	if (isNodeOfType(callee, "Identifier")) return isReactHocName(callee.name, state);
@@ -37582,6 +37663,10 @@ const onlyExportComponents = defineRule({
 							return false;
 						})();
 						if (isHoc && firstArgIsValid) hasReactExport = true;
+						else if (!isHoc && isConfigOnlyFactoryCall(stripped)) exports.push({
+							kind: "non-component",
+							reportNode: stripped
+						});
 						else context.report({
 							node: stripped,
 							message: ANONYMOUS_MESSAGE
@@ -48549,25 +48634,6 @@ const isInsideLoop = (descendant, ancestor) => {
 	}
 	return false;
 };
-const isUseEffectEventSymbol = (symbol) => {
-	const initializer = symbol.initializer;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	return getHookNameFromCallee(initializer.callee) === "useEffectEvent";
-};
-const resolvesToLocalNonImportBinding = (identifier, scopes) => {
-	const symbol = scopes.referenceFor(identifier)?.resolvedSymbol;
-	return Boolean(symbol && symbol.kind !== "import");
-};
-const isNonReactEffectEventCallee = (callee, contextNode, scopes) => {
-	if (isNodeOfType(callee, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.name) || resolvesToLocalNonImportBinding(callee, scopes);
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.object.name);
-	return false;
-};
-const isNonReactEffectEventSymbol = (symbol, contextNode, scopes) => {
-	const initializer = symbol.initializer;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	return isNonReactEffectEventCallee(initializer.callee, contextNode, scopes);
-};
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
@@ -48757,8 +48823,7 @@ const rulesOfHooks = defineRule({
 			},
 			Identifier(node) {
 				const symbol = context.scopes.referenceFor(node)?.resolvedSymbol;
-				if (!symbol || !isUseEffectEventSymbol(symbol)) return;
-				if (isNonReactEffectEventSymbol(symbol, node, context.scopes)) return;
+				if (!symbol || !symbolHasReactUseEffectEventOrigin(symbol, context.scopes)) return;
 				if (!isSameComponentOrHookScope(symbol, node)) return;
 				if (isInsideAllowedEffectEventCallback(node, additionalEffectHooksRegex)) return;
 				context.report({
@@ -56983,6 +57048,7 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"nextjs-no-use-search-params-without-suspense",
 	"no-dynamic-import-path",
 	"no-full-lodash-import",
+	"no-locale-format-in-render",
 	"no-mutating-reducer-state",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
@@ -57117,6 +57183,7 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["nextjs-no-use-search-params-without-suspense", collectNextjsSearchParamsDependencies],
 	["no-dynamic-import-path", collectNearestManifestDependencies],
 	["no-full-lodash-import", collectNearestManifestDependencies],
+	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-mutating-reducer-state", collectMutatingReducerDependencies],
 	["prefer-dynamic-import", collectNearestManifestDependencies],
 	["rendering-hydration-mismatch-time", collectNearestManifestDependencies],

package/package.json

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