@kubb/plugin-ts 5.0.0-beta.76 → 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
@@ -550,7 +550,7 @@ function applyEnumKeyCasing(key, casing = "none") {
 *   type: 'enum',
 *   name: 'petType',
 *   typeName: 'PetType',
-*   enums: [['cat', 'cat'], ['dog', 'dog']],
+*   enums: [['cat', 'cat', 'A cat'], ['dog', 'dog']],
 * })
 * ```
 */
@@ -563,30 +563,39 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 		if (typeof value === "boolean") return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse());
 		if (value !== null && value !== void 0) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
 	}).filter((node) => node !== void 0)))];
-	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value]) => {
+	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value, description]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
 		if (Number.parseInt(value.toString(), 10) === value && isNumber(Number.parseInt(value.toString(), 10))) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 		else initializer = factory.createNumericLiteral(value);
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
 		if (isNumber(Number.parseInt(key.toString(), 10))) {
 			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
-			return factory.createEnumMember(propertyName(casingKey), initializer);
+			return appendJSDocToNode({
+				node: factory.createEnumMember(propertyName(casingKey), initializer),
+				comments: [description]
+			});
 		}
 		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
-			return factory.createEnumMember(propertyName(casingKey), initializer);
+			return appendJSDocToNode({
+				node: factory.createEnumMember(propertyName(casingKey), initializer),
+				comments: [description]
+			});
 		}
 	}).filter((member) => member !== void 0))];
 	const identifierName = name;
 	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword))];
-	return [factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value]) => {
+	return [factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value, description]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
 		if (isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 		else initializer = factory.createNumericLiteral(value);
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
 		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
-			return factory.createPropertyAssignment(propertyName(casingKey), initializer);
+			return appendJSDocToNode({
+				node: factory.createPropertyAssignment(propertyName(casingKey), initializer),
+				comments: [description]
+			});
 		}
 	}).filter((property) => property !== void 0), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], ts.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
 }
@@ -791,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
@@ -817,7 +826,11 @@ function Enum({ node, enum: enumOptions, resolver }) {
 	const [nameNode, typeNode] = createEnumDeclaration({
 		name: enumName,
 		typeName,
-		enums: node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
+		enums: node.namedEnumValues?.map((v) => [
+			trimQuotes(v.name.toString()),
+			v.value,
+			v.description
+		]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
 		type: enumOptions.type,
 		enumKeyCasing: enumOptions.keyCasing
 	});
@@ -837,39 +850,6 @@ function Enum({ node, enum: enumOptions, resolver }) {
 	})] });
 }
 //#endregion
-//#region src/components/Type.tsx
-function Type({ name, node, printer, enum: enumOptions, resolver }) {
-	const enumSchemaNodes = ast.collect(node, { schema(n) {
-		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
-		if (enumNode?.name) return enumNode;
-	} });
-	const output = printer.print(node);
-	if (!output) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-		return {
-			node,
-			...getEnumNames({
-				node,
-				enum: enumOptions,
-				resolver
-			})
-		};
-	});
-	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
-	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
-		node,
-		enum: enumOptions,
-		resolver
-	}, node.name)), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] });
-}
-//#endregion
 //#region ../../internals/shared/src/params.ts
 const caseParamsCache = /* @__PURE__ */ new WeakMap();
 /**
@@ -890,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
 /**
@@ -943,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
@@ -983,6 +980,18 @@ function createGroupConfig(group) {
 //#endregion
 //#region src/utils.ts
 /**
+* Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
+* rather than a named enum reference or a runtime enum declaration.
+*
+* The parser folds `const` into a single-value enum node. The adapter decides which schemas are
+* named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for
+* example `StatusKey`). A const renders as a literal only when the adapter has not registered it as
+* a named enum, which keeps the declaration and its references in sync across adapter versions.
+*/
+function isInlineConstEnum(node, enumSchemaNames) {
+	return (node.namedEnumValues ?? node.enumValues ?? []).length === 1 && !(node.name && enumSchemaNames?.has(node.name));
+}
+/**
 * Collects JSDoc annotation strings for a schema node.
 *
 * Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.
@@ -1094,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)
 		}))
 	});
 }
@@ -1120,6 +1160,39 @@ function buildResponseUnion(node, { resolver }) {
 	});
 }
 //#endregion
+//#region src/components/Type.tsx
+function Type({ name, node, printer, enum: enumOptions, resolver }) {
+	const enumSchemaNodes = ast.collect(node, { schema(n) {
+		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
+		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
+	} });
+	const output = printer.print(node);
+	if (!output) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+		return {
+			node,
+			...getEnumNames({
+				node,
+				enum: enumOptions,
+				resolver
+			})
+		};
+	});
+	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
+	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
+		node,
+		enum: enumOptions,
+		resolver
+	}, node.name)), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] });
+}
+//#endregion
 //#region src/printers/printerTs.ts
 const { isNonNullable } = factory_exports;
 /**
@@ -1175,16 +1248,16 @@ 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 ?? [];
-				if (this.options.enum.type === "inlineLiteral" || !node.name) return createUnionDeclaration({
+				if (this.options.enum.type === "inlineLiteral" || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) return createUnionDeclaration({
 					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 ?? [];
@@ -1310,7 +1383,8 @@ const typeGenerator = defineGenerator({
 				group: group ?? void 0
 			}).path
 		}));
-		const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum);
+		const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum);
+		const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames);
 		const meta = {
 			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolver.resolveTypeName(node.name),
 			file: resolver.resolveFile({
@@ -1331,6 +1405,7 @@ const typeGenerator = defineGenerator({
 			description: node.description,
 			resolver,
 			enumSchemaNames,
+			nameMapping: adapter.options.nameMapping,
 			nodes: printer?.nodes
 		});
 		return /* @__PURE__ */ jsxs(File, {
@@ -1413,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, {
@@ -1433,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);