@kubb/plugin-ts 5.0.0-alpha.21 → 5.0.0-alpha.23

package/dist/chunk-ByKO4r7w.cjs

@@ -1,38 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-Object.defineProperty(exports, "__name", {
-	enumerable: true,
-	get: function() {
-		return __name;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});

package/dist/components.cjs

@@ -1,4 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_Type = require("./Type-oFwUfkZv.cjs");
-exports.Enum = require_Type.Enum;
-exports.Type = require_Type.Type;

package/dist/components.d.ts

@@ -1,67 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { i as ResolverTs, r as PluginTs } from "./types-BcyuFDn9.js";
-import { EnumSchemaNode, SchemaNode } from "@kubb/ast/types";
-import { FabricReactNode } from "@kubb/react-fabric/types";
-
-//#region src/components/Enum.d.ts
-type Props$1 = {
-  node: EnumSchemaNode;
-  enumType: PluginTs['resolvedOptions']['enumType'];
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing'];
-  resolver: ResolverTs;
-};
-/**
- * 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.
- */
-/**
- * Renders the enum declaration(s) for a single named `EnumSchemaNode`.
- *
- * Depending on `enumType` this may emit:
- * - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias
- * - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
- * - A union literal type alias (`literal`)
- *
- * The emitted `File.Source` nodes carry the resolved names so that the barrel
- * index picks up the correct export identifiers.
- */
-declare function Enum({
-  node,
-  enumType,
-  enumKeyCasing,
-  resolver
-}: Props$1): FabricReactNode;
-//#endregion
-//#region src/components/Type.d.ts
-type Props = {
-  name: string;
-  typedName: string;
-  node: SchemaNode;
-  optionalType: PluginTs['resolvedOptions']['optionalType'];
-  arrayType: PluginTs['resolvedOptions']['arrayType'];
-  enumType: PluginTs['resolvedOptions']['enumType'];
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing'];
-  syntaxType: PluginTs['resolvedOptions']['syntaxType'];
-  resolver: PluginTs['resolvedOptions']['resolver'];
-  description?: string;
-  keysToOmit?: string[];
-};
-declare function Type({
-  name,
-  typedName,
-  node,
-  keysToOmit,
-  optionalType,
-  arrayType,
-  syntaxType,
-  enumType,
-  enumKeyCasing,
-  description,
-  resolver
-}: Props): FabricReactNode;
-//#endregion
-export { Enum, Type };
-//# sourceMappingURL=components.d.ts.map

package/dist/components.js

@@ -1,2 +0,0 @@
-import { n as Enum, t as Type } from "./Type-B6fo0gSk.js";
-export { Enum, Type };

package/dist/generators-ByK18qUn.js

@@ -1,551 +0,0 @@
-import "./chunk--u3MIqq1.js";
-import { t as builderTs } from "./builderTs-DausqHpc.js";
-import { n as pascalCase } from "./casing-BJHFg-zZ.js";
-import { r as ENUM_TYPES_WITH_KEY_SUFFIX } from "./printerTs-BgZucv4T.js";
-import { t as Type } from "./Type-B6fo0gSk.js";
-import { t as resolverTsLegacy } from "./resolverTsLegacy-DLl854-P.js";
-import path from "node:path";
-import { caseParams, composeTransformers, createProperty, createSchema, narrowSchema, schemaTypes, transform } from "@kubb/ast";
-import { defineGenerator, getMode } from "@kubb/core";
-import { File } from "@kubb/react-fabric";
-import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
-//#region src/generators/typeGenerator.tsx
-const typeGenerator = defineGenerator({
-	name: "typescript",
-	type: "react",
-	Operation({ node, adapter, options, config }) {
-		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
-		const file = resolver.resolveFile({
-			name: node.operationId,
-			extname: ".ts",
-			tag: node.tags[0] ?? "default",
-			path: node.path
-		}, {
-			root,
-			output,
-			group
-		});
-		const params = caseParams(node.parameters, paramsCasing);
-		function renderSchemaType({ node: schemaNode, name, typedName, description, keysToOmit }) {
-			if (!schemaNode) return null;
-			const transformedNode = transform(schemaNode, composeTransformers(...transformers));
-			const imports = adapter.getImports(transformedNode, (schemaName) => ({
-				name: resolver.default(schemaName, "type"),
-				path: resolver.resolveFile({
-					name: schemaName,
-					extname: ".ts"
-				}, {
-					root,
-					output,
-					group
-				}).path
-			}));
-			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-				root: file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ jsx(Type, {
-				name,
-				typedName,
-				node: transformedNode,
-				description,
-				enumType,
-				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
-				resolver,
-				keysToOmit
-			})] });
-		}
-		const paramTypes = params.map((param) => renderSchemaType({
-			node: param.schema,
-			name: resolver.resolveParamName(node, param),
-			typedName: resolver.resolveParamTypedName(node, param)
-		}));
-		const requestType = node.requestBody?.schema ? renderSchemaType({
-			node: node.requestBody.schema,
-			name: resolver.resolveDataName(node),
-			typedName: resolver.resolveDataTypedName(node),
-			description: node.requestBody.description ?? node.requestBody.schema.description,
-			keysToOmit: node.requestBody.keysToOmit
-		}) : null;
-		const responseTypes = node.responses.map((res) => renderSchemaType({
-			node: res.schema,
-			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
-			description: res.description,
-			keysToOmit: res.keysToOmit
-		}));
-		const dataType = renderSchemaType({
-			node: builderTs.buildData({
-				node: {
-					...node,
-					parameters: params
-				},
-				resolver
-			}),
-			name: resolver.resolveRequestConfigName(node),
-			typedName: resolver.resolveRequestConfigTypedName(node)
-		});
-		const responsesType = renderSchemaType({
-			node: builderTs.buildResponses({
-				node,
-				resolver
-			}),
-			name: resolver.resolveResponsesName(node),
-			typedName: resolver.resolveResponsesTypedName(node)
-		});
-		const responseType = renderSchemaType({
-			node: builderTs.buildResponseUnion({
-				node,
-				resolver
-			}),
-			name: resolver.resolveResponseName(node),
-			typedName: resolver.resolveResponseTypedName(node),
-			description: "Union of all possible responses"
-		});
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: file.baseName,
-			path: file.path,
-			meta: file.meta,
-			banner: resolver.resolveBanner(adapter.rootNode, {
-				output,
-				config
-			}),
-			footer: resolver.resolveFooter(adapter.rootNode, {
-				output,
-				config
-			}),
-			children: [
-				paramTypes,
-				responseTypes,
-				requestType,
-				dataType,
-				responsesType,
-				responseType
-			]
-		});
-	},
-	Schema({ node, adapter, options, config }) {
-		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
-		if (!node.name) return;
-		const transformedNode = transform(node, composeTransformers(...transformers));
-		const imports = adapter.getImports(transformedNode, (schemaName) => ({
-			name: resolver.default(schemaName, "type"),
-			path: resolver.resolveFile({
-				name: schemaName,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			}).path
-		}));
-		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
-		const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name);
-		const type = {
-			name: resolver.resolveName(node.name),
-			typedName,
-			file: resolver.resolveFile({
-				name: node.name,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			})
-		};
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: type.file.baseName,
-			path: type.file.path,
-			meta: type.file.meta,
-			banner: resolver.resolveBanner(adapter.rootNode, {
-				output,
-				config
-			}),
-			footer: resolver.resolveFooter(adapter.rootNode, {
-				output,
-				config
-			}),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-				root: type.file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				node.name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ jsx(Type, {
-				name: type.name,
-				typedName: type.typedName,
-				node: transformedNode,
-				enumType,
-				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
-				resolver
-			})]
-		});
-	}
-});
-//#endregion
-//#region src/generators/typeGeneratorLegacy.tsx
-function buildGroupedParamsSchema({ params, parentName }) {
-	return createSchema({
-		type: "object",
-		properties: params.map((param) => {
-			let schema = param.schema;
-			if (narrowSchema(schema, "enum") && !schema.name && parentName) schema = {
-				...schema,
-				name: pascalCase([
-					parentName,
-					param.name,
-					"enum"
-				].join(" "))
-			};
-			return createProperty({
-				name: param.name,
-				required: param.required,
-				schema
-			});
-		})
-	});
-}
-function buildLegacyResponsesSchemaNode({ node, resolver }) {
-	const isGet = node.method.toLowerCase() === "get";
-	const successResponses = node.responses.filter((res) => {
-		const code = Number(res.statusCode);
-		return !Number.isNaN(code) && code >= 200 && code < 300;
-	});
-	const errorResponses = node.responses.filter((res) => res.statusCode === "default" || Number(res.statusCode) >= 400);
-	const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? createSchema({
-		type: "ref",
-		name: resolver.resolveResponseStatusTypedName(node, successResponses[0].statusCode)
-	}) : createSchema({
-		type: "union",
-		members: successResponses.map((res) => createSchema({
-			type: "ref",
-			name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
-		}))
-	}) : createSchema({ type: "any" });
-	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? createSchema({
-		type: "ref",
-		name: resolver.resolveResponseStatusTypedName(node, errorResponses[0].statusCode)
-	}) : createSchema({
-		type: "union",
-		members: errorResponses.map((res) => createSchema({
-			type: "ref",
-			name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
-		}))
-	}) : createSchema({ type: "any" });
-	const properties = [createProperty({
-		name: "Response",
-		required: true,
-		schema: responseSchema
-	})];
-	if (!isGet && node.requestBody?.schema) properties.push(createProperty({
-		name: "Request",
-		required: true,
-		schema: createSchema({
-			type: "ref",
-			name: resolver.resolveDataTypedName(node)
-		})
-	}));
-	if (node.parameters.some((p) => p.in === "query") && resolver.resolveQueryParamsTypedName) properties.push(createProperty({
-		name: "QueryParams",
-		required: true,
-		schema: createSchema({
-			type: "ref",
-			name: resolver.resolveQueryParamsTypedName(node)
-		})
-	}));
-	if (node.parameters.some((p) => p.in === "path") && resolver.resolvePathParamsTypedName) properties.push(createProperty({
-		name: "PathParams",
-		required: true,
-		schema: createSchema({
-			type: "ref",
-			name: resolver.resolvePathParamsTypedName(node)
-		})
-	}));
-	if (node.parameters.some((p) => p.in === "header") && resolver.resolveHeaderParamsTypedName) properties.push(createProperty({
-		name: "HeaderParams",
-		required: true,
-		schema: createSchema({
-			type: "ref",
-			name: resolver.resolveHeaderParamsTypedName(node)
-		})
-	}));
-	properties.push(createProperty({
-		name: "Errors",
-		required: true,
-		schema: errorsSchema
-	}));
-	return createSchema({
-		type: "object",
-		properties
-	});
-}
-function buildLegacyResponseUnionSchemaNode({ node, resolver }) {
-	const successResponses = node.responses.filter((res) => {
-		const code = Number(res.statusCode);
-		return !Number.isNaN(code) && code >= 200 && code < 300;
-	});
-	if (successResponses.length === 0) return createSchema({ type: "any" });
-	if (successResponses.length === 1) return createSchema({
-		type: "ref",
-		name: resolver.resolveResponseStatusTypedName(node, successResponses[0].statusCode)
-	});
-	return createSchema({
-		type: "union",
-		members: successResponses.map((res) => createSchema({
-			type: "ref",
-			name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
-		}))
-	});
-}
-function nameUnnamedEnums(node, parentName) {
-	return transform(node, {
-		schema(n) {
-			const enumNode = narrowSchema(n, "enum");
-			if (enumNode && !enumNode.name) return {
-				...enumNode,
-				name: pascalCase([parentName, "enum"].join(" "))
-			};
-		},
-		property(p) {
-			const enumNode = narrowSchema(p.schema, "enum");
-			if (enumNode && !enumNode.name) return {
-				...p,
-				schema: {
-					...enumNode,
-					name: pascalCase([
-						parentName,
-						p.name,
-						"enum"
-					].join(" "))
-				}
-			};
-		}
-	});
-}
-const typeGeneratorLegacy = defineGenerator({
-	name: "typescript-legacy",
-	type: "react",
-	Operation({ node, adapter, options, config }) {
-		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
-		const file = resolver.resolveFile({
-			name: node.operationId,
-			extname: ".ts",
-			tag: node.tags[0] ?? "default",
-			path: node.path
-		}, {
-			root,
-			output,
-			group
-		});
-		const params = caseParams(node.parameters, paramsCasing);
-		function renderSchemaType({ node: schemaNode, name, typedName, description, keysToOmit }) {
-			if (!schemaNode) return null;
-			const transformedNode = transform(schemaNode, composeTransformers(...transformers));
-			const imports = adapter.getImports(transformedNode, (schemaName) => ({
-				name: resolver.default(schemaName, "type"),
-				path: resolver.resolveFile({
-					name: schemaName,
-					extname: ".ts"
-				}, {
-					root,
-					output,
-					group
-				}).path
-			}));
-			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-				root: file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ jsx(Type, {
-				name,
-				typedName,
-				node: transformedNode,
-				description,
-				enumType,
-				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
-				resolver,
-				keysToOmit
-			})] });
-		}
-		const pathParams = params.filter((p) => p.in === "path");
-		const queryParams = params.filter((p) => p.in === "query");
-		const headerParams = params.filter((p) => p.in === "header");
-		const responseTypes = node.responses.map((res) => {
-			const responseName = resolver.resolveResponseStatusName(node, res.statusCode);
-			const baseResponseName = resolverTsLegacy.resolveResponseStatusName(node, res.statusCode);
-			return renderSchemaType({
-				node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
-				name: responseName,
-				typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
-				description: res.description,
-				keysToOmit: res.keysToOmit
-			});
-		});
-		const requestType = node.requestBody?.schema ? renderSchemaType({
-			node: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
-			name: resolver.resolveDataName(node),
-			typedName: resolver.resolveDataTypedName(node),
-			description: node.requestBody.description ?? node.requestBody.schema.description,
-			keysToOmit: node.requestBody.keysToOmit
-		}) : null;
-		const legacyParamTypes = [
-			pathParams.length > 0 ? renderSchemaType({
-				node: buildGroupedParamsSchema({
-					params: pathParams,
-					parentName: resolverTsLegacy.resolvePathParamsName(node)
-				}),
-				name: resolver.resolvePathParamsName(node),
-				typedName: resolver.resolvePathParamsTypedName(node)
-			}) : null,
-			queryParams.length > 0 ? renderSchemaType({
-				node: buildGroupedParamsSchema({
-					params: queryParams,
-					parentName: resolverTsLegacy.resolveQueryParamsName(node)
-				}),
-				name: resolver.resolveQueryParamsName(node),
-				typedName: resolver.resolveQueryParamsTypedName(node)
-			}) : null,
-			headerParams.length > 0 ? renderSchemaType({
-				node: buildGroupedParamsSchema({
-					params: headerParams,
-					parentName: resolverTsLegacy.resolveHeaderParamsName(node)
-				}),
-				name: resolver.resolveHeaderParamsName(node),
-				typedName: resolver.resolveHeaderParamsTypedName(node)
-			}) : null
-		];
-		const legacyResponsesType = renderSchemaType({
-			node: buildLegacyResponsesSchemaNode({
-				node,
-				resolver
-			}),
-			name: resolver.resolveResponsesName(node),
-			typedName: resolver.resolveResponsesTypedName(node)
-		});
-		const legacyResponseType = renderSchemaType({
-			node: buildLegacyResponseUnionSchemaNode({
-				node,
-				resolver
-			}),
-			name: resolver.resolveResponseName(node),
-			typedName: resolver.resolveResponseTypedName(node)
-		});
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: file.baseName,
-			path: file.path,
-			meta: file.meta,
-			banner: resolver.resolveBanner(adapter.rootNode, {
-				output,
-				config
-			}),
-			footer: resolver.resolveFooter(adapter.rootNode, {
-				output,
-				config
-			}),
-			children: [
-				legacyParamTypes,
-				responseTypes,
-				requestType,
-				legacyResponseType,
-				legacyResponsesType
-			]
-		});
-	},
-	Schema({ node, adapter, options, config }) {
-		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
-		if (!node.name) return;
-		const transformedNode = transform(node, composeTransformers(...transformers));
-		const imports = adapter.getImports(transformedNode, (schemaName) => ({
-			name: resolver.default(schemaName, "type"),
-			path: resolver.resolveFile({
-				name: schemaName,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			}).path
-		}));
-		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
-		const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name);
-		const type = {
-			name: resolver.resolveName(node.name),
-			typedName,
-			file: resolver.resolveFile({
-				name: node.name,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			})
-		};
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: type.file.baseName,
-			path: type.file.path,
-			meta: type.file.meta,
-			banner: resolver.resolveBanner(adapter.rootNode, {
-				output,
-				config
-			}),
-			footer: resolver.resolveFooter(adapter.rootNode, {
-				output,
-				config
-			}),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-				root: type.file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				node.name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ jsx(Type, {
-				name: type.name,
-				typedName: type.typedName,
-				node: transformedNode,
-				enumType,
-				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
-				resolver
-			})]
-		});
-	}
-});
-//#endregion
-export { typeGenerator as n, typeGeneratorLegacy as t };
-
-//# sourceMappingURL=generators-ByK18qUn.js.map