@kubb/plugin-ts 5.0.0-beta.95 → 5.0.0-beta.98

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
 import { KubbReactNode } from "kubb/jsx";
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
 import ts from "typescript";
+import "@kubb/adapter-oas";
 //#region src/printers/printerTs.d.ts
 /**
  * Partial map of node-type overrides for the TypeScript printer.
@@ -445,16 +446,6 @@ type Props$1 = {
   resolver: ResolverTs;
   key?: string | number | null;
 };
-/**
- * Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
- *
- * The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
- * valid TypeScript identifier. The resolver normalizes it. For inline enum properties the adapter
- * already emits a PascalCase+suffix name, so resolution is typically a no-op.
- *
- * When `constCasing` is `'pascalCase'` and `typeSuffix` is empty, the const and the type
- * resolve to the same name, which TypeScript merges into a single value+type declaration.
- */
 /**
  * Renders the enum declaration(s) for a single named `EnumSchemaNode`.
  *
@@ -466,11 +457,7 @@ type Props$1 = {
  * The emitted `File.Source` nodes carry the resolved names so that the barrel
  * index picks up the correct export identifiers.
  */
-declare function Enum({
-  node,
-  enum: enumOptions,
-  resolver
-}: Props$1): KubbReactNode;
+declare function Enum({ node, enum: enumOptions, resolver }: Props$1): KubbReactNode;
 //#endregion
 //#region src/components/Type.d.ts
 type Props = {
@@ -484,13 +471,7 @@ type Props = {
   enum: PluginTs['resolvedOptions']['enum'];
   resolver: ResolverTs;
 };
-declare function Type({
-  name,
-  node,
-  printer,
-  enum: enumOptions,
-  resolver
-}: Props): KubbReactNode;
+declare function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode;
 //#endregion
 //#region src/generators/typeGenerator.d.ts
 /**
@@ -967,9 +948,7 @@ type BuildParamsSchemaOptions = {
  * header), embedding each param's own schema (and JSDoc) directly rather than referencing a
  * separate per-param type — the group itself is the only type these params get exported as.
  */
-declare function buildParams({
-  params
-}: BuildParamsSchemaOptions): ast.SchemaNode;
+declare function buildParams({ params }: BuildParamsSchemaOptions): ast.SchemaNode;
 //#endregion
 export { type CreateOperationParamsOptions, Enum, type FunctionParameterNode, type FunctionParametersNode, type IndexedAccessTypeNode, type ObjectBindingPatternNode, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, Type, type TypeExpression, type TypeLiteralNode, buildParams, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -67,31 +67,6 @@ function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
 	}).toUpperCase();
 }
 //#endregion
-//#region ../../internals/utils/src/fs.ts
-/**
-* Builds a nested file path from a dotted name. Splits on dots that precede a letter
-* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
-* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
-*
-* Empty segments are dropped before joining. They arise when the name starts with a dot
-* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
-* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
-* absolute path, letting generated files escape the configured output directory.
-*
-* @example Nested path from a dotted name
-* `toFilePath('pet.petId') // 'pet/petId'`
-*
-* @example PascalCase the final segment
-* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
-*
-* @example Suffix applied to the final segment only
-* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
-*/
-function toFilePath(name, caseLast = camelCase) {
-	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
-}
-//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -292,6 +267,31 @@ function jsStringEscape(input) {
 	});
 }
 //#endregion
+//#region ../../internals/utils/src/fs.ts
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
+//#endregion
 //#region src/constants.ts
 /**
 * `optionalType` values that cause a property's type to include `| undefined`.
@@ -1151,6 +1151,10 @@ function isInlineConstEnum(node, enumSchemaNames) {
 function isSchemaOptional(schema) {
 	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
 }
+function formatExample(value) {
+	if (value === null || typeof value !== "object") return String(value);
+	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
+}
 function buildPropertyJSDocComments(schema, optional) {
 	const meta = ast.syncSchemaRef(schema);
 	const isArray = meta?.primitive === "array";
@@ -1165,7 +1169,7 @@ function buildPropertyJSDocComments(schema, optional) {
 		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
 		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
 		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : meta.default}` : null,
-		...exampleValues.map((example) => `@example ${example}`),
+		...exampleValues.map((example) => `@example ${formatExample(example)}`),
 		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null
 	].filter(Boolean);
 }
@@ -1398,7 +1402,8 @@ const printerTs = ast.createPrinter((options) => {
 				if (!node.name) return null;
 				const refName = ast.resolveRefName(node);
 				if (!refName) return null;
-				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.enum.keyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.name(refName) : refName, void 0);
+				const name = node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.enum.keyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.name(refName) : refName;
+				return createTypeReferenceNode(name, void 0);
 			},
 			enum(node) {
 				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
@@ -1406,7 +1411,8 @@ 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.enum.keyName(node, this.options.enum.typeSuffix) : this.options.resolver.name(node.name), void 0);
+				const resolvedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix ? this.options.resolver.enum.keyName(node, this.options.enum.typeSuffix) : this.options.resolver.name(node.name);
+				return createTypeReferenceNode(resolvedName, void 0);
 			},
 			union(node) {
 				const members = node.members ?? [];