@kubb/plugin-ts 5.0.0-alpha.26 → 5.0.0-alpha.28

package/dist/index.js

@@ -2,7 +2,7 @@ import "./chunk--u3MIqq1.js";
 import path from "node:path";
 import { safePrint } from "@kubb/fabric-core/parsers/typescript";
 import { File } from "@kubb/react-fabric";
-import { caseParams, collect, composeTransformers, createPrinterFactory, createProperty, createSchema, extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef, transform, walk } from "@kubb/ast";
+import { caseParams, collect, createPrinterFactory, createProperty, createSchema, extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef, transform, walk } from "@kubb/ast";
 import { isNumber } from "remeda";
 import ts from "typescript";
 import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
@@ -532,6 +532,42 @@ function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
 	})] });
 }
 //#endregion
+//#region src/components/Type.tsx
+function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
+	const enumSchemaNodes = collect(node, { schema(n) {
+		const enumNode = narrowSchema(n, schemaTypes.enum);
+		if (enumNode?.name) return enumNode;
+	} });
+	const output = printer.print(node);
+	if (!output) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+		return {
+			node,
+			...getEnumNames({
+				node,
+				enumType,
+				enumTypeSuffix,
+				resolver
+			})
+		};
+	});
+	const shouldExportEnums = enumType !== "inlineLiteral";
+	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
+		node,
+		enumType,
+		enumTypeSuffix,
+		enumKeyCasing,
+		resolver
+	})), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] });
+}
+//#endregion
 //#region src/utils.ts
 /**
 * Collects JSDoc annotation strings for a schema node.
@@ -784,7 +820,8 @@ const printerTs = definePrinter((options) => {
 				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, transform)];
 				if (!allElements.length) return keywordTypeNodes.object;
 				return createTypeLiteralNode(allElements);
-			}
+			},
+			...options.nodes
 		},
 		print(node) {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
@@ -818,68 +855,20 @@ const printerTs = definePrinter((options) => {
 	};
 });
 //#endregion
-//#region src/components/Type.tsx
-function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumTypeSuffix, enumKeyCasing, description, resolver, enumSchemaNames }) {
-	const resolvedDescription = description || node?.description;
-	const enumSchemaNodes = collect(node, { schema(n) {
-		const enumNode = narrowSchema(n, schemaTypes.enum);
-		if (enumNode?.name) return enumNode;
-	} });
-	const output = printerTs({
-		optionalType,
-		arrayType,
-		enumType,
-		enumTypeSuffix,
-		name,
-		syntaxType,
-		description: resolvedDescription,
-		keysToOmit,
-		resolver,
-		enumSchemaNames
-	}).print(node);
-	if (!output) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-		return {
-			node,
-			...getEnumNames({
-				node,
-				enumType,
-				enumTypeSuffix,
-				resolver
-			})
-		};
-	});
-	const shouldExportEnums = enumType !== "inlineLiteral";
-	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
-		node,
-		enumType,
-		enumTypeSuffix,
-		enumKeyCasing,
-		resolver
-	})), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] });
-}
-//#endregion
 //#region src/generators/typeGenerator.tsx
 const typeGenerator = defineGenerator({
 	name: "typescript",
 	type: "react",
-	Schema({ node, adapter, options, config, resolver }) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
-		const transformedNode = transform(node, composeTransformers(...transformers));
+	Schema({ node, adapter, options, config, resolver, plugin }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = options;
+		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
 		if (!transformedNode.name) return;
 		const root = path.resolve(config.root, config.output.path);
 		const mode = getMode(path.resolve(root, output.path));
 		const enumSchemaNames = new Set((adapter.rootNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
 		function resolveImportName(schemaName) {
 			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
-			return resolver.default(schemaName, "type");
+			return resolver.resolveTypeName(schemaName);
 		}
 		const imports = adapter.getImports(transformedNode, (schemaName) => ({
 			name: resolveImportName(schemaName),
@@ -894,7 +883,7 @@ const typeGenerator = defineGenerator({
 		}));
 		const isEnumSchema = !!narrowSchema(transformedNode, schemaTypes.enum);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix) : resolver.resolveName(transformedNode.name),
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix) : resolver.resolveTypeName(transformedNode.name),
 			file: resolver.resolveFile({
 				name: transformedNode.name,
 				extname: ".ts"
@@ -904,6 +893,18 @@ const typeGenerator = defineGenerator({
 				group
 			})
 		};
+		const schemaPrinter = printerTs({
+			optionalType,
+			arrayType,
+			enumType,
+			enumTypeSuffix,
+			name: meta.name,
+			syntaxType,
+			description: transformedNode.description,
+			resolver,
+			enumSchemaNames,
+			nodes: printer?.nodes
+		});
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
@@ -931,17 +932,14 @@ const typeGenerator = defineGenerator({
 				enumType,
 				enumTypeSuffix,
 				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
 				resolver,
-				enumSchemaNames
+				printer: schemaPrinter
 			})]
 		});
 	},
-	Operation({ node, adapter, options, config, resolver }) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
-		const transformedNode = transform(node, composeTransformers(...transformers));
+	Operation({ node, adapter, options, config, resolver, plugin }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = options;
+		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
 		const root = path.resolve(config.root, config.output.path);
 		const mode = getMode(path.resolve(root, output.path));
 		const params = caseParams(transformedNode.parameters, paramsCasing);
@@ -958,7 +956,7 @@ const typeGenerator = defineGenerator({
 		const enumSchemaNames = new Set((adapter.rootNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
 		function resolveImportName(schemaName) {
 			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
-			return resolver.default(schemaName, "type");
+			return resolver.resolveTypeName(schemaName);
 		}
 		function renderSchemaType({ schema, name, keysToOmit }) {
 			if (!schema) return null;
@@ -973,6 +971,19 @@ const typeGenerator = defineGenerator({
 					group
 				}).path
 			}));
+			const schemaPrinter = printerTs({
+				optionalType,
+				arrayType,
+				enumType,
+				enumTypeSuffix,
+				name,
+				syntaxType,
+				description: schema.description,
+				keysToOmit,
+				resolver,
+				enumSchemaNames,
+				nodes: printer?.nodes
+			});
 			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
@@ -988,12 +999,8 @@ const typeGenerator = defineGenerator({
 				enumType,
 				enumTypeSuffix,
 				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
 				resolver,
-				keysToOmit,
-				enumSchemaNames
+				printer: schemaPrinter
 			})] });
 		}
 		const paramTypes = params.map((param) => renderSchemaType({
@@ -1056,9 +1063,6 @@ const typeGenerator = defineGenerator({
 });
 //#endregion
 //#region src/resolvers/resolverTs.ts
-function toTypeName(name, type) {
-	return pascalCase(name, { isFile: type === "file" });
-}
 /**
 * 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
@@ -1081,34 +1085,34 @@ const resolverTs = defineResolver(() => {
 		name: "default",
 		pluginName: "plugin-ts",
 		default(name, type) {
-			return toTypeName(name, type);
+			return pascalCase(name, { isFile: type === "file" });
 		},
-		resolveName(name) {
-			return this.default(name, "function");
+		resolveTypeName(name) {
+			return pascalCase(name);
 		},
 		resolvePathName(name, type) {
-			return this.default(name, type);
+			return pascalCase(name, { isFile: type === "file" });
 		},
 		resolveParamName(node, param) {
-			return this.resolveName(`${node.operationId} ${param.in} ${param.name}`);
+			return this.resolveTypeName(`${node.operationId} ${param.in} ${param.name}`);
 		},
 		resolveResponseStatusName(node, statusCode) {
-			return this.resolveName(`${node.operationId} Status ${statusCode}`);
+			return this.resolveTypeName(`${node.operationId} Status ${statusCode}`);
 		},
 		resolveDataName(node) {
-			return this.resolveName(`${node.operationId} Data`);
+			return this.resolveTypeName(`${node.operationId} Data`);
 		},
 		resolveRequestConfigName(node) {
-			return this.resolveName(`${node.operationId} RequestConfig`);
+			return this.resolveTypeName(`${node.operationId} RequestConfig`);
 		},
 		resolveResponsesName(node) {
-			return this.resolveName(`${node.operationId} Responses`);
+			return this.resolveTypeName(`${node.operationId} Responses`);
 		},
 		resolveResponseName(node) {
-			return this.resolveName(`${node.operationId} Response`);
+			return this.resolveTypeName(`${node.operationId} Response`);
 		},
 		resolveEnumKeyName(node, enumTypeSuffix = "key") {
-			return `${this.resolveName(node.name ?? "")}${enumTypeSuffix}`;
+			return `${this.resolveTypeName(node.name ?? "")}${enumTypeSuffix}`;
 		},
 		resolvePathParamsName(node, param) {
 			return this.resolveParamName(node, param);
@@ -1151,29 +1155,29 @@ const resolverTsLegacy = defineResolver(() => {
 		...resolverTs,
 		pluginName: "plugin-ts",
 		resolveResponseStatusName(node, statusCode) {
-			if (statusCode === "default") return this.resolveName(`${node.operationId} Error`);
-			return this.resolveName(`${node.operationId} ${statusCode}`);
+			if (statusCode === "default") return this.resolveTypeName(`${node.operationId} Error`);
+			return this.resolveTypeName(`${node.operationId} ${statusCode}`);
 		},
 		resolveDataName(node) {
 			const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
-			return this.resolveName(`${node.operationId} ${suffix}`);
+			return this.resolveTypeName(`${node.operationId} ${suffix}`);
 		},
 		resolveResponsesName(node) {
 			const suffix = node.method === "GET" ? "Query" : "Mutation";
-			return this.resolveName(`${node.operationId} ${suffix}`);
+			return this.resolveTypeName(`${node.operationId} ${suffix}`);
 		},
 		resolveResponseName(node) {
 			const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
-			return this.resolveName(`${node.operationId} ${suffix}`);
+			return this.resolveTypeName(`${node.operationId} ${suffix}`);
 		},
 		resolvePathParamsName(node, _param) {
-			return this.resolveName(`${node.operationId} PathParams`);
+			return this.resolveTypeName(`${node.operationId} PathParams`);
 		},
 		resolveQueryParamsName(node, _param) {
-			return this.resolveName(`${node.operationId} QueryParams`);
+			return this.resolveTypeName(`${node.operationId} QueryParams`);
 		},
 		resolveHeaderParamsName(node, _param) {
-			return this.resolveName(`${node.operationId} HeaderParams`);
+			return this.resolveTypeName(`${node.operationId} HeaderParams`);
 		}
 	};
 });
@@ -1332,14 +1336,14 @@ function nameUnnamedEnums(node, parentName) {
 const typeGeneratorLegacy = defineGenerator({
 	name: "typescript-legacy",
 	type: "react",
-	Schema({ node, adapter, options, config, resolver }) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
-		const transformedNode = transform(node, composeTransformers(...transformers));
+	Schema({ node, adapter, options, config, resolver, plugin }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group } = options;
+		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
 		if (!transformedNode.name) return;
 		const root = path.resolve(config.root, config.output.path);
 		const mode = getMode(path.resolve(root, output.path));
 		const imports = adapter.getImports(transformedNode, (schemaName) => ({
-			name: resolver.default(schemaName, "type"),
+			name: resolver.resolveTypeName(schemaName),
 			path: resolver.resolveFile({
 				name: schemaName,
 				extname: ".ts"
@@ -1351,7 +1355,7 @@ const typeGeneratorLegacy = defineGenerator({
 		}));
 		const isEnumSchema = !!narrowSchema(transformedNode, schemaTypes.enum);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix) : resolver.resolveName(transformedNode.name),
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix) : resolver.resolveTypeName(transformedNode.name),
 			file: resolver.resolveFile({
 				name: transformedNode.name,
 				extname: ".ts"
@@ -1361,6 +1365,16 @@ const typeGeneratorLegacy = defineGenerator({
 				group
 			})
 		};
+		const schemaPrinter = printerTs({
+			optionalType,
+			arrayType,
+			enumType,
+			enumTypeSuffix,
+			name: meta.name,
+			syntaxType,
+			description: transformedNode.description,
+			resolver
+		});
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
@@ -1388,16 +1402,14 @@ const typeGeneratorLegacy = defineGenerator({
 				enumType,
 				enumTypeSuffix,
 				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
-				resolver
+				resolver,
+				printer: schemaPrinter
 			})]
 		});
 	},
-	Operation({ node, adapter, options, config, resolver }) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
-		const transformedNode = transform(node, composeTransformers(...transformers));
+	Operation({ node, adapter, options, config, resolver, plugin }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output } = options;
+		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
 		const root = path.resolve(config.root, config.output.path);
 		const mode = getMode(path.resolve(root, output.path));
 		const params = caseParams(node.parameters, paramsCasing);
@@ -1414,7 +1426,7 @@ const typeGeneratorLegacy = defineGenerator({
 		function renderSchemaType({ schema, name, description, keysToOmit }) {
 			if (!schema) return null;
 			const imports = adapter.getImports(schema, (schemaName) => ({
-				name: resolver.default(schemaName, "type"),
+				name: resolver.resolveTypeName(schemaName),
 				path: resolver.resolveFile({
 					name: schemaName,
 					extname: ".ts"
@@ -1424,6 +1436,17 @@ const typeGeneratorLegacy = defineGenerator({
 					group
 				}).path
 			}));
+			const opPrinter = printerTs({
+				optionalType,
+				arrayType,
+				enumType,
+				enumTypeSuffix,
+				name,
+				syntaxType,
+				description,
+				keysToOmit,
+				resolver
+			});
 			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
@@ -1436,15 +1459,11 @@ const typeGeneratorLegacy = defineGenerator({
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name,
 				node: schema,
-				description,
 				enumType,
 				enumTypeSuffix,
 				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
 				resolver,
-				keysToOmit
+				printer: opPrinter
 			})] });
 		}
 		const pathParams = params.filter((p) => p.in === "path");
@@ -1530,13 +1549,15 @@ const typeGeneratorLegacy = defineGenerator({
 const presets = definePresets({
 	default: {
 		name: "default",
-		resolvers: [resolverTs],
-		generators: [typeGenerator]
+		resolver: resolverTs,
+		generators: [typeGenerator],
+		printer: printerTs
 	},
 	kubbV4: {
 		name: "kubbV4",
-		resolvers: [resolverTsLegacy],
-		generators: [typeGeneratorLegacy]
+		resolver: resolverTsLegacy,
+		generators: [typeGeneratorLegacy],
+		printer: printerTs
 	}
 });
 //#endregion
@@ -1565,12 +1586,12 @@ const pluginTs = createPlugin((options) => {
 	const { output = {
 		path: "types",
 		barrelType: "named"
-	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, compatibilityPreset = "default", resolvers: userResolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = options;
+	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, printer, compatibilityPreset = "default", resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
 	const preset = getPreset({
 		preset: compatibilityPreset,
 		presets,
-		resolvers: userResolvers,
-		transformers: userTransformers,
+		resolver: userResolver,
+		transformer: userTransformer,
 		generators: userGenerators
 	});
 	let resolveNameWarning = false;
@@ -1580,6 +1601,9 @@ const pluginTs = createPlugin((options) => {
 		get resolver() {
 			return preset.resolver;
 		},
+		get transformer() {
+			return preset.transformer;
+		},
 		get options() {
 			return {
 				output,
@@ -1597,7 +1621,7 @@ const pluginTs = createPlugin((options) => {
 				enumKeyCasing,
 				syntaxType,
 				paramsCasing,
-				transformers: preset.transformers
+				printer
 			};
 		},
 		resolvePath(baseName, pathMode, options) {
@@ -1723,7 +1747,8 @@ const functionPrinter = defineFunctionPrinter((options) => ({
 			if (node.variant === "member") return `${node.base}['${node.key}']`;
 			if (node.variant === "struct") return `{ ${node.properties.map((p) => {
 				const typeStr = this.transform(p.type);
-				return p.optional ? `${p.name}?: ${typeStr}` : `${p.name}: ${typeStr}`;
+				const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
+				return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
 			}).join("; ")} }`;
 			if (node.variant === "reference") return node.name;
 			return null;