@kubb/plugin-react-query 5.8.0-canary.20261028T230157 → 5.8.0-canary.20261029T082933

package/dist/index.cjs

@@ -510,7 +510,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.8.0-canary.20261028T230157";
+var version = "5.8.0-canary.20261029T082933";
 // ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
@@ -551,32 +551,34 @@ function toZodTypeResolver(resolver) {
 * ```
 */
 function resolveOperationTypes(driver, pluginName) {
-	const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
-	const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
-	if (pluginTs && pluginZod?.options?.inferred !== "codec") {
-		const resolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+	return driver.memo(`operationTypes:${pluginName}`, () => {
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
+		if (pluginTs && pluginZod?.options?.inferred !== "codec") {
+			const resolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+			return {
+				response: resolver.response,
+				resolver,
+				output: pluginTs.options?.output,
+				group: pluginTs.options?.group ?? void 0
+			};
+		}
+		if (!pluginZod?.options?.inferred) throw new kubb_kit.Diagnostics.Error({
+			code: kubb_kit.Diagnostics.code.missingDependency,
+			severity: "error",
+			message: `Plugin "${pluginName}" has no source for operation types.`,
+			help: `Add \`pluginTs()\` before "${pluginName}", or add \`pluginZod({ inferred: true })\`.`,
+			location: { kind: "config" },
+			plugin: pluginName
+		});
+		const resolver = toZodTypeResolver(driver.getResolver(_kubb_plugin_zod.pluginZodName));
 		return {
 			response: resolver.response,
 			resolver,
-			output: pluginTs.options?.output,
-			group: pluginTs.options?.group ?? void 0
+			output: pluginZod.options.output,
+			group: pluginZod.options.group ?? void 0
 		};
-	}
-	if (!pluginZod?.options?.inferred) throw new kubb_kit.Diagnostics.Error({
-		code: kubb_kit.Diagnostics.code.missingDependency,
-		severity: "error",
-		message: `Plugin "${pluginName}" has no source for operation types.`,
-		help: `Add \`pluginTs()\` before "${pluginName}", or add \`pluginZod({ inferred: true })\`.`,
-		location: { kind: "config" },
-		plugin: pluginName
 	});
-	const resolver = toZodTypeResolver(driver.getResolver(_kubb_plugin_zod.pluginZodName));
-	return {
-		response: resolver.response,
-		resolver,
-		output: pluginZod.options.output,
-		group: pluginZod.options.group ?? void 0
-	};
 }
 // ../../internals/client/src/resolveClient.ts
 /**
@@ -977,13 +979,15 @@ function buildCallResultBody(call, options = {}) {
 * success responses into `TData` and wrapping the error responses in `ResponseErrorConfig<...>`.
 */
 function buildResponseTypes(node, resolver) {
-	const successNames = resolveSuccessNames(node, resolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
-	const errorNames = resolveErrorNames(node, resolver);
-	return {
-		TData: responseName,
-		TError: `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`
-	};
+	return resolver.memo(`responseTypes:${node.method}\0${node.path}`, () => {
+		const successNames = resolveSuccessNames(node, resolver);
+		const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
+		const errorNames = resolveErrorNames(node, resolver);
+		return {
+			TData: responseName,
+			TError: `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`
+		};
+	});
 }
 function resolveFallbackPageParamType(initialPageParam) {
 	if (typeof initialPageParam === "number") return "number";
@@ -1371,20 +1375,13 @@ function createQueryResolver(variant = "") {
 				key: operationKey(node, "query", variant, "keyTypeName"),
 				name
 			});
-		},
-		clientName(node) {
-			const name = `${this.name(node.operationId)}${variant}`;
-			return this.resolveName({
-				key: operationKey(node, "query", variant, "clientName"),
-				name
-			});
 		}
 	};
 }
 /**
 * Builds the shared mutation namespace. Spread the result into
 * `createResolver` and add plugin-specific methods (`optionsName`,
-* `typeName`, `argTypeName`) next to it.
+* `argTypeName`) next to it.
 *
 * @example
 * ```ts
@@ -1600,93 +1597,35 @@ const hookOptionsGenerator = (0, kubb_kit.defineGenerator)({
 			const nodeMutation = "mutation" in opOverrides ? opOverrides.mutation : mutation;
 			const nodeInfinite = "infinite" in opOverrides ? opOverrides.infinite : infinite;
 			const nodeInfiniteOptions = nodeInfinite && typeof nodeInfinite === "object" ? nodeInfinite : null;
-			const { isQuery: isQueryOp, isMutation: isMutationOp } = classifyOperation(node, {
-				query: nodeQuery === false ? query : nodeQuery,
+			const { isQuery, isMutation } = classifyOperation(node, {
+				query: nodeQuery,
 				mutation: nodeMutation
 			});
-			const isSuspenseOp = !!suspense;
-			const isInfiniteOp = !!nodeInfiniteOptions;
-			if (isQueryOp) {
-				const queryOptionsName = resolver.query.optionsName(node);
-				const queryHookName = resolver.query.name(node);
-				const queryHookFile = resolver.file({
-					...operationFileEntry(node, queryHookName),
-					root,
-					output,
-					group: group ?? void 0
-				});
-				imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
-					name: [queryOptionsName],
-					root: hookOptionsFile.path,
-					path: queryHookFile.path
-				}));
-				hookOptions[queryHookName] = `Partial<ReturnType<typeof ${queryOptionsName}>>`;
-				if (isSuspenseOp) {
-					const suspenseOptionsName = resolver.suspenseQuery.optionsName(node);
-					const suspenseHookName = resolver.suspenseQuery.name(node);
-					const suspenseHookFile = resolver.file({
-						...operationFileEntry(node, suspenseHookName),
-						root,
-						output,
-						group: group ?? void 0
-					});
-					imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
-						name: [suspenseOptionsName],
-						root: hookOptionsFile.path,
-						path: suspenseHookFile.path
-					}));
-					hookOptions[suspenseHookName] = `Partial<ReturnType<typeof ${suspenseOptionsName}>>`;
-				}
-				if (isInfiniteOp) {
-					if (matchesInfinite(node, nodeInfiniteOptions)) {
-						const infiniteOptionsName = resolver.infiniteQuery.optionsName(node);
-						const infiniteHookName = resolver.infiniteQuery.name(node);
-						const infiniteHookFile = resolver.file({
-							...operationFileEntry(node, infiniteHookName),
-							root,
-							output,
-							group: group ?? void 0
-						});
-						imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
-							name: [infiniteOptionsName],
-							root: hookOptionsFile.path,
-							path: infiniteHookFile.path
-						}));
-						hookOptions[infiniteHookName] = `Partial<ReturnType<typeof ${infiniteOptionsName}>>`;
-						if (isSuspenseOp) {
-							const suspenseInfiniteOptionsName = resolver.suspenseInfiniteQuery.optionsName(node);
-							const suspenseInfiniteHookName = resolver.suspenseInfiniteQuery.name(node);
-							const suspenseInfiniteHookFile = resolver.file({
-								...operationFileEntry(node, suspenseInfiniteHookName),
-								root,
-								output,
-								group: group ?? void 0
-							});
-							imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
-								name: [suspenseInfiniteOptionsName],
-								root: hookOptionsFile.path,
-								path: suspenseInfiniteHookFile.path
-							}));
-							hookOptions[suspenseInfiniteHookName] = `Partial<ReturnType<typeof ${suspenseInfiniteOptionsName}>>`;
-						}
-					}
-				}
-			}
-			if (isMutationOp) {
-				const mutationOptionsName = resolver.mutation.optionsName(node);
-				const mutationHookName = resolver.mutation.name(node);
-				const mutationHookFile = resolver.file({
-					...operationFileEntry(node, mutationHookName),
+			const isSuspense = !!suspense;
+			const isInfinite = isQuery && !!nodeInfiniteOptions && matchesInfinite(node, nodeInfiniteOptions);
+			const namespaces = [
+				[resolver.query, isQuery],
+				[resolver.suspenseQuery, isQuery && isSuspense],
+				[resolver.infiniteQuery, isInfinite],
+				[resolver.suspenseInfiniteQuery, isInfinite && isSuspense],
+				[resolver.mutation, isMutation]
+			];
+			for (const [ns, enabled] of namespaces) {
+				if (!enabled) continue;
+				const optionsName = ns.optionsName(node);
+				const hookName = ns.name(node);
+				const hookFile = resolver.file({
+					...operationFileEntry(node, hookName),
 					root,
 					output,
 					group: group ?? void 0
 				});
 				imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
-					name: [mutationOptionsName],
+					name: [optionsName],
 					root: hookOptionsFile.path,
-					path: mutationHookFile.path
+					path: hookFile.path
 				}));
-				hookOptions[mutationHookName] = `Partial<ReturnType<typeof ${mutationOptionsName}>>`;
+				hookOptions[hookName] = `Partial<ReturnType<typeof ${optionsName}>>`;
 			}
 		}
 		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
@@ -2306,13 +2245,6 @@ const resolverReactQuery = (0, kubb_kit.createResolver)({
 				key: operationKey(node, "mutation", "optionsName"),
 				name
 			});
-		},
-		typeName(node) {
-			const name = capitalize(this.name(node.operationId));
-			return this.resolveName({
-				key: operationKey(node, "mutation", "typeName"),
-				name
-			});
 		}
 	},
 	hook: {