@kubb/plugin-client 5.8.0-canary.20261025T201031 → 5.8.1

package/dist/index.js

@@ -1,11 +1,10 @@
-import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, macroSimplifyUnion, setMacros, setResolver } from "kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, macroSimplifyUnion, pascalCase, setMacros, setResolver } from "kubb/kit";
 import path from "node:path";
 import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, jsxRenderer } from "kubb/jsx";
 import { jsx, jsxs } from "kubb/jsx/jsx-runtime";
-//#endregion
-//#region ../../internals/shared/src/operation.ts
+// ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
 * `resolver.file`: a file named `name`, tagged by the operation's first
@@ -183,6 +182,16 @@ function getOperationParameters(node) {
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
 }
+/**
+* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
+* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
+* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
+* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
+* printer to emit `z.object(…)` rather than a record.
+*/
+function hasRequestContentTypeChoice(node) {
+	return (node.requestBody?.content ?? []).filter((entry) => entry.schema).length > 1;
+}
 function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
 	return Number.isNaN(code) ? null : code;
@@ -200,58 +209,7 @@ function getOperationSuccessResponses(node) {
 function getPrimarySuccessResponse(node) {
 	return getOperationSuccessResponses(node)[0] ?? null;
 }
-//#endregion
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function convert(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).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);
-}
-/**
-* Converts `text` to PascalCase.
-*
-* @example Word boundaries
-* `pascalCase('hello-world') // 'HelloWorld'`
-*
-* @example With a suffix
-* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
-*/
-function pascalCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
+// ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
 * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
@@ -259,6 +217,7 @@ function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 const reservedWords = /* @__PURE__ */ new Set([
 	"abstract",
 	"arguments",
+	"await",
 	"boolean",
 	"break",
 	"byte",
@@ -389,8 +348,32 @@ function ensureValidVarName(name) {
 function isIdentifier(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-//#endregion
-//#region ../../internals/shared/src/group.ts
+// ../../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 this.memo(`operation:${name}`, () => ensureValidVarName(camelCase(name)));
+}
+/**
+* Builds the allocation key for a declaration an operation owns. `scope` names which declaration
+* it is, so two of them never share an allocation even when a custom resolver gives both the same
+* name. Leave `scope` empty for the operation's own declaration.
+*
+* @example
+* ```ts
+* resolver.resolveName({ key: operationKey(node, 'response', 'status', 404), name })
+* ```
+*/
+function operationKey(node, ...scope) {
+	return [
+		"operation",
+		node.method,
+		node.path,
+		...scope.map(String)
+	];
+}
+// ../../internals/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
 * shared default naming so every plugin groups output consistently:
@@ -420,17 +403,14 @@ function createGroupConfig(group) {
 		name: group.name ? group.name : defaultName
 	};
 }
-//#endregion
-//#region kubb-extension.json
+// kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.8.3",
+	"kubb": ">=5.14.6",
 	"node": ">=22.22"
 };
-//#endregion
-//#region package.json
-var version = "5.8.0-canary.20261025T201031";
-//#endregion
-//#region ../../internals/client/src/builders/validatorOptions.ts
+// package.json
+var version = "5.8.1";
+// ../../internals/client/src/builders/validatorOptions.ts
 /**
 * Returns `true` when any direction of the validator uses zod (used for dependency checks).
 */
@@ -473,8 +453,7 @@ function buildZodErrorParse(node, zodResolver) {
 	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
 	return zodResolver.response.error?.(node) || null;
 }
-//#endregion
-//#region ../../internals/client/src/builders/security.ts
+// ../../internals/client/src/builders/security.ts
 function serializeAuth(auth) {
 	const parts = [`type: '${auth.type}'`];
 	if (auth.scheme) parts.push(`scheme: '${auth.scheme}'`);
@@ -545,8 +524,7 @@ function buildSecurityMetadata({ security }) {
 	if (!security?.length) return null;
 	return `[${security.map(serializeAuth).join(", ")}]`;
 }
-//#endregion
-//#region ../../internals/client/src/builders/validator.ts
+// ../../internals/client/src/builders/validator.ts
 /**
 * Builds the validator-hook references for one operation. Request body and params validation run before the send.
 * Response validation runs on the success body only. Returns `null` references when the matching
@@ -588,17 +566,16 @@ function buildValidatorLiteral(hooks, keys) {
 	const entries = keys.flatMap((key) => hooks?.[key] ? [`${key}: ${hooks[key]}`] : []);
 	return entries.length ? `validator: { ${entries.join(", ")} }` : null;
 }
-//#endregion
-//#region ../../internals/client/src/builders/contentType.ts
+// ../../internals/client/src/builders/contentType.ts
 /**
-* Builds the `contentType` entry baked into the call config, or `null` for the JSON default.
+* Builds the `contentType` entry baked into the call config, or `null` without a request body.
 *
 * `merge` is `true` when the generated function must destructure `contentType` from `options` and
 * merge it over the baked request default, because the caller can also pick a response content type.
 */
 function buildContentType({ node }) {
 	const { defaultContentType } = getContentTypeInfo(node);
-	const requestContentType = Boolean(node.requestBody?.content?.[0]?.schema) && defaultContentType !== "application/json" ? defaultContentType : null;
+	const requestContentType = Boolean(node.requestBody?.content?.[0]?.schema) ? defaultContentType : null;
 	if (!requestContentType) return {
 		literal: null,
 		merge: false
@@ -609,8 +586,7 @@ function buildContentType({ node }) {
 		literal: merge ? `contentType: { request: '${requestContentType}', ...(typeof contentType === 'string' ? { request: contentType } : contentType) }` : `contentType: { request: '${requestContentType}' }`
 	};
 }
-//#endregion
-//#region ../../internals/client/src/builders/generics.ts
+// ../../internals/client/src/builders/generics.ts
 /**
 * Builds the `RequestResult` generic arguments for one operation: the per-status responses record
 * plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
@@ -641,8 +617,7 @@ function buildResultType({ node, types, returnType }) {
 	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
 	return `Unwrappable<RequestResult<${generics}>>`;
 }
-//#endregion
-//#region ../../internals/client/src/builders/returnStatement.ts
+// ../../internals/client/src/builders/returnStatement.ts
 /**
 * Builds the return statement of a generated operation function. With the default
 * `returnType: 'full'` the runtime call already resolves to `{ data, error, request, response }`.
@@ -666,22 +641,22 @@ function buildResultType({ node, types, returnType }) {
 * `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
 */
 function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
-	if (returnType === "data") return `return unwrapResult(request(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
+	const request = returnType !== "plain" && hasRequestContentTypeChoice(node) ? `request<${types.response.options(node)}['body']>` : "request";
+	if (returnType === "data") return `return unwrapResult(${request}(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
 		node,
 		types,
 		returnType
 	})}`;
-	if (returnType === "plain") return `return request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+	if (returnType === "plain") return `return ${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
 		node,
 		types
 	})}>>`;
-	return `return withUnwrap(request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+	return `return withUnwrap(${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
 		node,
 		types
 	})}>>)`;
 }
-//#endregion
-//#region ../../internals/client/src/builders/signature.ts
+// ../../internals/client/src/builders/signature.ts
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 /**
 * Builds the grouped-options signature for one operation: a single `options` object whose `TData`
@@ -709,8 +684,7 @@ function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDef
 		generics: [`ThrowOnError extends boolean = ${throwOnErrorDefault}`]
 	};
 }
-//#endregion
-//#region ../../internals/client/src/builders/styles.ts
+// ../../internals/client/src/builders/styles.ts
 /**
 * Renders a parameter name as an object-literal key, quoted when it is not a bare identifier. Every
 * location keeps the spec name: the runtime looks path styles up by the `{name}` placeholder in the
@@ -782,8 +756,7 @@ function buildStyles({ node }) {
 	const entries = [...Object.keys(groups).filter((location) => groups[location].length > 0).map((location) => `${location}: { ${groups[location].join(", ")} }`), serializeBodyEncoding(node)].filter(Boolean);
 	return entries.length > 0 ? `{ ${entries.join(", ")} }` : null;
 }
-//#endregion
-//#region ../../internals/client/src/components/Operation.tsx
+// ../../internals/client/src/components/Operation.tsx
 /**
 * Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
 * single `options` object to the resolved client and returns the `Unwrappable<RequestResult>`. The
@@ -860,8 +833,7 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 		})
 	});
 }
-//#endregion
-//#region ../../internals/client/src/resolveOperationTypes.ts
+// ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
 * exports next to each schema, so code written against `plugin-ts` names picks up the zod types.
@@ -871,6 +843,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)),
@@ -927,8 +900,7 @@ function resolveOperationTypes(driver, pluginName) {
 		group: pluginZod.options.group ?? void 0
 	};
 }
-//#endregion
-//#region ../../internals/client/src/generators/clientGenerator.tsx
+// ../../internals/client/src/generators/clientGenerator.tsx
 /**
 * Builds the built-in per-operation generator shared by the client plugins (`@kubb/plugin-fetch`,
 * `@kubb/plugin-axios`). Emits one async function per OpenAPI operation using the shared
@@ -955,8 +927,12 @@ function createClientGenerator(name, resolveClientPath) {
 				zodResolver
 			});
 			const importedZodNames = validatorHooks.importedZodNames;
+			const operationName = resolver.name(node.operationId);
 			const meta = {
-				name: resolver.name(node.operationId),
+				name: resolver.resolveName({
+					key: operationKey(node),
+					name: operationName
+				}),
 				file: resolver.file({
 					...operationFileEntry(node, node.operationId),
 					root,
@@ -1071,19 +1047,17 @@ function createClientGenerator(name, resolveClientPath) {
 		}
 	});
 }
-//#endregion
-//#region ../../internals/client/src/macros.ts
+// ../../internals/client/src/macros.ts
 /**
 * Macros the client plugins apply by default, ahead of any user macros. `macroSimplifyUnion`
 * drops union members a broader scalar already covers, keeping the generated response and error
 * unions tidy. A plugin wires them with `ctx.setMacros([...defaultMacros, ...userMacros])`.
 */
 const defaultMacros = [macroSimplifyUnion];
-//#endregion
-//#region ../../internals/client/src/resolver.ts
+// ../../internals/client/src/resolver.ts
 /**
-* Default resolver shared by the client plugins. Functions and files inherit the built-in camelCase
-* `name` and `file`; classes and tag groups use PascalCase.
+* Default resolver shared by the client plugins. Functions use safe camelCase identifiers and
+* files inherit the built-in casing; classes and tag groups use PascalCase.
 *
 * @example
 * ```ts
@@ -1093,6 +1067,7 @@ const defaultMacros = [macroSimplifyUnion];
 */
 const resolverClient = createResolver({
 	pluginName: "plugin-contract-client",
+	name: resolveOperationName,
 	className(name) {
 		return ensureValidVarName(pascalCase(name));
 	},
@@ -1103,16 +1078,14 @@ const resolverClient = createResolver({
 		return ensureValidVarName(camelCase(name));
 	}
 });
-//#endregion
-//#region src/generators/clientGenerator.tsx
+// src/generators/clientGenerator.tsx
 /**
 * Built-in operation generator for `@kubb/plugin-client`. Emits one async function per OpenAPI
 * operation using the shared `Operation` component: a grouped `<Name>Request` type and a function
 * that forwards a single `options` object to the user-provided client module and returns the `RequestResult`.
 */
 const clientGenerator = createClientGenerator("client", (options) => options.importPath);
-//#endregion
-//#region src/plugin.ts
+// src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-client`.
 */
@@ -1163,7 +1136,6 @@ const pluginClient = defineExtension({
 		};
 	}
 });
-//#endregion
 export { pluginClient as default, pluginClient, pluginClientName };
 
 //# sourceMappingURL=index.js.map