@kubb/agent 5.0.0-alpha.35 → 5.0.0-alpha.36

package/.output/server/node_modules/@kubb/plugin-ts/dist/index.js

@@ -0,0 +1,2 @@
+import { n as pluginTsName, t as pluginTs } from "./plugin-CYC-FGXe.js";
+export { pluginTs, pluginTsName };

package/.output/server/node_modules/@kubb/plugin-ts/dist/plugin-CYC-FGXe.js

@@ -0,0 +1,479 @@
+import "./chunk--u3MIqq1.js";
+import { a as createTypeAliasDeclaration, c as createTypeReferenceNode, d as getUnknownType, f as keywordTypeNodes, h as pascalCase, i as createPropertySignature, l as createUnionDeclaration, m as camelCase, n as createIdentifier, o as createTypeLiteralNode, p as modifiers, r as createIndexedAccessTypeNode, s as createTypeOperatorNode, t as Type, u as createUrlTemplateType } from "./components-C7fu-sK1.js";
+import path from "node:path";
+import { walk } from "@kubb/ast";
+import { definePlugin, getBarrelFiles, getMode } from "@kubb/core";
+import { OperationGenerator, SchemaGenerator, buildSchema, isKeyword, pluginOasName, schemaKeywords } from "@kubb/plugin-oas";
+import { 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 { File } from "@kubb/react-fabric";
+import ts from "typescript";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+//#region src/generators/typeGenerator.tsx
+function printCombinedSchema({ name, schemas, pluginManager }) {
+	const properties = {};
+	if (schemas.response) properties["response"] = createUnionDeclaration({ nodes: schemas.responses.map((res) => {
+		return createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+			name: res.name,
+			pluginKey: [pluginTsName],
+			type: "function"
+		})), void 0);
+	}) });
+	if (schemas.request) properties["request"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		name: schemas.request.name,
+		pluginKey: [pluginTsName],
+		type: "function"
+	})), void 0);
+	if (schemas.pathParams) properties["pathParams"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		name: schemas.pathParams.name,
+		pluginKey: [pluginTsName],
+		type: "function"
+	})), void 0);
+	if (schemas.queryParams) properties["queryParams"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		name: schemas.queryParams.name,
+		pluginKey: [pluginTsName],
+		type: "function"
+	})), void 0);
+	if (schemas.headerParams) properties["headerParams"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		name: schemas.headerParams.name,
+		pluginKey: [pluginTsName],
+		type: "function"
+	})), void 0);
+	if (schemas.errors) properties["errors"] = createUnionDeclaration({ nodes: schemas.errors.map((error) => {
+		return createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+			name: error.name,
+			pluginKey: [pluginTsName],
+			type: "function"
+		})), void 0);
+	}) });
+	return safePrint(createTypeAliasDeclaration({
+		name,
+		type: createTypeLiteralNode(Object.keys(properties).map((key) => {
+			const type = properties[key];
+			if (!type) return;
+			return createPropertySignature({
+				name: pascalCase(key),
+				type
+			});
+		}).filter(Boolean)),
+		modifiers: [modifiers.export]
+	}));
+}
+function printRequestSchema({ baseName, operation, schemas, pluginManager }) {
+	const name = pluginManager.resolveName({
+		name: `${baseName} Request`,
+		pluginKey: [pluginTsName],
+		type: "type"
+	});
+	const results = [];
+	const dataRequestProperties = [];
+	if (schemas.request) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.request.name,
+			pluginKey: [pluginTsName],
+			type: "type"
+		});
+		dataRequestProperties.push(createPropertySignature({
+			name: "data",
+			questionToken: true,
+			type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+		}));
+	} else dataRequestProperties.push(createPropertySignature({
+		name: "data",
+		questionToken: true,
+		type: keywordTypeNodes.never
+	}));
+	if (schemas.pathParams) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.pathParams.name,
+			pluginKey: [pluginTsName],
+			type: "type"
+		});
+		dataRequestProperties.push(createPropertySignature({
+			name: "pathParams",
+			type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+		}));
+	} else dataRequestProperties.push(createPropertySignature({
+		name: "pathParams",
+		questionToken: true,
+		type: keywordTypeNodes.never
+	}));
+	if (schemas.queryParams) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.queryParams.name,
+			pluginKey: [pluginTsName],
+			type: "type"
+		});
+		dataRequestProperties.push(createPropertySignature({
+			name: "queryParams",
+			questionToken: true,
+			type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+		}));
+	} else dataRequestProperties.push(createPropertySignature({
+		name: "queryParams",
+		questionToken: true,
+		type: keywordTypeNodes.never
+	}));
+	if (schemas.headerParams) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.headerParams.name,
+			pluginKey: [pluginTsName],
+			type: "type"
+		});
+		dataRequestProperties.push(createPropertySignature({
+			name: "headerParams",
+			questionToken: true,
+			type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+		}));
+	} else dataRequestProperties.push(createPropertySignature({
+		name: "headerParams",
+		questionToken: true,
+		type: keywordTypeNodes.never
+	}));
+	dataRequestProperties.push(createPropertySignature({
+		name: "url",
+		type: createUrlTemplateType(operation.path)
+	}));
+	const dataRequestNode = createTypeAliasDeclaration({
+		name,
+		type: createTypeLiteralNode(dataRequestProperties),
+		modifiers: [modifiers.export]
+	});
+	results.push(safePrint(dataRequestNode));
+	return results.join("\n\n");
+}
+function printResponseSchema({ baseName, schemas, pluginManager, unknownType }) {
+	const results = [];
+	const name = pluginManager.resolveName({
+		name: `${baseName} ResponseData`,
+		pluginKey: [pluginTsName],
+		type: "type"
+	});
+	if (schemas.responses && schemas.responses.length > 0) {
+		const responsesProperties = schemas.responses.map((res) => {
+			const identifier = pluginManager.resolveName({
+				name: res.name,
+				pluginKey: [pluginTsName],
+				type: "type"
+			});
+			return createPropertySignature({
+				name: res.statusCode?.toString() ?? "default",
+				type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+			});
+		});
+		const responsesNode = createTypeAliasDeclaration({
+			name: `${baseName}Responses`,
+			type: createTypeLiteralNode(responsesProperties),
+			modifiers: [modifiers.export]
+		});
+		results.push(safePrint(responsesNode));
+		const responseNode = createTypeAliasDeclaration({
+			name,
+			type: createIndexedAccessTypeNode(createTypeReferenceNode(createIdentifier(`${baseName}Responses`), void 0), createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, createTypeReferenceNode(createIdentifier(`${baseName}Responses`), void 0))),
+			modifiers: [modifiers.export]
+		});
+		results.push(safePrint(responseNode));
+	} else {
+		const responseNode = createTypeAliasDeclaration({
+			name,
+			modifiers: [modifiers.export],
+			type: getUnknownType(unknownType)
+		});
+		results.push(safePrint(responseNode));
+	}
+	return results.join("\n\n");
+}
+const typeGenerator = createReactGenerator({
+	name: "typescript",
+	version: "1",
+	Operation({ operation, generator, plugin }) {
+		const { options, options: { mapper, enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
+		const mode = useMode();
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const { getSchemas, getFile, getName, getGroup } = useOperationManager(generator);
+		const schemaManager = useSchemaManager();
+		const name = getName(operation, {
+			type: "type",
+			pluginKey: [pluginTsName]
+		});
+		const file = getFile(operation);
+		const schemas = getSchemas(operation);
+		const schemaGenerator = new SchemaGenerator(options, {
+			fabric: generator.context.fabric,
+			oas,
+			events: generator.context.events,
+			plugin,
+			pluginManager,
+			mode,
+			override: options.override
+		});
+		const operationSchemas = [
+			schemas.pathParams,
+			schemas.queryParams,
+			schemas.headerParams,
+			schemas.statusCodes,
+			schemas.request,
+			schemas.response
+		].flat().filter(Boolean);
+		const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }) => {
+			const transformedSchema = paramsCasing && isParameterSchema(name) ? applyParamsCasing(schema, paramsCasing) : schema;
+			const tree = schemaGenerator.parse({
+				schema: transformedSchema,
+				name,
+				parentName: null
+			});
+			const imports = getImports(tree);
+			const group = options.operation ? getGroup(options.operation) : void 0;
+			const type = {
+				name: schemaManager.getName(name, { type: "type" }),
+				typedName: schemaManager.getName(name, { type: "type" }),
+				file: schemaManager.getFile(options.operationName || name, { group })
+			};
+			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.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name: type.name,
+				typedName: type.typedName,
+				description,
+				tree,
+				schema: transformedSchema,
+				mapper,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				keysToOmit,
+				syntaxType
+			})] });
+		};
+		const responseName = schemaManager.getName(schemas.response.name, { type: "type" });
+		const combinedSchemaName = operation.method === "get" ? `${name}Query` : `${name}Mutation`;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: getBanner({
+				oas,
+				output: plugin.options.output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output: plugin.options.output
+			}),
+			children: [operationSchemas.map(mapOperationSchema), generator.context.UNSTABLE_NAMING ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+				name: `${name}Request`,
+				isExportable: true,
+				isIndexable: true,
+				isTypeOnly: true,
+				children: printRequestSchema({
+					baseName: name,
+					operation,
+					schemas,
+					pluginManager
+				})
+			}), /* @__PURE__ */ jsx(File.Source, {
+				name: responseName,
+				isExportable: true,
+				isIndexable: true,
+				isTypeOnly: true,
+				children: printResponseSchema({
+					baseName: name,
+					schemas,
+					pluginManager,
+					unknownType
+				})
+			})] }) : /* @__PURE__ */ jsx(File.Source, {
+				name: combinedSchemaName,
+				isExportable: true,
+				isIndexable: true,
+				isTypeOnly: true,
+				children: printCombinedSchema({
+					name: combinedSchemaName,
+					schemas,
+					pluginManager
+				})
+			})]
+		});
+	},
+	Schema({ schema, plugin }) {
+		const { options: { mapper, enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
+		const mode = useMode();
+		const oas = useOas();
+		const pluginManager = usePluginManager();
+		const { getName, getFile } = useSchemaManager();
+		const imports = getImports(schema.tree);
+		const schemaFromTree = schema.tree.find((item) => item.keyword === schemaKeywords.schema);
+		let typedName = getName(schema.name, { type: "type" });
+		if (["asConst", "asPascalConst"].includes(enumType) && schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.enum)) typedName += enumTypeSuffix;
+		const type = {
+			name: getName(schema.name, { type: "function" }),
+			typedName,
+			file: getFile(schema.name)
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: type.file.baseName,
+			path: type.file.path,
+			meta: type.file.meta,
+			banner: getBanner({
+				oas,
+				output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output
+			}),
+			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: type.file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				schema.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name: type.name,
+				typedName: type.typedName,
+				description: schema.value.description,
+				tree: schema.tree,
+				schema: schema.value,
+				mapper,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/plugin.ts
+const pluginTsName = "plugin-ts";
+const pluginTs = definePlugin((options) => {
+	const { output = {
+		path: "types",
+		barrelType: "named"
+	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", enumSuffix = "enum", dateType = "string", integerType = "number", unknownType = "any", optionalType = "questionToken", arrayType = "array", emptySchemaType = unknownType, syntaxType = "type", transformers = {}, mapper = {}, paramsCasing, generators = [typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
+	return {
+		name: pluginTsName,
+		options: {
+			output,
+			transformers,
+			dateType,
+			integerType,
+			optionalType,
+			arrayType,
+			enumType,
+			enumTypeSuffix,
+			enumKeyCasing,
+			enumSuffix,
+			unknownType,
+			emptySchemaType,
+			syntaxType,
+			group,
+			override,
+			mapper,
+			paramsCasing,
+			usedEnumNames: {}
+		},
+		pre: [pluginOasName],
+		resolvePath(baseName, pathMode, options) {
+			const root = path.resolve(this.config.root, this.config.output.path);
+			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
+ /**
+			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
+			*/
+			return path.resolve(root, output.path);
+			if (group && (options?.group?.path || options?.group?.tag)) {
+				const groupName = group?.name ? group.name : (ctx) => {
+					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
+					return `${camelCase(ctx.group)}Controller`;
+				};
+				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
+			}
+			return path.resolve(root, output.path, baseName);
+		},
+		resolveName(name, type) {
+			const resolvedName = pascalCase(name, { isFile: type === "file" });
+			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
+			return resolvedName;
+		},
+		async install() {
+			const { config, fabric, plugin } = this;
+			const root = path.resolve(config.root, config.output.path);
+			const mode = getMode(path.resolve(root, output.path));
+			if (this.rootNode) {
+				await this.openInStudio({ ast: true });
+				await walk(this.rootNode, { async schema(schemaNode) {
+					await generators.map(async (generator) => {
+						if (generator.type === "react" && generator.version === "2") await buildSchema(schemaNode, {
+							config,
+							fabric,
+							Component: generator.Schema,
+							plugin,
+							version: generator.version
+						});
+					});
+				} }, { depth: "shallow" });
+				return;
+			}
+			const oas = await this.getOas();
+			const schemaFiles = await new SchemaGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				include: void 0,
+				override,
+				mode,
+				output: output.path
+			}).build(...generators);
+			await this.upsertFile(...schemaFiles);
+			const operationFiles = await new OperationGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				exclude,
+				include,
+				override,
+				mode,
+				UNSTABLE_NAMING
+			}).build(...generators);
+			await this.upsertFile(...operationFiles);
+			const barrelFiles = await getBarrelFiles(this.fabric.files, {
+				type: output.barrelType ?? "named",
+				root,
+				output,
+				meta: { pluginKey: this.plugin.key }
+			});
+			await this.upsertFile(...barrelFiles);
+		}
+	};
+});
+//#endregion
+export { pluginTsName as n, typeGenerator as r, pluginTs as t };
+
+//# sourceMappingURL=plugin-CYC-FGXe.js.map

package/.output/server/node_modules/@kubb/plugin-ts/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@kubb/plugin-ts",
+  "version": "4.37.2",
+  "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
+  "keywords": [
+    "typescript",
+    "types",
+    "type-generation",
+    "interfaces",
+    "type-definitions",
+    "type-safe",
+    "openapi",
+    "swagger",
+    "oas",
+    "code-generator",
+    "codegen",
+    "plugins",
+    "kubb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kubb-labs/kubb.git",
+    "directory": "packages/plugin-ts"
+  },
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs"
+    },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
+  "size-limit": [
+    {
+      "path": "./dist/*.js",
+      "limit": "510 KiB",
+      "gzip": true
+    }
+  ],
+  "dependencies": {
+    "@kubb/fabric-core": "0.14.0",
+    "@kubb/react-fabric": "0.14.0",
+    "remeda": "^2.33.6",
+    "typescript": "5.9.3",
+    "@kubb/core": "4.37.2",
+    "@kubb/oas": "4.37.2",
+    "@kubb/plugin-oas": "4.37.2",
+    "@kubb/ast": "4.37.2"
+  },
+  "peerDependencies": {
+    "@kubb/react-fabric": "0.14.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "devDependencies": {
+    "@internals/utils": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown && size-limit",
+    "clean": "npx rimraf ./dist",
+    "lint": "bun biome lint .",
+    "lint:fix": "bun biome lint --fix --unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsdown --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/.output/server/node_modules/@kubb/plugin-vue-query/dist/chunk--u3MIqq1.js

@@ -0,0 +1,8 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+//#endregion
+export { __name as t };