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

package/.output/server/node_modules/@kubb/ast/dist/index.js

@@ -0,0 +1,423 @@
+import "./chunk--u3MIqq1.js";
+//#region src/constants.ts
+const visitorDepths = {
+	shallow: "shallow",
+	deep: "deep"
+};
+const nodeKinds = {
+	root: "Root",
+	operation: "Operation",
+	schema: "Schema",
+	property: "Property",
+	parameter: "Parameter",
+	response: "Response"
+};
+const schemaTypes = {
+	string: "string",
+	number: "number",
+	integer: "integer",
+	bigint: "bigint",
+	boolean: "boolean",
+	null: "null",
+	any: "any",
+	unknown: "unknown",
+	void: "void",
+	object: "object",
+	array: "array",
+	tuple: "tuple",
+	union: "union",
+	intersection: "intersection",
+	enum: "enum",
+	ref: "ref",
+	date: "date",
+	datetime: "datetime",
+	time: "time",
+	uuid: "uuid",
+	email: "email",
+	url: "url",
+	blob: "blob"
+};
+const httpMethods = {
+	get: "GET",
+	post: "POST",
+	put: "PUT",
+	patch: "PATCH",
+	delete: "DELETE",
+	head: "HEAD",
+	options: "OPTIONS",
+	trace: "TRACE"
+};
+const mediaTypes = {
+	applicationJson: "application/json",
+	applicationXml: "application/xml",
+	applicationFormUrlEncoded: "application/x-www-form-urlencoded",
+	applicationOctetStream: "application/octet-stream",
+	applicationPdf: "application/pdf",
+	applicationZip: "application/zip",
+	applicationGraphql: "application/graphql",
+	multipartFormData: "multipart/form-data",
+	textPlain: "text/plain",
+	textHtml: "text/html",
+	textCsv: "text/csv",
+	textXml: "text/xml",
+	imagePng: "image/png",
+	imageJpeg: "image/jpeg",
+	imageGif: "image/gif",
+	imageWebp: "image/webp",
+	imageSvgXml: "image/svg+xml",
+	audioMpeg: "audio/mpeg",
+	videoMp4: "video/mp4"
+};
+//#endregion
+//#region src/factory.ts
+/**
+* Creates a `RootNode`.
+*/
+function createRoot(overrides = {}) {
+	return {
+		schemas: [],
+		operations: [],
+		...overrides,
+		kind: "Root"
+	};
+}
+/**
+* Creates an `OperationNode`.
+*/
+function createOperation(props) {
+	return {
+		tags: [],
+		parameters: [],
+		responses: [],
+		...props,
+		kind: "Operation"
+	};
+}
+function createSchema(props) {
+	if (props["type"] === "object") return {
+		properties: [],
+		...props,
+		kind: "Schema"
+	};
+	return {
+		...props,
+		kind: "Schema"
+	};
+}
+/**
+* Creates a `PropertyNode`. `required` defaults to `false`.
+*/
+function createProperty(props) {
+	return {
+		required: false,
+		...props,
+		kind: "Property"
+	};
+}
+/**
+* Creates a `ParameterNode`. `required` defaults to `false`.
+*/
+function createParameter(props) {
+	return {
+		required: false,
+		...props,
+		kind: "Parameter"
+	};
+}
+/**
+* Creates a `ResponseNode`.
+*/
+function createResponse(props) {
+	return {
+		...props,
+		kind: "Response"
+	};
+}
+//#endregion
+//#region src/guards.ts
+/**
+* Narrows a `SchemaNode` to the specific variant matching `type`.
+*/
+function narrowSchema(node, type) {
+	return node?.type === type ? node : void 0;
+}
+function isKind(kind) {
+	return (node) => node.kind === kind;
+}
+/**
+* Type guard for `RootNode`.
+*/
+const isRootNode = isKind("Root");
+/**
+* Type guard for `OperationNode`.
+*/
+const isOperationNode = isKind("Operation");
+/**
+* Type guard for `SchemaNode`.
+*/
+const isSchemaNode = isKind("Schema");
+/**
+* Type guard for `PropertyNode`.
+*/
+const isPropertyNode = isKind("Property");
+/**
+* Type guard for `ParameterNode`.
+*/
+const isParameterNode = isKind("Parameter");
+/**
+* Type guard for `ResponseNode`.
+*/
+const isResponseNode = isKind("Response");
+//#endregion
+//#region src/printer.ts
+/**
+* Creates a named printer factory. Mirrors the `definePlugin` / `defineAdapter` pattern
+* from `@kubb/core` — wraps a builder to make options optional and separates raw options
+* from resolved options.
+*
+* @example
+* ```ts
+* type ZodPrinter = PrinterFactoryOptions<'zod', { strict?: boolean }, { strict: boolean }, string>
+*
+* export const zodPrinter = definePrinter<ZodPrinter>((options) => {
+*   const { strict = true } = options
+*   return {
+*     name: 'zod',
+*     options: { strict },
+*     nodes: {
+*       string(node) {
+*         return `z.string()`
+*       },
+*       object(node) {
+*         const props = node.properties
+*           ?.map(p => `${p.name}: ${this.print(p)}`)
+*           .join(', ') ?? ''
+*         return `z.object({ ${props} })`
+*       },
+*     },
+*   }
+* })
+*
+* const printer = zodPrinter({ strict: false })
+* printer.name            // 'zod'
+* printer.options         // { strict: false }
+* printer.print(node)     // 'z.string()'
+* ```
+*/
+function definePrinter(build) {
+	return (options) => {
+		const { name, options: resolvedOptions, nodes } = build(options ?? {});
+		const context = {
+			options: resolvedOptions,
+			print: (node) => {
+				const handler = nodes[node.type];
+				return handler ? handler.call(context, node) : void 0;
+			}
+		};
+		return {
+			name,
+			options: resolvedOptions,
+			print: context.print,
+			for: (nodes) => nodes.map(context.print)
+		};
+	};
+}
+//#endregion
+//#region src/refs.ts
+/**
+* Indexes named schemas from `root.schemas` by name. Unnamed schemas are skipped.
+*/
+function buildRefMap(root) {
+	const map = /* @__PURE__ */ new Map();
+	for (const schema of root.schemas) if (schema.name) map.set(schema.name, schema);
+	return map;
+}
+/**
+* Looks up a schema by name. Prefer over `RefMap.get()` to keep the resolution strategy swappable.
+*/
+function resolveRef(refMap, ref) {
+	return refMap.get(ref);
+}
+/**
+* Converts a `RefMap` to a plain object.
+*/
+function refMapToObject(refMap) {
+	return Object.fromEntries(refMap);
+}
+//#endregion
+//#region src/visitor.ts
+function createLimit(concurrency) {
+	let active = 0;
+	const queue = [];
+	function next() {
+		if (active < concurrency && queue.length > 0) {
+			active++;
+			queue.shift()();
+		}
+	}
+	return function limit(fn) {
+		return new Promise((resolve, reject) => {
+			queue.push(() => {
+				Promise.resolve(fn()).then(resolve, reject).finally(() => {
+					active--;
+					next();
+				});
+			});
+			next();
+		});
+	};
+}
+/**
+* Traversable children of `node`, respecting `recurse` for schema nodes.
+*/
+function getChildren(node, recurse) {
+	switch (node.kind) {
+		case "Root": return [...node.schemas, ...node.operations];
+		case "Operation": return [
+			...node.parameters,
+			...node.requestBody ? [node.requestBody] : [],
+			...node.responses
+		];
+		case "Schema": {
+			const children = [];
+			if (!recurse) return [];
+			if ("properties" in node && node.properties.length > 0) children.push(...node.properties);
+			if ("items" in node && node.items) children.push(...node.items);
+			if ("members" in node && node.members) children.push(...node.members);
+			return children;
+		}
+		case "Property": return [node.schema];
+		case "Parameter": return [node.schema];
+		case "Response": return node.schema ? [node.schema] : [];
+	}
+}
+/**
+* Depth-first traversal for side effects. Visitor return values are ignored.
+* Sibling nodes at each level are visited concurrently up to `options.concurrency` (default: 30).
+*/
+async function walk(node, visitor, options = {}) {
+	return _walk(node, visitor, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30));
+}
+async function _walk(node, visitor, recurse, limit) {
+	switch (node.kind) {
+		case "Root":
+			await limit(() => visitor.root?.(node));
+			break;
+		case "Operation":
+			await limit(() => visitor.operation?.(node));
+			break;
+		case "Schema":
+			await limit(() => visitor.schema?.(node));
+			break;
+		case "Property":
+			await limit(() => visitor.property?.(node));
+			break;
+		case "Parameter":
+			await limit(() => visitor.parameter?.(node));
+			break;
+		case "Response":
+			await limit(() => visitor.response?.(node));
+			break;
+	}
+	const children = getChildren(node, recurse);
+	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit)));
+}
+function transform(node, visitor, options = {}) {
+	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+	switch (node.kind) {
+		case "Root": {
+			let root = node;
+			const replaced = visitor.root?.(root);
+			if (replaced) root = replaced;
+			return {
+				...root,
+				schemas: root.schemas.map((s) => transform(s, visitor, options)),
+				operations: root.operations.map((op) => transform(op, visitor, options))
+			};
+		}
+		case "Operation": {
+			let op = node;
+			const replaced = visitor.operation?.(op);
+			if (replaced) op = replaced;
+			return {
+				...op,
+				parameters: op.parameters.map((p) => transform(p, visitor, options)),
+				requestBody: op.requestBody ? transform(op.requestBody, visitor, options) : void 0,
+				responses: op.responses.map((r) => transform(r, visitor, options))
+			};
+		}
+		case "Schema": {
+			let schema = node;
+			const replaced = visitor.schema?.(schema);
+			if (replaced) schema = replaced;
+			return {
+				...schema,
+				..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, visitor, options)) } : {},
+				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, visitor, options)) } : {},
+				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, visitor, options)) } : {}
+			};
+		}
+		case "Property": {
+			let prop = node;
+			const replaced = visitor.property?.(prop);
+			if (replaced) prop = replaced;
+			return {
+				...prop,
+				schema: transform(prop.schema, visitor, options)
+			};
+		}
+		case "Parameter": {
+			let param = node;
+			const replaced = visitor.parameter?.(param);
+			if (replaced) param = replaced;
+			return {
+				...param,
+				schema: transform(param.schema, visitor, options)
+			};
+		}
+		case "Response": {
+			let response = node;
+			const replaced = visitor.response?.(response);
+			if (replaced) response = replaced;
+			return {
+				...response,
+				schema: response.schema ? transform(response.schema, visitor, options) : void 0
+			};
+		}
+	}
+}
+/**
+* Depth-first synchronous reduction. Collects non-`undefined` visitor return values into an array.
+*/
+function collect(node, visitor, options = {}) {
+	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+	const results = [];
+	let v;
+	switch (node.kind) {
+		case "Root":
+			v = visitor.root?.(node);
+			break;
+		case "Operation":
+			v = visitor.operation?.(node);
+			break;
+		case "Schema":
+			v = visitor.schema?.(node);
+			break;
+		case "Property":
+			v = visitor.property?.(node);
+			break;
+		case "Parameter":
+			v = visitor.parameter?.(node);
+			break;
+		case "Response":
+			v = visitor.response?.(node);
+			break;
+	}
+	if (v !== void 0) results.push(v);
+	for (const child of getChildren(node, recurse)) for (const item of collect(child, visitor, options)) results.push(item);
+	return results;
+}
+//#endregion
+export { buildRefMap, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, definePrinter, httpMethods, isOperationNode, isParameterNode, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, mediaTypes, narrowSchema, nodeKinds, refMapToObject, resolveRef, schemaTypes, transform, walk };
+
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@kubb/ast/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@kubb/ast",
+  "version": "4.37.2",
+  "description": "Spec-agnostic AST layer for Kubb. Defines nodes, visitor pattern, and factory functions used across codegen plugins.",
+  "keywords": [
+    "kubb",
+    "ast",
+    "typescript",
+    "codegen",
+    "openapi"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kubb-labs/kubb.git",
+    "directory": "packages/ast"
+  },
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "require": "./dist/types.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "types": [
+        "./dist/types.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.19.37"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "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/core/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 };

package/.output/server/node_modules/@kubb/core/dist/hooks.js

@@ -0,0 +1,23 @@
+import "./chunk--u3MIqq1.js";
+import { useFabric } from "@kubb/react-fabric";
+//#region src/hooks/useMode.ts
+function useMode() {
+	const { meta } = useFabric();
+	return meta.mode;
+}
+//#endregion
+//#region src/hooks/usePlugin.ts
+function usePlugin() {
+	const { meta } = useFabric();
+	return meta.plugin;
+}
+//#endregion
+//#region src/hooks/usePluginManager.ts
+function usePluginManager() {
+	const { meta } = useFabric();
+	return meta.pluginManager;
+}
+//#endregion
+export { useMode, usePlugin, usePluginManager };
+
+//# sourceMappingURL=hooks.js.map