@kubb/plugin-ts 5.0.0-beta.94 → 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.
@@ -77,11 +78,6 @@ 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.
    */
@@ -450,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`.
  *
@@ -471,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 = {
@@ -489,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
 /**
@@ -972,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`.
@@ -335,7 +335,6 @@ const PARAM_RANK = {
 //#endregion
 //#region src/factory.ts
 var factory_exports = /* @__PURE__ */ __exportAll({
-	SyntaxKind: () => SyntaxKind,
 	appendJSDocToNode: () => appendJSDocToNode,
 	buildIndexSignatures: () => buildIndexSignatures,
 	buildMemberNodes: () => buildMemberNodes,
@@ -343,29 +342,15 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	buildTupleNode: () => buildTupleNode,
 	constToTypeNode: () => constToTypeNode,
 	createArrayDeclaration: () => createArrayDeclaration,
-	createArrayTypeNode: () => createArrayTypeNode,
 	createEnumDeclaration: () => createEnumDeclaration,
 	createExportDeclaration: () => createExportDeclaration,
-	createFalse: () => createFalse,
-	createIdentifier: () => createIdentifier,
 	createImportDeclaration: () => createImportDeclaration,
-	createIndexSignature: () => createIndexSignature,
-	createInterfaceDeclaration: () => createInterfaceDeclaration,
 	createIntersectionDeclaration: () => createIntersectionDeclaration,
 	createJSDoc: () => createJSDoc,
-	createLiteralTypeNode: () => createLiteralTypeNode,
-	createNumericLiteral: () => createNumericLiteral,
 	createOmitDeclaration: () => createOmitDeclaration,
-	createOptionalTypeNode: () => createOptionalTypeNode,
 	createParameterSignature: () => createParameterSignature,
-	createPrefixUnaryExpression: () => createPrefixUnaryExpression,
 	createPropertySignature: () => createPropertySignature,
 	createQuestionToken: () => createQuestionToken,
-	createRestTypeNode: () => createRestTypeNode,
-	createStringLiteral: () => createStringLiteral,
-	createTrue: () => createTrue,
-	createTupleTypeNode: () => createTupleTypeNode,
-	createTypeAliasDeclaration: () => createTypeAliasDeclaration,
 	createTypeDeclaration: () => createTypeDeclaration,
 	createTypeLiteralNode: () => createTypeLiteralNode,
 	createTypeReferenceNode: () => createTypeReferenceNode,
@@ -1023,22 +1008,93 @@ function getOperationParameters(node, options = {}) {
 	};
 }
 //#endregion
-//#region ../../internals/shared/src/adapter.ts
+//#region ../../internals/shared/src/resolver.ts
 /**
-* Narrows the generic `Adapter` from a generator context to the OpenAPI adapter,
-* so OAS-only options (`dateType`, `nameMapping`) and the parsed `document` are typed.
+* Resolves a single operation parameter name with the
+* `<operationId> <in> <name>` template.
 *
-* Throws when a non-OAS adapter is configured, turning a silently wrong cast into a
-* clear, actionable error at the point of use.
+* @example
+* `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`
+*/
+function operationParamName(node, param) {
+	return this.name(`${node.operationId} ${param.in} ${param.name}`);
+}
+/**
+* Builds the shared `param` namespace. Spread the result into `createResolver`
+* and override individual methods next to it when a plugin deviates.
 *
 * @example
 * ```ts
-* const { dateType } = getOasAdapter(ctx.adapter).options
+* createResolver<PluginTs>({ param: createOperationParamResolver(), ... })
 * ```
 */
-function getOasAdapter(adapter) {
-	if (adapter.name !== "oas") throw new Error(`Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}". Configure \`adapter: adapterOas()\` in your Kubb config.`);
-	return adapter;
+function createOperationParamResolver() {
+	return {
+		name: operationParamName,
+		path(node) {
+			return this.name(`${node.operationId} Path`);
+		},
+		query(node) {
+			return this.name(`${node.operationId} Query`);
+		},
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	};
+}
+/**
+* Builds the shared `response` namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`options`, `error`) next
+* to it.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })
+* ```
+*/
+function createOperationResponseResolver() {
+	return {
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
+		},
+		body(node) {
+			return this.name(`${node.operationId} Body`);
+		},
+		responses(node) {
+			return this.name(`${node.operationId} Responses`);
+		},
+		response(node) {
+			return this.name(`${node.operationId} Response`);
+		}
+	};
+}
+/**
+* Builds a resolver `file` override whose base name runs every path segment
+* through `toFilePath`, casing the final segment with `caseLast`.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })
+* ```
+*/
+function createCasedFile(caseLast) {
+	return { baseName({ name, extname }) {
+		return `${toFilePath(name, caseLast)}${extname}`;
+	} };
+}
+//#endregion
+//#region ../../internals/shared/src/refs.ts
+/**
+* Collects the resolved target name of every pointer-carrying ref in a schema tree, in
+* first-occurrence order. Use this for name-only checks (e.g. redeclaration detection) where
+* `resolver.imports` would resolve file paths that are then discarded.
+*/
+function collectRefNames(schema) {
+	return ast.collect(schema, { schema: (node) => {
+		const refNode = ast.narrowSchema(node, "ref");
+		if (!refNode?.ref) return null;
+		return ast.resolveRefName(refNode);
+	} });
 }
 //#endregion
 //#region ../../internals/shared/src/group.ts
@@ -1095,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";
@@ -1109,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);
 }
@@ -1340,8 +1400,10 @@ const printerTs = ast.createPrinter((options) => {
 			time: dateOrStringNode,
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? ast.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.enum.keyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.name(refName) : refName, void 0);
+				const refName = ast.resolveRefName(node);
+				if (!refName) return null;
+				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 ?? [];
@@ -1349,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 ?? [];
@@ -1466,24 +1529,22 @@ const typeGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	schema(node, ctx) {
 		const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
-		const { adapter, config, resolver, root } = ctx;
+		const { config, resolver, root } = ctx;
 		if (!node.name) return;
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
-		const imports = adapter.getImports(node, (schemaName) => ({
-			name: resolveImportName({
-				schemaName,
-				enumOptions,
-				enumSchemaNames,
-				resolver
-			}),
-			path: resolver.file({
-				name: schemaName,
-				extname: ".ts",
-				root,
-				output,
-				group: group ?? void 0
-			}).path
-		}));
+		const importName = (schemaName) => resolveImportName({
+			schemaName,
+			enumOptions,
+			enumSchemaNames,
+			resolver
+		});
+		const imports = resolver.imports({
+			node,
+			root,
+			output,
+			group: group ?? void 0,
+			name: importName
+		});
 		const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum);
 		const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames);
 		const meta = {
@@ -1505,7 +1566,6 @@ const typeGenerator = defineGenerator({
 			description: node.description,
 			resolver,
 			enumSchemaNames,
-			nameMapping: getOasAdapter(adapter).options.nameMapping,
 			nodes: printer?.nodes
 		});
 		return /* @__PURE__ */ jsxs(File, {
@@ -1548,7 +1608,7 @@ const typeGenerator = defineGenerator({
 	},
 	operation(node, ctx) {
 		const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options;
-		const { adapter, config, resolver, root } = ctx;
+		const { config, resolver, root } = ctx;
 		const params = caseParams(node.parameters, "camelcase");
 		const meta = { file: resolver.file({
 			name: node.operationId,
@@ -1560,23 +1620,21 @@ const typeGenerator = defineGenerator({
 			group: group ?? void 0
 		}) };
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
+		const importName = (schemaName) => resolveImportName({
+			schemaName,
+			enumOptions,
+			enumSchemaNames,
+			resolver
+		});
 		function renderSchemaType({ schema, name, keysToOmit }) {
 			if (!schema) return null;
-			const imports = adapter.getImports(schema, (schemaName) => ({
-				name: resolveImportName({
-					schemaName,
-					enumOptions,
-					enumSchemaNames,
-					resolver
-				}),
-				path: resolver.file({
-					name: schemaName,
-					extname: ".ts",
-					root,
-					output,
-					group: group ?? void 0
-				}).path
-			}));
+			const imports = resolver.imports({
+				node: schema,
+				root,
+				output,
+				group: group ?? void 0,
+				name: importName
+			});
 			const schemaPrinter = printerTs({
 				optionalType,
 				arrayType,
@@ -1587,7 +1645,6 @@ const typeGenerator = defineGenerator({
 				keysToOmit,
 				resolver,
 				enumSchemaNames,
-				nameMapping: getOasAdapter(adapter).options.nameMapping,
 				nodes: printer?.nodes
 			});
 			return /* @__PURE__ */ jsxs(Fragment, { children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
@@ -1696,15 +1753,7 @@ const typeGenerator = defineGenerator({
 			if (!node.responses.some(hasSchema)) return null;
 			const responseName = resolver.response.response(node);
 			const responsesWithSchema = node.responses.filter(hasSchema);
-			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
-				name: resolveImportName({
-					schemaName,
-					enumOptions,
-					enumSchemaNames,
-					resolver
-				}),
-				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(responseName)) return null;
+			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? collectRefNames(entry.schema).map(importName) : []))).has(responseName)) return null;
 			return renderSchemaType({
 				schema: {
 					...buildResponseUnion(node, { resolver }),
@@ -1771,38 +1820,12 @@ const resolverTs = createResolver({
 	name(name) {
 		return ensureValidVarName(pascalCase(name));
 	},
-	file: { baseName({ name, extname }) {
-		return `${toFilePath(name, pascalCase)}${extname}`;
-	} },
-	param: {
-		name(node, param) {
-			return this.name(`${node.operationId} ${param.in} ${param.name}`);
-		},
-		path(node) {
-			return this.name(`${node.operationId} Path`);
-		},
-		query(node) {
-			return this.name(`${node.operationId} Query`);
-		},
-		headers(node) {
-			return this.name(`${node.operationId} Headers`);
-		}
-	},
+	file: createCasedFile(pascalCase),
+	param: createOperationParamResolver(),
 	response: {
-		status(node, statusCode) {
-			return this.name(`${node.operationId} Status ${statusCode}`);
-		},
+		...createOperationResponseResolver(),
 		options(node) {
 			return this.name(`${node.operationId} Options`);
-		},
-		responses(node) {
-			return this.name(`${node.operationId} Responses`);
-		},
-		response(node) {
-			return this.name(`${node.operationId} Response`);
-		},
-		body(node) {
-			return this.name(`${node.operationId} Body`);
 		}
 	},
 	enum: { keyName(node, enumTypeSuffix = "key") {