@kubb/plugin-react-query 5.0.0-beta.56 → 5.0.0-beta.64

package/dist/{components-yMQOuFmI.cjs → components-B0j2b6y8.cjs}

@@ -25,10 +25,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let _kubb_core = require("@kubb/core");
+let _kubb_ast_utils = require("@kubb/ast/utils");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
 let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
 let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
-let _kubb_ast_utils = require("@kubb/ast/utils");
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -303,7 +303,7 @@ function buildOperationComments(node, options = {}) {
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
 function getOperationParameters(node, options = {}) {
-	const params = _kubb_core.ast.caseParams(node.parameters, options.paramsCasing);
+	const params = (0, _kubb_ast_utils.caseParams)(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -385,7 +385,7 @@ const mutationKeyTransformer = ({ node }) => {
 	return [`{ url: '${Url.toPath(node.path)}' }`];
 };
 function MutationKey({ name, paramsCasing, node, transformer }) {
-	const paramsNode = _kubb_core.ast.createFunctionParameters({ params: [] });
+	const paramsNode = _kubb_core.ast.factory.createFunctionParameters({ params: [] });
 	const paramsSignature = declarationPrinter$10.print(paramsNode) ?? "";
 	const keys = (transformer ?? mutationKeyTransformer)({
 		node,
@@ -407,6 +407,14 @@ function MutationKey({ name, paramsCasing, node, transformer }) {
 //#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
 /**
+* Returns the `TypeLiteral` members of a destructured group parameter, or `null`
+* for a plain named parameter.
+*/
+function groupMembers(param) {
+	if (typeof param.name === "string") return null;
+	return param.type && typeof param.type !== "string" && param.type.kind === "TypeLiteral" ? param.type.members : [];
+}
+/**
 * Builds the shared `(…params, config = {})` parameter list for a TanStack
 * query-options function. The trailing `config` parameter is typed as a partial
 * `RequestConfig` with an optional `client`. Framework plugins wrap the result
@@ -415,17 +423,14 @@ function MutationKey({ name, paramsCasing, node, transformer }) {
 function buildQueryOptionsParams(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
-	return _kubb_core.ast.createOperationParams(node, {
+	return (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver,
-		extraParams: [_kubb_core.ast.createFunctionParameter({
+		extraParams: [_kubb_core.ast.factory.createFunctionParameter({
 			name: "config",
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
-			}),
+			type: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
 			default: "{}"
 		})]
 	});
@@ -498,107 +503,52 @@ function resolveZodSchemaNames(node, zodResolver, parser) {
 	].filter((n) => Boolean(n));
 }
 /**
-* Resolve the type for a single path parameter.
-*
-* - When the resolver's group name differs from the individual param name
-*   (e.g. kubbV4) → `GroupName['paramName']` (member access).
-* - When they match (v5 default) → `TypeName` (direct reference).
-*/
-function resolvePathParamType(node, param, resolver) {
-	const individualName = resolver.resolveParamName(node, param);
-	const groupName = resolver.resolvePathParamsName(node, param);
-	if (groupName !== individualName) return _kubb_core.ast.createParamsType({
-		variant: "member",
-		base: groupName,
-		key: param.name
-	});
-	return _kubb_core.ast.createParamsType({
-		variant: "reference",
-		name: individualName
-	});
-}
-/**
-* Derive a query-params group type from the resolver.
-* Returns `null` when no query params exist or when the group name
-* equals the individual param name (no real group).
-*/
-function resolveQueryGroupType(node, params, resolver) {
-	if (!params.length) return null;
-	const firstParam = params[0];
-	const groupName = resolver.resolveQueryParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* Build a single `FunctionParameterNode` for a query or header group.
-*/
-function buildGroupParam(name, node, params, groupType, resolver) {
-	if (groupType) return [_kubb_core.ast.createFunctionParameter({
-		name,
-		type: groupType.type,
-		optional: groupType.optional
-	})];
-	if (params.length) {
-		const structProps = params.map((p) => ({
-			name: p.name,
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: resolver.resolveParamName(node, p)
-			}),
-			optional: !p.required
-		}));
-		return [_kubb_core.ast.createFunctionParameter({
-			name,
-			type: _kubb_core.ast.createParamsType({
-				variant: "struct",
-				properties: structProps
-			}),
-			optional: params.every((p) => !p.required)
-		})];
-	}
-	return [];
-}
-/**
 * Build QueryKey params: pathParams + data + queryParams (NO headers, NO config).
 */
 function buildQueryKeyParams(node, options) {
 	const { pathParamsType, paramsCasing, resolver } = options;
-	const casedParams = _kubb_core.ast.caseParams(node.parameters, paramsCasing);
+	const casedParams = (0, _kubb_ast_utils.caseParams)(node.parameters, paramsCasing);
 	const pathParams = casedParams.filter((p) => p.in === "path");
 	const queryParams = casedParams.filter((p) => p.in === "query");
-	const queryGroupType = resolveQueryGroupType(node, queryParams, resolver);
-	const bodyType = node.requestBody?.content?.[0]?.schema ? _kubb_core.ast.createParamsType({
-		variant: "reference",
-		name: resolver.resolveDataName(node)
-	}) : null;
+	const queryGroupType = (0, _kubb_ast_utils.resolveGroupType)({
+		node,
+		params: queryParams,
+		group: "query",
+		resolver
+	});
+	const bodyType = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
 	const bodyRequired = node.requestBody?.required ?? false;
 	const params = [];
 	if (pathParams.length) {
-		const pathChildren = pathParams.map((p) => _kubb_core.ast.createFunctionParameter({
+		const pathChildren = pathParams.map((p) => ({
 			name: p.name,
-			type: resolvePathParamType(node, p, resolver),
+			type: (0, _kubb_ast_utils.resolveParamType)({
+				node,
+				param: p,
+				resolver
+			}),
 			optional: !p.required
 		}));
-		params.push({
-			kind: "ParameterGroup",
+		if (pathParamsType === "object") params.push(_kubb_core.ast.factory.createFunctionParameter({
 			properties: pathChildren,
-			inline: pathParamsType === "inline",
 			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
-		});
+		}));
+		else params.push(...pathChildren.map((child) => _kubb_core.ast.factory.createFunctionParameter(child)));
 	}
-	if (bodyType) params.push(_kubb_core.ast.createFunctionParameter({
+	if (bodyType) params.push(_kubb_core.ast.factory.createFunctionParameter({
 		name: "data",
 		type: bodyType,
 		optional: !bodyRequired
 	}));
-	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
-	return _kubb_core.ast.createFunctionParameters({ params });
+	params.push(...(0, _kubb_ast_utils.buildGroupParam)({
+		name: "params",
+		node,
+		params: queryParams,
+		groupType: queryGroupType,
+		resolver,
+		wrapType: (type) => type
+	}));
+	return _kubb_core.ast.factory.createFunctionParameters({ params });
 }
 /**
 * Collect the names of the required params (no default) that drive the `enabled`
@@ -607,12 +557,11 @@ function buildQueryKeyParams(node, options) {
 */
 function getEnabledParamNames(paramsNode) {
 	const required = [];
-	for (const param of paramsNode.params) if ("kind" in param && param.kind === "ParameterGroup") {
-		const group = param;
-		for (const child of group.properties) if (!child.optional && child.default === void 0) required.push(child.name);
-	} else {
-		const fp = param;
-		if (!fp.optional && fp.default === void 0) required.push(fp.name);
+	for (const param of paramsNode.params) {
+		const members = groupMembers(param);
+		if (members) {
+			for (const member of members) if (!member.optional) required.push(member.name);
+		} else if (typeof param.name === "string" && !param.optional && param.default === void 0) required.push(param.name);
 	}
 	return required;
 }
@@ -628,27 +577,25 @@ function markParamsOptional(paramsNode, names) {
 	if (names.length === 0) return paramsNode;
 	const nameSet = new Set(names);
 	const params = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
+		const members = groupMembers(param);
+		if (members) {
+			const next = members.map((member) => nameSet.has(member.name) ? {
+				...member,
+				optional: true
+			} : member);
 			return {
-				...group,
-				properties: group.properties.map((child) => nameSet.has(child.name) ? _kubb_core.ast.createFunctionParameter({
-					name: child.name,
-					type: child.type,
-					rest: child.rest,
-					optional: true
-				}) : child)
+				...param,
+				type: _kubb_core.ast.factory.createTypeLiteral({ members: next })
 			};
 		}
-		const fp = param;
-		return nameSet.has(fp.name) ? _kubb_core.ast.createFunctionParameter({
-			name: fp.name,
-			type: fp.type,
-			rest: fp.rest,
+		return typeof param.name === "string" && nameSet.has(param.name) ? _kubb_core.ast.factory.createFunctionParameter({
+			name: param.name,
+			type: param.type,
+			rest: param.rest,
 			optional: true
-		}) : fp;
+		}) : param;
 	});
-	return _kubb_core.ast.createFunctionParameters({ params });
+	return _kubb_core.ast.factory.createFunctionParameters({ params });
 }
 /**
 * Add a non-null assertion (`!`) to the named params inside a printed client-call
@@ -776,18 +723,15 @@ const callPrinter$7 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
 function buildInfiniteQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const optionsParam = _kubb_core.ast.createFunctionParameter({
+	const optionsParam = _kubb_core.ast.factory.createFunctionParameter({
 		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return _kubb_core.ast.createOperationParams(node, {
+	return (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -976,14 +920,11 @@ return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${que
 //#region src/components/MutationOptions.tsx
 const declarationPrinter$5 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$5 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-const keysPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "keys" });
+const keysPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
 function buildMutationConfigParamsNode(node, resolver) {
-	return _kubb_core.ast.createFunctionParameters({ params: [_kubb_core.ast.createFunctionParameter({
+	return _kubb_core.ast.factory.createFunctionParameters({ params: [_kubb_core.ast.factory.createFunctionParameter({
 		name: "config",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: buildRequestConfigType(node, resolver)
-		}),
+		type: buildRequestConfigType(node, resolver),
 		default: "{}"
 	})] });
 }
@@ -995,7 +936,7 @@ function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, p
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const configParamsNode = buildMutationConfigParamsNode(node, tsResolver);
 	const paramsSignature = declarationPrinter$5.print(configParamsNode) ?? "";
-	const mutationArgParamsNode = _kubb_core.ast.createOperationParams(node, {
+	const mutationArgParamsNode = (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing,
@@ -1004,17 +945,14 @@ function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, p
 	const hasMutationParams = mutationArgParamsNode.params.length > 0;
 	const TRequest = hasMutationParams ? declarationPrinter$5.print(mutationArgParamsNode) ?? "" : "";
 	const argKeysStr = hasMutationParams ? keysPrinter.print(mutationArgParamsNode) ?? "" : "";
-	const clientCallParamsNode = _kubb_core.ast.createOperationParams(node, {
+	const clientCallParamsNode = (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver: tsResolver,
-		extraParams: [_kubb_core.ast.createFunctionParameter({
+		extraParams: [_kubb_core.ast.factory.createFunctionParameter({
 			name: "config",
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: buildRequestConfigType(node, tsResolver)
-			}),
+			type: buildRequestConfigType(node, tsResolver),
 			default: "{}"
 		})]
 	});
@@ -1045,7 +983,7 @@ function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, p
 const declarationPrinter$4 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$4 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
 function createMutationArgParams(node, options) {
-	return _kubb_core.ast.createOperationParams(node, {
+	return (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing: options.paramsCasing,
@@ -1070,15 +1008,12 @@ function buildMutationParamsNode(node, options) {
 		TRequest ? `{${TRequest}}` : "undefined",
 		"TContext"
 	].join(", ");
-	return _kubb_core.ast.createFunctionParameters({ params: [_kubb_core.ast.createFunctionParameter({
+	return _kubb_core.ast.factory.createFunctionParameters({ params: [_kubb_core.ast.factory.createFunctionParameter({
 		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   mutation?: UseMutationOptions<${generics}> & { client?: QueryClient },
   client?: ${buildRequestConfigType(node, resolver)},
-}`
-		}),
+}`,
 		default: "{}"
 	})] });
 }
@@ -1146,24 +1081,21 @@ function buildQueryParamsNode(node, options) {
 	const errorNames = resolveErrorNames(node, resolver);
 	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = _kubb_core.ast.createFunctionParameter({
+	const optionsParam = _kubb_core.ast.factory.createFunctionParameter({
 		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<QueryObserverOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
+			TData,
+			TError,
+			"TData",
+			"TQueryData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return _kubb_core.ast.createOperationParams(node, {
+	return (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1240,18 +1172,15 @@ const callPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
 function buildSuspenseInfiniteQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const optionsParam = _kubb_core.ast.createFunctionParameter({
+	const optionsParam = _kubb_core.ast.factory.createFunctionParameter({
 		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return _kubb_core.ast.createOperationParams(node, {
+	return (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1445,23 +1374,20 @@ function buildSuspenseQueryParamsNode(node, options) {
 	const errorNames = resolveErrorNames(node, resolver);
 	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = _kubb_core.ast.createFunctionParameter({
+	const optionsParam = _kubb_core.ast.factory.createFunctionParameter({
 		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<UseSuspenseQueryOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
+			TData,
+			TError,
+			"TData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return _kubb_core.ast.createOperationParams(node, {
+	return (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1654,4 +1580,4 @@ Object.defineProperty(exports, "resolveZodSchemaNames", {
 	}
 });
 
-//# sourceMappingURL=components-yMQOuFmI.cjs.map
+//# sourceMappingURL=components-B0j2b6y8.cjs.map