fumadocs-openapi 11.4.3 → 12.0.0

package/dist/{playground → ui/playground}/components/server-select.js

@@ -1,18 +1,18 @@
 "use client";
-import { useServerContext } from "../../ui/contexts/api.js";
-import { cn } from "../../utils/cn.js";
+import { useServer } from "../../../utils/use-server.js";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../../../packages/shared-api/dist/components/select.js";
+import { cn } from "../../../utils/cn.js";
+import { Label } from "../../../packages/shared-api/dist/components/label.js";
+import { Input } from "../../../packages/shared-api/dist/components/input.js";
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogTrigger } from "../../../packages/shared-api/dist/components/dialog.js";
 import { useEffect, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { EditIcon } from "lucide-react";
-import { useTranslations } from "@fuma-translate/react";
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@fumadocs/api-docs/components/select";
-import { Input, labelVariants } from "@fumadocs/api-docs/components/input";
-import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogTrigger } from "@fumadocs/api-docs/components/dialog";
 import { StfProvider, useFieldValue, useListener, useStf } from "@fumari/stf";
-import { resolveServerUrl } from "@fumadocs/api-docs/utils/url";
-//#region src/playground/components/server-select.tsx
+import { useTranslations } from "@fuma-translate/react";
+import { EditIcon } from "lucide-react";
+//#region src/ui/playground/components/server-select.tsx
 function ServerSelect(props) {
-	const { servers, server, setServer, setServerVariables } = useServerContext();
+	const { servers, server, resolveUrl, setServer, setServerVariables } = useServer();
 	const [open, setOpen] = useState(false);
 	const [isMounted, setIsMounted] = useState(false);
 	const t = useTranslations({ note: "playground server select" });
@@ -34,7 +34,7 @@ function ServerSelect(props) {
 				}),
 				/* @__PURE__ */ jsx("code", {
 					className: "truncate min-w-0 flex-1",
-					children: isMounted ? new URL(server ? resolveServerUrl(server.url, server.variables) : "/", window.location.origin).href : t("loading...")
+					children: isMounted ? resolveUrl() : t("loading...")
 				}),
 				/* @__PURE__ */ jsx(EditIcon, { className: "size-4" })
 			]
@@ -87,8 +87,7 @@ function ServerSelectContent({ defaultValues, onChange, schema }) {
 				return /* @__PURE__ */ jsxs("fieldset", {
 					className: "flex flex-col gap-1",
 					children: [
-						/* @__PURE__ */ jsx("label", {
-							className: cn(labelVariants()),
+						/* @__PURE__ */ jsx(Label, {
 							htmlFor: key,
 							children: key
 						}),

package/dist/{playground → ui/playground}/status-info.js

@@ -1,7 +1,7 @@
 import { useMemo } from "react";
-import { CircleCheck, CircleX } from "lucide-react";
 import { useTranslations } from "@fuma-translate/react";
-//#region src/playground/status-info.tsx
+import { CircleCheck, CircleX } from "lucide-react";
+//#region src/ui/playground/status-info.tsx
 function useStatusInfo(status) {
 	const t = useTranslations({ note: "playground status info" });
 	return useMemo(() => {

package/dist/{scalar → ui/scalar}/client.js

@@ -1,6 +1,7 @@
 "use client";
-import { cn } from "../utils/cn.js";
-import { MethodLabel } from "../ui/components/method-label.js";
+import { useOpenAPI } from "../../utils/create-page.js";
+import { MethodLabel } from "../components/method-label.js";
+import { cn } from "../../utils/cn.js";
 import { useEffect, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useTranslations } from "@fuma-translate/react";
@@ -8,12 +9,13 @@ import { buttonVariants } from "fumadocs-ui/components/ui/button";
 import { useApiClient } from "@scalar/api-client-react";
 import { useTheme } from "fumadocs-ui/provider/base";
 import "@scalar/api-client-react/style.css";
-//#region src/scalar/client.tsx
-function ScalarPlayground({ path, method, spec }) {
+//#region src/ui/scalar/client.tsx
+function ScalarPlayground({ path, method }) {
 	const { resolvedTheme } = useTheme();
+	const { bundled } = useOpenAPI().doc;
 	const t = useTranslations({ note: "scalar API client" });
 	const [mounted, setMounted] = useState(false);
-	const client = useApiClient({ configuration: { content: spec } });
+	const client = useApiClient({ configuration: { content: bundled } });
 	useEffect(() => {
 		setMounted(true);
 	}, []);

package/dist/{scalar → ui/scalar}/index.d.ts

@@ -1,5 +1,5 @@
-import { CreateOpenAPIPageOptions } from "../ui/index.js";
-//#region src/scalar/index.d.ts
+import { CreateOpenAPIPageOptions } from "../index.js";
+//#region src/ui/scalar/index.d.ts
 /**
  * Enable Scalar for API playgrounds by wrapping your options inside.
  *

package/dist/{scalar → ui/scalar}/index.js

@@ -1,7 +1,7 @@
 "use client";
 import { lazy } from "react";
 import { jsx } from "react/jsx-runtime";
-//#region src/scalar/index.tsx
+//#region src/ui/scalar/index.tsx
 const Client = lazy(() => import("./client.js"));
 /**
 * Enable Scalar for API playgrounds by wrapping your options inside.
@@ -13,14 +13,10 @@ function withScalar(options = {}) {
 		...options,
 		playground: {
 			...options.playground,
-			provider(props) {
-				return props.children;
-			},
-			render({ method, path, ctx }) {
+			render({ method, path }) {
 				return /* @__PURE__ */ jsx(Client, {
 					method,
-					path,
-					spec: ctx.schema.bundled
+					path
 				});
 			}
 		}

package/dist/utils/create-page.d.ts

@@ -0,0 +1,216 @@
+import { MediaAdapter } from "../requests/media/adapter.js";
+import { CodeUsageGeneratorRegistry, InlineCodeUsageGenerator } from "../requests/generators/index.js";
+import { Awaitable, HttpMethods, OperationObject, PathItemObject } from "../types.js";
+import { ExampleRequest, PageOperationProps, ResponseTab } from "../operation.js";
+import { OpenAPIPageProps, OperationItem, WebhookItem } from "./pages/builder.js";
+import { DereferencedDocument } from "./document/dereference.js";
+import { SchemaUIOptions } from "../packages/shared-api/dist/components/schema/index.js";
+import { PlaygroundClientOptions } from "../ui/playground/client.js";
+import { PageComponents, ShikiOptions } from "../packages/shared-api/dist/components/defaults.js";
+import { FC, ReactNode } from "react";
+import { JsonSchema } from "@fumadocs/json-schema";
+import { ShikiFactory } from "fumadocs-core/highlight/shiki";
+//#region src/utils/create-page.d.ts
+/** components the UI renders through, so a page can replace them */
+export interface OpenAPIComponents extends PageComponents {
+  SchemaUI: FC<SchemaUIOptions>;
+}
+export interface GenerateTypeScriptDefinitionsContext {
+  name: string;
+  readOnly: boolean;
+  writeOnly: boolean;
+  doc: DereferencedDocument;
+}
+export interface OpenAPIRuntimeOptions {
+  /**
+   * Support other media types.
+   */
+  mediaAdapters?: Record<string, MediaAdapter>;
+  /**
+   * Set a prefix for `localStorage` keys.
+   *
+   * Useful when using multiple OpenAPI instances to prevent state conflicts.
+   *
+   * @defaultValue `fumadocs-openapi-`
+   */
+  storageKeyPrefix?: string;
+  /**
+   * Generate example code usage for all endpoints.
+   */
+  codeUsages?: CodeUsageGeneratorRegistry;
+  /**
+   * Generate example code usage for each endpoint.
+   */
+  generateCodeSamples?: (options: {
+    path: string;
+    operation: OperationObject;
+    method: HttpMethods;
+    pathItem: PathItemObject;
+  }) => InlineCodeUsageGenerator[];
+  /**
+   * Generate TypeScript definitions from JSON schema.
+   *
+   * Pass `false` to disable it.
+   */
+  generateTypeScriptDefinitions?: ((schema: JsonSchema, ctx: GenerateTypeScriptDefinitionsContext) => Awaitable<string | undefined>) | false;
+}
+/**
+ * The document and request options of the page, read from `useOpenAPI()`.
+ */
+export interface OpenAPIRuntime extends OpenAPIRuntimeOptions {
+  doc: DereferencedDocument;
+  proxyUrl?: string;
+  mediaAdapters: Record<string, MediaAdapter>;
+  storageKeyPrefix: string;
+}
+export interface APIPlaygroundProps {
+  path: string;
+  method: HttpMethods;
+  operation: OperationObject;
+  pathItem: PathItemObject;
+}
+export interface OperationPlaygroundOptions extends PlaygroundClientOptions {
+  /**
+   * @defaultValue true
+   */
+  enabled?: boolean;
+  /**
+   * Replace the renderer, e.g. the playground installed with Fumadocs CLI.
+   */
+  render?: (props: APIPlaygroundProps) => ReactNode;
+}
+export interface PageLayoutProps {
+  operations?: {
+    item: OperationItem;
+    children: ReactNode;
+  }[];
+  webhooks?: {
+    item: WebhookItem;
+    children: ReactNode;
+  }[];
+}
+/**
+ * The options the UI renders with, read from `useRenderContext()`.
+ */
+export interface OpenAPIRenderOptions {
+  /** the Shiki highlighter of code blocks */
+  shiki?: ShikiFactory;
+  shikiOptions?: ShikiOptions;
+  /**
+   * Show full response schema instead of only example response & Typescript definitions.
+   *
+   * @default true
+   */
+  showResponseSchema?: boolean;
+  /**
+   * Customize page content.
+   */
+  content?: {
+    renderResponseTabs?: (options: {
+      tabs: ResponseTab[];
+    }, ctx: RenderContext) => ReactNode;
+    renderRequestTabs?: (options: {
+      route: string;
+      items: ExampleRequest[];
+      method: HttpMethods;
+      pathItem: PathItemObject;
+      operation: OperationObject;
+    }, ctx: RenderContext) => ReactNode;
+    renderAPIExampleLayout?: (slots: {
+      selector: ReactNode;
+      usageTabs: ReactNode;
+      responseTabs: ReactNode;
+    }, ctx: RenderContext) => ReactNode;
+    /**
+     * @param generators - codegens for API example usages
+     */
+    renderAPIExampleUsageTabs?: (generators: CodeUsageGeneratorRegistry, ctx: RenderContext) => ReactNode;
+    /**
+     * renderer of the entire page's layout (containing all operations & webhooks UI)
+     */
+    renderPageLayout?: (slots: PageLayoutProps, ctx: RenderContext) => ReactNode;
+    renderOperationLayout?: (slots: {
+      header: ReactNode;
+      description: ReactNode;
+      apiExample: ReactNode;
+      apiPlayground: ReactNode;
+      authSchemes: ReactNode;
+      parameters: ReactNode;
+      body: ReactNode;
+      responses: ReactNode;
+      callbacks: ReactNode;
+    }, context: {
+      path: string;
+      operation: OperationObject;
+      method: HttpMethods;
+      pathItem: PathItemObject;
+      ctx: RenderContext;
+    }) => ReactNode;
+    renderWebhookLayout?: (slots: {
+      header: ReactNode;
+      description: ReactNode;
+      authSchemes: ReactNode;
+      parameters: ReactNode;
+      body: ReactNode;
+      requests: ReactNode;
+      responses: ReactNode;
+      callbacks: ReactNode;
+    }) => ReactNode;
+  };
+  /**
+   * Info UI for JSON schemas.
+   */
+  schemaUI?: {
+    /**
+     * Show examples under the generated content of JSON schemas.
+     *
+     * @defaultValue false
+     */
+    showExample?: boolean;
+  };
+  /**
+   * Customize API playground.
+   */
+  playground?: OperationPlaygroundOptions;
+}
+/**
+ * The render options of the page with their defaults applied, read from `useRenderContext()`.
+ */
+export interface RenderContext extends OpenAPIRenderOptions {
+  shiki: ShikiFactory;
+  shikiOptions: ShikiOptions;
+}
+export interface CreateOpenAPIRendererOptions extends OpenAPIRuntimeOptions, OpenAPIRenderOptions {
+  components: Partial<PageComponents> & {
+    SchemaUI: FC<SchemaUIOptions>;
+    /** renders an operation or webhook of the page */
+    Operation: FC<PageOperationProps>;
+    /** wraps the rendered operations and webhooks */
+    Layout?: FC<PageLayoutProps>;
+  };
+}
+/**
+ * The runtime of the API page: the document and request options.
+ */
+export declare function useOpenAPI(): OpenAPIRuntime;
+export declare function useComponents(): OpenAPIComponents;
+/**
+ * The render options of the page, available under a page created with `createOpenAPIRenderer()`.
+ */
+export declare function useRenderContext(): RenderContext;
+/**
+ * Generate TypeScript definitions of a JSON schema, `undefined` when disabled.
+ */
+export declare function useTypeScriptDefinitions(schema: JsonSchema | undefined, options: Pick<GenerateTypeScriptDefinitionsContext, 'name' | 'readOnly' | 'writeOnly'>): string | undefined;
+/**
+ * Create `<OpenAPIPage />` from your own UI, it takes the props of generated pages.
+ */
+export declare function createOpenAPIRenderer(options: CreateOpenAPIRendererOptions): FC<OpenAPIPageProps>;
+/**
+ * `createOpenAPIRenderer()` with nothing built in: it highlights through the `shiki` you pass, and
+ * generates code usages and TypeScript definitions only when you pass them.
+ */
+export declare function createOpenAPIBaseRenderer({ components, ...options }: CreateOpenAPIRendererOptions & {
+  shiki: ShikiFactory;
+}): FC<OpenAPIPageProps>;
+//#endregion

package/dist/utils/create-page.js

@@ -0,0 +1,221 @@
+"use client";
+import { dereferenceBundledDocument } from "./document/dereference.js";
+import { defaultAdapters } from "../requests/media/adapter.js";
+import { createCodeUsageGeneratorRegistry } from "../requests/generators/index.js";
+import { registerDefault } from "../requests/generators/all.js";
+import { createPageComponents, defaultShikiOptions } from "../packages/shared-api/dist/components/defaults.js";
+import { AuthProvider } from "../playground/auth.js";
+import { ServerProvider } from "./use-server.js";
+import { createContext, use, useMemo } from "react";
+import { getRaw } from "@scalar/json-magic/magic-proxy";
+import { generate } from "@fumari/json-schema-ts";
+import { defaultShikiFactory } from "fumadocs-core/highlight/shiki/full";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region src/utils/create-page.tsx
+const OpenAPIContext = createContext(null);
+const ComponentsContext = createContext(null);
+const OptionsContext = createContext(null);
+/**
+* The runtime of the API page: the document and request options.
+*/
+function useOpenAPI() {
+	const ctx = use(OpenAPIContext);
+	if (!ctx) throw new Error("Component must be used under <OpenAPIProvider />");
+	return ctx;
+}
+function useComponents() {
+	const components = use(ComponentsContext);
+	if (!components) throw new Error("Component must be used under <OpenAPIProvider />");
+	return components;
+}
+/**
+* The render options of the page, available under a page created with `createOpenAPIRenderer()`.
+*/
+function useRenderContext() {
+	const ctx = use(OptionsContext);
+	if (!ctx) throw new Error("Component must be used under <OpenAPIProvider />");
+	return ctx;
+}
+/**
+* Generate TypeScript definitions of a JSON schema, `undefined` when disabled.
+*/
+function useTypeScriptDefinitions(schema, options) {
+	const runtime = useOpenAPI();
+	const { name, readOnly, writeOnly } = options;
+	const result = useMemo(() => {
+		if (!schema || !runtime.generateTypeScriptDefinitions) return;
+		return runtime.generateTypeScriptDefinitions(schema, {
+			name,
+			readOnly,
+			writeOnly,
+			doc: runtime.doc
+		});
+	}, [
+		runtime,
+		schema,
+		name,
+		readOnly,
+		writeOnly
+	]);
+	return result instanceof Promise ? use(result) : result;
+}
+function OpenAPIProvider({ document, mediaAdapters, codeUsages, generateCodeSamples, generateTypeScriptDefinitions, proxyUrl, storageKeyPrefix = "fumadocs-openapi-", shiki, shikiOptions = defaultShikiOptions, showResponseSchema, content, schemaUI, playground, components, children }) {
+	const runtime = useMemo(() => ({
+		doc: dereferenceBundledDocument(document),
+		mediaAdapters: {
+			...defaultAdapters,
+			...mediaAdapters
+		},
+		codeUsages,
+		generateCodeSamples,
+		generateTypeScriptDefinitions,
+		proxyUrl,
+		storageKeyPrefix
+	}), [
+		document,
+		mediaAdapters,
+		codeUsages,
+		generateCodeSamples,
+		generateTypeScriptDefinitions,
+		proxyUrl,
+		storageKeyPrefix
+	]);
+	const render = useMemo(() => ({
+		shiki,
+		shikiOptions,
+		showResponseSchema,
+		content,
+		schemaUI,
+		playground
+	}), [
+		shiki,
+		shikiOptions,
+		showResponseSchema,
+		content,
+		schemaUI,
+		playground
+	]);
+	return /* @__PURE__ */ jsx(OpenAPIContext, {
+		value: runtime,
+		children: /* @__PURE__ */ jsx(ComponentsContext, {
+			value: components,
+			children: /* @__PURE__ */ jsx(OptionsContext, {
+				value: render,
+				children: /* @__PURE__ */ jsx(ServerProvider, {
+					servers: runtime.doc.dereferenced.servers,
+					storageKeyPrefix: runtime.storageKeyPrefix,
+					children: /* @__PURE__ */ jsx(AuthProvider, { children })
+				})
+			})
+		})
+	});
+}
+let defaultCodeUsages;
+const defaultTypeScriptDefinitions = (schema, ctx) => {
+	if (typeof schema !== "object") return;
+	try {
+		return generate({
+			...ctx.doc.bundled,
+			...getRaw(schema)
+		}, {
+			name: ctx.name,
+			readOnly: ctx.readOnly,
+			writeOnly: ctx.writeOnly
+		});
+	} catch (e) {
+		console.warn("Failed to generate typescript schema:", e);
+	}
+};
+/**
+* Create `<OpenAPIPage />` from your own UI, it takes the props of generated pages.
+*/
+function createOpenAPIRenderer(options) {
+	return createOpenAPIBaseRenderer({
+		...options,
+		shiki: options.shiki ?? defaultShikiFactory,
+		codeUsages: options.codeUsages ?? (defaultCodeUsages ??= registerDefault(createCodeUsageGeneratorRegistry())),
+		generateTypeScriptDefinitions: options.generateTypeScriptDefinitions ?? defaultTypeScriptDefinitions
+	});
+}
+/**
+* `createOpenAPIRenderer()` with nothing built in: it highlights through the `shiki` you pass, and
+* generates code usages and TypeScript definitions only when you pass them.
+*/
+function createOpenAPIBaseRenderer({ components, ...options }) {
+	const { Operation, Layout = DefaultLayout } = components;
+	const slots = {
+		SchemaUI: components.SchemaUI,
+		...createPageComponents({
+			...options,
+			components
+		})
+	};
+	function Content({ showTitle, showDescription, operations, webhooks }) {
+		const { dereferenced, resolve } = useOpenAPI().doc;
+		const ctx = useRenderContext();
+		const layout = {
+			operations: operations?.map((item) => {
+				const pathItem = resolve(dereferenced.paths?.[item.path]);
+				if (!pathItem) throw new Error(`[Fumadocs OpenAPI] Path not found in OpenAPI schema: ${item.path}`);
+				const operation = pathItem[item.method];
+				if (!operation) throw new Error(`[Fumadocs OpenAPI] Method ${item.method} not found in operation: ${item.path}`);
+				return {
+					item,
+					children: /* @__PURE__ */ jsx(Operation, {
+						type: "operation",
+						path: item.path,
+						method: item.method,
+						operation,
+						pathItem,
+						showTitle,
+						showDescription
+					}, `${item.path}:${item.method}`)
+				};
+			}),
+			webhooks: webhooks?.map((item) => {
+				const pathItem = resolve(dereferenced.webhooks?.[item.name]);
+				if (!pathItem) throw new Error(`[Fumadocs OpenAPI] Webhook not found in OpenAPI schema: ${item.name}`);
+				const operation = pathItem[item.method];
+				if (!operation) throw new Error(`[Fumadocs OpenAPI] Method ${item.method} not found in webhook: ${item.name}`);
+				return {
+					item,
+					children: /* @__PURE__ */ jsx(Operation, {
+						type: "webhook",
+						path: `/${item.name}`,
+						method: item.method,
+						operation,
+						pathItem,
+						showTitle,
+						showDescription
+					}, `${item.name}:${item.method}`)
+				};
+			})
+		};
+		if (ctx.content?.renderPageLayout) return ctx.content.renderPageLayout(layout, ctx);
+		return /* @__PURE__ */ jsx(Layout, { ...layout });
+	}
+	return function OpenAPIPage(props) {
+		let document;
+		let proxyUrl;
+		if ("preloaded" in props) {
+			document = props.preloaded.docs[props.document];
+			if (!document) throw new Error(`[Fumadocs OpenAPI] the document ${props.document} is not preloaded, make sure to pass the "preloaded" prop to <OpenAPIPage />`);
+			proxyUrl = props.preloaded.proxyUrl;
+		} else {
+			document = props.payload.bundled;
+			proxyUrl = props.payload.proxyUrl;
+		}
+		return /* @__PURE__ */ jsx(OpenAPIProvider, {
+			...options,
+			document,
+			proxyUrl,
+			components: slots,
+			children: /* @__PURE__ */ jsx(Content, { ...props })
+		});
+	};
+}
+function DefaultLayout({ operations, webhooks }) {
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [operations?.map((item) => item.children), webhooks?.map((item) => item.children)] });
+}
+//#endregion
+export { createOpenAPIBaseRenderer, createOpenAPIRenderer, useComponents, useOpenAPI, useRenderContext, useTypeScriptDefinitions };

package/dist/utils/document/dereference.d.ts

@@ -1,5 +1,5 @@
 import { Document } from "../../types.js";
-import { NoReferenceSwallow } from "@fumadocs/api-docs/schema";
+import { DereferencedShallow } from "@fumadocs/json-schema";
 //#region src/utils/document/dereference.d.ts
 export interface DereferencedDocument {
   /**
@@ -13,7 +13,7 @@ export interface DereferencedDocument {
    *
    * Non-reference values are returned as-is.
    */
-  resolve: <T>(node: T) => NoReferenceSwallow<T>;
+  resolve: <T>(node: T) => DereferencedShallow<T>;
   bundled: Document;
 }
 //#endregion

package/dist/utils/document/dereference.js

@@ -1,14 +1,19 @@
-import { dereferenceShallow } from "@fumadocs/api-docs/schema/dereference";
 import { createMagicProxy } from "@scalar/json-magic/magic-proxy";
+import { dereference } from "@fumadocs/json-schema";
 //#region src/utils/document/dereference.ts
+const cache = /* @__PURE__ */ new WeakMap();
 function dereferenceBundledDocument(bundled) {
-	return {
+	const cached = cache.get(bundled);
+	if (cached) return cached;
+	const doc = {
 		bundled,
 		dereferenced: createMagicProxy(bundled),
 		resolve(node) {
-			return dereferenceShallow(node);
+			return dereference(node);
 		}
 	};
+	cache.set(bundled, doc);
+	return doc;
 }
 //#endregion
 export { dereferenceBundledDocument };

package/dist/utils/document/load.js

@@ -1,5 +1,5 @@
-import { upgrade } from "../../node_modules/.pnpm/@scalar_openapi-upgrader@0.2.15/node_modules/@scalar/openapi-upgrader/dist/upgrade.js";
-import { bundle } from "@fumadocs/api-docs/schema/bundle";
+import { upgrade } from "@scalar/openapi-upgrader";
+import { bundle } from "@fumadocs/json-schema/bundle";
 //#region src/utils/document/load.ts
 /**
 * Process input document to a Fumadocs OpenAPI compatible format

package/dist/utils/get-example-requests.js

@@ -1,18 +1,16 @@
 import { getPreferredType, pickExample } from "./schema.js";
 import { encodeRequestData } from "../requests/media/encode.js";
-import { dereferenceShallow } from "@fumadocs/api-docs/schema/dereference";
 import { getRaw } from "@scalar/json-magic/magic-proxy";
-import { sample } from "@fumadocs/api-docs/schema/sample";
+import { dereference, sample } from "@fumadocs/json-schema";
 //#region src/utils/get-example-requests.ts
-function getExampleRequests({ path, method, ctx, operation, pathItem }) {
-	const requestBody = dereferenceShallow(operation.requestBody);
+function getExampleRequests({ path, method, mediaAdapters, operation, parameters }) {
+	const requestBody = dereference(operation.requestBody);
 	const media = requestBody?.content ? getPreferredType(requestBody.content) : null;
-	const bodyOfType = media ? dereferenceShallow(requestBody.content[media]) : null;
-	const parameters = [...operation.parameters ?? [], ...pathItem.parameters ?? []].map(dereferenceShallow);
+	const bodyOfType = media ? dereference(requestBody.content[media]) : null;
 	if (bodyOfType?.examples) {
 		const result = [];
 		for (const [key, item] of Object.entries(bodyOfType.examples)) {
-			const { summary, description } = dereferenceShallow(item);
+			const { summary, description } = dereference(item);
 			const data = getRequestData({
 				path,
 				body: requestBody,
@@ -25,7 +23,7 @@ function getExampleRequests({ path, method, ctx, operation, pathItem }) {
 				name: summary || key,
 				description,
 				data,
-				encoded: encodeRequestData(data, ctx.mediaAdapters, parameters)
+				encoded: encodeRequestData(data, mediaAdapters, parameters)
 			});
 		}
 		if (result.length > 0) return result;
@@ -36,13 +34,13 @@ function getExampleRequests({ path, method, ctx, operation, pathItem }) {
 		method,
 		parameters
 	});
-	const schema = dereferenceShallow(bodyOfType?.schema);
+	const schema = dereference(bodyOfType?.schema);
 	return [{
 		id: "_default",
 		name: "Default",
 		description: typeof schema === "object" ? schema.description : void 0,
 		data,
-		encoded: encodeRequestData(data, ctx.mediaAdapters, parameters)
+		encoded: encodeRequestData(data, mediaAdapters, parameters)
 	}];
 }
 function getRequestData({ method, path, parameters, sampleKey, body }) {
@@ -59,7 +57,7 @@ function getRequestData({ method, path, parameters, sampleKey, body }) {
 			if (param.schema) value = sample(param.schema);
 			else if (param.content) {
 				const type = getPreferredType(param.content);
-				const content = type ? dereferenceShallow(param.content[type]) : void 0;
+				const content = type ? dereference(param.content[type]) : void 0;
 				if (!content || !content.schema) throw new Error(`Cannot find "${param.name}" parameter info for media type "${type}" in ${path} ${method}`);
 				value = sample(content.schema);
 			}
@@ -81,8 +79,8 @@ function getRequestData({ method, path, parameters, sampleKey, body }) {
 		const type = getPreferredType(body.content);
 		if (!type) throw new Error(`Cannot find body schema for ${path} ${method}: missing media type`);
 		result.bodyMediaType = type;
-		const bodyOfType = dereferenceShallow(body.content[type]);
-		if (bodyOfType.examples && sampleKey) result.body = getRaw(dereferenceShallow(bodyOfType.examples[sampleKey]).value);
+		const bodyOfType = dereference(body.content[type]);
+		if (bodyOfType.examples && sampleKey) result.body = getRaw(dereference(bodyOfType.examples[sampleKey]).value);
 		else if (bodyOfType.example) result.body = getRaw(bodyOfType.example);
 		else result.body = sample(bodyOfType?.schema ?? {}, {
 			skipReadOnly: method !== "get",