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

package/.output/server/node_modules/@kubb/plugin-oas/dist/generators-D7C3CXsN.js

@@ -0,0 +1,79 @@
+import "./chunk--u3MIqq1.js";
+import { n as getBanner, r as camelCase, t as getFooter } from "./getFooter-Pw3tLCiV.js";
+//#region src/generators/createGenerator.ts
+function createGenerator(generator) {
+	return {
+		type: "core",
+		version: generator.version ?? "1",
+		async operations() {
+			return [];
+		},
+		async operation() {
+			return [];
+		},
+		async schema() {
+			return [];
+		},
+		...generator
+	};
+}
+//#endregion
+//#region src/generators/createReactGenerator.ts
+/****
+* Creates a generator that uses React component functions to generate files for OpenAPI operations and schemas.
+*
+* The returned generator exposes async methods for generating files from operations, a single operation, or a schema, using the corresponding React components if provided. If a component is not defined, the method returns an empty array.
+*
+* @returns A generator object with async methods for operations, operation, and schema file generation.
+*/
+function createReactGenerator(generator) {
+	return {
+		type: "react",
+		version: generator.version ?? "1",
+		Operations() {
+			return null;
+		},
+		Operation() {
+			return null;
+		},
+		Schema() {
+			return null;
+		},
+		...generator
+	};
+}
+//#endregion
+//#region src/generators/jsonGenerator.ts
+const jsonGenerator = createGenerator({
+	name: "plugin-oas",
+	async schema({ schema, generator }) {
+		const { pluginManager, plugin } = generator.context;
+		return [{
+			...pluginManager.getFile({
+				name: camelCase(schema.name),
+				extname: ".json",
+				mode: "split",
+				pluginKey: plugin.key
+			}),
+			sources: [{
+				name: camelCase(schema.name),
+				isExportable: false,
+				isIndexable: false,
+				value: JSON.stringify(schema.value)
+			}],
+			banner: getBanner({
+				oas: generator.context.oas,
+				output: plugin.options.output,
+				config: pluginManager.config
+			}),
+			format: getFooter({
+				oas: generator.context.oas,
+				output: plugin.options.output
+			})
+		}];
+	}
+});
+//#endregion
+export { createReactGenerator as n, createGenerator as r, jsonGenerator as t };
+
+//# sourceMappingURL=generators-D7C3CXsN.js.map

package/.output/server/node_modules/@kubb/plugin-oas/dist/generators.js

@@ -0,0 +1,2 @@
+import { n as createReactGenerator, r as createGenerator, t as jsonGenerator } from "./generators-D7C3CXsN.js";
+export { createGenerator, createReactGenerator, jsonGenerator };

package/.output/server/node_modules/@kubb/plugin-oas/dist/getFooter-Pw3tLCiV.js

@@ -0,0 +1,112 @@
+import "./chunk--u3MIqq1.js";
+import path from "node:path";
+import { isFunction } from "remeda";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+*/
+function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
+		prefix,
+		suffix
+	}) : camelCase(part));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region src/utils/getBanner.ts
+/**
+* Generate a default banner for files created by Kubb
+* @returns A string with the default banner
+*/
+function getDefaultBanner({ title, description, version, config }) {
+	try {
+		let source = "";
+		if ("path" in config.input) source = path.basename(config.input.path);
+		else if ("data" in config.input) source = "text content";
+		let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
+		if (config.output.defaultBanner === "simple") {
+			banner += "*/\n";
+			return banner;
+		}
+		if (source) banner += `* Source: ${source}\n`;
+		if (title) banner += `* Title: ${title}\n`;
+		if (description) {
+			const formattedDescription = description.replace(/\n/gm, "\n* ");
+			banner += `* Description: ${formattedDescription}\n`;
+		}
+		if (version) banner += `* OpenAPI spec version: ${version}\n`;
+		banner += "*/\n";
+		return banner;
+	} catch (_error) {
+		return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
+	}
+}
+function getBanner({ output, oas, config }) {
+	let banner = "";
+	if (config?.output?.defaultBanner !== false && config) {
+		const { title, description, version } = oas.api?.info || {};
+		banner = getDefaultBanner({
+			title,
+			description,
+			version,
+			config
+		});
+	}
+	if (!output.banner) return banner;
+	if (isFunction(output.banner)) return `${output.banner(oas)}\n${banner}`;
+	return `${output.banner}\n${banner}`;
+}
+//#endregion
+//#region src/utils/getFooter.ts
+function getFooter({ output, oas }) {
+	if (!output.footer) return;
+	if (isFunction(output.footer)) return output.footer(oas);
+	return output.footer;
+}
+//#endregion
+export { pascalCase as i, getBanner as n, camelCase as r, getFooter as t };
+
+//# sourceMappingURL=getFooter-Pw3tLCiV.js.map

package/.output/server/node_modules/@kubb/plugin-oas/dist/hooks.js

@@ -0,0 +1,200 @@
+import "./chunk--u3MIqq1.js";
+import { useFabric } from "@kubb/react-fabric";
+import { usePlugin, usePluginManager } from "@kubb/core/hooks";
+//#region src/hooks/useOas.ts
+function useOas() {
+	const { meta } = useFabric();
+	return meta.oas;
+}
+//#endregion
+//#region src/hooks/useOperationManager.ts
+/**
+* `useOperationManager` returns helper functions to get the operation file and operation name.
+*/
+function useOperationManager(generator) {
+	const plugin = usePlugin();
+	const pluginManager = usePluginManager();
+	const getName = (operation, { prefix = "", suffix = "", pluginKey = plugin.key, type }) => {
+		return pluginManager.resolveName({
+			name: `${prefix} ${operation.getOperationId()} ${suffix}`,
+			pluginKey,
+			type
+		});
+	};
+	const getGroup = (operation) => {
+		return {
+			tag: operation.getTags().at(0)?.name,
+			path: operation.path
+		};
+	};
+	const getSchemas = (operation, params) => {
+		if (!generator) throw new Error(`useOperationManager: 'generator' parameter is required but was not provided`);
+		return generator.getSchemas(operation, { resolveName: (name) => pluginManager.resolveName({
+			name,
+			pluginKey: params?.pluginKey,
+			type: params?.type
+		}) });
+	};
+	const getFile = (operation, { prefix, suffix, pluginKey = plugin.key, extname = ".ts" } = {}) => {
+		const name = getName(operation, {
+			type: "file",
+			pluginKey,
+			prefix,
+			suffix
+		});
+		const group = getGroup(operation);
+		const file = pluginManager.getFile({
+			name,
+			extname,
+			pluginKey,
+			options: {
+				type: "file",
+				pluginKey,
+				group
+			}
+		});
+		return {
+			...file,
+			meta: {
+				...file.meta,
+				name,
+				pluginKey,
+				group
+			}
+		};
+	};
+	const groupSchemasByName = (operation, { pluginKey = plugin.key, type }) => {
+		if (!generator) throw new Error(`useOperationManager: 'generator' parameter is required but was not provided`);
+		const schemas = generator.getSchemas(operation);
+		const errors = (schemas.errors || []).reduce((prev, acc) => {
+			if (!acc.statusCode) return prev;
+			prev[acc.statusCode] = pluginManager.resolveName({
+				name: acc.name,
+				pluginKey,
+				type
+			});
+			return prev;
+		}, {});
+		const responses = (schemas.responses || []).reduce((prev, acc) => {
+			if (!acc.statusCode) return prev;
+			prev[acc.statusCode] = pluginManager.resolveName({
+				name: acc.name,
+				pluginKey,
+				type
+			});
+			return prev;
+		}, {});
+		return {
+			request: schemas.request?.name ? pluginManager.resolveName({
+				name: schemas.request.name,
+				pluginKey,
+				type
+			}) : void 0,
+			parameters: {
+				path: schemas.pathParams?.name ? pluginManager.resolveName({
+					name: schemas.pathParams.name,
+					pluginKey,
+					type
+				}) : void 0,
+				query: schemas.queryParams?.name ? pluginManager.resolveName({
+					name: schemas.queryParams.name,
+					pluginKey,
+					type
+				}) : void 0,
+				header: schemas.headerParams?.name ? pluginManager.resolveName({
+					name: schemas.headerParams.name,
+					pluginKey,
+					type
+				}) : void 0
+			},
+			responses: {
+				...responses,
+				["default"]: pluginManager.resolveName({
+					name: schemas.response.name,
+					pluginKey,
+					type
+				}),
+				...errors
+			},
+			errors
+		};
+	};
+	return {
+		getName,
+		getFile,
+		getSchemas,
+		groupSchemasByName,
+		getGroup
+	};
+}
+//#endregion
+//#region src/hooks/useRootNode.ts
+/**
+* Returns the universal `@kubb/ast` `RootNode` produced by the configured adapter.
+*
+* Use this hook inside generator components when you want to consume the
+* format-agnostic AST directly instead of going through `useOas()`.
+*
+* Returns `undefined` when no adapter was configured (legacy OAS-only mode).
+*
+* @example
+* ```tsx
+* function MyComponent() {
+*   const rootNode = useRootNode()
+*   if (!rootNode) return null
+*   return <>{rootNode.schemas.map(s => <Schema key={s.name} node={s} />)}</>
+* }
+* ```
+*/
+function useRootNode() {
+	const { meta } = useFabric();
+	return meta.pluginManager?.rootNode;
+}
+//#endregion
+//#region src/hooks/useSchemaManager.ts
+/**
+* `useSchemaManager` returns helper functions to get the schema file and schema name.
+*/
+function useSchemaManager() {
+	const plugin = usePlugin();
+	const pluginManager = usePluginManager();
+	const getName = (name, { pluginKey = plugin.key, type }) => {
+		return pluginManager.resolveName({
+			name,
+			pluginKey,
+			type
+		});
+	};
+	const getFile = (name, { mode = "split", pluginKey = plugin.key, extname = ".ts", group } = {}) => {
+		const resolvedName = mode === "single" ? "" : getName(name, {
+			type: "file",
+			pluginKey
+		});
+		const file = pluginManager.getFile({
+			name: resolvedName,
+			extname,
+			pluginKey,
+			options: {
+				type: "file",
+				pluginKey,
+				group
+			}
+		});
+		return {
+			...file,
+			meta: {
+				...file.meta,
+				name: resolvedName,
+				pluginKey
+			}
+		};
+	};
+	return {
+		getName,
+		getFile
+	};
+}
+//#endregion
+export { useOas, useOperationManager, useRootNode, useSchemaManager };
+
+//# sourceMappingURL=hooks.js.map