@kubb/plugin-ts 5.0.0-alpha.8 → 5.0.0-alpha.9

package/dist/components.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as PluginTs } from "./types-CsvB6X5Y.js";
+import { n as PluginTs } from "./types-mSXmB8WU.js";
 import { Schema } from "@kubb/plugin-oas";
 import { SchemaObject } from "@kubb/oas";
 import { FabricReactNode } from "@kubb/react-fabric/types";

package/dist/generators.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_plugin = require("./plugin-MLTxoa8p.cjs");
+const require_plugin = require("./plugin-Bunz1oGa.cjs");
 exports.typeGenerator = require_plugin.typeGenerator$1;
 exports.typeGeneratorV2 = require_plugin.typeGenerator;

package/dist/generators.d.ts

@@ -1,11 +1,40 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as PluginTs } from "./types-CsvB6X5Y.js";
+import { n as PluginTs } from "./types-mSXmB8WU.js";
 import * as _kubb_core0 from "@kubb/core";
-import { AsyncEventEmitter, Config, FileMetaBase, Generator, Group, KubbEvents, Output, Plugin, PluginDriver, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
+import { Config, FileMetaBase, Generator, Group, KubbEvents, Output, Plugin, PluginDriver, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
 import { HttpMethod, Oas, Operation, SchemaObject, contentType } from "@kubb/oas";
 import { FabricReactNode } from "@kubb/react-fabric/types";
 import { Fabric, KubbFile } from "@kubb/fabric-core/types";
 
+//#region ../../internals/utils/src/asyncEventEmitter.d.ts
+/** A function that can be registered as an event listener, synchronous or async. */
+type AsyncListener<TArgs extends unknown[]> = (...args: TArgs) => void | Promise<void>;
+/**
+ * A typed EventEmitter that awaits all async listeners before resolving.
+ * Wraps Node's `EventEmitter` with full TypeScript event-map inference.
+ */
+declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: unknown[] }> {
+  #private;
+  /**
+   * `maxListener` controls the maximum number of listeners per event before Node emits a memory-leak warning.
+   * @default 10
+   */
+  constructor(maxListener?: number);
+  /**
+   * Emits an event and awaits all registered listeners in parallel.
+   * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+   */
+  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void>;
+  /** Registers a persistent listener for the given event. */
+  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /** Registers a one-shot listener that removes itself after the first invocation. */
+  onOnce<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /** Removes a previously registered listener. */
+  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /** Removes all listeners from every event channel. */
+  removeAll(): void;
+}
+//#endregion
 //#region ../plugin-oas/src/types.d.ts
 type GetOasOptions = {
   validate?: boolean;

package/dist/generators.js

@@ -1,2 +1,2 @@
-import { i as typeGenerator, r as typeGenerator$1 } from "./plugin-D5NGPj0v.js";
+import { a as typeGenerator, r as typeGenerator$1 } from "./plugin-BZkBwnEA.js";
 export { typeGenerator, typeGenerator$1 as typeGeneratorV2 };

package/dist/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_plugin = require("./plugin-MLTxoa8p.cjs");
+const require_plugin = require("./plugin-Bunz1oGa.cjs");
 exports.pluginTs = require_plugin.pluginTs;
 exports.pluginTsName = require_plugin.pluginTsName;
+exports.resolverTs = require_plugin.resolverTs;

package/dist/index.d.ts

@@ -1,10 +1,49 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as PluginTs, t as Options } from "./types-CsvB6X5Y.js";
+import { n as PluginTs, t as Options } from "./types-mSXmB8WU.js";
 import * as _kubb_core0 from "@kubb/core";
+import * as _kubb_ast_types0 from "@kubb/ast/types";
 
 //#region src/plugin.d.ts
 declare const pluginTsName = "plugin-ts";
 declare const pluginTs: (options?: Options | undefined) => _kubb_core0.UserPluginWithLifeCycle<PluginTs>;
 //#endregion
-export { type PluginTs, pluginTs, pluginTsName };
+//#region src/resolverTs.d.ts
+/**
+ * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
+ * helpers used by the plugin. Import this in other plugins to resolve the exact names and
+ * paths that `plugin-ts` generates without hardcoding the conventions.
+ *
+ * The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
+ * for identifiers/files and `pascalCase` for type names.
+ *
+ * @example
+ * ```ts
+ * import { resolver } from '@kubb/plugin-ts'
+ *
+ * resolver.default('list pets', 'type')              // → 'ListPets'
+ * resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'
+ * resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'
+ * resolver.resolvePathName('list pets', 'file')       // → 'listPets'
+ * ```
+ */
+declare const resolverTs: _kubb_core0.Resolver & {
+  resolveName(name: string): string;
+  resolveTypedName(name: string): string;
+  resolvePathName(name: string, type?: "file" | "function" | "type" | "const"): string;
+  resolveParamName(node: _kubb_ast_types0.OperationNode, param: _kubb_ast_types0.ParameterNode): string;
+  resolveParamTypedName(node: _kubb_ast_types0.OperationNode, param: _kubb_ast_types0.ParameterNode): string;
+  resolveResponseStatusName(node: _kubb_ast_types0.OperationNode, statusCode: _kubb_ast_types0.StatusCode): string;
+  resolveResponseStatusTypedName(node: _kubb_ast_types0.OperationNode, statusCode: _kubb_ast_types0.StatusCode): string;
+  resolveDataName(node: _kubb_ast_types0.OperationNode): string;
+  resolveDataTypedName(node: _kubb_ast_types0.OperationNode): string;
+  resolveRequestConfigName(node: _kubb_ast_types0.OperationNode): string;
+  resolveRequestConfigTypedName(node: _kubb_ast_types0.OperationNode): string;
+  resolveResponsesName(node: _kubb_ast_types0.OperationNode): string;
+  resolveResponsesTypedName(node: _kubb_ast_types0.OperationNode): string;
+  resolveResponseName(node: _kubb_ast_types0.OperationNode): string;
+  resolveResponseTypedName(node: _kubb_ast_types0.OperationNode): string;
+  resolveEnumKeyTypedName(node: _kubb_ast_types0.SchemaNode): string;
+};
+//#endregion
+export { type PluginTs, pluginTs, pluginTsName, resolverTs };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,2 +1,2 @@
-import { n as pluginTsName, t as pluginTs } from "./plugin-D5NGPj0v.js";
-export { pluginTs, pluginTsName };
+import { i as resolverTs, n as pluginTsName, t as pluginTs } from "./plugin-BZkBwnEA.js";
+export { pluginTs, pluginTsName, resolverTs };

package/dist/{plugin-D5NGPj0v.js → plugin-BZkBwnEA.js}

@@ -2,7 +2,7 @@ import "./chunk--u3MIqq1.js";
 import { A as keywordTypeNodes, C as createTypeDeclaration, D as createUnionDeclaration, E as createTypeReferenceNode, F as camelCase, I as pascalCase, M as syntaxKind, N as jsStringEscape, O as createUrlTemplateType, P as trimQuotes, S as createTypeAliasDeclaration, T as createTypeOperatorNode, _ as createPropertySignature, a as createArrayTypeNode, b as createTrue, c as createIdentifier, d as createIntersectionDeclaration, f as createLiteralTypeNode, g as createPrefixUnaryExpression, h as createOptionalTypeNode, i as createArrayDeclaration, j as modifiers, k as getUnknownType, l as createIndexSignature, m as createOmitDeclaration, n as SyntaxKind, o as createEnumDeclaration, p as createNumericLiteral, r as appendJSDocToNode, s as createFalse, t as Type$1, u as createIndexedAccessTypeNode, v as createRestTypeNode, w as createTypeLiteralNode, x as createTupleTypeNode, y as createStringLiteral } from "./components-CRu8IKY3.js";
 import path from "node:path";
 import { applyParamsCasing, collect, createProperty, createSchema, isPlainStringType, walk } from "@kubb/ast";
-import { createGenerator, createPlugin, definePrinter, getBarrelFiles, getMode, resolveOptions } from "@kubb/core";
+import { createPlugin, defineGenerator, definePrinter, defineResolver, getBarrelFiles, getMode } from "@kubb/core";
 import { OperationGenerator, SchemaGenerator, buildOperation, buildSchema, isKeyword, pluginOasName, schemaKeywords } from "@kubb/plugin-oas";
 import { useKubb, useMode, usePluginDriver } from "@kubb/core/hooks";
 import { safePrint } from "@kubb/fabric-core/parsers/typescript";
@@ -555,7 +555,7 @@ const printerTs = definePrinter((options) => {
 			},
 			union(node) {
 				const members = node.members ?? [];
-				const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
+				const hasStringLiteral = members.some((m) => m.type === "enum" && (m.enumType === "string" || m.primitive === "string"));
 				const hasPlainString = members.some((m) => isPlainStringType(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
@@ -727,6 +727,81 @@ function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, synt
 	})] });
 }
 //#endregion
+//#region src/resolverTs.ts
+/**
+* Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
+* helpers used by the plugin. Import this in other plugins to resolve the exact names and
+* paths that `plugin-ts` generates without hardcoding the conventions.
+*
+* The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
+* for identifiers/files and `pascalCase` for type names.
+*
+* @example
+* ```ts
+* import { resolver } from '@kubb/plugin-ts'
+*
+* resolver.default('list pets', 'type')              // → 'ListPets'
+* resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'
+* resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'
+* resolver.resolvePathName('list pets', 'file')       // → 'listPets'
+* ```
+*/
+const resolverTs = defineResolver(() => {
+	return {
+		default(name, type) {
+			return pascalCase(name, { isFile: type === "file" });
+		},
+		resolveName(name) {
+			return this.default(name, "function");
+		},
+		resolveTypedName(name) {
+			return this.default(name, "type");
+		},
+		resolvePathName(name, type) {
+			return this.default(name, type);
+		},
+		resolveParamName(node, param) {
+			return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
+		},
+		resolveParamTypedName(node, param) {
+			return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
+		},
+		resolveResponseStatusName(node, statusCode) {
+			return this.resolveName(`${node.operationId} Status ${statusCode}`);
+		},
+		resolveResponseStatusTypedName(node, statusCode) {
+			return this.resolveTypedName(`${node.operationId} Status ${statusCode}`);
+		},
+		resolveDataName(node) {
+			return this.resolveName(`${node.operationId} Data`);
+		},
+		resolveDataTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} Data`);
+		},
+		resolveRequestConfigName(node) {
+			return this.resolveName(`${node.operationId} RequestConfig`);
+		},
+		resolveRequestConfigTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} RequestConfig`);
+		},
+		resolveResponsesName(node) {
+			return this.resolveName(`${node.operationId} Responses`);
+		},
+		resolveResponsesTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} Responses`);
+		},
+		resolveResponseName(node) {
+			return this.resolveName(`${node.operationId} Response`);
+		},
+		resolveResponseTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} Response`);
+		},
+		resolveEnumKeyTypedName(node) {
+			return `${this.resolveTypedName(node.name ?? "")}Key`;
+		}
+	};
+});
+//#endregion
 //#region src/generators/v2/utils.ts
 /**
 * Builds an `ObjectSchemaNode` for a group of parameters (path/query/header).
@@ -764,6 +839,7 @@ function buildDataSchemaNode({ node, resolveName }) {
 	const headerParams = node.parameters.filter((p) => p.in === "header");
 	return createSchema({
 		type: "object",
+		deprecated: node.deprecated,
 		properties: [
 			createProperty({
 				name: "data",
@@ -831,13 +907,13 @@ function buildDataSchemaNode({ node, resolveName }) {
 /**
 * Builds an `ObjectSchemaNode` representing `<OperationId>Responses` — keyed by HTTP status code.
 * Numeric status codes produce unquoted numeric keys (e.g. `200:`).
+* All responses are included; those without a schema are represented as a ref to a `never` type.
 */
 function buildResponsesSchemaNode({ node, resolveName }) {
-	const responsesWithSchema = node.responses.filter((res) => res.schema);
-	if (responsesWithSchema.length === 0) return null;
+	if (node.responses.length === 0) return null;
 	return createSchema({
 		type: "object",
-		properties: responsesWithSchema.map((res) => createProperty({
+		properties: node.responses.map((res) => createProperty({
 			name: String(res.statusCode),
 			schema: createSchema({
 				type: "ref",
@@ -869,12 +945,12 @@ function buildResponseUnionSchemaNode({ node, resolveName }) {
 }
 //#endregion
 //#region src/generators/v2/typeGenerator.tsx
-const typeGenerator = createGenerator({
+const typeGenerator = defineGenerator({
 	name: "typescript",
 	type: "react",
 	Operation({ node, adapter, options }) {
 		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options;
-		const { mode, getFile, resolveName } = useKubb();
+		const { mode, getFile, resolveName, resolveBanner, resolveFooter } = useKubb();
 		const file = getFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -918,37 +994,19 @@ const typeGenerator = createGenerator({
 		}
 		const paramTypes = params.map((param) => renderSchemaType({
 			node: param.schema,
-			name: resolveName({
-				name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`,
-				type: "function"
-			}),
-			typedName: resolveName({
-				name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`,
-				type: "type"
-			})
+			name: resolverTs.resolveParamName(node, param),
+			typedName: resolverTs.resolveParamTypedName(node, param)
 		}));
-		const responseTypes = node.responses.filter((res) => res.schema).map((res) => renderSchemaType({
+		const responseTypes = node.responses.map((res) => renderSchemaType({
 			node: res.schema,
-			name: resolveName({
-				name: `${node.operationId} Status ${res.statusCode}`,
-				type: "function"
-			}),
-			typedName: resolveName({
-				name: `${node.operationId} Status ${res.statusCode}`,
-				type: "type"
-			}),
+			name: resolverTs.resolveResponseStatusName(node, res.statusCode),
+			typedName: resolverTs.resolveResponseStatusTypedName(node, res.statusCode),
 			description: res.description
 		}));
 		const requestType = node.requestBody ? renderSchemaType({
 			node: node.requestBody,
-			name: resolveName({
-				name: `${node.operationId} Data`,
-				type: "function"
-			}),
-			typedName: resolveName({
-				name: `${node.operationId} Data`,
-				type: "type"
-			}),
+			name: resolverTs.resolveDataName(node),
+			typedName: resolverTs.resolveDataTypedName(node),
 			description: node.requestBody.description
 		}) : null;
 		const dataType = renderSchemaType({
@@ -959,48 +1017,32 @@ const typeGenerator = createGenerator({
 				},
 				resolveName
 			}),
-			name: resolveName({
-				name: `${node.operationId} RequestConfig`,
-				type: "function"
-			}),
-			typedName: resolveName({
-				name: `${node.operationId} RequestConfig`,
-				type: "type"
-			})
+			name: resolverTs.resolveRequestConfigName(node),
+			typedName: resolverTs.resolveRequestConfigTypedName(node)
 		});
 		const responsesType = renderSchemaType({
 			node: buildResponsesSchemaNode({
 				node,
 				resolveName
 			}),
-			name: resolveName({
-				name: `${node.operationId} Responses`,
-				type: "function"
-			}),
-			typedName: resolveName({
-				name: `${node.operationId} Responses`,
-				type: "type"
-			})
+			name: resolverTs.resolveResponsesName(node),
+			typedName: resolverTs.resolveResponsesTypedName(node)
 		});
 		const responseType = renderSchemaType({
 			node: buildResponseUnionSchemaNode({
 				node,
 				resolveName
 			}),
-			name: resolveName({
-				name: `${node.operationId} Response`,
-				type: "function"
-			}),
-			typedName: resolveName({
-				name: `${node.operationId} Response`,
-				type: "type"
-			}),
+			name: resolverTs.resolveResponseName(node),
+			typedName: resolverTs.resolveResponseTypedName(node),
 			description: "Union of all possible responses"
 		});
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: file.baseName,
 			path: file.path,
 			meta: file.meta,
+			banner: resolveBanner(),
+			footer: resolveFooter(),
 			children: [
 				paramTypes,
 				responseTypes,
@@ -1013,7 +1055,7 @@ const typeGenerator = createGenerator({
 	},
 	Schema({ node, adapter, options }) {
 		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
-		const { mode, resolveName, getFile } = useKubb();
+		const { mode, resolveName, getFile, resolveBanner, resolveFooter } = useKubb();
 		if (!node.name) return;
 		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolveName({
@@ -1027,16 +1069,9 @@ const typeGenerator = createGenerator({
 			}).path
 		}));
 		const isEnumSchema = node.type === "enum";
-		let typedName = resolveName({
-			name: node.name,
-			type: "type"
-		});
-		if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema) typedName += "Key";
+		const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolverTs.resolveEnumKeyTypedName(node) : resolverTs.resolveTypedName(node.name);
 		const type = {
-			name: resolveName({
-				name: node.name,
-				type: "function"
-			}),
+			name: resolverTs.resolveName(node.name),
 			typedName,
 			file: getFile({
 				name: node.name,
@@ -1048,6 +1083,8 @@ const typeGenerator = createGenerator({
 			baseName: type.file.baseName,
 			path: type.file.path,
 			meta: type.file.meta,
+			banner: resolveBanner(),
+			footer: resolveFooter(),
 			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: type.file.path,
 				path: imp.path,
@@ -1117,7 +1154,7 @@ const pluginTs = createPlugin((options) => {
 			return path.resolve(root, output.path, baseName);
 		},
 		resolveName(name, type) {
-			const resolvedName = pascalCase(name, { isFile: type === "file" });
+			const resolvedName = resolverTs.default(name, type);
 			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
 			return resolvedName;
 		},
@@ -1131,7 +1168,7 @@ const pluginTs = createPlugin((options) => {
 					async schema(schemaNode) {
 						const writeTasks = generators.map(async (generator) => {
 							if (generator.type === "react" && generator.version === "2") {
-								const options = resolveOptions(schemaNode, {
+								const options = resolverTs.resolveOptions(schemaNode, {
 									options: plugin.options,
 									exclude,
 									include,
@@ -1156,7 +1193,7 @@ const pluginTs = createPlugin((options) => {
 					async operation(operationNode) {
 						const writeTasks = generators.map(async (generator) => {
 							if (generator.type === "react" && generator.version === "2") {
-								const options = resolveOptions(operationNode, {
+								const options = resolverTs.resolveOptions(operationNode, {
 									options: plugin.options,
 									exclude,
 									include,
@@ -1227,6 +1264,6 @@ const pluginTs = createPlugin((options) => {
 	};
 });
 //#endregion
-export { typeGenerator$1 as i, pluginTsName as n, typeGenerator as r, pluginTs as t };
+export { typeGenerator$1 as a, resolverTs as i, pluginTsName as n, typeGenerator as r, pluginTs as t };
 
-//# sourceMappingURL=plugin-D5NGPj0v.js.map
+//# sourceMappingURL=plugin-BZkBwnEA.js.map