@kubb/plugin-ts 5.0.0-beta.77 → 5.0.0-beta.79

package/dist/index.d.ts

@@ -126,6 +126,11 @@ type PrinterTsOptions = {
    * Schema names that represent enums for suffixed key references.
    */
   enumSchemaNames?: Set<string>;
+  /**
+   * Maps a component `$ref` path to its collision-resolved name, so a reference to a renamed
+   * component (e.g. `#/components/schemas/Order` → `OrderSchema`) emits the renamed name.
+   */
+  nameMapping?: ReadonlyMap<string, string>;
   /**
    * Custom handler map for node type overrides.
    */

package/dist/index.js

@@ -98,7 +98,7 @@ function toFilePath(name, caseLast = camelCase) {
 * JavaScript and Java reserved words.
 * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
 */
-const reservedWords = new Set([
+const reservedWords = /* @__PURE__ */ new Set([
 	"abstract",
 	"arguments",
 	"boolean",
@@ -220,19 +220,19 @@ function ensureValidVarName(name) {
 /**
 * `optionalType` values that cause a property's type to include `| undefined`.
 */
-const OPTIONAL_ADDS_UNDEFINED = new Set(["undefined", "questionTokenAndUndefined"]);
+const OPTIONAL_ADDS_UNDEFINED = /* @__PURE__ */ new Set(["undefined", "questionTokenAndUndefined"]);
 /**
 * `optionalType` values that render the property key with a `?` token.
 */
-const OPTIONAL_ADDS_QUESTION_TOKEN = new Set(["questionToken", "questionTokenAndUndefined"]);
+const OPTIONAL_ADDS_QUESTION_TOKEN = /* @__PURE__ */ new Set(["questionToken", "questionTokenAndUndefined"]);
 /**
 * `enum.type` values that append a `typeSuffix` to the generated enum type alias.
 */
-const ENUM_TYPES_WITH_KEY_SUFFIX = new Set(["asConst"]);
+const ENUM_TYPES_WITH_KEY_SUFFIX = /* @__PURE__ */ new Set(["asConst"]);
 /**
 * `enum.type` values that require a runtime value declaration (object, enum, or literal).
 */
-const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set([
+const ENUM_TYPES_WITH_RUNTIME_VALUE = /* @__PURE__ */ new Set([
 	"enum",
 	"asConst",
 	"constEnum",
@@ -242,7 +242,7 @@ const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set([
 /**
 * `enum.type` values whose type declaration is type-only (no runtime value emitted for the type alias).
 */
-const ENUM_TYPES_WITH_TYPE_ONLY = new Set([
+const ENUM_TYPES_WITH_TYPE_ONLY = /* @__PURE__ */ new Set([
 	"asConst",
 	"literal",
 	void 0
@@ -800,7 +800,7 @@ function buildIndexSignatures(node, propertyCount, print) {
 * resolve to the same name, which TypeScript merges into a single value+type declaration.
 */
 function getEnumNames({ node, enum: enumOptions, resolver }) {
-	const resolved = resolver.default(node.name, "type");
+	const resolved = resolver.resolveTypeName(node.name);
 	return {
 		enumName: enumOptions.constCasing === "pascalCase" ? resolved : camelCase(node.name),
 		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolved
@@ -870,6 +870,23 @@ function caseParams(params, casing) {
 	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) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		const key = camelCase(param.name);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
 //#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
@@ -923,10 +940,10 @@ function resolveContentTypeVariants(entries, baseName) {
 function getOperationParameters(node, options = {}) {
 	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
 	return {
-		path: params.filter((param) => param.in === "path"),
-		query: params.filter((param) => param.in === "query"),
-		header: params.filter((param) => param.in === "header"),
-		cookie: params.filter((param) => param.in === "cookie")
+		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"))
 	};
 }
 //#endregion
@@ -1086,17 +1103,48 @@ function buildData(node, { resolver }) {
 		]
 	});
 }
+/**
+* The schema a status occupies in the `<Name>Responses` record. A status that documents several
+* content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type
+* on `result.parsed`, while the standalone `<Name>StatusNNN` alias stays the plain body union that the
+* query hooks and `result.data` use.
+*/
+function buildResponseRecordEntry(node, res, resolver) {
+	const statusName = resolver.resolveResponseStatusName(node, res.statusCode);
+	const variants = (res.content ?? []).filter((entry) => entry.schema);
+	if (variants.length <= 1) return ast.factory.createSchema({
+		type: "ref",
+		name: statusName
+	});
+	return ast.factory.createSchema({
+		type: "union",
+		members: resolveContentTypeVariants(variants, statusName).map((variant) => ast.factory.createSchema({
+			type: "object",
+			properties: [ast.factory.createProperty({
+				name: "contentType",
+				required: true,
+				schema: ast.factory.createSchema({
+					type: "enum",
+					enumValues: [variant.contentType]
+				})
+			}), ast.factory.createProperty({
+				name: "data",
+				required: true,
+				schema: ast.factory.createSchema({
+					type: "ref",
+					name: variant.name
+				})
+			})]
+		}))
+	});
+}
 function buildResponses(node, { resolver }) {
-	if (node.responses.length === 0) return null;
 	return ast.factory.createSchema({
 		type: "object",
 		properties: node.responses.map((res) => ast.factory.createProperty({
 			name: String(res.statusCode),
 			required: true,
-			schema: ast.factory.createSchema({
-				type: "ref",
-				name: resolver.resolveResponseStatusName(node, res.statusCode)
-			})
+			schema: buildResponseRecordEntry(node, res, resolver)
 		}))
 	});
 }
@@ -1200,8 +1248,8 @@ const printerTs = ast.createPrinter((options) => {
 			time: dateOrStringNode,
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? extractRefName(node.ref) ?? node.name : node.name;
-				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
+				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? extractRefName(node.ref) ?? node.name : node.name;
+				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.resolveTypeName(refName) : refName, void 0);
 			},
 			enum(node) {
 				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
@@ -1209,7 +1257,7 @@ const printerTs = ast.createPrinter((options) => {
 					withParentheses: true,
 					nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable)
 				}) ?? void 0;
-				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enum.typeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
+				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enum.typeSuffix) : this.options.resolver.resolveTypeName(node.name), void 0);
 			},
 			union(node) {
 				const members = node.members ?? [];
@@ -1357,6 +1405,7 @@ const typeGenerator = defineGenerator({
 			description: node.description,
 			resolver,
 			enumSchemaNames,
+			nameMapping: adapter.options.nameMapping,
 			nodes: printer?.nodes
 		});
 		return /* @__PURE__ */ jsxs(File, {
@@ -1439,6 +1488,7 @@ const typeGenerator = defineGenerator({
 				keysToOmit,
 				resolver,
 				enumSchemaNames,
+				nameMapping: adapter.options.nameMapping,
 				nodes: printer?.nodes
 			});
 			return /* @__PURE__ */ jsxs(Fragment, { children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
@@ -1459,8 +1509,10 @@ const typeGenerator = defineGenerator({
 			})] });
 		}
 		/**
-		* Emits an individual type per content type plus a union alias under `baseName`.
-		* Shared by the request body and multi-content-type responses.
+		* Emits an individual type per content type plus a plain union alias under `baseName`. Shared by
+		* the request body and multi-content-type responses. The response record discriminates these
+		* variants by content type in {@link buildResponses}; the standalone alias stays a plain union so
+		* query hooks and `result.data` keep the bare body.
 		*/
 		function buildContentTypeVariants(entries, baseName, decorate) {
 			const variants = resolveContentTypeVariants(entries, baseName);