oxlint-plugin-react-doctor 0.9.2-dev.1f6e181 → 0.9.2-dev.2992a03

package/dist/index.js

@@ -56090,6 +56090,9 @@ const isInitialOnlyPropName = (propName) => {
 	return /^initial[A-Z]/.test(propName) || /^default[A-Z]/.test(propName) || /^seed[A-Z]/.test(propName) || /^starting[A-Z]/.test(propName) || /^baseline[A-Z]/.test(propName) || /^preset[A-Z]/.test(propName);
 };
 //#endregion
+//#region src/plugin/utils/nextjs-page-data-export-names.ts
+const NEXTJS_PAGE_DATA_EXPORT_NAMES = new Set(["getServerSideProps", "getStaticProps"]);
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-derived-use-state.ts
 const isInitialOnlySeedName = (propName) => isInitialOnlyPropName(propName) || propName === "initial" || propName === "autoFocus" || propName === "autoPlay" || propName === "startOpen" || /^initially[A-Z]/.test(propName) || /Initial([A-Z]|$)/.test(propName);
 const SNAPSHOT_STATE_NAME_PATTERN = /^(initial|previous|prev|preserved|saved|original|cached|snapshot|prior|debounced|deferred)([A-Z_]|$)/;
@@ -56246,7 +56249,6 @@ const isDraftCommittedToParent = (componentFunction, stateValueName, isPropName)
 	});
 	return isCommitted;
 };
-const NEXTJS_PAGE_DATA_EXPORT_NAMES = new Set(["getServerSideProps", "getStaticProps"]);
 const isNextjsDataFetchingPage = (node) => {
 	const program = findProgramRoot(node);
 	if (!program) return false;
@@ -67191,6 +67193,124 @@ const isInsideSnapshotHelper = (node) => {
 	}
 	return false;
 };
+const findEnclosingNextjsPageDataFunction = (node) => {
+	let outermostFunction = null;
+	let cursor = node.parent;
+	while (cursor) {
+		if (isFunctionLike$1(cursor)) outermostFunction = cursor;
+		if (isNodeOfType(cursor, "Program")) {
+			if (!outermostFunction) return null;
+			for (const exportName of NEXTJS_PAGE_DATA_EXPORT_NAMES) {
+				const exportedValue = findExportedValue(cursor, exportName);
+				if (exportedValue && isAstDescendant(outermostFunction, exportedValue)) return outermostFunction;
+			}
+			return null;
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+const findConditionalReturnExpressionRoot = (node) => {
+	let expressionRoot = findTransparentExpressionRoot(node);
+	while (expressionRoot.parent && isNodeOfType(expressionRoot.parent, "ConditionalExpression") && (expressionRoot.parent.consequent === expressionRoot || expressionRoot.parent.alternate === expressionRoot)) expressionRoot = findTransparentExpressionRoot(expressionRoot.parent);
+	return expressionRoot;
+};
+const isReturnedPageDataResultBinding = (returnExpression, pageDataFunction, context) => {
+	const declarator = returnExpression.parent;
+	if (!isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== returnExpression || !isNodeOfType(declarator.id, "Identifier") || findEnclosingFunction$1(declarator) !== pageDataFunction) return false;
+	const bindingSymbol = context.scopes.symbolFor(declarator.id);
+	if (!bindingSymbol || bindingSymbol.references.length !== 1) return false;
+	const referenceRoot = findTransparentExpressionRoot(bindingSymbol.references[0].identifier);
+	const returnStatement = referenceRoot.parent;
+	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument === referenceRoot && findEnclosingFunction$1(returnStatement) === pageDataFunction;
+};
+const isSameShorthandPropertyValue = (node, property) => property.shorthand && (node === property.key || node === property.value);
+const isValueForwardedThroughLiteralStructure = (node, structure) => {
+	const strippedNode = stripParenExpression(node);
+	const strippedStructure = stripParenExpression(structure);
+	if (strippedNode === strippedStructure) return true;
+	if (isNodeOfType(strippedStructure, "ConditionalExpression")) return isValueForwardedThroughLiteralStructure(strippedNode, strippedStructure.consequent) || isValueForwardedThroughLiteralStructure(strippedNode, strippedStructure.alternate);
+	if (isNodeOfType(strippedStructure, "ArrayExpression")) return strippedStructure.elements.some((element) => element && !isNodeOfType(element, "SpreadElement") && isValueForwardedThroughLiteralStructure(strippedNode, element));
+	if (!isNodeOfType(strippedStructure, "ObjectExpression")) return false;
+	return strippedStructure.properties.some((property) => {
+		if (isNodeOfType(property, "SpreadElement")) return isValueForwardedThroughLiteralStructure(strippedNode, property.argument);
+		if (!isNodeOfType(property, "Property")) return false;
+		if (isValueForwardedThroughLiteralStructure(strippedNode, property.value)) return true;
+		return isSameShorthandPropertyValue(strippedNode, property);
+	});
+};
+const isValueForwardedToPropertyValue = (node, property) => {
+	const directValue = findConditionalReturnExpressionRoot(node);
+	if (isValueForwardedThroughLiteralStructure(directValue, property.value)) return true;
+	return isSameShorthandPropertyValue(directValue, property);
+};
+const isInsideReturnedNextjsProps = (node, pageDataFunction, context) => {
+	let cursor = node.parent;
+	while (cursor && cursor !== pageDataFunction) {
+		if (isNodeOfType(cursor, "Property") && getStaticPropertyKeyName(cursor, { allowComputedString: true }) === "props" && isValueForwardedToPropertyValue(node, cursor)) {
+			const propertyContainer = cursor.parent;
+			if (!propertyContainer) return false;
+			const returnExpression = findConditionalReturnExpressionRoot(propertyContainer);
+			const returnStatement = returnExpression.parent;
+			if (isNodeOfType(returnStatement, "ReturnStatement") && findEnclosingFunction$1(returnStatement) === pageDataFunction) return true;
+			if (isNodeOfType(pageDataFunction, "ArrowFunctionExpression") && !isNodeOfType(pageDataFunction.body, "BlockStatement") && stripParenExpression(pageDataFunction.body) === stripParenExpression(returnExpression)) return true;
+			if (isReturnedPageDataResultBinding(returnExpression, pageDataFunction, context)) return true;
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return false;
+};
+const isExpressionReturnedByFunction = (node, functionNode) => {
+	const returnExpression = findConditionalReturnExpressionRoot(node);
+	if (isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode.body, "BlockStatement")) return stripParenExpression(functionNode.body) === stripParenExpression(returnExpression);
+	const returnStatement = returnExpression.parent;
+	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument === returnExpression && findEnclosingFunction$1(returnStatement) === functionNode;
+};
+const isValueForwardedToBindingInitializer = (node, bindingInitializer) => {
+	if (isValueForwardedThroughLiteralStructure(findConditionalReturnExpressionRoot(node), bindingInitializer)) return true;
+	const initializer = stripParenExpression(bindingInitializer);
+	if (!isNodeOfType(initializer, "CallExpression")) return false;
+	const callee = stripParenExpression(initializer.callee);
+	return isFunctionLike$1(callee) && isExpressionReturnedByFunction(node, callee);
+};
+const findPageDataResultBinding = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isNodeOfType(cursor, "VariableDeclarator")) {
+			if (cursor.init && isNodeOfType(cursor.id, "Identifier") && isValueForwardedToBindingInitializer(node, cursor.init)) return cursor.id;
+			return null;
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+const isUsedToSerializeNextjsPageProps = (node, context) => {
+	if (!isInProjectDirectory(context, "pages") || isInProjectDirectory(context, "pages/api")) return false;
+	const pageDataFunction = findEnclosingNextjsPageDataFunction(node);
+	if (!pageDataFunction) return false;
+	if (isInsideReturnedNextjsProps(node, pageDataFunction, context)) return true;
+	const bindingIdentifier = findPageDataResultBinding(node);
+	const bindingSymbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
+	if (!bindingSymbol) return false;
+	const aliasSymbols = collectConstAliasSymbols(bindingSymbol, context.scopes);
+	const aliasSymbolIds = new Set(aliasSymbols.map((aliasSymbol) => aliasSymbol.id));
+	let hasPagePropsReference = false;
+	for (const aliasSymbol of aliasSymbols) for (const reference of aliasSymbol.references) {
+		if (findEnclosingFunction$1(reference.identifier) !== pageDataFunction) return false;
+		if (isInsideReturnedNextjsProps(reference.identifier, pageDataFunction, context)) {
+			hasPagePropsReference = true;
+			continue;
+		}
+		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+		const declarator = referenceRoot.parent;
+		if (isNodeOfType(declarator, "VariableDeclarator") && declarator.init === referenceRoot && isNodeOfType(declarator.id, "Identifier")) {
+			const aliasSymbolForReference = context.scopes.symbolFor(declarator.id);
+			if (aliasSymbolForReference && aliasSymbolIds.has(aliasSymbolForReference.id)) continue;
+		}
+		return false;
+	}
+	return hasPagePropsReference;
+};
 const noJsonParseStringifyClone = defineRule({
 	id: "no-json-parse-stringify-clone",
 	title: "JSON parse/stringify deep clone",
@@ -67208,6 +67328,7 @@ const noJsonParseStringifyClone = defineRule({
 		if (isInsideSnapshotHelper(node)) return;
 		if (isAssignedToNormalizationBinding(node)) return;
 		if (isCatchParameterRoundTrip(firstArgument)) return;
+		if (isUsedToSerializeNextjsPageProps(node, context)) return;
 		context.report({
 			node,
 			message: MESSAGE$35

package/package.json

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