@kubb/plugin-react-query 5.8.0-canary.20261027T202821 → 5.8.0-canary.20261029T082701

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
 import "@kubb/plugin-zod";
-import "@kubb/plugin-ts";
+import { ResolverTs } from "@kubb/plugin-ts";
 import "kubb/jsx";
 /**
  * The client selector accepted by a consumer's `client` option. Each calls a registered contract
@@ -16,6 +16,51 @@ type ResolvedContractClient = {
   kind: 'contract';
   pluginName: string;
 };
+/**
+ * The two per-operation type names a generated client references: the grouped input and the
+ * per-status responses record its `RequestResult` is keyed on.
+ */
+type OperationTypeNames = {
+  response: {
+    /**
+     * Resolves the name of the operation's grouped `{ body, path, query, headers }` input type.
+     */
+    options(node: ast.OperationNode): string;
+    /**
+     * Resolves the name of the operation's per-status responses record type.
+     */
+    responses(node: ast.OperationNode): string;
+  };
+};
+/**
+ * Where a generated client sources its operation types, plus the resolver and output the file
+ * declaring them is resolved with.
+ */
+type OperationTypeSource = OperationTypeNames & {
+  /**
+   * `plugin-ts` shaped resolver of the plugin supplying the names, also used to resolve the file they are exported from.
+   */
+  resolver: ResolverTs;
+  /**
+   * The supplying plugin's own `output`, when it configured one.
+   */
+  output: Output | undefined;
+  /**
+   * The supplying plugin's own `group`, when it configured one.
+   */
+  group: Group | undefined;
+};
+declare global {
+  namespace Kubb {
+    interface MemoRegistry {
+      operationTypes: OperationTypeSource;
+      /**
+       * Nests every key the zod-backed `ResolverTs` memoizes, so it holds each of their value types.
+       */
+      zodTypes: unknown;
+    }
+  }
+}
 type ParamsCasing = 'camelcase' | undefined;
 /**
  * The hook a key is built for. Plain and suspense queries can share a key, but an infinite query
@@ -156,6 +201,10 @@ export declare const mutationKeyTransformer: Transformer;
  * ```
  */
 export declare const queryKeyTransformer: Transformer;
+type ResponseTypes = {
+  TData: string;
+  TError: string;
+};
 /**
  * Helper to define a typed page param function for `infinite.getNextPageParam` or
  * `infinite.getPreviousPageParam`. Serializes the function to a string for inlining in generated code.
@@ -165,6 +214,13 @@ export declare const queryKeyTransformer: Transformer;
  * the config file.
  */
 export declare function definePageParam<TPage = any, TParam = any>(fn: PageParamFn<TPage, TParam>): string;
+declare global {
+  namespace Kubb {
+    interface MemoRegistry {
+      responseTypes: ResponseTypes;
+    }
+  }
+}
 /**
  * The concrete resolver type for `@kubb/plugin-react-query`.
  * Extends the base `Resolver` (which provides `default` naming and option helpers, the top-level

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
 import "@kubb/plugin-zod";
-import "@kubb/plugin-ts";
+import { ResolverTs } from "@kubb/plugin-ts";
 import "kubb/jsx";
 /**
  * The client selector accepted by a consumer's `client` option. Each calls a registered contract
@@ -16,6 +16,51 @@ type ResolvedContractClient = {
   kind: 'contract';
   pluginName: string;
 };
+/**
+ * The two per-operation type names a generated client references: the grouped input and the
+ * per-status responses record its `RequestResult` is keyed on.
+ */
+type OperationTypeNames = {
+  response: {
+    /**
+     * Resolves the name of the operation's grouped `{ body, path, query, headers }` input type.
+     */
+    options(node: ast.OperationNode): string;
+    /**
+     * Resolves the name of the operation's per-status responses record type.
+     */
+    responses(node: ast.OperationNode): string;
+  };
+};
+/**
+ * Where a generated client sources its operation types, plus the resolver and output the file
+ * declaring them is resolved with.
+ */
+type OperationTypeSource = OperationTypeNames & {
+  /**
+   * `plugin-ts` shaped resolver of the plugin supplying the names, also used to resolve the file they are exported from.
+   */
+  resolver: ResolverTs;
+  /**
+   * The supplying plugin's own `output`, when it configured one.
+   */
+  output: Output | undefined;
+  /**
+   * The supplying plugin's own `group`, when it configured one.
+   */
+  group: Group | undefined;
+};
+declare global {
+  namespace Kubb {
+    interface MemoRegistry {
+      operationTypes: OperationTypeSource;
+      /**
+       * Nests every key the zod-backed `ResolverTs` memoizes, so it holds each of their value types.
+       */
+      zodTypes: unknown;
+    }
+  }
+}
 type ParamsCasing = 'camelcase' | undefined;
 /**
  * The hook a key is built for. Plain and suspense queries can share a key, but an infinite query
@@ -156,6 +201,10 @@ export declare const mutationKeyTransformer: Transformer;
  * ```
  */
 export declare const queryKeyTransformer: Transformer;
+type ResponseTypes = {
+  TData: string;
+  TError: string;
+};
 /**
  * Helper to define a typed page param function for `infinite.getNextPageParam` or
  * `infinite.getPreviousPageParam`. Serializes the function to a string for inlining in generated code.
@@ -165,6 +214,13 @@ export declare const queryKeyTransformer: Transformer;
  * the config file.
  */
 export declare function definePageParam<TPage = any, TParam = any>(fn: PageParamFn<TPage, TParam>): string;
+declare global {
+  namespace Kubb {
+    interface MemoRegistry {
+      responseTypes: ResponseTypes;
+    }
+  }
+}
 /**
  * The concrete resolver type for `@kubb/plugin-react-query`.
  * Extends the base `Resolver` (which provides `default` naming and option helpers, the top-level

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
 import path from "node:path";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
@@ -229,86 +229,37 @@ function resolveSuccessNames(node, resolver) {
 function resolveStatusCodeNames(node, resolver) {
 	return node.responses.map((response) => resolver.response.status(node, response.statusCode));
 }
-const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
-function resolveOperationTypeNames(node, resolver, options = {}) {
-	const cacheKey = `${node.operationId}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${options.includeParams === false ? "noparams" : ""}\0${(options.exclude ?? []).join(",")}`;
-	let byResolver = typeNamesByResolver.get(resolver);
-	if (byResolver) {
-		const cached = byResolver.get(cacheKey);
-		if (cached) return cached;
-	} else {
-		byResolver = /* @__PURE__ */ new Map();
-		typeNamesByResolver.set(resolver, byResolver);
-	}
-	const { path, query, header } = getOperationParameters(node);
-	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
-	const exclude = new Set(options.exclude ?? []);
-	const paramNames = options.includeParams === false ? [] : [
-		...path.map((param) => resolver.param.path(node, param)),
-		...query.map((param) => resolver.param.query(node, param)),
-		...header.map((param) => resolver.param.headers(node, param))
-	];
-	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(node)];
-	const result = (options.order === "body-response-first" ? [
-		...bodyAndResponseNames,
-		...paramNames,
-		...responseStatusNames
-	] : [
-		...paramNames,
-		...bodyAndResponseNames,
-		...responseStatusNames
-	]).filter((name) => Boolean(name) && !exclude.has(name));
-	byResolver.set(cacheKey, result);
-	return result;
-}
-// ../../internals/utils/src/casing.ts
-const wordStart = /(?<=[a-z\d])(?=[A-Z])|(?<=[A-Z]{2})(?=[A-Z][a-z]{2})/;
 /**
-* Splits `text` into words on separators (whitespace, hyphens, underscores, dots, slashes, colons)
-* and on {@link wordStart}. A segment without lowercase letters, such as `COOL` or `2D`, is one word,
-* so snake case leaves a name that is already in it unchanged.
+* Lists the type names an operation's types file declares, computed once per resolver and `options` so every
+* dependent reads the same list.
 */
-function words(text) {
-	return text.split(/[\s\-_./\\:]+/).filter(Boolean).flatMap((segment) => segment === segment.toUpperCase() ? segment : segment.split(wordStart));
-}
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Capitalizes each word from {@link words} according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function convert(text, pascal) {
-	return words(text).flatMap((word) => word.split(/(?<=\d)(?=[a-z])|(?<=[A-Z])(?=[A-Z][a-z])/)).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-const cache = /* @__PURE__ */ new Map();
-const cacheLimit = 1e4;
-function toCamelOrPascal(text, pascal) {
-	const key = `${pascal ? "P" : "c"}${text}`;
-	const cached = cache.get(key);
-	if (cached !== void 0) return cached;
-	const result = convert(text, pascal);
-	if (cache.size >= cacheLimit) cache.clear();
-	cache.set(key, result);
-	return result;
-}
-/**
-* Converts `text` to camelCase.
-*
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
-*
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
-*/
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+function resolveOperationTypeNames(node, resolver, options = {}) {
+	const key = `${node.operationId}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${options.includeParams === false ? "noparams" : ""}\0${(options.exclude ?? []).join(",")}`;
+	return resolver.memo(`operationTypeNames:${key}`, () => {
+		const { path, query, header } = getOperationParameters(node);
+		const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
+		const exclude = new Set(options.exclude ?? []);
+		const paramNames = options.includeParams === false ? [] : [
+			...path.map((param) => resolver.param.path(node, param)),
+			...query.map((param) => resolver.param.query(node, param)),
+			...header.map((param) => resolver.param.headers(node, param))
+		];
+		const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(node)];
+		return (options.order === "body-response-first" ? [
+			...bodyAndResponseNames,
+			...paramNames,
+			...responseStatusNames
+		] : [
+			...paramNames,
+			...bodyAndResponseNames,
+			...responseStatusNames
+		]).filter((name) => Boolean(name) && !exclude.has(name));
+	});
 }
+// ../../internals/utils/src/casing.ts
 /**
 * Uppercases only the first character of `text`, leaving the rest untouched.
-* Unlike {@link pascalCase} it never re-splits word boundaries or strips characters.
+* Unlike `pascalCase` it never re-splits word boundaries or strips characters.
 *
 * @example
 * `capitalize('getPetById') // 'GetPetById'`
@@ -472,8 +423,11 @@ function getNestedAccessor(param, accessor) {
 	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
 }
 // ../../internals/shared/src/resolver.ts
+/**
+* The shared top-level `name` of the operation plugins, computed once per operation name and build.
+*/
 function resolveOperationName(name) {
-	return ensureValidVarName(camelCase(name));
+	return this.memo(`operation:${name}`, () => ensureValidVarName(camelCase(name)));
 }
 /**
 * Builds the allocation key for a declaration an operation owns. `scope` names which declaration
@@ -529,7 +483,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.8.0-canary.20261027T202821";
+var version = "5.8.0-canary.20261029T082701";
 // ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
@@ -540,6 +494,7 @@ function toZodTypeResolver(resolver) {
 	return {
 		...resolver,
 		file: resolver.file.bind(resolver),
+		memo: (key, compute) => resolver.memo(`zodTypes:${key}`, compute),
 		param: {
 			name: (node, p) => type(resolver.param.name(node, p)),
 			path: (node, p) => type(resolver.param.path(node, p)),
@@ -569,32 +524,34 @@ function toZodTypeResolver(resolver) {
 * ```
 */
 function resolveOperationTypes(driver, pluginName) {
-	const pluginTs = driver.getPlugin(pluginTsName);
-	const pluginZod = driver.getPlugin(pluginZodName);
-	if (pluginTs && pluginZod?.options?.inferred !== "codec") {
-		const resolver = driver.getResolver(pluginTsName);
+	return driver.memo(`operationTypes:${pluginName}`, () => {
+		const pluginTs = driver.getPlugin(pluginTsName);
+		const pluginZod = driver.getPlugin(pluginZodName);
+		if (pluginTs && pluginZod?.options?.inferred !== "codec") {
+			const resolver = driver.getResolver(pluginTsName);
+			return {
+				response: resolver.response,
+				resolver,
+				output: pluginTs.options?.output,
+				group: pluginTs.options?.group ?? void 0
+			};
+		}
+		if (!pluginZod?.options?.inferred) throw new Diagnostics.Error({
+			code: 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(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 Diagnostics.Error({
-		code: 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(pluginZodName));
-	return {
-		response: resolver.response,
-		resolver,
-		output: pluginZod.options.output,
-		group: pluginZod.options.group ?? void 0
-	};
 }
 // ../../internals/client/src/resolveClient.ts
 /**
@@ -995,13 +952,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";