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

package/dist/index.js

@@ -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))))];
 }
@@ -753,24 +762,30 @@ function buildPropertyType(schema, baseType, optionalType, optional) {
 	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
 	return type;
 }
+const indexSignaturePrinter = ts.createPrinter();
+const indexSignatureSource = ts.createSourceFile("", "", ts.ScriptTarget.Latest);
 /**
-* Creates TypeScript index signatures for `additionalProperties` and `patternProperties` on an object schema node.
+* Creates a TypeScript index signature for `additionalProperties` and `patternProperties` on an
+* object schema node. TypeScript allows only one string index signature and its value must be
+* assignable from every named property, so both keywords collapse into a single signature: the
+* union of all value types (deduplicated), or `unknown` when the object also has fixed properties.
+* The key regex of `patternProperties` cannot be expressed by an index signature and is dropped.
 */
 function buildIndexSignatures(node, propertyCount, print) {
-	const elements = [];
-	if (node.additionalProperties && node.additionalProperties !== true) {
-		const additionalType = print(node.additionalProperties) ?? keywordTypeNodes.unknown;
-		elements.push(createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : additionalType));
-	} else if (node.additionalProperties === true) elements.push(createIndexSignature(keywordTypeNodes.unknown));
-	if (node.patternProperties) {
-		const first = Object.values(node.patternProperties)[0];
-		if (first) {
-			let patternType = print(first) ?? keywordTypeNodes.unknown;
-			if (first.nullable) patternType = createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] });
-			elements.push(createIndexSignature(patternType));
-		}
+	const valueTypes = [];
+	if (node.additionalProperties && node.additionalProperties !== true) valueTypes.push(print(node.additionalProperties) ?? keywordTypeNodes.unknown);
+	else if (node.additionalProperties === true) valueTypes.push(keywordTypeNodes.unknown);
+	for (const schema of Object.values(node.patternProperties ?? {})) {
+		const patternType = print(schema) ?? keywordTypeNodes.unknown;
+		valueTypes.push(schema.nullable ? createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] }) : patternType);
 	}
-	return elements;
+	if (valueTypes.length === 0) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const distinct = valueTypes.filter((type) => {
+		const key = indexSignaturePrinter.printNode(ts.EmitHint.Unspecified, type, indexSignatureSource);
+		return seen.has(key) ? false : (seen.add(key), true);
+	});
+	return [createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : createUnionDeclaration({ nodes: distinct }))];
 }
 //#endregion
 //#region src/components/Enum.tsx
@@ -811,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
 	});
@@ -831,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();
 /**
@@ -977,6 +963,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`.
@@ -1114,6 +1112,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;
 /**
@@ -1174,7 +1205,7 @@ const printerTs = ast.createPrinter((options) => {
 			},
 			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;
@@ -1304,7 +1335,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({