@farming-labs/next 0.2.104 → 0.2.105

package/dist/api-reference.mjs

@@ -0,0 +1,755 @@
+import DocsClientCallbacks from "./client-callbacks.mjs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { buildApiReferenceOpenApiDocumentAsync, buildApiReferencePageTitle, buildApiReferenceScalarCss, resolveApiReferenceConfig, resolveApiReferenceRenderer } from "@farming-labs/docs/server";
+import { ApiReference } from "@scalar/nextjs-api-reference";
+import { SidebarTabsDropdown } from "fumadocs-ui/components/sidebar/tabs/dropdown";
+import Link from "next/link";
+import { notFound } from "next/navigation";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/api-reference.tsx
+const ROUTE_FILE_RE = /^route\.(ts|tsx|js|jsx)$/;
+const METHOD_RE = /export\s+(?:async\s+function|function|const)\s+(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/g;
+function getNextAppDir(root) {
+	if (existsSync(join(root, "src", "app"))) return "src/app";
+	return "app";
+}
+function normalizeRouteRoot(value) {
+	return value.replace(/^\/+|\/+$/g, "") || "api";
+}
+function normalizeExcludeMatcher(value) {
+	return value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").replace(/\.(ts|tsx|js|jsx)$/i, "").replace(/\/route$/i, "");
+}
+function getRoutePathBase(config) {
+	const routeRoot = normalizeRouteRoot(config.routeRoot);
+	if (routeRoot === "app" || routeRoot === "src/app") return "";
+	if (routeRoot.startsWith("app/")) return `/${routeRoot.slice(4)}`;
+	if (routeRoot.startsWith("src/app/")) return `/${routeRoot.slice(8)}`;
+	return `/${routeRoot}`;
+}
+function resolveNextApiRouteRoot(root, config) {
+	const routeRoot = normalizeRouteRoot(config.routeRoot);
+	if (routeRoot === "app" || routeRoot.startsWith("app/") || routeRoot === "src/app" || routeRoot.startsWith("src/app/")) return join(root, ...routeRoot.split("/"));
+	return join(root, getNextAppDir(root), ...routeRoot.split("/"));
+}
+function shouldExcludeRoute(excludes, routePath, relativeFile, relativeDir) {
+	if (excludes.length === 0) return false;
+	const normalizedRoutePath = normalizeExcludeMatcher(routePath);
+	const candidates = new Set([
+		normalizedRoutePath,
+		normalizeExcludeMatcher(routePath.replace(/^\/+/, "")),
+		normalizeExcludeMatcher(relativeFile),
+		normalizeExcludeMatcher(relativeDir)
+	]);
+	return excludes.some((entry) => candidates.has(entry));
+}
+function humanizeSegment(value) {
+	return value.replace(/^\[\[?\.{3}/, "").replace(/^\[/, "").replace(/\]\]?$/, "").replace(/^\$/, "").replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function slugifyApiReferencePageName(value) {
+	return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function endpointSegmentFromFsSegment(value) {
+	if (value.startsWith("[[...") && value.endsWith("]]")) return `{${value.slice(5, -2)}}`;
+	if (value.startsWith("[...") && value.endsWith("]")) return `{${value.slice(4, -1)}}`;
+	if (value.startsWith("[") && value.endsWith("]")) return `{${value.slice(1, -1)}}`;
+	return value;
+}
+function getPathParamName(value) {
+	if (value.startsWith("[[...") && value.endsWith("]]")) return value.slice(5, -2);
+	if (value.startsWith("[...") && value.endsWith("]")) return value.slice(4, -1);
+	if (value.startsWith("[") && value.endsWith("]")) return value.slice(1, -1);
+}
+function extractDocBlock(source) {
+	const match = source.match(/\/\*\*([\s\S]*?)\*\//);
+	if (!match) return {};
+	const lines = match[1].split("\n").map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter(Boolean).filter((line) => !line.startsWith("@"));
+	if (lines.length === 0) return {};
+	return {
+		summary: lines[0],
+		description: lines.slice(1).join(" ")
+	};
+}
+function extractMethods(source) {
+	const methods = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(METHOD_RE)) methods.add(match[1]);
+	return Array.from(methods);
+}
+function scanRouteFiles(dir) {
+	if (!existsSync(dir)) return [];
+	const results = [];
+	for (const name of readdirSync(dir)) {
+		const full = join(dir, name);
+		if (statSync(full).isDirectory()) {
+			results.push(...scanRouteFiles(full));
+			continue;
+		}
+		if (ROUTE_FILE_RE.test(name)) results.push(full);
+	}
+	return results;
+}
+function getDocsUrl(config) {
+	if (typeof config.nav?.url === "string") return config.nav.url;
+	return `/${config.entry ?? "docs"}`;
+}
+function getForcedMode(config) {
+	const toggle = config.themeToggle;
+	if (!toggle || typeof toggle !== "object") return void 0;
+	if (toggle.default === "dark") return "dark";
+	if (toggle.default === "light") return "light";
+}
+function isThemeToggleHidden(config) {
+	if (config.themeToggle === false) return true;
+	if (config.themeToggle && typeof config.themeToggle === "object") return config.themeToggle.enabled === false;
+	return false;
+}
+function getOriginFromRequest(request) {
+	if (!request) return void 0;
+	try {
+		return new URL(request.url).origin;
+	} catch {
+		return;
+	}
+}
+function getForwardedHeaderValue(value) {
+	if (!value) return void 0;
+	return value.split(",").map((entry) => entry.trim()).find(Boolean) || void 0;
+}
+function getOriginFromHeaderUrl(value) {
+	if (!value) return void 0;
+	try {
+		return new URL(value).origin;
+	} catch {
+		return;
+	}
+}
+async function getOriginFromNextHeaders() {
+	const { headers } = await import("next/headers");
+	const headerList = await headers();
+	const hintedOrigin = getOriginFromHeaderUrl(headerList.get("origin")) ?? getOriginFromHeaderUrl(headerList.get("referer"));
+	if (hintedOrigin) return hintedOrigin;
+	const host = getForwardedHeaderValue(headerList.get("x-forwarded-host")) ?? getForwardedHeaderValue(headerList.get("host"));
+	if (!host || host === "loading") return process.env.FARMING_LABS_DOCS_DEV_ORIGIN;
+	return `${getForwardedHeaderValue(headerList.get("x-forwarded-proto")) ?? "https"}://${host}`;
+}
+function buildPathParameters(fsSegments) {
+	const parameters = [];
+	for (const segment of fsSegments) {
+		const name = getPathParamName(segment);
+		if (!name) continue;
+		const optional = segment.startsWith("[[...");
+		parameters.push({
+			name,
+			in: "path",
+			required: !optional,
+			description: optional ? `${humanizeSegment(name)} catch-all parameter.` : `${humanizeSegment(name)} path parameter.`,
+			schema: { type: "string" }
+		});
+	}
+	return parameters;
+}
+function buildApiReferenceRoutes(config) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	if (!apiReference.enabled) return [];
+	const root = process.cwd();
+	const apiDir = resolveNextApiRouteRoot(root, apiReference);
+	const routePathBase = getRoutePathBase(apiReference);
+	const files = scanRouteFiles(apiDir);
+	const excludes = apiReference.exclude;
+	const routes = [];
+	for (const file of files) {
+		const source = readFileSync(file, "utf-8");
+		const methods = extractMethods(source);
+		if (methods.length === 0) continue;
+		const relativeFile = relative(apiDir, file).replace(/\\/g, "/");
+		const fsSegments = relativeFile.split("/").slice(0, -1).filter(Boolean);
+		const relativeDir = fsSegments.join("/");
+		const routeSegments = fsSegments.map(endpointSegmentFromFsSegment);
+		const routePath = `${routePathBase}${routeSegments.length > 0 ? `/${routeSegments.join("/")}` : ""}` || "/";
+		if (shouldExcludeRoute(excludes, routePath, relativeFile, relativeDir)) continue;
+		const docBlock = extractDocBlock(source);
+		const title = fsSegments.length > 0 ? humanizeSegment(fsSegments[fsSegments.length - 1]) : "Overview";
+		routes.push({
+			title,
+			summary: docBlock.summary ?? `${title} endpoint`,
+			description: docBlock.description,
+			routePath,
+			sourceFile: relative(root, file).replace(/\\/g, "/"),
+			methods,
+			segments: fsSegments,
+			tag: fsSegments.length > 0 ? humanizeSegment(fsSegments[0]) : "General",
+			parameters: buildPathParameters(fsSegments)
+		});
+	}
+	return routes.sort((a, b) => a.routePath.localeCompare(b.routePath));
+}
+function createOperationId(route, method) {
+	return `${method.toLowerCase()}_${route.routePath.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
+}
+function buildRequestBody(method) {
+	if (![
+		"POST",
+		"PUT",
+		"PATCH"
+	].includes(method)) return void 0;
+	return {
+		required: method === "POST",
+		content: { "application/json": {
+			schema: {
+				type: "object",
+				additionalProperties: true
+			},
+			example: { example: true }
+		} }
+	};
+}
+function buildResponses(method) {
+	return { "200": {
+		description: method === "DELETE" ? "Resource removed successfully." : "Request completed successfully.",
+		content: { "application/json": {
+			schema: {
+				type: "object",
+				additionalProperties: true
+			},
+			example: { ok: true }
+		} }
+	} };
+}
+function buildOpenApiPaths(routes) {
+	const paths = {};
+	for (const route of routes) {
+		const pathItem = {};
+		for (const method of route.methods) pathItem[method.toLowerCase()] = {
+			tags: [route.tag],
+			summary: route.summary,
+			description: route.description ?? route.summary,
+			operationId: createOperationId(route, method),
+			...route.parameters.length > 0 ? { parameters: route.parameters } : {},
+			...buildRequestBody(method) ? { requestBody: buildRequestBody(method) } : {},
+			responses: buildResponses(method),
+			"x-farming-labs-source": route.sourceFile
+		};
+		paths[route.routePath] = pathItem;
+	}
+	return paths;
+}
+function buildNextOpenApiDocument(config) {
+	if (resolveApiReferenceConfig(config.apiReference).specUrl) return {
+		openapi: "3.1.0",
+		info: {
+			title: "API Reference",
+			description: "Remote OpenAPI specs are resolved at request time through the Next.js API reference renderer.",
+			version: "0.0.0"
+		},
+		servers: [{ url: "/" }],
+		tags: [],
+		paths: {}
+	};
+	const routes = buildApiReferenceRoutes(config);
+	const tags = Array.from(new Set(routes.map((route) => route.tag))).map((name) => ({
+		name,
+		description: `${name} endpoints`
+	}));
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: "API Reference",
+			description: config.metadata?.description ?? "Generated API reference from Next.js route handlers.",
+			version: "0.0.0"
+		},
+		servers: [{ url: "/" }],
+		tags,
+		paths: buildOpenApiPaths(routes)
+	};
+}
+function SwitcherGlyph({ kind }) {
+	const isApi = kind === "api";
+	return /* @__PURE__ */ jsx("span", {
+		className: "fd-api-reference-switcher-glyph",
+		"data-kind": kind,
+		"aria-hidden": "true",
+		children: isApi ? /* @__PURE__ */ jsx("svg", {
+			viewBox: "0 0 24 24",
+			fill: "none",
+			children: /* @__PURE__ */ jsx("path", {
+				d: "M8 8L4 12L8 16M16 8L20 12L16 16M13.5 6L10.5 18",
+				stroke: "currentColor",
+				strokeWidth: "1.8",
+				strokeLinecap: "round",
+				strokeLinejoin: "round"
+			})
+		}) : /* @__PURE__ */ jsx("svg", {
+			viewBox: "0 0 24 24",
+			fill: "none",
+			children: /* @__PURE__ */ jsx("path", {
+				d: "M4.75 6.75C4.75 5.64543 5.64543 4.75 6.75 4.75H11.25V19.25H6.75C5.64543 19.25 4.75 18.3546 4.75 17.25V6.75ZM12.75 4.75H17.25C18.3546 4.75 19.25 5.64543 19.25 6.75V17.25C19.25 18.3546 18.3546 19.25 17.25 19.25H12.75V4.75Z",
+				stroke: "currentColor",
+				strokeWidth: "1.8",
+				strokeLinejoin: "round"
+			})
+		})
+	});
+}
+const API_REFERENCE_COLOR_MAP = {
+	primary: "--color-fd-primary",
+	primaryForeground: "--color-fd-primary-foreground",
+	background: "--color-fd-background",
+	foreground: "--color-fd-foreground",
+	muted: "--color-fd-muted",
+	mutedForeground: "--color-fd-muted-foreground",
+	border: "--color-fd-border",
+	card: "--color-fd-card",
+	cardForeground: "--color-fd-card-foreground",
+	accent: "--color-fd-accent",
+	accentForeground: "--color-fd-accent-foreground",
+	popover: "--color-fd-popover",
+	popoverForeground: "--color-fd-popover-foreground",
+	secondary: "--color-fd-secondary",
+	secondaryForeground: "--color-fd-secondary-foreground",
+	ring: "--color-fd-ring"
+};
+function buildApiReferenceColorsCSS(colors) {
+	if (!colors) return "";
+	const vars = [];
+	for (const [key, value] of Object.entries(colors)) {
+		if (!value || !API_REFERENCE_COLOR_MAP[key]) continue;
+		vars.push(`${API_REFERENCE_COLOR_MAP[key]}: ${value};`);
+	}
+	if (vars.length === 0) return "";
+	const block = vars.join("\n  ");
+	return `:root {\n  ${block}\n}\n.dark {\n  ${block}\n}`;
+}
+function ApiReferenceColorStyle({ colors }) {
+	const css = buildApiReferenceColorsCSS(colors);
+	if (!css) return null;
+	return /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: css } });
+}
+function buildApiReferenceFontStyleVars(prefix, style) {
+	if (!style) return "";
+	const parts = [];
+	if (style.size) parts.push(`${prefix}-size: ${style.size};`);
+	if (style.weight != null) parts.push(`${prefix}-weight: ${style.weight};`);
+	if (style.lineHeight) parts.push(`${prefix}-line-height: ${style.lineHeight};`);
+	if (style.letterSpacing) parts.push(`${prefix}-letter-spacing: ${style.letterSpacing};`);
+	return parts.join("\n  ");
+}
+function buildApiReferenceTypographyCSS(typography) {
+	if (!typography?.font) return "";
+	const vars = [];
+	const fontStyle = typography.font.style;
+	if (fontStyle?.sans) vars.push(`--fd-font-sans: ${fontStyle.sans};`);
+	if (fontStyle?.mono) vars.push(`--fd-font-mono: ${fontStyle.mono};`);
+	for (const element of [
+		"h1",
+		"h2",
+		"h3",
+		"h4",
+		"body",
+		"small"
+	]) {
+		const style = typography.font[element];
+		if (!style) continue;
+		const cssVars = buildApiReferenceFontStyleVars(`--fd-${element}`, style);
+		if (cssVars) vars.push(cssVars);
+	}
+	if (vars.length === 0) return "";
+	const cssVars = vars.join("\n  ");
+	return `:root {
+  ${cssVars}
+}
+body:has(.fd-api-reference-page) {
+  ${cssVars}
+}
+.fd-api-reference-page {
+  ${cssVars}
+}`;
+}
+function ApiReferenceTypographyStyle({ typography }) {
+	const css = buildApiReferenceTypographyCSS(typography);
+	if (!css) return null;
+	return /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: css } });
+}
+function ApiReferenceLayoutStyle({ layout }) {
+	if (!layout) return null;
+	const rootVars = [];
+	const desktopRootVars = [];
+	const desktopGridVars = [];
+	if (layout.sidebarWidth) {
+		const value = `--fd-sidebar-width: ${layout.sidebarWidth}px`;
+		desktopRootVars.push(`${value};`);
+		desktopGridVars.push(`${value} !important;`);
+	}
+	if (layout.contentWidth) rootVars.push(`--fd-content-width: ${layout.contentWidth}px;`);
+	if (layout.tocWidth) {
+		const value = `--fd-toc-width: ${layout.tocWidth}px`;
+		desktopRootVars.push(`${value};`);
+		desktopGridVars.push(`${value} !important;`);
+	}
+	if (rootVars.length === 0 && desktopRootVars.length === 0) return null;
+	const parts = [];
+	if (rootVars.length > 0) parts.push(`:root {\n  ${rootVars.join("\n  ")}\n}`);
+	if (desktopRootVars.length > 0) {
+		const inner = [`:root {\n    ${desktopRootVars.join("\n    ")}\n  }`];
+		if (desktopGridVars.length > 0) inner.push(`[style*="fd-sidebar-col"] {\n    ${desktopGridVars.join("\n    ")}\n  }`);
+		parts.push(`@media (min-width: 1024px) {\n  ${inner.join("\n  ")}\n}`);
+	}
+	return /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: parts.join("\n") } });
+}
+function resolveApiReferenceThemeSwitch(toggle) {
+	if (toggle === void 0 || toggle === true) return { enabled: true };
+	if (toggle === false) return { enabled: false };
+	return {
+		enabled: toggle.enabled !== false,
+		mode: toggle.mode
+	};
+}
+function ApiReferenceForcedThemeScript({ theme }) {
+	return /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: `document.documentElement.classList.remove('light','dark');document.documentElement.classList.add('${theme}');` } });
+}
+function ApiReferenceThemeBridge({ config }) {
+	const colors = config.theme?._userColorOverrides;
+	const typography = config.theme?.ui?.typography;
+	const layout = config.theme?.ui?.layout;
+	const themeSwitch = resolveApiReferenceThemeSwitch(config.themeToggle);
+	const toggleConfig = typeof config.themeToggle === "object" ? config.themeToggle : void 0;
+	const forcedTheme = themeSwitch.enabled === false && toggleConfig?.default && toggleConfig.default !== "system" ? toggleConfig.default : void 0;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(ApiReferenceColorStyle, { colors }),
+		/* @__PURE__ */ jsx(ApiReferenceTypographyStyle, { typography }),
+		/* @__PURE__ */ jsx(ApiReferenceLayoutStyle, { layout }),
+		forcedTheme ? /* @__PURE__ */ jsx(ApiReferenceForcedThemeScript, { theme: forcedTheme }) : null
+	] });
+}
+function ApiReferenceServerUrlPatchScript({ serverUrl }) {
+	if (!serverUrl) return null;
+	return /* @__PURE__ */ jsx("script", {
+		id: "fd-api-reference-server-url-patch",
+		dangerouslySetInnerHTML: { __html: `(function () {
+    var raw = ${JSON.stringify(serverUrl)};
+    var resolve = function () {
+      try {
+        return new URL(raw, window.location.origin).toString();
+      } catch {
+        return window.location.origin;
+      }
+    };
+    var apply = function () {
+      var label = resolve();
+      document
+        .querySelectorAll('.fd-api-reference-route button[aria-haspopup="dialog"] code.truncate')
+        .forEach(function (node) {
+          if (node.textContent && node.textContent.trim() === 'loading...') {
+            node.textContent = label;
+          }
+        });
+    };
+
+    apply();
+    window.requestAnimationFrame(apply);
+    window.setTimeout(apply, 200);
+    window.setTimeout(apply, 1200);
+  })();` }
+	});
+}
+function ApiReferenceSwitcher({ docsUrl, apiUrl }) {
+	return /* @__PURE__ */ jsx(SidebarTabsDropdown, {
+		className: "fd-api-reference-switcher w-full mb-4",
+		options: [{
+			url: docsUrl,
+			title: "Documentation",
+			description: "Guides & concepts",
+			icon: /* @__PURE__ */ jsx(SwitcherGlyph, { kind: "docs" })
+		}, {
+			url: apiUrl,
+			title: "API Reference",
+			description: "Endpoints & examples",
+			icon: /* @__PURE__ */ jsx(SwitcherGlyph, { kind: "api" })
+		}]
+	});
+}
+function getExistingSidebarBanner(config) {
+	if (!config.sidebar || config.sidebar === true) return void 0;
+	return config.sidebar.banner;
+}
+function resolveApiReferenceThemeStyle(config) {
+	if ((config.theme?.name?.toLowerCase() ?? "").includes("colorful")) return "colorful";
+}
+function mergeBanner(existing, next) {
+	if (!existing) return next;
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			display: "flex",
+			flexDirection: "column",
+			gap: 12
+		},
+		children: [existing, next]
+	});
+}
+function flattenApiReferencePageTreeForSidebar(tree) {
+	if (!tree || typeof tree !== "object") return tree;
+	const root = tree;
+	if (!Array.isArray(root.children) || root.children.length !== 1) return tree;
+	const [onlyChild] = root.children;
+	if (!onlyChild || typeof onlyChild !== "object") return tree;
+	const folder = onlyChild;
+	if (folder.type !== "folder" || !Array.isArray(folder.children)) return tree;
+	const nextChildren = [...folder.index ? [folder.index] : [], ...folder.children];
+	if (nextChildren.length === 0) return tree;
+	return {
+		...root,
+		children: nextChildren
+	};
+}
+function renderApiReferenceOperationLayout(slots) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "fd-api-reference-operation",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "fd-api-reference-operation-main",
+			children: [
+				slots.header,
+				slots.apiPlayground,
+				slots.description ? /* @__PURE__ */ jsx("div", {
+					className: "fd-api-reference-operation-description",
+					children: slots.description
+				}) : null,
+				slots.authSchemes,
+				slots.parameters,
+				slots.body,
+				slots.responses,
+				slots.callbacks
+			]
+		}), slots.apiExample ? /* @__PURE__ */ jsx("div", {
+			className: "fd-api-reference-operation-example",
+			children: slots.apiExample
+		}) : null]
+	});
+}
+function withNextApiReferenceBanner(config) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	if (!apiReference.enabled) return config;
+	if (config.sidebar === false) return config;
+	const switcher = /* @__PURE__ */ jsx(ApiReferenceSwitcher, {
+		docsUrl: getDocsUrl(config),
+		apiUrl: `/${apiReference.path}`,
+		current: "docs",
+		config
+	});
+	const banner = mergeBanner(getExistingSidebarBanner(config), switcher);
+	if (!config.sidebar || config.sidebar === true) return {
+		...config,
+		sidebar: { banner }
+	};
+	return {
+		...config,
+		sidebar: {
+			...config.sidebar,
+			banner
+		}
+	};
+}
+function createNextApiReference(config) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	return async (request) => {
+		if (!apiReference.enabled) return new Response("Not Found", { status: 404 });
+		const document = await buildApiReferenceOpenApiDocumentAsync(config, {
+			framework: "next",
+			rootDir: process.cwd(),
+			baseUrl: getOriginFromRequest(request)
+		});
+		return ApiReference({
+			pageTitle: buildApiReferencePageTitle(config, "API Reference"),
+			title: "API Reference",
+			content: document,
+			theme: "deepSpace",
+			layout: "modern",
+			darkMode: getForcedMode(config) === "dark" ? true : void 0,
+			forceDarkModeState: getForcedMode(config),
+			hideDarkModeToggle: isThemeToggleHidden(config),
+			customCss: buildApiReferenceScalarCss(config),
+			pathRouting: { basePath: `/${apiReference.path}` },
+			showSidebar: true,
+			defaultOpenFirstTag: true,
+			tagsSorter: "alpha",
+			operationsSorter: "alpha",
+			operationTitleSource: "summary",
+			defaultHttpClient: {
+				targetKey: "shell",
+				clientKey: "curl"
+			},
+			documentDownloadType: "json"
+		})();
+	};
+}
+function getOpenApiInfo(document) {
+	const info = document.info && typeof document.info === "object" && !Array.isArray(document.info) ? document.info : {};
+	return {
+		title: typeof info.title === "string" && info.title.trim() ? info.title : "API Reference",
+		description: typeof info.description === "string" && info.description.trim() ? info.description : void 0
+	};
+}
+function createNextApiReferencePage(config) {
+	return async function NextApiReferencePage(props) {
+		const [{ createAPIPage }, { DocsDescription, DocsPage, DocsTitle }] = await Promise.all([import("fumadocs-openapi/ui"), import("fumadocs-ui/layouts/notebook/page")]);
+		const { info, pages, server, source } = await getNextApiReferenceSourceState(config);
+		const slug = (props?.params ? await props.params : void 0)?.slug ?? [];
+		if (pages.length === 0) return /* @__PURE__ */ jsxs(DocsPage, {
+			full: true,
+			children: [
+				/* @__PURE__ */ jsx(DocsTitle, { children: info.title }),
+				/* @__PURE__ */ jsx(DocsDescription, { children: info.description }),
+				/* @__PURE__ */ jsx("div", {
+					className: "fd-api-reference-body",
+					children: /* @__PURE__ */ jsx("div", {
+						className: "rounded-xl border border-fd-border bg-fd-card p-6 text-sm text-fd-muted-foreground",
+						children: "No operations were found in the OpenAPI document."
+					})
+				})
+			]
+		});
+		const page = slug.length === 0 ? pages[0] : source.getPage(slug);
+		if (!page || typeof page.data?.getAPIPageProps !== "function") notFound();
+		const APIPage = createAPIPage(server, { content: { renderOperationLayout: renderApiReferenceOperationLayout } });
+		const currentPageIndex = slug.length === 0 ? 0 : pages.findIndex((entry) => entry.url === page.url);
+		const previousPage = currentPageIndex > 0 ? pages[currentPageIndex - 1] : void 0;
+		const nextPage = currentPageIndex >= 0 && currentPageIndex < pages.length - 1 ? pages[currentPageIndex + 1] : void 0;
+		return /* @__PURE__ */ jsxs(DocsPage, {
+			toc: page.data.toc,
+			full: true,
+			footer: { enabled: false },
+			className: "fd-api-reference-page",
+			children: [
+				/* @__PURE__ */ jsx(DocsTitle, { children: page.data.title ?? info.title }),
+				/* @__PURE__ */ jsx(DocsDescription, { children: typeof page.data.description === "string" && page.data.description.trim() ? page.data.description : info.description }),
+				/* @__PURE__ */ jsx("div", {
+					className: "fd-api-reference-body",
+					children: /* @__PURE__ */ jsx(APIPage, { ...page.data.getAPIPageProps() })
+				}),
+				previousPage || nextPage ? /* @__PURE__ */ jsxs("nav", {
+					className: "fd-api-reference-pagination",
+					"aria-label": "API reference pagination",
+					children: [previousPage ? /* @__PURE__ */ jsxs(Link, {
+						href: previousPage.url,
+						prefetch: true,
+						className: "fd-api-reference-pagination-item",
+						"data-direction": "previous",
+						children: [
+							/* @__PURE__ */ jsx("span", {
+								className: "fd-api-reference-pagination-label",
+								children: "Previous"
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: "fd-api-reference-pagination-title",
+								children: previousPage.data?.title ?? previousPage.url
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: "fd-api-reference-pagination-description",
+								children: previousPage.data?.description ?? "Previous API operation"
+							})
+						]
+					}) : /* @__PURE__ */ jsx("div", {
+						className: "fd-api-reference-pagination-spacer",
+						"aria-hidden": "true"
+					}), nextPage ? /* @__PURE__ */ jsxs(Link, {
+						href: nextPage.url,
+						prefetch: true,
+						className: "fd-api-reference-pagination-item",
+						"data-direction": "next",
+						children: [
+							/* @__PURE__ */ jsx("span", {
+								className: "fd-api-reference-pagination-label",
+								children: "Next"
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: "fd-api-reference-pagination-title",
+								children: nextPage.data?.title ?? nextPage.url
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: "fd-api-reference-pagination-description",
+								children: nextPage.data?.description ?? "Next API operation"
+							})
+						]
+					}) : /* @__PURE__ */ jsx("div", {
+						className: "fd-api-reference-pagination-spacer",
+						"aria-hidden": "true"
+					})]
+				}) : null
+			]
+		});
+	};
+}
+function createNextApiReferenceLayout(config) {
+	return async function NextApiReferenceLayout(props) {
+		const { DocsLayout } = await import("fumadocs-ui/layouts/notebook");
+		const { apiReference, primaryServerUrl, source } = await getNextApiReferenceSourceState(config);
+		const sidebarTree = flattenApiReferencePageTreeForSidebar(source.getPageTree());
+		const docsUrl = getDocsUrl(config);
+		const apiUrl = `/${apiReference.path}`;
+		const themeSwitch = resolveApiReferenceThemeSwitch(config.themeToggle);
+		const themeStyle = resolveApiReferenceThemeStyle(config);
+		const banner = mergeBanner(getExistingSidebarBanner(config), /* @__PURE__ */ jsx(ApiReferenceSwitcher, {
+			docsUrl,
+			apiUrl,
+			current: "api",
+			config
+		}));
+		return /* @__PURE__ */ jsxs("div", {
+			className: "fd-api-reference-route",
+			"data-api-reference": "",
+			"data-theme-style": themeStyle,
+			children: [/* @__PURE__ */ jsx(DocsClientCallbacks, { apiReferencePrimaryServerUrl: primaryServerUrl }), /* @__PURE__ */ jsxs(DocsLayout, {
+				tree: sidebarTree,
+				sidebar: { banner },
+				themeSwitch,
+				nav: {
+					title: config.nav?.title ?? "Docs",
+					url: getDocsUrl(config)
+				},
+				children: [
+					/* @__PURE__ */ jsx(ApiReferenceThemeBridge, { config }),
+					/* @__PURE__ */ jsx(ApiReferenceServerUrlPatchScript, { serverUrl: primaryServerUrl }),
+					props.children
+				]
+			})]
+		});
+	};
+}
+async function getNextApiReferenceSourceState(config) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	const [{ createOpenAPI, openapiPlugin, openapiSource }, { loader }] = await Promise.all([import("fumadocs-openapi/server"), import("fumadocs-core/source")]);
+	const baseUrl = await getOriginFromNextHeaders();
+	const document = await buildApiReferenceOpenApiDocumentAsync(config, {
+		framework: "next",
+		rootDir: process.cwd(),
+		baseUrl
+	});
+	const server = createOpenAPI({ input: async () => ({ main: document }) });
+	const info = getOpenApiInfo(document);
+	const source = loader(await openapiSource(server, {
+		per: "operation",
+		groupBy: "tag",
+		name(output, dereferenced) {
+			if (output.type !== "operation") return slugifyApiReferencePageName(output.item.name);
+			const operation = (dereferenced.paths?.[output.item.path])?.[output.item.method];
+			return slugifyApiReferencePageName(typeof operation?.summary === "string" && operation.summary.trim() ? operation.summary : typeof operation?.operationId === "string" && operation.operationId.trim() ? operation.operationId : `${output.item.method} ${output.item.path}`);
+		}
+	}), {
+		baseUrl: `/${apiReference.path}`,
+		plugins: [openapiPlugin()]
+	});
+	return {
+		apiReference,
+		document,
+		info,
+		primaryServerUrl: Array.isArray(document.servers) && typeof document.servers?.[0]?.url === "string" ? document.servers?.[0]?.url ?? void 0 : void 0,
+		pages: source.getPages(),
+		server,
+		source
+	};
+}
+function getNextApiReferenceMode(config) {
+	return resolveApiReferenceRenderer(config.apiReference, "next");
+}
+
+//#endregion
+export { buildNextOpenApiDocument, createNextApiReference, createNextApiReferenceLayout, createNextApiReferencePage, flattenApiReferencePageTreeForSidebar, getNextApiReferenceMode, getNextApiReferenceSourceState, resolveApiReferenceConfig, withNextApiReferenceBanner };