@kubb/plugin-swr 5.0.0-beta.95 → 5.0.0-beta.99

package/dist/index.js

@@ -1,7 +1,7 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import path from "node:path";
 import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import path from "node:path";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
@@ -161,33 +161,17 @@ function isIdentifier(name) {
 }
 //#endregion
 //#region ../../internals/utils/src/url.ts
-function transformParam(raw, casing) {
-	const param = isValidVarName(raw) ? raw : camelCase(raw);
-	return casing === "camelcase" ? camelCase(param) : param;
-}
-function toParamsObject(path, { replacer, casing } = {}) {
-	const params = {};
-	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
-		const param = transformParam(match[1], casing);
-		const key = replacer ? replacer(param) : param;
-		params[key] = key;
-	}
-	return Object.keys(params).length > 0 ? params : null;
+/**
+* Keeps the OpenAPI parameter name as-is when it is already a valid JS identifier, and
+* camelCases it only enough to become one otherwise (for example a hyphenated path segment).
+*/
+function transformParam(raw) {
+	return isValidVarName(raw) ? raw : camelCase(raw);
 }
 /**
-* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
+* Helpers for OpenAPI/Swagger paths.
 */
 var Url = class Url {
-	/**
-	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
-	*
-	* @example
-	* Url.canParse('https://petstore.swagger.io/v2') // true
-	* Url.canParse('/pet/{petId}')                   // false
-	*/
-	static canParse(url, base) {
-		return URL.canParse(url, base);
-	}
 	/**
 	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
 	*
@@ -203,15 +187,14 @@ var Url = class Url {
 	* key.
 	*
 	* @example
-	* Url.toCasedTemplate('/projects/{project_id}', { casing: 'camelcase' }) // '/projects/{projectId}'
+	* Url.toSafeTemplate('/user/{monetary-account-id}') // '/user/{monetaryAccountId}'
 	*/
-	static toCasedTemplate(path, { casing } = {}) {
-		return path.replace(/\{([^}]+)\}/g, (_, name) => `{${transformParam(name, casing)}}`);
+	static toSafeTemplate(path) {
+		return path.replace(/\{([^}]+)\}/g, (_, name) => `{${transformParam(name)}}`);
 	}
 	/**
 	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
-	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
-	* and `casing` controls parameter identifier casing.
+	* `prefix` is prepended inside the literal, and `replacer` transforms each parameter name.
 	*
 	* @example
 	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
@@ -219,10 +202,10 @@ var Url = class Url {
 	* @example
 	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
 	*/
-	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+	static toTemplateString(path, { prefix, replacer } = {}) {
 		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
 			if (i % 2 === 0) return part;
-			const param = transformParam(part, casing);
+			const param = transformParam(part);
 			return `\${${replacer ? replacer(param) : param}}`;
 		}).join("");
 		return `\`${prefix ?? ""}${result}\``;
@@ -230,8 +213,8 @@ var Url = class Url {
 	/**
 	* Converts an OpenAPI/Swagger path to a template literal that reads each parameter off the
 	* grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``. Parameter
-	* names are camelCased to match the generated `path` type, and `prefix` is prepended inside the
-	* literal. Shared by the client and cypress generators that pass a grouped `path` object.
+	* names match the generated `path` type, and `prefix` is prepended inside the literal. Shared by
+	* the client and cypress generators that pass a grouped `path` object.
 	*
 	* @example
 	* Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'
@@ -239,72 +222,25 @@ var Url = class Url {
 	static toGroupedTemplateString(path, { prefix } = {}) {
 		return Url.toTemplateString(path, {
 			prefix,
-			casing: "camelcase",
 			replacer: (name) => `path.${name}`
 		});
 	}
-	/**
-	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
-	* expression when `stringify` is set.
-	*
-	* @example
-	* Url.toObject('/pet/{petId}')
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	*/
-	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
-		const object = {
-			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
-				replacer,
-				casing
-			}),
-			params: toParamsObject(path, {
-				replacer,
-				casing
-			})
-		};
-		if (stringify) {
-			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
-	}
 };
 //#endregion
 //#region ../../internals/shared/src/params.ts
-const caseParamsCache = /* @__PURE__ */ new WeakMap();
 /**
-* Applies camelCase to parameter names and returns a new array without mutating the input.
+* Drops parameters that share the same name, keeping the first.
 *
-* Run it before handing parameters to schema builders so output property keys get the right casing
-* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
-* original array is returned unchanged. Results are cached per input array.
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
 */
-function caseParams(params, casing) {
-	if (!casing) return params;
-	const cached = caseParamsCache.get(params);
-	if (cached) return cached;
-	const result = params.map((param) => ({
-		...param,
-		name: camelCase(param.name)
-	}));
-	caseParamsCache.set(params, result);
-	return result;
-}
-/**
-* Drops parameters that collapse to the same property identity once camelCased, keeping the first.
-*
-* Some specs declare the same parameter twice under different casings (for example AWS S3 lists both
-* `max-uploads` and `MaxUploads`). Both resolve to one output property, so emitting both would yield
-* an object type with a duplicate member, which TypeScript rejects. De-duplicate by the camelCased
-* identity so the resulting group is collision-free regardless of the names each caller carries.
-*/
-function dedupeByCasedName(params) {
+function dedupeParams(params) {
 	const seen = /* @__PURE__ */ new Set();
 	return params.filter((param) => {
-		const key = camelCase(param.name);
-		if (seen.has(key)) return false;
-		seen.add(key);
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
 		return true;
 	});
 }
@@ -423,13 +359,15 @@ function buildOperationComments(node, options = {}) {
 	if (!splitLines) return filteredComments;
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
-function getOperationParameters(node, options = {}) {
-	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
+function getOperationParameters(node) {
 	return {
-		path: dedupeByCasedName(params.filter((param) => param.in === "path")),
-		query: dedupeByCasedName(params.filter((param) => param.in === "query")),
-		header: dedupeByCasedName(params.filter((param) => param.in === "header")),
-		cookie: dedupeByCasedName(params.filter((param) => param.in === "cookie"))
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path").map((param) => isValidVarName(param.name) ? param : {
+			...param,
+			name: camelCase(param.name)
+		})),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
 	};
 }
 function getStatusCodeNumber(statusCode) {
@@ -461,7 +399,7 @@ function resolveStatusCodeNames(node, resolver) {
 }
 const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
 function resolveOperationTypeNames(node, resolver, options = {}) {
-	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${options.includeParams === false ? "noparams" : ""}\0${(options.exclude ?? []).join(",")}`;
+	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);
@@ -470,7 +408,7 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 		byResolver = /* @__PURE__ */ new Map();
 		typeNamesByResolver.set(resolver, byResolver);
 	}
-	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
+	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 ? [] : [
@@ -630,87 +568,6 @@ function resolveClientOperation(options) {
 	};
 }
 //#endregion
-//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
-const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
-const mutationKeyTransformer = ({ node }) => {
-	if (!node.path) return [];
-	return [`{ url: '${Url.toPath(node.path)}' }`];
-};
-function MutationKey$1({ name, node, transformer }) {
-	const paramsNode = createFunctionParameters({ params: [] });
-	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
-	const keys = (transformer ?? mutationKeyTransformer)({
-		node,
-		casing: "camelcase"
-	});
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function.Arrow, {
-			name,
-			export: true,
-			params: paramsSignature,
-			singleLine: true,
-			children: `[${keys.join(", ")}] as const`
-		})
-	});
-}
-__name(MutationKey$1, "MutationKey");
-//#endregion
-//#region ../../internals/tanstack-query/src/resolver.ts
-/**
-* Builds the shared query namespace for a variant. Spread the result into
-* `createResolver` once per variant the plugin supports.
-*
-* @example
-* ```ts
-* createResolver<PluginReactQuery>({
-*   query: createQueryResolver(),
-*   suspenseQuery: createQueryResolver('Suspense'),
-* })
-* ```
-*/
-function createQueryResolver(variant = "") {
-	return {
-		name(node) {
-			return `use${capitalize(this.name(node.operationId))}${variant}`;
-		},
-		optionsName(node) {
-			return `${this.name(node.operationId)}${variant}QueryOptions`;
-		},
-		keyName(node) {
-			return `${this.name(node.operationId)}${variant}QueryKey`;
-		},
-		keyTypeName(node) {
-			return `${capitalize(this.name(node.operationId))}${variant}QueryKey`;
-		},
-		clientName(node) {
-			return `${this.name(node.operationId)}${variant}`;
-		}
-	};
-}
-/**
-* Builds the shared mutation namespace. Spread the result into
-* `createResolver` and add plugin-specific methods (`optionsName`,
-* `typeName`, `argTypeName`) next to it.
-*
-* @example
-* ```ts
-* createResolver<PluginSwr>({ mutation: { ...createMutationResolver(), argTypeName(node) {...} } })
-* ```
-*/
-function createMutationResolver() {
-	return {
-		name(node) {
-			return `use${capitalize(this.name(node.operationId))}`;
-		},
-		keyName(node) {
-			return `${this.name(node.operationId)}MutationKey`;
-		}
-	};
-}
-//#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
 /**
 * The grouped request options, ordered for both the destructured signature and the
@@ -858,6 +715,87 @@ function buildQueryKeyParams(node, options) {
 	return createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
 }
 //#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
+const mutationKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	return [`{ url: '${Url.toPath(node.path)}' }`];
+};
+function MutationKey$1({ name, node, transformer }) {
+	const paramsNode = createFunctionParameters({ params: [] });
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	const keys = (transformer ?? mutationKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	});
+}
+__name(MutationKey$1, "MutationKey");
+//#endregion
+//#region ../../internals/tanstack-query/src/resolver.ts
+/**
+* Builds the shared query namespace for a variant. Spread the result into
+* `createResolver` once per variant the plugin supports.
+*
+* @example
+* ```ts
+* createResolver<PluginReactQuery>({
+*   query: createQueryResolver(),
+*   suspenseQuery: createQueryResolver('Suspense'),
+* })
+* ```
+*/
+function createQueryResolver(variant = "") {
+	return {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}${variant}`;
+		},
+		optionsName(node) {
+			return `${this.name(node.operationId)}${variant}QueryOptions`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}${variant}QueryKey`;
+		},
+		keyTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}${variant}QueryKey`;
+		},
+		clientName(node) {
+			return `${this.name(node.operationId)}${variant}`;
+		}
+	};
+}
+/**
+* Builds the shared mutation namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`optionsName`,
+* `typeName`, `argTypeName`) next to it.
+*
+* @example
+* ```ts
+* createResolver<PluginSwr>({ mutation: { ...createMutationResolver(), argTypeName(node) {...} } })
+* ```
+*/
+function createMutationResolver() {
+	return {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}MutationKey`;
+		}
+	};
+}
+//#endregion
 //#region ../../internals/tanstack-query/src/components/QueryKey.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
 const queryKeyTransformer = ({ node }) => {