fumadocs-openapi 10.10.0 → 10.10.2

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/url.js

@@ -0,0 +1,315 @@
+import convertPathToPosix from "./convert-path-to-posix.js";
+import { isWindows } from "./is-windows.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/url.js
+const forwardSlashPattern = /\//g;
+const protocolPattern = /^(\w{2,}):\/\//i;
+const jsonPointerSlash = /~1/g;
+const jsonPointerTilde = /~0/g;
+const isAbsoluteWin32Path = /^[a-zA-Z]:[\\/]/;
+const urlEncodePatterns = [[/\?/g, "%3F"], [/#/g, "%23"]];
+const urlDecodePatterns = [
+	/%23/g,
+	"#",
+	/%24/g,
+	"$",
+	/%26/g,
+	"&",
+	/%2C/g,
+	",",
+	/%40/g,
+	"@"
+];
+const parse = (u) => new URL(u);
+/**
+* Returns resolved target URL relative to a base URL in a manner similar to that of a Web browser resolving an anchor tag HREF.
+*
+* @returns
+*/
+function resolve(from, to) {
+	const fromUrl = new URL(convertPathToPosix(from), "https://aaa.nonexistanturl.com");
+	const resolvedUrl = new URL(convertPathToPosix(to), fromUrl);
+	const endSpaces = to.match(/(\s*)$/)?.[1] || "";
+	if (resolvedUrl.hostname === "aaa.nonexistanturl.com") {
+		const { pathname, search, hash } = resolvedUrl;
+		return pathname + search + decodeURIComponent(hash) + endSpaces;
+	}
+	const resolved = resolvedUrl.toString() + endSpaces;
+	if (resolved.includes("#")) {
+		const [base, hash] = resolved.split("#", 2);
+		return base + "#" + decodeURIComponent(hash || "");
+	}
+	return resolved;
+}
+/**
+* Returns the current working directory (in Node) or the current page URL (in browsers).
+*
+* @returns
+*/
+function cwd() {
+	if (typeof window !== "undefined" && window.location && window.location.href) {
+		const href = window.location.href;
+		if (!href || !href.startsWith("http")) try {
+			new URL(href);
+			return href;
+		} catch {
+			return "/";
+		}
+		return href;
+	}
+	if (typeof process !== "undefined" && process.cwd) {
+		const path = process.cwd();
+		const lastChar = path.slice(-1);
+		if (lastChar === "/" || lastChar === "\\") return path;
+		else return path + "/";
+	}
+	return "/";
+}
+/**
+* Returns the protocol of the given URL, or `undefined` if it has no protocol.
+*
+* @param path
+* @returns
+*/
+function getProtocol(path) {
+	const match = protocolPattern.exec(path || "");
+	if (match) return match[1].toLowerCase();
+}
+/**
+* Returns the lowercased file extension of the given URL,
+* or an empty string if it has no extension.
+*
+* @param path
+* @returns
+*/
+function getExtension(path) {
+	const lastDot = path.lastIndexOf(".");
+	if (lastDot >= 0) return stripQuery(path.substring(lastDot).toLowerCase());
+	return "";
+}
+/**
+* Removes the query, if any, from the given path.
+*
+* @param path
+* @returns
+*/
+function stripQuery(path) {
+	const queryIndex = path.indexOf("?");
+	if (queryIndex >= 0) path = path.substring(0, queryIndex);
+	return path;
+}
+/**
+* Returns the hash (URL fragment), of the given path.
+* If there is no hash, then the root hash ("#") is returned.
+*
+* @param path
+* @returns
+*/
+function getHash(path) {
+	if (!path) return "#";
+	const hashIndex = path.indexOf("#");
+	if (hashIndex >= 0) return path.substring(hashIndex);
+	return "#";
+}
+/**
+* Removes the hash (URL fragment), if any, from the given path.
+*
+* @param path
+* @returns
+*/
+function stripHash(path) {
+	if (!path) return "";
+	const hashIndex = path.indexOf("#");
+	if (hashIndex >= 0) path = path.substring(0, hashIndex);
+	return path;
+}
+/**
+* Determines whether the given path is an HTTP(S) URL.
+*
+* @param path
+* @returns
+*/
+function isHttp(path) {
+	const protocol = getProtocol(path);
+	if (protocol === "http" || protocol === "https") return true;
+	else if (protocol === void 0) return typeof window !== "undefined";
+	else return false;
+}
+/**
+* Determines whether the given url is an unsafe or internal url.
+*
+* @param path - The URL or path to check
+* @returns true if the URL is unsafe/internal, false otherwise
+*/
+function isUnsafeUrl(path) {
+	if (!path || typeof path !== "string") return true;
+	const normalizedPath = path.trim().toLowerCase();
+	if (!normalizedPath) return true;
+	if (normalizedPath.startsWith("javascript:") || normalizedPath.startsWith("vbscript:") || normalizedPath.startsWith("data:")) return true;
+	if (normalizedPath.startsWith("file:")) return true;
+	if (typeof window !== "undefined" && window.location && window.location.href) return false;
+	const localPatterns = [
+		"localhost",
+		"127.0.0.1",
+		"::1",
+		"10.",
+		"172.16.",
+		"172.17.",
+		"172.18.",
+		"172.19.",
+		"172.20.",
+		"172.21.",
+		"172.22.",
+		"172.23.",
+		"172.24.",
+		"172.25.",
+		"172.26.",
+		"172.27.",
+		"172.28.",
+		"172.29.",
+		"172.30.",
+		"172.31.",
+		"192.168.",
+		"169.254.",
+		".local",
+		".internal",
+		".intranet",
+		".corp",
+		".home",
+		".lan"
+	];
+	try {
+		const url = new URL(normalizedPath.startsWith("//") ? "http:" + normalizedPath : normalizedPath);
+		const hostname = url.hostname.toLowerCase();
+		for (const pattern of localPatterns) if (hostname === pattern || hostname.startsWith(pattern) || hostname.endsWith(pattern)) return true;
+		if (isPrivateIP(hostname)) return true;
+		const port = url.port;
+		if (port && isInternalPort(parseInt(port))) return true;
+	} catch {
+		if (normalizedPath.startsWith("/") && !normalizedPath.startsWith("//")) return false;
+		for (const pattern of localPatterns) if (normalizedPath.includes(pattern)) return true;
+	}
+	return false;
+}
+/**
+* Helper function to check if an IP address is in a private range
+*/
+function isPrivateIP(ip) {
+	const match = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+	if (!match) return false;
+	const [, a, b, c, d] = match.map(Number);
+	if (a > 255 || b > 255 || c > 255 || d > 255) return false;
+	return a === 10 || a === 127 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+}
+/**
+* Helper function to check if a port is typically used for internal services
+*/
+function isInternalPort(port) {
+	return [
+		22,
+		23,
+		25,
+		53,
+		135,
+		139,
+		445,
+		993,
+		995,
+		1433,
+		1521,
+		3306,
+		3389,
+		5432,
+		5900,
+		6379,
+		8080,
+		8443,
+		9200,
+		27017
+	].includes(port);
+}
+/**
+* Determines whether the given path is a filesystem path.
+* This includes "file://" URLs.
+*
+* @param path
+* @returns
+*/
+function isFileSystemPath(path) {
+	if (typeof window !== "undefined" || typeof process !== "undefined" && process.browser) return false;
+	const protocol = getProtocol(path);
+	return protocol === void 0 || protocol === "file";
+}
+/**
+* Converts a filesystem path to a properly-encoded URL.
+*
+* This is intended to handle situations where JSON Schema $Ref Parser is called
+* with a filesystem path that contains characters which are not allowed in URLs.
+*
+* @example
+* The following filesystem paths would be converted to the following URLs:
+*
+*    <"!@#$%^&*+=?'>.json              ==>   %3C%22!@%23$%25%5E&*+=%3F\'%3E.json
+*    C:\\My Documents\\File (1).json   ==>   C:/My%20Documents/File%20(1).json
+*    file://Project #42/file.json      ==>   file://Project%20%2342/file.json
+*
+* @param path
+* @returns
+*/
+function fromFileSystemPath(path) {
+	if (isWindows()) {
+		const projectDir = cwd();
+		const upperPath = path.toUpperCase();
+		const posixUpper = convertPathToPosix(projectDir).toUpperCase();
+		const hasProjectDir = upperPath.includes(posixUpper);
+		const hasProjectUri = upperPath.includes(posixUpper);
+		const isAbsolutePath = isAbsoluteWin32Path.test(path) || path.startsWith("http://") || path.startsWith("https://") || path.startsWith("file://");
+		if (!(hasProjectDir || hasProjectUri || isAbsolutePath) && !projectDir.startsWith("http")) {
+			const join = (a, b) => {
+				if (a.endsWith("/") || a.endsWith("\\")) return a + b;
+				else return a + "/" + b;
+			};
+			path = join(projectDir, path);
+		}
+		path = convertPathToPosix(path);
+	}
+	path = encodeURI(path);
+	for (const pattern of urlEncodePatterns) path = path.replace(pattern[0], pattern[1]);
+	return path;
+}
+/**
+* Converts a URL to a local filesystem path.
+*/
+function toFileSystemPath(path, keepFileProtocol) {
+	path = path.replace(/%(?![0-9A-Fa-f]{2})/g, "%25");
+	path = decodeURI(path);
+	for (let i = 0; i < urlDecodePatterns.length; i += 2) path = path.replace(urlDecodePatterns[i], urlDecodePatterns[i + 1]);
+	let isFileUrl = path.toLowerCase().startsWith("file://");
+	if (isFileUrl) {
+		path = path.replace(/^file:\/\//, "").replace(/^\//, "");
+		if (isWindows() && path[1] === "/") path = `${path[0]}:${path.substring(1)}`;
+		if (keepFileProtocol) path = "file:///" + path;
+		else {
+			isFileUrl = false;
+			path = isWindows() ? path : "/" + path;
+		}
+	}
+	if (isWindows() && !isFileUrl) {
+		path = path.replace(forwardSlashPattern, "\\");
+		if (path.match(/^[a-z]:\\/i)) path = path[0].toUpperCase() + path.substring(1);
+	}
+	return path;
+}
+/**
+* Converts a $ref pointer to a valid JSON Path.
+*
+* @param pointer
+* @returns
+*/
+function safePointerToPath(pointer) {
+	if (pointer.length <= 1 || pointer[0] !== "#" || pointer[1] !== "/") return [];
+	return pointer.slice(2).split("/").map((value) => {
+		return value.replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
+	});
+}
+//#endregion
+export { cwd, fromFileSystemPath, getExtension, getHash, isFileSystemPath, isHttp, isUnsafeUrl, parse, resolve, safePointerToPath, stripHash, toFileSystemPath };

package/dist/playground/client.d.ts

@@ -50,7 +50,7 @@ interface PlaygroundClientOptions {
    * for updating values, use:
    * - the `Custom.useController()` from `fumadocs-openapi/playground/client`.
    *
-   * Recommended types packages: `json-schema-typed`, `openapi-types`.
+   * Recommended types packages: `json-schema-typed`.
    */
   renderParameterField?: (fieldName: FieldKey, param: ParameterObject) => ReactNode;
   /**

package/dist/requests/generators/all.d.ts

@@ -1,6 +1,6 @@
 import { CodeUsageGeneratorRegistry } from "./index.js";
 
 //#region src/requests/generators/all.d.ts
-declare function registerDefault(registry: CodeUsageGeneratorRegistry): void;
+declare function registerDefault(registry: CodeUsageGeneratorRegistry): CodeUsageGeneratorRegistry;
 //#endregion
 export { registerDefault };

package/dist/requests/generators/all.js

@@ -12,6 +12,7 @@ function registerDefault(registry) {
 	registry.add("python", python);
 	registry.add("java", java);
 	registry.add("csharp", csharp);
+	return registry;
 }
 //#endregion
 export { registerDefault };

package/dist/types.d.ts

@@ -1,12 +1,10 @@
-import { MediaAdapter } from "./requests/media/adapter.js";
 import { InlineCodeUsageGenerator } from "./requests/generators/index.js";
 import { boundary_d_exports } from "./ui/client/boundary.js";
-import { OpenAPIV3, OpenAPIV3_2 } from "./_openapi/types.js";
+import { OpenAPIV3_2 } from "./_openapi/types.js";
 import { CreateAPIPageOptions } from "./ui/base.js";
 import { OpenAPIOptions } from "./server/index.js";
 import { NoReference } from "./utils/schema/index.js";
 import { DereferencedDocument } from "./utils/document/dereference.js";
-import { ReactNode } from "react";
 
 //#region src/types.d.ts
 type Document = OpenAPIV3_2.Document;
@@ -17,14 +15,8 @@ type ReferenceObject = OpenAPIV3_2.ReferenceObject;
 type PathItemObject = OpenAPIV3_2.PathItemObject;
 type TagObject = OpenAPIV3_2.TagObject;
 type ServerObject = OpenAPIV3_2.ServerObject;
-type CallbackObject = OpenAPIV3_2.CallbackObject;
-type ServerVariableObject = OpenAPIV3.ServerVariableObject;
 type ResponseObject = OpenAPIV3_2.ResponseObject;
-type OAuth2SecurityScheme = OpenAPIV3_2.OAuth2SecurityScheme;
 type HttpMethods = OpenAPIV3_2.HttpMethods;
-type ExampleObject = OpenAPIV3_2.ExampleObject;
-type MediaTypeObject = OpenAPIV3_2.MediaTypeObject;
-type RequestBodyObject = OpenAPIV3_2.RequestBodyObject;
 type MethodInformation = NoReference<OperationObject> & {
   method: HttpMethods;
   'x-codeSamples'?: InlineCodeUsageGenerator[];
@@ -32,16 +24,14 @@ type MethodInformation = NoReference<OperationObject> & {
   'x-exclusiveCodeSample'?: string;
 };
 type RequireKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
-interface RenderContext extends Pick<OpenAPIOptions, 'proxyUrl'>, Omit<RequireKeys<CreateAPIPageOptions, 'renderMarkdown' | 'generateTypeScriptDefinitions'>, 'renderCodeBlock' | 'renderHeading' | 'generateTypeScriptSchema'> {
+interface RenderContext extends Pick<OpenAPIOptions, 'proxyUrl'>, Omit<RequireKeys<CreateAPIPageOptions, 'renderMarkdown' | 'generateTypeScriptDefinitions' | 'renderCodeBlock' | 'mediaAdapters' | 'codeUsages'>, 'renderHeading' | 'generateTypeScriptSchema'> {
   /**
    * dereferenced schema
    */
   schema: DereferencedDocument;
   clientBoundary: typeof boundary_d_exports;
-  mediaAdapters: Record<string, MediaAdapter>;
-  renderCodeBlock: (lang: string, code: string) => ReactNode;
 }
 type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
 type Awaitable<T> = T | Promise<T>;
 //#endregion
-export { Awaitable, CallbackObject, DistributiveOmit, Document, ExampleObject, HttpMethods, MediaTypeObject, MethodInformation, OAuth2SecurityScheme, OperationObject, ParameterObject, PathItemObject, ReferenceObject, RenderContext, RequestBodyObject, ResponseObject, SecuritySchemeObject, ServerObject, ServerVariableObject, TagObject };
+export { Awaitable, DistributiveOmit, Document, HttpMethods, MethodInformation, OperationObject, ParameterObject, PathItemObject, ReferenceObject, RenderContext, ResponseObject, SecuritySchemeObject, ServerObject, TagObject };

package/dist/ui/base.d.ts

@@ -147,7 +147,7 @@ interface CreateAPIPageOptions {
       children: ReactNode;
     }) => ReactNode;
     /**
-     * replace the server-side renderer
+     * replace the renderer
      */
     render?: (props: APIPlaygroundProps) => ReactNode;
   };

package/dist/ui/base.js

@@ -1,11 +1,12 @@
 import { parseSecurities } from "../utils/schema/index.js";
 import { defaultAdapters } from "../requests/media/adapter.js";
+import { createCodeUsageGeneratorRegistry } from "../requests/generators/index.js";
+import { registerDefault } from "../requests/generators/all.js";
 import { ClientCodeBlockProvider } from "./components/codeblock.js";
 import { encodeInternalRef } from "../utils/schema/ref.js";
 import { APIPage } from "./api-page.js";
 import { pickSchema } from "../utils/schema/pick.js";
 import { PlaygroundAuthProvider } from "./client/boundary.lazy.js";
-import Slugger from "github-slugger";
 import * as JsxRuntime from "react/jsx-runtime";
 import { jsx } from "react/jsx-runtime";
 import { createRehypeCode } from "fumadocs-core/mdx-plugins/rehype-code.core";
@@ -61,7 +62,6 @@ function createAPIPage(server, options) {
 		let processed;
 		if (typeof document === "string") processed = await server.getSchema(document);
 		else processed = document;
-		new Slugger();
 		const { ApiProvider, PlaygroundClient, SchemaUI, ServerProvider, UsageTab, UsageTabsSelector } = await import("./client/boundary.lazy.js");
 		const ctx = {
 			schema: processed,
@@ -75,6 +75,7 @@ function createAPIPage(server, options) {
 				UsageTabsSelector
 			},
 			...options,
+			codeUsages: options.codeUsages ?? registerDefault(createCodeUsageGeneratorRegistry()),
 			mediaAdapters: {
 				...defaultAdapters,
 				...options.mediaAdapters
@@ -106,7 +107,7 @@ function createAPIPage(server, options) {
 				processor ??= createMarkdownProcessor();
 				return (await processor.process({ value: text })).result;
 			},
-			async renderCodeBlock(lang, code) {
+			async renderCodeBlock({ lang, code }) {
 				if (options.renderCodeBlock) return options.renderCodeBlock({
 					lang,
 					code

package/dist/ui/client/index.d.ts

@@ -2,12 +2,24 @@ import { MediaAdapter } from "../../requests/media/adapter.js";
 import { PlaygroundClientOptions } from "../../playground/client.js";
 import { CodeUsageGeneratorRegistry } from "../../requests/generators/index.js";
 import { ExampleRequestItem } from "../operation/get-example-requests.js";
-import { FC } from "react";
+import { ComponentProps, FC } from "react";
 
 //#region src/ui/client/index.d.ts
 interface APIPageClientOptions {
   playground?: PlaygroundClientOptions;
-  operation?: OperationClientOptions;
+  operation?: {
+    APIExampleSelector?: FC<{
+      items: ExampleRequestItem[];
+      value: string | undefined;
+      onValueChange: (id: string) => void;
+    }>;
+  };
+  components?: {
+    Heading?: FC<ComponentProps<'h1'> & {
+      id: string;
+      depth: number;
+    }>;
+  };
   /**
    * Set a prefix for `localStorage` keys.
    *
@@ -25,13 +37,6 @@ interface APIPageClientOptions {
    */
   codeUsages?: CodeUsageGeneratorRegistry;
 }
-interface OperationClientOptions {
-  APIExampleSelector?: FC<{
-    items: ExampleRequestItem[];
-    value: string | undefined;
-    onValueChange: (id: string) => void;
-  }>;
-}
 declare function defineClientConfig(options?: APIPageClientOptions): APIPageClientOptions;
 //#endregion
-export { APIPageClientOptions, OperationClientOptions, defineClientConfig };
+export { APIPageClientOptions, defineClientConfig };

package/dist/ui/components/heading.js

@@ -1,11 +1,19 @@
 "use client";
+import { useApiContext } from "../contexts/api.js";
 import { useAnchorId } from "../../utils/auto-anchor.client.js";
 import { jsx } from "react/jsx-runtime";
 import { Heading } from "fumadocs-ui/components/heading";
 //#region src/ui/components/heading.tsx
 function Heading$1({ id: _id, depth, ...props }) {
+	const id = useAnchorId([_id]);
+	const Component = useApiContext().client.components?.Heading;
+	if (Component) return /* @__PURE__ */ jsx(Component, {
+		id,
+		depth,
+		...props
+	});
 	return /* @__PURE__ */ jsx(Heading, {
-		id: useAnchorId([_id]),
+		id,
 		as: `h${depth}`,
 		...props
 	});

package/dist/ui/contexts/api.js

@@ -21,16 +21,10 @@ function useServerContext() {
 function ApiProvider({ children, shikiOptions, client, schemes }) {
 	return /* @__PURE__ */ jsx(ApiContext, {
 		value: useMemo(() => {
-			let codeUsages;
-			if (client.codeUsages) codeUsages = createCodeUsageGeneratorRegistry(client.codeUsages);
-			else {
-				codeUsages = createCodeUsageGeneratorRegistry();
-				registerDefault(codeUsages);
-			}
 			return {
 				shikiOptions,
 				client,
-				codeUsages,
+				codeUsages: client.codeUsages ?? registerDefault(createCodeUsageGeneratorRegistry()),
 				schemes,
 				mediaAdapters: {
 					...defaultAdapters,

package/dist/ui/create-client.d.ts

@@ -1,3 +1,4 @@
+import { APIPageClientOptions } from "./client/index.js";
 import { ApiPageProps } from "./api-page.js";
 import { CreateAPIPageOptions } from "./base.js";
 import { Document } from "../types.js";
@@ -11,7 +12,7 @@ interface ClientApiPagePayload {
   bundled: Document;
   proxyUrl?: string;
 }
-type CreateClientAPIPageOptions = Omit<Partial<CreateAPIPageOptions>, 'generateTypeScriptSchema'>;
+type CreateClientAPIPageOptions = Partial<Omit<CreateAPIPageOptions, 'generateTypeScriptSchema' | 'client'> & Omit<APIPageClientOptions, 'mediaAdapters' | 'codeUsages'>>;
 /**
  * Create `<APIPage />` for non-RSC environment, note that this may be unstable, and doesn't support the full set of features.
  */

package/dist/ui/create-client.js

@@ -1,5 +1,8 @@
+"use client";
 import { parseSecurities } from "../utils/schema/index.js";
 import { defaultAdapters } from "../requests/media/adapter.js";
+import { createCodeUsageGeneratorRegistry } from "../requests/generators/index.js";
+import { registerDefault } from "../requests/generators/all.js";
 import { ClientCodeBlock, ClientCodeBlockProvider } from "./components/codeblock.js";
 import { AuthProvider } from "../playground/auth.js";
 import { dereferenceDocument } from "../utils/document/dereference.js";
@@ -78,7 +81,9 @@ function createClientAPIPage({ shiki = defaultShikiFactory, shikiOptions = { the
 			shikiOptions,
 			generateTypeScriptDefinitions,
 			clientBoundary: boundary_exports,
+			client: options,
 			...options,
+			codeUsages: options.codeUsages ?? registerDefault(createCodeUsageGeneratorRegistry()),
 			mediaAdapters: {
 				...defaultAdapters,
 				...options.mediaAdapters
@@ -93,15 +98,9 @@ function createClientAPIPage({ shiki = defaultShikiFactory, shikiOptions = { the
 				processor ??= createMarkdownProcessor();
 				return processor.processSync({ value: text }).result;
 			},
-			renderCodeBlock(lang, code) {
-				if (options.renderCodeBlock) return options.renderCodeBlock({
-					lang,
-					code
-				});
-				return /* @__PURE__ */ jsx(ClientCodeBlock, {
-					lang,
-					code
-				});
+			renderCodeBlock(props) {
+				if (options.renderCodeBlock) return options.renderCodeBlock(props);
+				return /* @__PURE__ */ jsx(ClientCodeBlock, { ...props });
 			}
 		}), [payload.proxyUrl, processed]);
 		return /* @__PURE__ */ jsx(ClientCodeBlockProvider, {

package/dist/ui/operation/request-tabs.js

@@ -73,7 +73,10 @@ function RequestTabsItem({ item, ctx }) {
 					value: k,
 					children: [/* @__PURE__ */ jsx(AccordionHeader, { children: /* @__PURE__ */ jsx(AccordionTrigger, { children: v }) }), /* @__PURE__ */ jsx(AccordionContent, {
 						className: "prose-no-margin",
-						children: ctx.renderCodeBlock("json", JSON.stringify(data, null, 2))
+						children: ctx.renderCodeBlock({
+							lang: "json",
+							code: JSON.stringify(data, null, 2)
+						})
 					})]
 				}, k);
 			})

package/dist/ui/operation/response-tabs.js

@@ -45,7 +45,10 @@ function ResponseTabs({ operation, ctx }) {
 }
 function renderResponseTabsDefault(tabs, ctx) {
 	function renderExampleContent(example) {
-		return /* @__PURE__ */ jsxs(Fragment$1, { children: [example.description && ctx.renderMarkdown(example.description), ctx.renderCodeBlock("json", JSON.stringify(example.sample, null, 2))] });
+		return /* @__PURE__ */ jsxs(Fragment$1, { children: [example.description && ctx.renderMarkdown(example.description), ctx.renderCodeBlock({
+			lang: "json",
+			code: JSON.stringify(example.sample, null, 2)
+		})] });
 	}
 	return /* @__PURE__ */ jsx(Tabs, {
 		groupId: "fumadocs_openapi_responses",

package/dist/ui/operation/usage-tabs/index.js

@@ -1,5 +1,4 @@
 import { createCodeUsageGeneratorRegistry } from "../../../requests/generators/index.js";
-import { registerDefault } from "../../../requests/generators/all.js";
 import { ResponseTabs } from "../response-tabs.js";
 import { useMemo } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -37,13 +36,8 @@ function UsageTabs({ method, ctx }) {
 		});
 	};
 	const registry = useMemo(() => {
-		let registry;
-		if (ctx.codeUsages) registry = createCodeUsageGeneratorRegistry(ctx.codeUsages);
-		else {
-			registry = createCodeUsageGeneratorRegistry();
-			registerDefault(registry);
-		}
-		for (const gen of ctx.generateCodeSamples?.(method) ?? []) registry.addInline(gen);
+		const registry = createCodeUsageGeneratorRegistry(ctx.codeUsages);
+		if (ctx.generateCodeSamples) for (const gen of ctx.generateCodeSamples(method)) registry.addInline(gen);
 		if (method["x-codeSamples"]) for (const sample of method["x-codeSamples"]) registry.addInline(sample);
 		return registry;
 	}, [ctx, method]);

package/dist/utils/document/process.js

@@ -1,23 +1,18 @@
-import { bundle } from "../../node_modules/.pnpm/@scalar_json-magic@0.12.14/node_modules/@scalar/json-magic/dist/bundle/bundle.js";
 import { upgrade } from "../../node_modules/.pnpm/@scalar_openapi-upgrader@0.2.8/node_modules/@scalar/openapi-upgrader/dist/upgrade.js";
-import { fetchUrls } from "../../node_modules/.pnpm/@scalar_json-magic@0.12.14/node_modules/@scalar/json-magic/dist/bundle/plugins/fetch-urls/index.js";
-import { readFiles } from "../../node_modules/.pnpm/@scalar_json-magic@0.12.14/node_modules/@scalar/json-magic/dist/bundle/plugins/read-files/index.js";
-import "../../node_modules/.pnpm/@scalar_json-magic@0.12.14/node_modules/@scalar/json-magic/dist/bundle/plugins/node.js";
 import { dereferenceDocument } from "./dereference.js";
+import { bundle } from "../../node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.js";
 //#region src/utils/document/process.ts
 /**
 * process & reference input document to a Fumadocs OpenAPI compatible format
 */
 async function processDocument(input) {
-	return dereferenceDocument(await bundle(input, {
-		plugins: [fetchUrls(), readFiles()],
-		treeShake: true,
-		hooks: { onResolveError(node) {
-			throw new Error(`Failed to resolve ${node.$ref}`);
-		} }
-	}).then((v) => upgrade(v, "3.2")).catch((e) => {
+	try {
+		let bundled = await bundle(input);
+		bundled = upgrade(bundled, "3.2");
+		return dereferenceDocument(bundled);
+	} catch (e) {
 		throw new Error(`[OpenAPI] Failed to resolve input: ${input}`, { cause: e });
-	}));
+	}
 }
 //#endregion
 export { processDocument };

package/dist/utils/pages/builder.d.ts

@@ -1,4 +1,4 @@
-import { ApiPageProps, OperationItem, WebhookItem } from "../../ui/api-page.js";
+import { OperationItem, WebhookItem } from "../../ui/api-page.js";
 import { OperationObject, PathItemObject, TagObject } from "../../types.js";
 import { NoReference } from "../schema/index.js";
 import { DereferencedDocument } from "../document/dereference.js";
@@ -82,7 +82,5 @@ interface ExtractedInfo {
     tags?: string[];
   })[];
 }
-declare function fromSchema(schemaId: string, processed: DereferencedDocument, config: PagesBuilderConfig): OutputEntry[];
-declare function getPageProps(entry: PageOutput | OperationOutput | WebhookOutput): ApiPageProps;
 //#endregion
-export { OperationOutput, OutputEntry, OutputGroup, PageOutput, PagesBuilder, PagesBuilderConfig, WebhookOutput, fromSchema, getPageProps };
+export { OperationOutput, OutputEntry, OutputGroup, PageOutput, PagesBuilder, PagesBuilderConfig, WebhookOutput };