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

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
 /**
@@ -864,10 +845,6 @@ type CreateOperationParamsOptions = {
    * - `'inlineSpread'` emits a single rest parameter `...pathParams: PathParams`
    */
   pathParamsType: 'object' | 'inline' | 'inlineSpread';
-  /**
-   * Converts parameter names to camelCase before output.
-   */
-  paramsCasing?: 'camelcase';
   /**
    * Resolver for parameter and request body type names.
    * Pass `ResolverTs` from `@kubb/plugin-ts` directly.
@@ -967,9 +944,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`.
@@ -912,39 +912,19 @@ function Enum({ node, enum: enumOptions, resolver }) {
 }
 //#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;
 	});
 }
@@ -998,13 +978,15 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
-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"))
 	};
 }
 //#endregion
@@ -1128,6 +1110,35 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
+//#region ../../internals/shared/src/schemaTraversal.ts
+/**
+* Maps each property of an object schema to its transformed output. Pairs every result with the
+* original property so the printer keeps full control over modifiers, getters, and key syntax.
+*
+* @example
+* ```ts
+* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+* ```
+*/
+function mapSchemaProperties(node, transform) {
+	return node.properties.map((property) => ({
+		name: property.name,
+		property,
+		output: transform(property.schema)
+	}));
+}
+/**
+* Maps each item of an array or tuple schema to its transformed output, pairing every result with
+* the original item.
+*/
+function mapSchemaItems(node, transform) {
+	return (node.items ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+//#endregion
 //#region src/utils.ts
 /**
 * Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
@@ -1151,6 +1162,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 +1180,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);
 }
@@ -1188,7 +1203,7 @@ function buildParams({ params }) {
 	});
 }
 function buildOptions(node, { resolver }) {
-	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing: "original" });
+	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
 	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
 	const hasRequiredPath = pathParams.some((param) => param.required);
 	const hasRequiredQuery = queryParams.some((param) => param.required);
@@ -1398,7 +1413,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 +1422,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 ?? [];
@@ -1437,7 +1454,7 @@ const printerTs = ast.createPrinter((options) => {
 			},
 			array(node) {
 				return createArrayDeclaration({
-					nodes: ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
+					nodes: mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
 					arrayType: this.options.arrayType
 				}) ?? null;
 			},
@@ -1447,7 +1464,7 @@ const printerTs = ast.createPrinter((options) => {
 			object(node) {
 				const { transform, options } = this;
 				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
-				const propertyNodes = ast.mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {
+				const propertyNodes = mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {
 					const baseType = output ?? keywordTypeNodes.unknown;
 					const optional = !property.required || !!property.schema.optional || !!property.schema.nullish;
 					const type = buildPropertyType(property.schema, baseType, options.optionalType, optional);
@@ -1603,7 +1620,6 @@ const typeGenerator = defineGenerator({
 	operation(node, ctx) {
 		const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options;
 		const { config, resolver, root } = ctx;
-		const params = caseParams(node.parameters, "camelcase");
 		const meta = { file: resolver.file({
 			name: node.operationId,
 			extname: ".ts",
@@ -1682,10 +1698,7 @@ const typeGenerator = defineGenerator({
 				name: baseName
 			})] });
 		}
-		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters({
-			...node,
-			parameters: params
-		}, { paramsCasing: "original" });
+		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
 		const paramGroupTypes = [
 			pathParams.length > 0 && renderSchemaType({
 				schema: buildParams({ params: pathParams }),
@@ -1732,10 +1745,7 @@ const typeGenerator = defineGenerator({
 			});
 		});
 		const optionsType = renderSchemaType({
-			schema: buildOptions({
-				...node,
-				parameters: params
-			}, { resolver }),
+			schema: buildOptions(node, { resolver }),
 			name: resolver.response.options(node)
 		});
 		const responsesType = renderSchemaType({
@@ -2185,17 +2195,14 @@ function resolveGroupType({ node, params, group, resolver }) {
 * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
 */
 function createOperationParams(node, options) {
-	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+	const { paramsType, pathParamsType, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
 	const dataName = paramNames?.data ?? "data";
 	const paramsName = paramNames?.params ?? "params";
 	const headersName = paramNames?.headers ?? "headers";
 	const pathName = paramNames?.path ?? "pathParams";
 	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
 	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
-	const casedParams = caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
+	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
 	const toProperty = (param) => ({
 		name: param.name,
 		type: wrapTypeExpression(resolveParamType({