@kubb/plugin-ts 5.0.0-alpha.3 → 5.0.0-alpha.5

package/dist/{plugin-DmwgRHK8.js → plugin-kdQ5D2cW.js}

@@ -1,14 +1,14 @@
 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-CRjwjdyE.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-Cwn1rflQ.js";
 import path from "node:path";
-import { collect, isPlainStringType, walk } from "@kubb/ast";
-import { definePlugin, definePrinter, getBarrelFiles, getMode } from "@kubb/core";
+import { applyParamsCasing, collect, createProperty, createSchema, isPlainStringType, walk } from "@kubb/ast";
+import { defineGenerator, definePlugin, definePrinter, getBarrelFiles, getMode, resolveOptions } from "@kubb/core";
 import { OperationGenerator, SchemaGenerator, buildOperation, buildSchema, isKeyword, pluginOasName, schemaKeywords } from "@kubb/plugin-oas";
 import { useKubb, useMode, usePluginManager } from "@kubb/core/hooks";
 import { safePrint } from "@kubb/fabric-core/parsers/typescript";
 import { createReactGenerator } from "@kubb/plugin-oas/generators";
 import { useOas, useOperationManager, useSchemaManager } from "@kubb/plugin-oas/hooks";
-import { applyParamsCasing, getBanner, getFooter, getImports, isParameterSchema } from "@kubb/plugin-oas/utils";
+import { applyParamsCasing as applyParamsCasing$1, getBanner, getFooter, getImports, isParameterSchema } from "@kubb/plugin-oas/utils";
 import { File } from "@kubb/react-fabric";
 import ts from "typescript";
 import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
@@ -201,7 +201,6 @@ function printResponseSchema({ baseName, schemas, pluginManager, unknownType })
 }
 const typeGenerator$1 = createReactGenerator({
 	name: "typescript",
-	version: "1",
 	Operation({ operation, generator, plugin }) {
 		const { options, options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
 		const mode = useMode();
@@ -233,7 +232,7 @@ const typeGenerator$1 = createReactGenerator({
 			schemas.response
 		].flat().filter(Boolean);
 		const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }) => {
-			const transformedSchema = paramsCasing && isParameterSchema(name) ? applyParamsCasing(schema, paramsCasing) : schema;
+			const transformedSchema = paramsCasing && isParameterSchema(name) ? applyParamsCasing$1(schema, paramsCasing) : schema;
 			const tree = schemaGenerator.parse({
 				schema: transformedSchema,
 				name,
@@ -451,13 +450,17 @@ const printerTs = definePrinter((options) => ({
 		any: () => keywordTypeNodes.any,
 		unknown: () => keywordTypeNodes.unknown,
 		void: () => keywordTypeNodes.void,
+		never: () => keywordTypeNodes.never,
 		boolean: () => keywordTypeNodes.boolean,
 		null: () => keywordTypeNodes.null,
 		blob: () => createTypeReferenceNode("Blob", []),
 		string: () => keywordTypeNodes.string,
 		uuid: () => keywordTypeNodes.string,
 		email: () => keywordTypeNodes.string,
-		url: () => keywordTypeNodes.string,
+		url: (node) => {
+			if (node.path) return createUrlTemplateType(node.path);
+			return keywordTypeNodes.string;
+		},
 		datetime: () => keywordTypeNodes.string,
 		number: () => keywordTypeNodes.number,
 		integer: () => keywordTypeNodes.number,
@@ -514,6 +517,7 @@ const printerTs = definePrinter((options) => ({
 			const addsQuestionToken = ["questionToken", "questionTokenAndUndefined"].includes(this.options.optionalType);
 			const { print } = this;
 			const propertyNodes = node.properties.map((prop) => {
+				if (this.options.mapper && Object.hasOwn(this.options.mapper, prop.name)) return this.options.mapper[prop.name];
 				const baseType = print(prop.schema) ?? keywordTypeNodes.unknown;
 				const type = buildPropertyType(prop.schema, baseType, this.options.optionalType);
 				return appendJSDocToNode({
@@ -534,7 +538,7 @@ const printerTs = definePrinter((options) => ({
 }));
 //#endregion
 //#region src/components/v2/Type.tsx
-function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, ...rest }) {
+function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, mapper, ...rest }) {
 	const typeNodes = [];
 	const description = rest.description || node?.description;
 	const enumSchemaNodes = collect(node, { schema(n) {
@@ -543,7 +547,8 @@ function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, synt
 	let type = printerTs({
 		optionalType,
 		arrayType,
-		enumType
+		enumType,
+		mapper
 	}).print(node);
 	if (!type) return;
 	if (["asConst", "asPascalConst"].includes(enumType) && enumSchemaNodes.length > 0) {
@@ -633,29 +638,175 @@ function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, synt
 	})] });
 }
 //#endregion
+//#region src/generators/v2/utils.ts
+/**
+* Builds an `ObjectSchemaNode` for a group of parameters (path/query/header).
+* Each property is a `ref` schema pointing to the individually-resolved parameter type.
+*/
+function buildParamsSchema({ params, operationId, resolveName }) {
+	return createSchema({
+		type: "object",
+		properties: params.map((param) => createProperty({
+			name: param.name,
+			schema: createSchema({
+				type: "ref",
+				name: resolveName({
+					name: `${operationId} ${param.name}`,
+					type: "function"
+				}),
+				optional: !param.required
+			})
+		}))
+	});
+}
+/**
+* Builds an `ObjectSchemaNode` representing the `<OperationId>Data` type:
+* - `data`         → request body ref (optional) or `never`
+* - `pathParams`   → inline object of path param refs, or `never`
+* - `queryParams`  → inline object of query param refs (optional), or `never`
+* - `headerParams` → inline object of header param refs (optional), or `never`
+* - `url`          → Express-style template literal (plugin-ts extension, handled by printer)
+*/
+function buildDataSchemaNode({ node, resolveName }) {
+	const pathParams = node.parameters.filter((p) => p.in === "path");
+	const queryParams = node.parameters.filter((p) => p.in === "query");
+	const headerParams = node.parameters.filter((p) => p.in === "header");
+	return createSchema({
+		type: "object",
+		properties: [
+			createProperty({
+				name: "data",
+				schema: node.requestBody ? createSchema({
+					type: "ref",
+					name: resolveName({
+						name: `${node.operationId} MutationRequest`,
+						type: "function"
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "pathParams",
+				schema: pathParams.length > 0 ? buildParamsSchema({
+					params: pathParams,
+					operationId: node.operationId,
+					resolveName
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "queryParams",
+				schema: queryParams.length > 0 ? createSchema({
+					...buildParamsSchema({
+						params: queryParams,
+						operationId: node.operationId,
+						resolveName
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "headerParams",
+				schema: headerParams.length > 0 ? createSchema({
+					...buildParamsSchema({
+						params: headerParams,
+						operationId: node.operationId,
+						resolveName
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "url",
+				schema: createSchema({
+					type: "url",
+					path: node.path
+				})
+			})
+		]
+	});
+}
+/**
+* Builds an `ObjectSchemaNode` representing `<OperationId>Responses` — keyed by HTTP status code.
+*
+* Example output:
+* ```ts
+* export type PlaceOrderPatchResponses = { 200: PlaceOrderPatch200; 405: PlaceOrderPatch405 }
+* ```
+*/
+function buildResponsesSchemaNode({ node, resolveName }) {
+	const responsesWithSchema = node.responses.filter((res) => res.schema);
+	if (responsesWithSchema.length === 0) return null;
+	return createSchema({
+		type: "object",
+		properties: responsesWithSchema.map((res) => createProperty({
+			name: String(res.statusCode),
+			schema: createSchema({
+				type: "ref",
+				name: resolveName({
+					name: `${node.operationId} ${res.statusCode}`,
+					type: "function"
+				})
+			})
+		}))
+	});
+}
+/**
+* Builds a `UnionSchemaNode` representing `<OperationId>Response` — all response types in union format.
+*
+* Example output:
+* ```ts
+* export type PlaceOrderPatchResponse = PlaceOrderPatch200 | PlaceOrderPatch405
+* ```
+*/
+function buildResponseUnionSchemaNode({ node, resolveName }) {
+	const responsesWithSchema = node.responses.filter((res) => res.schema);
+	if (responsesWithSchema.length === 0) return null;
+	return createSchema({
+		type: "union",
+		members: responsesWithSchema.map((res) => createSchema({
+			type: "ref",
+			name: resolveName({
+				name: `${node.operationId} ${res.statusCode}`,
+				type: "function"
+			})
+		}))
+	});
+}
+//#endregion
 //#region src/generators/v2/typeGenerator.tsx
-const typeGenerator = createReactGenerator({
+const typeGenerator = defineGenerator({
 	name: "typescript",
-	version: "2",
+	type: "react",
 	Operation({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType } = options;
-		const { plugin, mode, getFile, resolveName } = useKubb();
+		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, mapper } = options;
+		const { mode, getFile, resolveName } = useKubb();
 		const file = getFile({
 			name: node.operationId,
-			pluginName: plugin.name,
 			extname: ".ts",
 			mode
 		});
+		const params = applyParamsCasing(node.parameters, paramsCasing);
 		function renderSchemaType({ node: schemaNode, name, typedName, description }) {
+			if (!schemaNode) return null;
 			const imports = adapter.getImports(schemaNode, (schemaName) => ({
 				name: resolveName({
 					name: schemaName,
-					pluginName: plugin.name,
 					type: "type"
 				}),
 				path: getFile({
 					name: schemaName,
-					pluginName: plugin.name,
 					extname: ".ts",
 					mode
 				}).path
@@ -678,63 +829,90 @@ const typeGenerator = createReactGenerator({
 				enumKeyCasing,
 				optionalType,
 				arrayType,
-				syntaxType
+				syntaxType,
+				mapper
 			})] });
 		}
-		const paramTypes = node.parameters.map((param) => {
-			const name = resolveName({
+		const paramTypes = params.map((param) => renderSchemaType({
+			node: param.schema,
+			name: resolveName({
 				name: `${node.operationId} ${param.name}`,
-				pluginName: plugin.name,
 				type: "function"
-			});
-			const typedName = resolveName({
+			}),
+			typedName: resolveName({
 				name: `${node.operationId} ${param.name}`,
-				pluginName: plugin.name,
 				type: "type"
-			});
-			return renderSchemaType({
-				node: param.schema,
-				name,
-				typedName
-			});
+			})
+		}));
+		const responseTypes = node.responses.filter((res) => res.schema).map((res) => renderSchemaType({
+			node: res.schema,
+			name: resolveName({
+				name: `${node.operationId} ${res.statusCode}`,
+				type: "function"
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} ${res.statusCode}`,
+				type: "type"
+			}),
+			description: res.description
+		}));
+		const requestType = node.requestBody ? renderSchemaType({
+			node: node.requestBody,
+			name: resolveName({
+				name: `${node.operationId} MutationRequest`,
+				type: "function"
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} MutationRequest`,
+				type: "type"
+			}),
+			description: node.requestBody.description
+		}) : null;
+		const dataType = renderSchemaType({
+			node: buildDataSchemaNode({
+				node: {
+					...node,
+					parameters: params
+				},
+				resolveName
+			}),
+			name: resolveName({
+				name: `${node.operationId} Data`,
+				type: "function"
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} Data`,
+				type: "type"
+			})
 		});
-		const responseTypes = node.responses.filter((res) => res.schema).map((res) => {
-			const schemaNode = res.schema;
-			const responseName = `${node.operationId} ${res.statusCode}`;
-			return renderSchemaType({
-				node: schemaNode,
-				name: resolveName({
-					name: responseName,
-					pluginName: plugin.name,
-					type: "function"
-				}),
-				typedName: resolveName({
-					name: responseName,
-					pluginName: plugin.name,
-					type: "type"
-				}),
-				description: res.description
-			});
+		const responsesType = renderSchemaType({
+			node: buildResponsesSchemaNode({
+				node,
+				resolveName
+			}),
+			name: resolveName({
+				name: `${node.operationId} Responses`,
+				type: "function"
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} Responses`,
+				type: "type"
+			})
 		});
-		const requestType = node.requestBody ? (() => {
-			const requestName = `${node.operationId} MutationRequest`;
-			const resolvedName = resolveName({
-				name: requestName,
-				pluginName: plugin.name,
+		const responseType = renderSchemaType({
+			node: buildResponseUnionSchemaNode({
+				node,
+				resolveName
+			}),
+			name: resolveName({
+				name: `${node.operationId} Response`,
 				type: "function"
-			});
-			const typedName = resolveName({
-				name: requestName,
-				pluginName: plugin.name,
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} Response`,
 				type: "type"
-			});
-			return renderSchemaType({
-				node: node.requestBody,
-				name: resolvedName,
-				typedName,
-				description: node.requestBody.description
-			});
-		})() : null;
+			})
+		});
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: file.baseName,
 			path: file.path,
@@ -742,23 +920,24 @@ const typeGenerator = createReactGenerator({
 			children: [
 				paramTypes,
 				responseTypes,
-				requestType
+				requestType,
+				dataType,
+				responsesType,
+				responseType
 			]
 		});
 	},
 	Schema({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
-		const { plugin, mode, resolveName, getFile } = useKubb();
+		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, mapper } = options;
+		const { mode, resolveName, getFile } = useKubb();
 		if (!node.name) return;
 		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolveName({
 				name: schemaName,
-				pluginName: plugin.name,
 				type: "type"
 			}),
 			path: getFile({
 				name: schemaName,
-				pluginName: plugin.name,
 				extname: ".ts",
 				mode
 			}).path
@@ -766,20 +945,17 @@ const typeGenerator = createReactGenerator({
 		const isEnumSchema = node.type === "enum";
 		let typedName = resolveName({
 			name: node.name,
-			pluginName: plugin.name,
 			type: "type"
 		});
-		if (["asConst", "asPascalConst"].includes(enumType) && isEnumSchema) typedName = typedName += "Key";
+		if (["asConst", "asPascalConst"].includes(enumType) && isEnumSchema) typedName += "Key";
 		const type = {
 			name: resolveName({
 				name: node.name,
-				pluginName: plugin.name,
 				type: "function"
 			}),
 			typedName,
 			file: getFile({
 				name: node.name,
-				pluginName: plugin.name,
 				extname: ".ts",
 				mode
 			})
@@ -805,7 +981,8 @@ const typeGenerator = createReactGenerator({
 				enumKeyCasing,
 				optionalType,
 				arrayType,
-				syntaxType
+				syntaxType,
+				mapper
 			})]
 		});
 	}
@@ -870,34 +1047,63 @@ const pluginTs = definePlugin((options) => {
 				await openInStudio({ ast: true });
 				await walk(rootNode, {
 					async schema(schemaNode) {
-						await generators.map(async (generator) => {
-							if (generator.type === "react" && generator.version === "2") await buildSchema(schemaNode, {
-								adapter,
-								config,
-								fabric,
-								Component: generator.Schema,
-								plugin,
-								pluginManager,
-								mode,
-								version: generator.version
-							});
+						const writeTasks = generators.map(async (generator) => {
+							if (generator.type === "react" && generator.version === "2") {
+								const options = resolveOptions(schemaNode, {
+									options: plugin.options,
+									exclude,
+									include,
+									override
+								});
+								if (options === null) return;
+								await buildSchema(schemaNode, {
+									options,
+									adapter,
+									config,
+									fabric,
+									Component: generator.Schema,
+									plugin,
+									pluginManager,
+									mode,
+									version: generator.version
+								});
+							}
 						});
+						await Promise.all(writeTasks);
 					},
 					async operation(operationNode) {
-						await generators.map(async (generator) => {
-							if (generator.type === "react" && generator.version === "2") await buildOperation(operationNode, {
-								adapter,
-								config,
-								fabric,
-								Component: generator.Operation,
-								plugin,
-								pluginManager,
-								mode,
-								version: generator.version
-							});
+						const writeTasks = generators.map(async (generator) => {
+							if (generator.type === "react" && generator.version === "2") {
+								const options = resolveOptions(operationNode, {
+									options: plugin.options,
+									exclude,
+									include,
+									override
+								});
+								if (options === null) return;
+								await buildOperation(operationNode, {
+									options,
+									adapter,
+									config,
+									fabric,
+									Component: generator.Operation,
+									plugin,
+									pluginManager,
+									mode,
+									version: generator.version
+								});
+							}
 						});
+						await Promise.all(writeTasks);
 					}
 				}, { depth: "shallow" });
+				const barrelFiles = await getBarrelFiles(this.fabric.files, {
+					type: output.barrelType ?? "named",
+					root,
+					output,
+					meta: { pluginName: this.plugin.name }
+				});
+				await this.upsertFile(...barrelFiles);
 				return;
 			}
 			const oas = await this.getOas();
@@ -941,4 +1147,4 @@ const pluginTs = definePlugin((options) => {
 //#endregion
 export { typeGenerator$1 as i, pluginTsName as n, typeGenerator as r, pluginTs as t };
 
-//# sourceMappingURL=plugin-DmwgRHK8.js.map
+//# sourceMappingURL=plugin-kdQ5D2cW.js.map