fumadocs-openapi 10.10.2 → 11.0.0

package/dist/types.d.ts

@@ -1,37 +1,33 @@
+import { OpenAPIV3_2 } from "./types/openapi.js";
+import { DereferencedDocument } from "./utils/document/dereference.js";
 import { InlineCodeUsageGenerator } from "./requests/generators/index.js";
-import { boundary_d_exports } from "./ui/client/boundary.js";
-import { OpenAPIV3_2 } from "./_openapi/types.js";
-import { CreateAPIPageOptions } from "./ui/base.js";
+import { CreateOpenAPIPageOptions } from "./ui/index.js";
 import { OpenAPIOptions } from "./server/index.js";
-import { NoReference } from "./utils/schema/index.js";
-import { DereferencedDocument } from "./utils/document/dereference.js";
+import { FC, ReactNode } from "react";
+import { SchemaUIOptions } from "@fumadocs/api-docs/components/schema";
 
 //#region src/types.d.ts
 type Document = OpenAPIV3_2.Document;
-type OperationObject = OpenAPIV3_2.OperationObject;
+type OperationObject = OpenAPIV3_2.OperationObject & {
+  'x-codeSamples'?: InlineCodeUsageGenerator[];
+  'x-selectedCodeSample'?: string;
+  'x-exclusiveCodeSample'?: string;
+};
 type ParameterObject = OpenAPIV3_2.ParameterObject;
-type SecuritySchemeObject = OpenAPIV3_2.SecuritySchemeObject;
-type ReferenceObject = OpenAPIV3_2.ReferenceObject;
 type PathItemObject = OpenAPIV3_2.PathItemObject;
 type TagObject = OpenAPIV3_2.TagObject;
-type ServerObject = OpenAPIV3_2.ServerObject;
 type ResponseObject = OpenAPIV3_2.ResponseObject;
 type HttpMethods = OpenAPIV3_2.HttpMethods;
-type MethodInformation = NoReference<OperationObject> & {
-  method: HttpMethods;
-  'x-codeSamples'?: InlineCodeUsageGenerator[];
-  'x-selectedCodeSample'?: string;
-  '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' | 'mediaAdapters' | 'codeUsages'>, 'renderHeading' | 'generateTypeScriptSchema'> {
+interface RenderContext extends Pick<OpenAPIOptions, 'proxyUrl'>, Omit<RequireKeys<CreateOpenAPIPageOptions, 'generateTypeScriptDefinitions' | 'mediaAdapters' | 'codeUsages' | 'shikiOptions' | 'shiki'>, 'schemaUI'> {
   /**
    * dereferenced schema
    */
   schema: DereferencedDocument;
-  clientBoundary: typeof boundary_d_exports;
+  _default_processMarkdown: (md: string) => ReactNode;
+  SchemaUI: FC<Omit<SchemaUIOptions, 'resolver' | 'renderMarkdown'>>;
 }
 type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
 type Awaitable<T> = T | Promise<T>;
 //#endregion
-export { Awaitable, DistributiveOmit, Document, HttpMethods, MethodInformation, OperationObject, ParameterObject, PathItemObject, ReferenceObject, RenderContext, ResponseObject, SecuritySchemeObject, ServerObject, TagObject };
+export { Awaitable, DistributiveOmit, Document, HttpMethods, OperationObject, ParameterObject, PathItemObject, RenderContext, ResponseObject, TagObject };

package/dist/ui/base.d.ts

@@ -1,167 +1,20 @@
-import { MediaAdapter } from "../requests/media/adapter.js";
-import { CodeUsageGeneratorRegistry, InlineCodeUsageGenerator } from "../requests/generators/index.js";
-import { ExampleRequestItem } from "./operation/get-example-requests.js";
-import { APIPageClientOptions } from "./client/index.js";
-import { SchemaUIOptions } from "./schema/index.js";
-import { ApiPageProps, OperationItem, WebhookItem } from "./api-page.js";
-import { ResponseTab } from "./operation/response-tabs.js";
-import { RequestTabsRenderContext } from "./operation/request-tabs.js";
-import { ClientCodeBlockProvider } from "./components/codeblock.js";
-import { OpenAPIServer } from "../server/index.js";
-import { Awaitable, MethodInformation, RenderContext } from "../types.js";
-import { NoReference } from "../utils/schema/index.js";
-import { DereferencedDocument } from "../utils/document/dereference.js";
-import { FC, HTMLAttributes, ReactNode } from "react";
+import { CreateOpenAPIPageOptions, OpenAPIPageProps } from "./index.js";
+import { FC } from "react";
 import { ShikiFactory } from "fumadocs-core/highlight/shiki";
-import { JSONSchema } from "json-schema-typed";
-import { BundledTheme, CodeOptionsThemes, CodeToHastOptionsCommon } from "shiki";
 
 //#region src/ui/base.d.ts
-interface GenerateTypeScriptDefinitionsContext extends RenderContext {
-  operation: NoReference<MethodInformation>;
-  readOnly: boolean;
-  writeOnly: boolean;
-  /** @deprecated */
-  _internal_legacy?: {
-    statusCode: string;
-    contentType: string;
-  };
-}
-interface APIPlaygroundProps {
-  path: string;
-  method: MethodInformation;
-  ctx: RenderContext;
-}
-interface CreateAPIPageOptions {
-  /**
-   * Generate TypeScript definitions from response schema.
-   *
-   * Pass `false` to disable it.
-   *
-   * @param method - the operation object
-   * @param statusCode - status code
-   * @deprecated use `generateTypeScriptDefinitions` instead.
-   */
-  generateTypeScriptSchema?: ((method: NoReference<MethodInformation>, statusCode: string, contentType: string, ctx: RenderContext) => Awaitable<string | undefined>) | false;
-  /**
-   * Generate TypeScript definitions from JSON schema.
-   *
-   * Pass `false` to disable it.
-   */
-  generateTypeScriptDefinitions?: ((schema: JSONSchema, ctx: GenerateTypeScriptDefinitionsContext) => Awaitable<string | undefined>) | false;
-  /**
-   * Generate example code usage for all endpoints.
-   */
-  codeUsages?: CodeUsageGeneratorRegistry;
-  /**
-   * Generate example code usage for each endpoint.
-   */
-  generateCodeSamples?: (method: MethodInformation) => InlineCodeUsageGenerator[];
+/**
+ * Create `<OpenAPIPage />` (a client component) without the full Shiki bundle.
+ */
+declare function createOpenAPIPageBase({
+  shiki,
+  shikiOptions,
+  schemaUI: schemaUIOptions,
+  codeUsages,
+  generateTypeScriptDefinitions,
+  ...options
+}: CreateOpenAPIPageOptions & {
   shiki: ShikiFactory;
-  renderMarkdown?: (md: string) => ReactNode;
-  shikiOptions: Omit<CodeToHastOptionsCommon, 'lang'> & CodeOptionsThemes<BundledTheme>;
-  /**
-   * Show full response schema instead of only example response & Typescript definitions.
-   *
-   * @default true
-   */
-  showResponseSchema?: boolean;
-  /**
-   * Support other media types (for server-side generation).
-   */
-  mediaAdapters?: Record<string, MediaAdapter>;
-  /**
-   * Customize page content
-   */
-  content?: {
-    renderResponseTabs?: (tabs: ResponseTab[], ctx: RenderContext) => ReactNode;
-    renderRequestTabs?: (items: ExampleRequestItem[], ctx: RequestTabsRenderContext) => 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: {
-      operations?: {
-        item: OperationItem;
-        children: ReactNode;
-      }[];
-      webhooks?: {
-        item: WebhookItem;
-        children: ReactNode;
-      }[];
-    }, ctx: RenderContext) => ReactNode;
-    renderOperationLayout?: (slots: {
-      header: ReactNode;
-      description: ReactNode;
-      apiExample: ReactNode;
-      apiPlayground: ReactNode;
-      authSchemes: ReactNode;
-      parameters: ReactNode;
-      body: ReactNode;
-      responses: ReactNode;
-      callbacks: ReactNode;
-    }, ctx: RenderContext, method: NoReference<MethodInformation>) => 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?: {
-    render?: (options: SchemaUIOptions, ctx: RenderContext) => ReactNode;
-    /**
-     * Show examples under the generated content of JSON schemas.
-     *
-     * @defaultValue false
-     */
-    showExample?: boolean;
-  };
-  /**
-   * Customize API playground
-   */
-  playground?: {
-    /**
-     * @defaultValue true
-     */
-    enabled?: boolean;
-    /**
-     * render a page-level provider (useful for handling auth)
-     */
-    provider?: (props: {
-      children: ReactNode;
-    }) => ReactNode;
-    /**
-     * replace the renderer
-     */
-    render?: (props: APIPlaygroundProps) => ReactNode;
-  };
-  /** @deprecated no longer used */
-  renderHeading?: (props: HTMLAttributes<HTMLHeadingElement>, depth: number) => ReactNode;
-  renderCodeBlock?: (props: {
-    lang: string;
-    code: string;
-  }) => ReactNode;
-  client?: APIPageClientOptions;
-}
-interface ServerApiPageProps extends Omit<ApiPageProps, 'document'> {
-  document: string | DereferencedDocument;
-}
-declare function createAPIPage(server: OpenAPIServer, options: CreateAPIPageOptions): FC<ServerApiPageProps>;
+}): FC<OpenAPIPageProps>;
 //#endregion
-export { APIPlaygroundProps, ClientCodeBlockProvider, CreateAPIPageOptions, GenerateTypeScriptDefinitionsContext, ServerApiPageProps, createAPIPage };
+export { createOpenAPIPageBase };

package/dist/ui/base.js

@@ -1,135 +1,176 @@
-import { parseSecurities } from "../utils/schema/index.js";
-import { defaultAdapters } from "../requests/media/adapter.js";
+"use client";
+import { RenderContextProvider, ServerProvider, useRenderContext } from "./contexts/api.js";
+import { ClientCodeBlock } from "./components/codeblock.js";
 import { createCodeUsageGeneratorRegistry } from "../requests/generators/index.js";
+import { defaultAdapters } from "../requests/media/adapter.js";
+import { AuthProvider } from "../playground/auth.js";
+import { Markdown } from "./components/markdown.js";
+import { Operation } from "./operation/index.js";
+import { dereferenceBundledDocument } from "../utils/document/dereference.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 { Children, useMemo } from "react";
 import * as JsxRuntime from "react/jsx-runtime";
-import { jsx } from "react/jsx-runtime";
-import { createRehypeCode } from "fumadocs-core/mdx-plugins/rehype-code.core";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { remarkGfm } from "fumadocs-core/mdx-plugins/remark-gfm";
 import defaultMdxComponents from "fumadocs-ui/mdx";
 import { remark } from "remark";
 import remarkRehype from "remark-rehype";
 import { toJsxRuntime } from "hast-util-to-jsx-runtime";
-import { CodeBlock, Pre } from "fumadocs-ui/components/codeblock";
-import { highlightHast } from "fumadocs-core/highlight/shiki";
 import { compile } from "@fumari/json-schema-ts";
+import { Schema } from "@fumadocs/api-docs/components/schema";
 //#region src/ui/base.tsx
-function createAPIPage(server, options) {
+/**
+* Create `<OpenAPIPage />` (a client component) without the full Shiki bundle.
+*/
+function createOpenAPIPageBase({ shiki, shikiOptions = { themes: {
+	light: "github-light",
+	dark: "github-dark"
+} }, schemaUI: schemaUIOptions, codeUsages = registerDefault(createCodeUsageGeneratorRegistry()), generateTypeScriptDefinitions = (schema, ctx) => {
+	if (typeof schema !== "object") return;
+	try {
+		return compile(schema, {
+			name: "Response",
+			readOnly: ctx.readOnly,
+			writeOnly: ctx.writeOnly,
+			getSchemaId: ctx.ctx.schema.getRawRef
+		});
+	} catch (e) {
+		console.warn("Failed to generate typescript schema:", e);
+	}
+}, ...options }) {
 	let processor;
 	function createMarkdownProcessor() {
+		const mdxComponents = {
+			...defaultMdxComponents,
+			img: void 0,
+			pre: MarkdownPre
+		};
 		function rehypeReact() {
 			this.compiler = (tree, file) => {
 				return toJsxRuntime(tree, {
 					development: false,
 					filePath: file.path,
 					...JsxRuntime,
-					components: defaultMdxComponents
+					components: mdxComponents
 				});
 			};
 		}
-		return remark().use(remarkGfm).use(remarkRehype).use(createRehypeCode(options.shiki), {
-			langs: [],
-			lazy: true,
-			defaultColor: false,
-			...options.shikiOptions
-		}).use(rehypeReact);
-	}
-	function renderPlaygroundProviderDefault({ children }) {
-		return /* @__PURE__ */ jsx(PlaygroundAuthProvider, { children });
+		return remark().use(remarkGfm).use(remarkRehype).use(rehypeReact);
 	}
-	function renderPlaygroundDefault({ path, method, ctx }) {
-		return /* @__PURE__ */ jsx(ctx.clientBoundary.PlaygroundClient, {
-			route: path,
-			securities: parseSecurities(method, ctx.schema.dereferenced),
-			method: method.method,
-			doc: pickSchema(ctx.schema.bundled, encodeInternalRef([
-				"paths",
-				path,
-				method.method
-			])),
-			proxyUrl: ctx.proxyUrl,
-			writeOnly: true,
-			readOnly: false,
-			deprecated: method.deprecated
-		});
-	}
-	return async function APIPageWrapper({ document, ...props }) {
-		let processed;
-		if (typeof document === "string") processed = await server.getSchema(document);
-		else processed = document;
-		const { ApiProvider, PlaygroundClient, SchemaUI, ServerProvider, UsageTab, UsageTabsSelector } = await import("./client/boundary.lazy.js");
-		const ctx = {
-			schema: processed,
-			proxyUrl: server.options.proxyUrl,
-			clientBoundary: {
-				ApiProvider,
-				PlaygroundClient,
-				SchemaUI,
-				ServerProvider,
-				UsageTab,
-				UsageTabsSelector
-			},
-			...options,
-			codeUsages: options.codeUsages ?? registerDefault(createCodeUsageGeneratorRegistry()),
-			mediaAdapters: {
-				...defaultAdapters,
-				...options.mediaAdapters
-			},
-			playground: {
-				...options.playground,
-				provider: options.playground?.provider ?? renderPlaygroundProviderDefault,
-				render: options.playground?.render ?? renderPlaygroundDefault
-			},
-			generateTypeScriptDefinitions: options.generateTypeScriptDefinitions ?? ((schema, ctx) => {
-				if (options.generateTypeScriptSchema && ctx._internal_legacy) {
-					const { statusCode, contentType } = ctx._internal_legacy;
-					return options.generateTypeScriptSchema(ctx.operation, statusCode, contentType, ctx);
-				}
-				if (typeof schema !== "object") return;
-				try {
-					return compile(schema, {
-						name: "Response",
-						readOnly: ctx.readOnly,
-						writeOnly: ctx.writeOnly,
-						getSchemaId: ctx.schema.getRawRef
+	return function OpenAPIPage(props) {
+		let doc;
+		let proxyUrl;
+		if ("preloaded" in props) {
+			doc = props.preloaded.docs[props.document];
+			if (!doc) 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 {
+			doc = props.payload.bundled;
+			proxyUrl = props.payload.proxyUrl;
+		}
+		const processed = useMemo(() => dereferenceBundledDocument(doc), [doc]);
+		const ctx = useMemo(() => {
+			function renderMarkdown(md) {
+				return /* @__PURE__ */ jsx(Markdown, { md });
+			}
+			function resolver(v) {
+				return {
+					dereferenced: v,
+					$ref: typeof v === "object" ? processed.getRawRef(v) : void 0
+				};
+			}
+			return {
+				schema: processed,
+				proxyUrl,
+				shiki,
+				shikiOptions,
+				generateTypeScriptDefinitions,
+				codeUsages,
+				SchemaUI(props) {
+					if (schemaUIOptions?.render) return schemaUIOptions.render(props, ctx);
+					return /* @__PURE__ */ jsx(Schema, {
+						...props,
+						showExample: props.showExample ?? schemaUIOptions?.showExample,
+						resolver,
+						renderMarkdown
 					});
-				} catch (e) {
-					console.warn("Failed to generate typescript schema:", e);
+				},
+				...options,
+				_default_processMarkdown(md) {
+					processor ??= createMarkdownProcessor();
+					return processor.processSync(md).result;
+				},
+				mediaAdapters: {
+					...defaultAdapters,
+					...options.mediaAdapters
 				}
-			}),
-			async renderMarkdown(text) {
-				if (options.renderMarkdown) return options.renderMarkdown(text);
-				processor ??= createMarkdownProcessor();
-				return (await processor.process({ value: text })).result;
-			},
-			async renderCodeBlock({ lang, code }) {
-				if (options.renderCodeBlock) return options.renderCodeBlock({
-					lang,
-					code
-				});
-				return /* @__PURE__ */ jsx(CodeBlock, {
-					className: "my-0",
-					children: toJsxRuntime(await highlightHast(await options.shiki.getOrInit(), code, {
-						lang,
-						defaultColor: false,
-						...options.shikiOptions
-					}), {
-						...JsxRuntime,
-						components: { pre: Pre }
-					})
-				});
-			}
-		};
-		return /* @__PURE__ */ jsx(APIPage, {
-			...props,
-			ctx
+			};
+		}, [proxyUrl, processed]);
+		return /* @__PURE__ */ jsx(RenderContextProvider, {
+			ctx,
+			children: /* @__PURE__ */ jsx(PageContent, { ...props })
 		});
 	};
 }
+function PageContent({ showTitle: hasHead = false, showDescription, operations, webhooks }) {
+	const ctx = useRenderContext();
+	const { dereferenced } = ctx.schema;
+	let { renderPageLayout } = ctx.content ?? {};
+	renderPageLayout ??= (slots) => /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-24 text-sm @container",
+		children: [slots.operations?.map((op) => op.children), slots.webhooks?.map((op) => op.children)]
+	});
+	let content = renderPageLayout({
+		operations: operations?.map((item) => {
+			const pathItem = 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, {
+					method: item.method,
+					pathItem,
+					operation,
+					path: item.path,
+					showTitle: hasHead,
+					showDescription
+				}, `${item.path}:${item.method}`)
+			};
+		}),
+		webhooks: webhooks?.map((item) => {
+			const webhook = dereferenced.webhooks?.[item.name];
+			if (!webhook) throw new Error(`[Fumadocs OpenAPI] Webhook not found in OpenAPI schema: ${item.name}`);
+			const hook = webhook[item.method];
+			if (!hook) throw new Error(`[Fumadocs OpenAPI] Method ${item.method} not found in webhook: ${item.name}`);
+			return {
+				item,
+				children: /* @__PURE__ */ jsx(Operation, {
+					type: "webhook",
+					method: item.method,
+					pathItem: webhook,
+					operation: hook,
+					path: `/${item.name}`,
+					showTitle: hasHead,
+					showDescription
+				}, `${item.name}:${item.method}`)
+			};
+		})
+	}, ctx);
+	if (ctx.playground?.enabled !== false) content = ctx.playground?.provider ? ctx.playground.provider({ children: content }) : /* @__PURE__ */ jsx(AuthProvider, { children: content });
+	return /* @__PURE__ */ jsx(ServerProvider, {
+		servers: dereferenced.servers,
+		children: content
+	});
+}
+function MarkdownPre(props) {
+	const codeProps = Children.only(props.children).props;
+	const content = codeProps.children;
+	if (typeof content !== "string") return null;
+	return /* @__PURE__ */ jsx(ClientCodeBlock, {
+		lang: codeProps.className?.split(" ").find((v) => v.startsWith("language-"))?.slice(9) ?? "text",
+		code: content.trimEnd()
+	});
+}
 //#endregion
-export { ClientCodeBlockProvider, createAPIPage };
+export { createOpenAPIPageBase };

package/dist/ui/components/codeblock.js

@@ -1,25 +1,17 @@
 "use client";
-import { useApiContext } from "../contexts/api.js";
-import { createContext, use } from "react";
+import { useRenderContext } from "../contexts/api.js";
 import { jsx } from "react/jsx-runtime";
 import { DynamicCodeBlock } from "fumadocs-ui/components/dynamic-codeblock.core";
 //#region src/ui/components/codeblock.tsx
-const CodeBlockContext = createContext(null);
 function ClientCodeBlock(props) {
-	const { shikiOptions } = useApiContext();
-	const ctx = use(CodeBlockContext);
-	if (!ctx) throw new Error("Missing Shiki context, please wrap your <APIPage /> component under <ClientCodeBlockProvider />");
+	const { shiki, shikiOptions, renderCodeBlock, components: { CodeBlock: Comp } = {} } = useRenderContext();
+	if (renderCodeBlock) return renderCodeBlock(props);
+	if (Comp) return /* @__PURE__ */ jsx(Comp, { ...props });
 	return /* @__PURE__ */ jsx(DynamicCodeBlock, {
-		highlighter: () => ctx.getOrInit(),
+		highlighter: () => shiki.getOrInit(),
 		options: shikiOptions,
 		...props
 	});
 }
-function ClientCodeBlockProvider({ factory, children }) {
-	return /* @__PURE__ */ jsx(CodeBlockContext, {
-		value: factory,
-		children
-	});
-}
 //#endregion
-export { ClientCodeBlock, ClientCodeBlockProvider };
+export { ClientCodeBlock };

package/dist/ui/components/heading.js

@@ -1,13 +1,17 @@
 "use client";
-import { useApiContext } from "../contexts/api.js";
-import { useAnchorId } from "../../utils/auto-anchor.client.js";
+import { useRenderContext } from "../contexts/api.js";
 import { jsx } from "react/jsx-runtime";
+import { useAnchorId } from "@fumadocs/api-docs/auto-anchor/client";
 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, {
+	const { renderHeading, components: { Heading: Comp } = {} } = useRenderContext();
+	if (renderHeading) return renderHeading({
+		id,
+		...props
+	}, depth);
+	if (Comp) return /* @__PURE__ */ jsx(Comp, {
 		id,
 		depth,
 		...props

package/dist/ui/components/markdown.js

@@ -0,0 +1,12 @@
+import { useRenderContext } from "../contexts/api.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/ui/components/markdown.tsx
+function Markdown({ md }) {
+	const { _default_processMarkdown: processMarkdown, renderMarkdown, components: { Markdown: Comp } = {} } = useRenderContext();
+	if (renderMarkdown) return renderMarkdown(md);
+	if (Comp) return /* @__PURE__ */ jsx(Comp, { md });
+	return useMemo(() => processMarkdown(md), [processMarkdown, md]);
+}
+//#endregion
+export { Markdown };

package/dist/ui/contexts/api.js

@@ -1,15 +1,12 @@
 "use client";
-import { defaultAdapters } from "../../requests/media/adapter.js";
-import { useStorageKey } from "../client/storage-key.js";
-import { createCodeUsageGeneratorRegistry } from "../../requests/generators/index.js";
-import { registerDefault } from "../../requests/generators/all.js";
+import { useStorageKey } from "../../utils/storage-key.js";
 import { createContext, use, useEffect, useMemo, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/ui/contexts/api.tsx
-const ApiContext = createContext(null);
+const Context = createContext(null);
 const ServerContext = createContext(null);
-function useApiContext() {
-	const ctx = use(ApiContext);
+function useRenderContext() {
+	const ctx = use(Context);
 	if (!ctx) throw new Error("Component must be used under <ApiProvider />");
 	return ctx;
 }
@@ -18,24 +15,9 @@ function useServerContext() {
 	if (!ctx) throw new Error("Component must be used under <ApiProvider />");
 	return ctx;
 }
-function ApiProvider({ children, shikiOptions, client, schemes }) {
-	return /* @__PURE__ */ jsx(ApiContext, {
-		value: useMemo(() => {
-			return {
-				shikiOptions,
-				client,
-				codeUsages: client.codeUsages ?? registerDefault(createCodeUsageGeneratorRegistry()),
-				schemes,
-				mediaAdapters: {
-					...defaultAdapters,
-					...client.mediaAdapters
-				}
-			};
-		}, [
-			client,
-			schemes,
-			shikiOptions
-		]),
+function RenderContextProvider({ children, ctx }) {
+	return /* @__PURE__ */ jsx(Context, {
+		value: ctx,
 		children
 	});
 }
@@ -99,4 +81,4 @@ function getDefaultValues(server) {
 	return out;
 }
 //#endregion
-export { ApiProvider, ServerProvider, useApiContext, useServerContext };
+export { RenderContextProvider, ServerProvider, useRenderContext, useServerContext };