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

package/dist/index.js

@@ -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 ? [] : [