fumadocs-openapi 10.8.4 → 10.8.6

package/dist/node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js

@@ -0,0 +1,282 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {(value: string) => boolean} */
+	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
+	/** @type {(value: string) => boolean} */
+	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+	/**
+	* @param {Array<string>} input
+	* @returns {string}
+	*/
+	function stringArrayToHexStripped(input) {
+		let acc = "";
+		let code = 0;
+		let i = 0;
+		for (i = 0; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (code === 48) continue;
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+			break;
+		}
+		for (i += 1; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+		}
+		return acc;
+	}
+	/**
+	* @typedef {Object} GetIPV6Result
+	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
+	* @property {string} address - The parsed IPv6 address.
+	* @property {string} [zone] - The zone identifier, if present.
+	*/
+	/**
+	* @param {string} value
+	* @returns {boolean}
+	*/
+	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+	/**
+	* @param {Array<string>} buffer
+	* @returns {boolean}
+	*/
+	function consumeIsZone(buffer) {
+		buffer.length = 0;
+		return true;
+	}
+	/**
+	* @param {Array<string>} buffer
+	* @param {Array<string>} address
+	* @param {GetIPV6Result} output
+	* @returns {boolean}
+	*/
+	function consumeHextets(buffer, address, output) {
+		if (buffer.length) {
+			const hex = stringArrayToHexStripped(buffer);
+			if (hex !== "") address.push(hex);
+			else {
+				output.error = true;
+				return false;
+			}
+			buffer.length = 0;
+		}
+		return true;
+	}
+	/**
+	* @param {string} input
+	* @returns {GetIPV6Result}
+	*/
+	function getIPV6(input) {
+		let tokenCount = 0;
+		const output = {
+			error: false,
+			address: "",
+			zone: ""
+		};
+		/** @type {Array<string>} */
+		const address = [];
+		/** @type {Array<string>} */
+		const buffer = [];
+		let endipv6Encountered = false;
+		let endIpv6 = false;
+		let consume = consumeHextets;
+		for (let i = 0; i < input.length; i++) {
+			const cursor = input[i];
+			if (cursor === "[" || cursor === "]") continue;
+			if (cursor === ":") {
+				if (endipv6Encountered === true) endIpv6 = true;
+				if (!consume(buffer, address, output)) break;
+				if (++tokenCount > 7) {
+					output.error = true;
+					break;
+				}
+				if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
+				address.push(":");
+				continue;
+			} else if (cursor === "%") {
+				if (!consume(buffer, address, output)) break;
+				consume = consumeIsZone;
+			} else {
+				buffer.push(cursor);
+				continue;
+			}
+		}
+		if (buffer.length) if (consume === consumeIsZone) output.zone = buffer.join("");
+		else if (endIpv6) address.push(buffer.join(""));
+		else address.push(stringArrayToHexStripped(buffer));
+		output.address = address.join("");
+		return output;
+	}
+	/**
+	* @typedef {Object} NormalizeIPv6Result
+	* @property {string} host - The normalized host.
+	* @property {string} [escapedHost] - The escaped host.
+	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	*/
+	/**
+	* @param {string} host
+	* @returns {NormalizeIPv6Result}
+	*/
+	function normalizeIPv6(host) {
+		if (findToken(host, ":") < 2) return {
+			host,
+			isIPV6: false
+		};
+		const ipv6 = getIPV6(host);
+		if (!ipv6.error) {
+			let newHost = ipv6.address;
+			let escapedHost = ipv6.address;
+			if (ipv6.zone) {
+				newHost += "%" + ipv6.zone;
+				escapedHost += "%25" + ipv6.zone;
+			}
+			return {
+				host: newHost,
+				isIPV6: true,
+				escapedHost
+			};
+		} else return {
+			host,
+			isIPV6: false
+		};
+	}
+	/**
+	* @param {string} str
+	* @param {string} token
+	* @returns {number}
+	*/
+	function findToken(str, token) {
+		let ind = 0;
+		for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
+		return ind;
+	}
+	/**
+	* @param {string} path
+	* @returns {string}
+	*
+	* @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+	*/
+	function removeDotSegments(path) {
+		let input = path;
+		const output = [];
+		let nextSlash = -1;
+		let len = 0;
+		while (len = input.length) {
+			if (len === 1) if (input === ".") break;
+			else if (input === "/") {
+				output.push("/");
+				break;
+			} else {
+				output.push(input);
+				break;
+			}
+			else if (len === 2) {
+				if (input[0] === ".") {
+					if (input[1] === ".") break;
+					else if (input[1] === "/") {
+						input = input.slice(2);
+						continue;
+					}
+				} else if (input[0] === "/") {
+					if (input[1] === "." || input[1] === "/") {
+						output.push("/");
+						break;
+					}
+				}
+			} else if (len === 3) {
+				if (input === "/..") {
+					if (output.length !== 0) output.pop();
+					output.push("/");
+					break;
+				}
+			}
+			if (input[0] === ".") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(3);
+						continue;
+					}
+				} else if (input[1] === "/") {
+					input = input.slice(2);
+					continue;
+				}
+			} else if (input[0] === "/") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(2);
+						continue;
+					} else if (input[2] === ".") {
+						if (input[3] === "/") {
+							input = input.slice(3);
+							if (output.length !== 0) output.pop();
+							continue;
+						}
+					}
+				}
+			}
+			if ((nextSlash = input.indexOf("/", 1)) === -1) {
+				output.push(input);
+				break;
+			} else {
+				output.push(input.slice(0, nextSlash));
+				input = input.slice(nextSlash);
+			}
+		}
+		return output.join("");
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @param {boolean} esc
+	* @returns {import('../types/index').URIComponent}
+	*/
+	function normalizeComponentEncoding(component, esc) {
+		const func = esc !== true ? escape : unescape;
+		if (component.scheme !== void 0) component.scheme = func(component.scheme);
+		if (component.userinfo !== void 0) component.userinfo = func(component.userinfo);
+		if (component.host !== void 0) component.host = func(component.host);
+		if (component.path !== void 0) component.path = func(component.path);
+		if (component.query !== void 0) component.query = func(component.query);
+		if (component.fragment !== void 0) component.fragment = func(component.fragment);
+		return component;
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @returns {string|undefined}
+	*/
+	function recomposeAuthority(component) {
+		const uriTokens = [];
+		if (component.userinfo !== void 0) {
+			uriTokens.push(component.userinfo);
+			uriTokens.push("@");
+		}
+		if (component.host !== void 0) {
+			let host = unescape(component.host);
+			if (!isIPv4(host)) {
+				const ipV6res = normalizeIPv6(host);
+				if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
+				else host = component.host;
+			}
+			uriTokens.push(host);
+		}
+		if (typeof component.port === "number" || typeof component.port === "string") {
+			uriTokens.push(":");
+			uriTokens.push(String(component.port));
+		}
+		return uriTokens.length ? uriTokens.join("") : void 0;
+	}
+	module.exports = {
+		nonSimpleDomain,
+		recomposeAuthority,
+		normalizeComponentEncoding,
+		removeDotSegments,
+		isIPv4,
+		isUUID,
+		normalizeIPv6,
+		stringArrayToHexStripped
+	};
+}));
+//#endregion
+export default require_utils();
+export { require_utils };

package/dist/node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js

@@ -0,0 +1,78 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
+var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var traverse = module.exports = function(schema, opts, cb) {
+		if (typeof opts == "function") {
+			cb = opts;
+			opts = {};
+		}
+		cb = opts.cb || cb;
+		var pre = typeof cb == "function" ? cb : cb.pre || function() {};
+		var post = cb.post || function() {};
+		_traverse(opts, pre, post, schema, "", schema);
+	};
+	traverse.keywords = {
+		additionalItems: true,
+		items: true,
+		contains: true,
+		additionalProperties: true,
+		propertyNames: true,
+		not: true,
+		if: true,
+		then: true,
+		else: true
+	};
+	traverse.arrayKeywords = {
+		items: true,
+		allOf: true,
+		anyOf: true,
+		oneOf: true
+	};
+	traverse.propsKeywords = {
+		$defs: true,
+		definitions: true,
+		properties: true,
+		patternProperties: true,
+		dependencies: true
+	};
+	traverse.skipKeywords = {
+		default: true,
+		enum: true,
+		const: true,
+		required: true,
+		maximum: true,
+		minimum: true,
+		exclusiveMaximum: true,
+		exclusiveMinimum: true,
+		multipleOf: true,
+		maxLength: true,
+		minLength: true,
+		pattern: true,
+		format: true,
+		maxItems: true,
+		minItems: true,
+		uniqueItems: true,
+		maxProperties: true,
+		minProperties: true
+	};
+	function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+		if (schema && typeof schema == "object" && !Array.isArray(schema)) {
+			pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+			for (var key in schema) {
+				var sch = schema[key];
+				if (Array.isArray(sch)) {
+					if (key in traverse.arrayKeywords) for (var i = 0; i < sch.length; i++) _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
+				} else if (key in traverse.propsKeywords) {
+					if (sch && typeof sch == "object") for (var prop in sch) _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+				} else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+			}
+			post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+		}
+	}
+	function escapeJsonPtr(str) {
+		return str.replace(/~/g, "~0").replace(/\//g, "~1");
+	}
+}));
+//#endregion
+export default require_json_schema_traverse();
+export { require_json_schema_traverse };

package/dist/playground/client.js

@@ -1,6 +1,6 @@
 "use client";
-import { joinURL, resolveRequestData, resolveServerUrl, withBase } from "../utils/url.js";
 import { getPreferredType } from "../utils/schema/index.js";
+import { joinURL, resolveRequestData, resolveServerUrl, withBase } from "../utils/url.js";
 import { useStorageKey } from "../ui/client/storage-key.js";
 import { useApiContext, useServerContext } from "../ui/contexts/api.js";
 import { useTranslations } from "../ui/client/i18n.js";

package/dist/playground/schema.d.ts

@@ -1,7 +1,5 @@
 import { ReactNode } from "react";
-import { Ajv2020 } from "ajv/dist/2020.js";
 import { FieldKey } from "@fumari/stf";
-
 //#region src/playground/schema.d.ts
 interface SchemaScope {
   /**

package/dist/playground/schema.js

@@ -1,13 +1,14 @@
+import { require__2020 } from "../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/2020.js";
 import { mergeAllOf } from "../utils/schema/merge.js";
 import { sample } from "../utils/schema/sample.js";
 import { schemaToString } from "../utils/schema/to-string.js";
 import { dereferenceSwallow } from "../utils/schema/dereference.js";
 import { createContext, use, useMemo } from "react";
 import { jsx } from "react/jsx-runtime";
-import { Ajv2020 } from "ajv/dist/2020.js";
 import { useDataEngine, useFieldValue, useNamespace } from "@fumari/stf";
 import { stringifyFieldKey } from "@fumari/stf/lib/utils";
 //#region src/playground/schema.tsx
+var import__2020 = require__2020();
 const SchemaContext = createContext(void 0);
 const anyFields = {
 	type: [
@@ -21,7 +22,7 @@ const anyFields = {
 	additionalProperties: true
 };
 function SchemaProvider({ doc, readOnly, writeOnly, children }) {
-	const ajv = useMemo(() => new Ajv2020({
+	const ajv = useMemo(() => new import__2020.Ajv2020({
 		strict: false,
 		validateSchema: false,
 		validateFormats: false

package/dist/server/index.d.ts

@@ -1,3 +1,108 @@
-import { OpenAPIOptions, OpenAPIServer, createCodeSample, createOpenAPI } from "./create.js";
-import { InternalOpenAPIMeta, OpenAPIPageData, OpenAPISourceOptions, openapiPlugin, openapiSource, transformerOpenAPI } from "./source-api.js";
-export { InternalOpenAPIMeta, OpenAPIOptions, OpenAPIPageData, OpenAPIServer, OpenAPISourceOptions, createCodeSample, createOpenAPI, openapiPlugin, openapiSource, transformerOpenAPI };
+import { InlineCodeUsageGenerator } from "../requests/generators/index.js";
+import { CreateProxyOptions, Proxy, createProxy } from "./proxy.js";
+import { ProcessedDocument } from "../utils/document/process.js";
+import { ApiPageProps } from "../ui/api-page.js";
+import { ClientApiPageProps } from "../ui/create-client.js";
+import { SchemaToPagesOptions } from "../utils/pages/preset-auto.js";
+import { Document } from "../types.js";
+import { DereferencedDocument } from "../utils/document/dereference.js";
+import { DynamicSource, LoaderPlugin, MetaData, PageData, PageTreeTransformer, Source } from "fumadocs-core/source";
+import { StructuredData } from "fumadocs-core/mdx-plugins/remark-structure";
+import { TOCItemType } from "fumadocs-core/toc";
+
+//#region src/server/index.d.ts
+/**
+ * schema id -> file path, URL, or downloaded schema object
+ */
+type SchemaMap = Record<string, string | Document>;
+type ProcessedSchemaMap = Record<string, ProcessedDocument>;
+interface OpenAPIOptions {
+  /**
+   * Schema files, can be:
+   * - URL
+   * - file path
+   * - a function returning records of downloaded schemas.
+   */
+  input?: string[] | (() => SchemaMap | Promise<SchemaMap>);
+  disableCache?: boolean;
+  /**
+   * The url of proxy to avoid CORS issues
+   */
+  proxyUrl?: string;
+}
+interface OpenAPIServer {
+  createProxy: typeof createProxy;
+  getSchemas: () => Promise<ProcessedSchemaMap>;
+  getSchema: (document: string) => Promise<ProcessedDocument>;
+  readonly options: OpenAPIOptions;
+  /**
+   * Generate virtual pages for Fumadocs Source API
+   */
+  staticSource: (options?: OpenAPISourceOptions) => Promise<Source<{
+    metaData: MetaData;
+    pageData: OpenAPIPageData;
+  }>>;
+  /**
+   * Generate virtual pages for Fumadocs Source API
+   */
+  dynamicSource: (options?: OpenAPISourceOptions) => DynamicSource<{
+    metaData: MetaData;
+    pageData: OpenAPIPageData;
+  }>;
+  /**
+   * Fumadocs Source API integration, pass this to `plugins` array in `loader()`.
+   */
+  loaderPlugin: () => LoaderPlugin;
+  /** @private internal API */
+  _getWatchPaths: () => string[];
+}
+interface OpenAPIPageData extends PageData {
+  getAPIPageProps: () => ApiPageProps;
+  getSchema: () => {
+    id: string;
+  } & DereferencedDocument;
+  getClientAPIPageProps: () => Promise<ClientApiPageProps>;
+  structuredData: StructuredData;
+  toc: TOCItemType[];
+}
+type OpenAPISourceOptions = SchemaToPagesOptions & {
+  baseDir?: string; /** Generate `meta.json` files */
+  meta?: boolean | {
+    folderStyle?: 'folder' | 'separator';
+  };
+};
+declare function createOpenAPI(options?: OpenAPIOptions): OpenAPIServer;
+/**
+ * @deprecated
+ */
+declare function createCodeSample<T>(options: InlineCodeUsageGenerator<T>): InlineCodeUsageGenerator<T>;
+declare module 'fumadocs-core/source' {
+  interface PageData {
+    /**
+     * Added by Fumadocs OpenAPI
+     */
+    _openapi?: InternalOpenAPIMeta;
+  }
+}
+interface InternalOpenAPIMeta {
+  method?: string;
+  webhook?: boolean;
+  deprecated?: boolean;
+}
+/**
+ * Fumadocs Source API integration, pass this to `plugins` array in `loader()`.
+ */
+declare function openapiPlugin(): LoaderPlugin;
+/**
+ * Generate virtual pages for Fumadocs Source API
+ */
+declare function openapiSource(server: OpenAPIServer, options?: OpenAPISourceOptions): Promise<Source<{
+  metaData: MetaData;
+  pageData: OpenAPIPageData;
+}>>;
+/**
+ * @deprecated use `openapiPlugin()`
+ */
+declare function transformerOpenAPI(): PageTreeTransformer;
+//#endregion
+export { type CreateProxyOptions, InternalOpenAPIMeta, OpenAPIOptions, OpenAPIPageData, OpenAPIServer, OpenAPISourceOptions, type Proxy, createCodeSample, createOpenAPI, openapiPlugin, openapiSource, transformerOpenAPI };

package/dist/server/index.js

@@ -1,3 +1,182 @@
-import { createCodeSample, createOpenAPI } from "./create.js";
-import { openapiPlugin, openapiSource, transformerOpenAPI } from "./source-api.js";
+import { getPageProps } from "../utils/pages/builder.js";
+import { toStaticData } from "../utils/pages/to-static-data.js";
+import { MethodLabel } from "../ui/components/method-label.js";
+import { createProxy } from "./proxy.js";
+import { processDocument } from "../utils/document/process.js";
+import path from "node:path";
+import { PathUtils } from "fumadocs-core/source";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import fs from "node:fs";
+//#region src/server/index.tsx
+function createOpenAPI(options = {}) {
+	const { input = [], disableCache = false } = options;
+	let schemas;
+	async function getSchemas() {
+		if (Array.isArray(input)) {
+			const entries = await Promise.all(input.map(async (item) => [item, await processDocument(item)]));
+			return Object.fromEntries(entries);
+		} else {
+			const entries = await Promise.all(Object.entries(await input()).map(async ([k, v]) => [k, await processDocument(v)]));
+			return Object.fromEntries(entries);
+		}
+	}
+	async function getVirtualFiles(server, options) {
+		const { baseDir = "", meta = false } = options;
+		const { createAutoPreset } = await import("../utils/pages/preset-auto.js");
+		const { fromServer } = await import("../utils/pages/builder.js");
+		const files = [];
+		const entries = await fromServer(server, createAutoPreset(options));
+		for (const [schemaId, list] of Object.entries(entries)) {
+			const processed = await server.getSchema(schemaId);
+			function onEntry(entry) {
+				const props = getPageProps(entry);
+				files.push({
+					type: "page",
+					path: `${baseDir}/${entry.path}`,
+					data: {
+						...entry.info,
+						getAPIPageProps() {
+							return props;
+						},
+						async getClientAPIPageProps() {
+							return {
+								payload: {
+									bundled: processed.bundled,
+									proxyUrl: server.options.proxyUrl
+								},
+								...props
+							};
+						},
+						getSchema() {
+							return {
+								id: schemaId,
+								...processed
+							};
+						},
+						...toStaticData(props, processed.dereferenced),
+						_openapi: {
+							method: entry.type === "operation" || entry.type === "webhook" ? entry.item.method : void 0,
+							webhook: entry.type === "webhook",
+							deprecated: entry.info.deprecated
+						}
+					}
+				});
+			}
+			function onEntries(entries, parent) {
+				if (!meta) {
+					for (const entry of entries) if (entry.type === "group") onEntries(entry.entries, entry);
+					else onEntry(entry);
+					return;
+				}
+				const { folderStyle = "folder" } = meta === true ? {} : meta;
+				const pages = [];
+				for (const entry of entries) {
+					const relativePath = PathUtils.slash(parent ? path.relative(parent.path, entry.path) : entry.path);
+					if (entry.type === "group") {
+						onEntries(entry.entries, entry);
+						if (folderStyle === "folder") pages.push(relativePath);
+						else pages.push(`---${entry.info.title}---`, `...${relativePath}`);
+					} else {
+						onEntry(entry);
+						pages.push(relativePath.slice(0, -path.extname(entry.path).length));
+					}
+				}
+				if (pages.length === 0) return;
+				files.push({
+					type: "meta",
+					path: path.join(baseDir, parent?.path ?? "", "meta.json"),
+					data: {
+						title: parent?.info.title,
+						description: parent?.info.description,
+						pages
+					}
+				});
+			}
+			onEntries(list);
+		}
+		return files;
+	}
+	return {
+		options,
+		createProxy,
+		_getWatchPaths() {
+			return (Array.isArray(input) ? input : Object.keys(input)).filter((key) => !URL.canParse(key) && fs.existsSync(key));
+		},
+		async getSchema(document) {
+			const schemas = await this.getSchemas();
+			if (document in schemas) return schemas[document];
+			console.warn(`[Fumadocs OpenAPI] the document "${document}" is not listed in the input array, this may not be expected.`);
+			return processDocument(document);
+		},
+		async getSchemas() {
+			if (disableCache) return getSchemas();
+			return schemas ??= getSchemas();
+		},
+		async staticSource(options = {}) {
+			return { files: await getVirtualFiles(this, options) };
+		},
+		dynamicSource(options = {}) {
+			return { files: () => getVirtualFiles(this, options) };
+		},
+		loaderPlugin() {
+			return openapiPlugin();
+		}
+	};
+}
+/**
+* @deprecated
+*/
+function createCodeSample(options) {
+	return options;
+}
+/**
+* Fumadocs Source API integration, pass this to `plugins` array in `loader()`.
+*/
+function openapiPlugin() {
+	return {
+		name: "fumadocs:openapi",
+		enforce: "pre",
+		transformPageTree: { file(node, filePath) {
+			if (!filePath) return node;
+			const file = this.storage.read(filePath);
+			if (!file || file.format !== "page") return node;
+			const openApiData = file.data._openapi;
+			if (!openApiData || typeof openApiData !== "object") return node;
+			if (openApiData.deprecated) node.name = /* @__PURE__ */ jsx("span", {
+				className: "fd-page-tree-item-name line-through",
+				children: node.name
+			});
+			if (openApiData.webhook) node.name = /* @__PURE__ */ jsxs(Fragment, { children: [
+				node.name,
+				" ",
+				/* @__PURE__ */ jsx("span", {
+					className: "ms-auto border border-current px-1 rounded-lg text-xs text-nowrap font-mono",
+					children: "Webhook"
+				})
+			] });
+			else if (openApiData.method) node.name = /* @__PURE__ */ jsxs(Fragment, { children: [
+				node.name,
+				" ",
+				/* @__PURE__ */ jsx(MethodLabel, {
+					className: "ms-auto text-xs text-nowrap",
+					children: openApiData.method
+				})
+			] });
+			return node;
+		} }
+	};
+}
+/**
+* Generate virtual pages for Fumadocs Source API
+*/
+async function openapiSource(server, options = {}) {
+	return server.staticSource(options);
+}
+/**
+* @deprecated use `openapiPlugin()`
+*/
+function transformerOpenAPI() {
+	return openapiPlugin().transformPageTree;
+}
+//#endregion
 export { createCodeSample, createOpenAPI, openapiPlugin, openapiSource, transformerOpenAPI };