fumadocs-openapi 5.12.0 → 6.0.0

package/dist/server/index.js

@@ -4,7 +4,6 @@ import { Fragment as Fragment$1 } from 'react';
 import { sample } from 'openapi-sampler';
 import { js2xml } from 'xml-js';
 import { compile } from '@fumari/json-schema-to-typescript';
-import { ScalarPlayground, Root, API, APIInfo, APIExample as APIExample$1, Property, ObjectCollapsible, APIPlayground } from '../ui/index.js';
 import { remarkGfm, remarkImage, rehypeCode } from 'fumadocs-core/mdx-plugins';
 import defaultMdxComponents from 'fumadocs-ui/mdx';
 import { remark } from 'remark';
@@ -15,6 +14,7 @@ import { Tabs, Tab } from 'fumadocs-ui/components/tabs';
 import { Accordions, Accordion } from 'fumadocs-ui/components/accordion';
 import * as Base from 'fumadocs-ui/components/codeblock';
 import { highlight } from 'fumadocs-core/server';
+import { APIPlayground, Root, API, APIInfo, APIExample as APIExample$1, Property, ObjectCollapsible } from '../ui/index.js';
 import { load, upgrade, dereference } from '@scalar/openapi-parser';
 import { fetchUrls } from '@scalar/openapi-parser/plugins/fetch-urls';
 import { readFiles } from '@scalar/openapi-parser/plugins/read-files';
@@ -328,180 +328,6 @@ async function getTypescriptSchema(endpoint, code, dereferenceMap) {
     }
 }
 
-function Playground({ path, method, ctx }) {
-    if (ctx.useScalar) {
-        return /*#__PURE__*/ jsx(ScalarPlayground, {
-            spec: ctx.schema.downloaded,
-            method: method.method,
-            path: path
-        });
-    }
-    let currentId = 0;
-    const bodyContent = method.requestBody?.content;
-    const mediaType = bodyContent ? getPreferredType(bodyContent) : undefined;
-    const context = {
-        allowFile: mediaType === 'multipart/form-data',
-        references: {},
-        nextId () {
-            return String(currentId++);
-        },
-        registered: new WeakMap(),
-        render: ctx
-    };
-    const bodySchema = bodyContent && mediaType && bodyContent[mediaType].schema ? toSchema(bodyContent[mediaType].schema, true, context) : undefined;
-    const props = {
-        authorization: getAuthorizationField(method, ctx),
-        method: method.method,
-        route: path,
-        path: method.parameters?.filter((v)=>v.in === 'path').map((v)=>parameterToField(v, context)),
-        query: method.parameters?.filter((v)=>v.in === 'query').map((v)=>parameterToField(v, context)),
-        header: method.parameters?.filter((v)=>v.in === 'header').map((v)=>parameterToField(v, context)),
-        body: bodySchema && mediaType ? {
-            ...bodySchema,
-            mediaType: mediaType
-        } : undefined,
-        schemas: context.references,
-        proxyUrl: ctx.proxyUrl
-    };
-    return /*#__PURE__*/ jsx(ctx.renderer.APIPlayground, {
-        ...props
-    });
-}
-function getAuthorizationField(method, { schema: { document } }) {
-    const security = method.security ?? document.security ?? [];
-    if (security.length === 0) return;
-    const singular = security.find((requirements)=>Object.keys(requirements).length === 1);
-    if (!singular) return;
-    const scheme = getSecurities(singular, document)[0];
-    return {
-        type: 'string',
-        name: scheme.type === 'apiKey' ? scheme.name : 'Authorization',
-        authType: scheme.type,
-        defaultValue: scheme.type === 'oauth2' || scheme.type === 'http' && scheme.scheme === 'bearer' ? 'Bearer' : 'Basic',
-        isRequired: security.every((requirements)=>Object.keys(requirements).length > 0),
-        description: 'The Authorization access token'
-    };
-}
-function getIdFromSchema(schema, required, ctx) {
-    const registered = ctx.registered.get(schema);
-    if (registered === undefined) {
-        const id = ctx.nextId();
-        ctx.registered.set(schema, id);
-        ctx.references[id] = toSchema(schema, required, ctx);
-        return id;
-    }
-    return registered;
-}
-function parameterToField(v, ctx) {
-    return {
-        name: v.name,
-        ...toSchema(v.schema ?? {
-            type: 'string'
-        }, v.required ?? false, ctx)
-    };
-}
-function toReference(schema, required, ctx) {
-    return {
-        type: 'ref',
-        isRequired: required,
-        schema: getIdFromSchema(schema, false, ctx)
-    };
-}
-function toSchema(schema, required, ctx) {
-    if (schema.type === 'array') {
-        return {
-            type: 'array',
-            description: schema.description ?? schema.title,
-            isRequired: required,
-            items: getIdFromSchema(schema.items, false, ctx)
-        };
-    }
-    if (schema.type === 'object' || schema.properties !== undefined || schema.allOf !== undefined) {
-        const properties = {};
-        Object.entries(schema.properties ?? {}).forEach(([key, prop])=>{
-            properties[key] = toReference(prop, schema.required?.includes(key) ?? false, ctx);
-        });
-        schema.allOf?.forEach((c)=>{
-            const field = toSchema(c, true, ctx);
-            if (field.type === 'object') Object.assign(properties, field.properties);
-        });
-        const additional = schema.additionalProperties;
-        let additionalProperties;
-        if (additional && typeof additional === 'object') {
-            if ((!additional.type || additional.type.length === 0) && !additional.anyOf && !additional.allOf && !additional.oneOf) {
-                additionalProperties = true;
-            } else {
-                additionalProperties = getIdFromSchema(additional, false, ctx);
-            }
-        } else {
-            additionalProperties = additional;
-        }
-        return {
-            type: 'object',
-            isRequired: required,
-            description: schema.description ?? schema.title,
-            properties,
-            additionalProperties
-        };
-    }
-    if (schema.type === undefined) {
-        const combine = schema.anyOf ?? schema.oneOf;
-        if (combine) {
-            return {
-                type: 'switcher',
-                description: schema.description ?? schema.title,
-                items: Object.fromEntries(combine.map((item, idx)=>{
-                    return [
-                        item.title ?? item.type ?? `Item ${idx.toString()}`,
-                        toReference(item, true, ctx)
-                    ];
-                })),
-                isRequired: required
-            };
-        }
-        return {
-            type: 'null',
-            isRequired: false
-        };
-    }
-    if (ctx.allowFile && schema.type === 'string' && schema.format === 'binary') {
-        return {
-            type: 'file',
-            isRequired: required,
-            description: schema.description ?? schema.title
-        };
-    }
-    if (Array.isArray(schema.type)) {
-        const items = {};
-        for (const type of schema.type){
-            if (type === 'array') {
-                items[type] = {
-                    type,
-                    items: 'items' in schema && schema.items ? toSchema(schema.items, false, ctx) : toSchema({}, required, ctx),
-                    isRequired: required
-                };
-            } else {
-                items[type] = toSchema({
-                    ...schema,
-                    type
-                }, true, ctx);
-            }
-        }
-        return {
-            type: 'switcher',
-            description: schema.description ?? schema.title,
-            items,
-            isRequired: required
-        };
-    }
-    return {
-        type: schema.type === 'integer' ? 'number' : schema.type,
-        defaultValue: schema.example ?? '',
-        isRequired: required,
-        description: schema.description ?? schema.title
-    };
-}
-
 function idToTitle(id) {
     let result = [];
     for (const c of id){
@@ -938,7 +764,7 @@ function Operation({ type = 'operation', path, method, ctx, hasHead, headingLeve
         method: method.method,
         route: path,
         children: [
-            type === 'operation' ? /*#__PURE__*/ jsx(Playground, {
+            type === 'operation' ? /*#__PURE__*/ jsx(ctx.renderer.APIPlayground, {
                 path: path,
                 method: method,
                 ctx: ctx
@@ -1207,7 +1033,166 @@ async function CodeBlock({ code, lang, options, ...rest }) {
     });
 }
 
-function createRenders(shikiOptions, _useScalar) {
+function Playground({ path, method, ctx }) {
+    let currentId = 0;
+    const bodyContent = method.requestBody?.content;
+    const mediaType = bodyContent ? getPreferredType(bodyContent) : undefined;
+    const context = {
+        allowFile: mediaType === 'multipart/form-data',
+        references: {},
+        nextId () {
+            return String(currentId++);
+        },
+        registered: new WeakMap(),
+        render: ctx
+    };
+    const bodySchema = bodyContent && mediaType && bodyContent[mediaType].schema ? toSchema(bodyContent[mediaType].schema, true, context) : undefined;
+    const props = {
+        authorization: getAuthorizationField(method, ctx),
+        method: method.method,
+        route: path,
+        path: method.parameters?.filter((v)=>v.in === 'path').map((v)=>parameterToField(v, context)),
+        query: method.parameters?.filter((v)=>v.in === 'query').map((v)=>parameterToField(v, context)),
+        header: method.parameters?.filter((v)=>v.in === 'header').map((v)=>parameterToField(v, context)),
+        body: bodySchema && mediaType ? {
+            ...bodySchema,
+            mediaType: mediaType
+        } : undefined,
+        schemas: context.references,
+        proxyUrl: ctx.proxyUrl
+    };
+    return /*#__PURE__*/ jsx(APIPlayground, {
+        ...props
+    });
+}
+function getAuthorizationField(method, { schema: { document } }) {
+    const security = method.security ?? document.security ?? [];
+    if (security.length === 0) return;
+    const singular = security.find((requirements)=>Object.keys(requirements).length === 1);
+    if (!singular) return;
+    return getSecurities(singular, document)[0];
+}
+function getIdFromSchema(schema, required, ctx) {
+    const registered = ctx.registered.get(schema);
+    if (registered === undefined) {
+        const id = ctx.nextId();
+        ctx.registered.set(schema, id);
+        ctx.references[id] = toSchema(schema, required, ctx);
+        return id;
+    }
+    return registered;
+}
+function parameterToField(v, ctx) {
+    return {
+        name: v.name,
+        ...toSchema(v.schema ?? {
+            type: 'string'
+        }, v.required ?? false, ctx)
+    };
+}
+function toReference(schema, required, ctx) {
+    return {
+        type: 'ref',
+        isRequired: required,
+        schema: getIdFromSchema(schema, false, ctx)
+    };
+}
+function toSchema(schema, required, ctx) {
+    if (schema.type === 'array') {
+        return {
+            type: 'array',
+            description: schema.description ?? schema.title,
+            isRequired: required,
+            items: getIdFromSchema(schema.items, false, ctx)
+        };
+    }
+    if (schema.type === 'object' || schema.properties !== undefined || schema.allOf !== undefined) {
+        const properties = {};
+        Object.entries(schema.properties ?? {}).forEach(([key, prop])=>{
+            properties[key] = toReference(prop, schema.required?.includes(key) ?? false, ctx);
+        });
+        schema.allOf?.forEach((c)=>{
+            const field = toSchema(c, true, ctx);
+            if (field.type === 'object') Object.assign(properties, field.properties);
+        });
+        const additional = schema.additionalProperties;
+        let additionalProperties;
+        if (additional && typeof additional === 'object') {
+            if ((!additional.type || additional.type.length === 0) && !additional.anyOf && !additional.allOf && !additional.oneOf) {
+                additionalProperties = true;
+            } else {
+                additionalProperties = getIdFromSchema(additional, false, ctx);
+            }
+        } else {
+            additionalProperties = additional;
+        }
+        return {
+            type: 'object',
+            isRequired: required,
+            description: schema.description ?? schema.title,
+            properties,
+            additionalProperties
+        };
+    }
+    if (schema.type === undefined) {
+        const combine = schema.anyOf ?? schema.oneOf;
+        if (combine) {
+            return {
+                type: 'switcher',
+                description: schema.description ?? schema.title,
+                items: Object.fromEntries(combine.map((item, idx)=>{
+                    return [
+                        item.title ?? item.type ?? `Item ${idx.toString()}`,
+                        toReference(item, true, ctx)
+                    ];
+                })),
+                isRequired: required
+            };
+        }
+        return {
+            type: 'null',
+            isRequired: false
+        };
+    }
+    if (ctx.allowFile && schema.type === 'string' && schema.format === 'binary') {
+        return {
+            type: 'file',
+            isRequired: required,
+            description: schema.description ?? schema.title
+        };
+    }
+    if (Array.isArray(schema.type)) {
+        const items = {};
+        for (const type of schema.type){
+            if (type === 'array') {
+                items[type] = {
+                    type,
+                    items: 'items' in schema && schema.items ? toSchema(schema.items, false, ctx) : toSchema({}, required, ctx),
+                    isRequired: required
+                };
+            } else {
+                items[type] = toSchema({
+                    ...schema,
+                    type
+                }, required, ctx);
+            }
+        }
+        return {
+            type: 'switcher',
+            description: schema.description ?? schema.title,
+            items,
+            isRequired: required
+        };
+    }
+    return {
+        type: schema.type === 'integer' ? 'number' : schema.type,
+        defaultValue: schema.example ?? '',
+        isRequired: required,
+        description: schema.description ?? schema.title
+    };
+}
+
+function createRenders(shikiOptions) {
     return {
         Root: (props)=>/*#__PURE__*/ jsx(Root, {
                 shikiOptions: shikiOptions,
@@ -1252,7 +1237,7 @@ function createRenders(shikiOptions, _useScalar) {
                     options: shikiOptions
                 })
             }),
-        APIPlayground
+        APIPlayground: Playground
     };
 }
 
@@ -1346,12 +1331,11 @@ async function getContext(schema, options = {}) {
     ];
     const server = servers[0];
     return {
-        useScalar: options.useScalar ?? false,
         schema,
         proxyUrl: options.proxyUrl,
         showResponseSchema: options.showResponseSchema,
         renderer: {
-            ...createRenders(options.shikiOptions, options.useScalar ?? false),
+            ...createRenders(options.shikiOptions),
             ...options.renderer
         },
         shikiOptions: options.shikiOptions,

package/dist/ui/client-client-CpwKrzlY.js

@@ -0,0 +1,107 @@
+'use client';
+import { useContext, createContext, useState, useRef, useEffect, useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+import { cn } from 'fumadocs-ui/components/api';
+import dynamic from 'next/dynamic';
+
+const ApiContext = /*#__PURE__*/ createContext(undefined);
+const ServerSelectContext = /*#__PURE__*/ createContext(undefined);
+function useApiContext() {
+    const ctx = useContext(ApiContext);
+    if (!ctx) throw new Error('Component must be used under <ApiProvider />');
+    return ctx;
+}
+function useServerSelectContext() {
+    const ctx = useContext(ServerSelectContext);
+    if (!ctx) throw new Error('Component must be used under <ApiProvider />');
+    return ctx;
+}
+function ApiProvider({ defaultBaseUrl, children, ...props }) {
+    const [server, setServer] = useState(()=>{
+        const defaultItem = defaultBaseUrl ? props.servers.find((item)=>item.url === defaultBaseUrl) : undefined;
+        return defaultItem ? {
+            url: defaultItem.url,
+            variables: getDefaultValues(defaultItem)
+        } : null;
+    });
+    const serverRef = useRef(server);
+    serverRef.current = server;
+    useEffect(()=>{
+        const cached = localStorage.getItem('apiBaseUrl');
+        if (!cached) return;
+        try {
+            const obj = JSON.parse(cached);
+            if (!obj || typeof obj !== 'object') return;
+            setServer(obj);
+        } catch  {
+        // ignore
+        }
+    }, []);
+    return /*#__PURE__*/ jsx(ApiContext.Provider, {
+        value: useMemo(()=>({
+                ...props,
+                serverRef
+            }), [
+            props
+        ]),
+        children: /*#__PURE__*/ jsx(ServerSelectContext.Provider, {
+            value: useMemo(()=>({
+                    server,
+                    setServerVariables (variables) {
+                        setServer((prev)=>{
+                            if (!prev) return null;
+                            const updated = {
+                                ...prev,
+                                variables
+                            };
+                            localStorage.setItem('apiBaseUrl', JSON.stringify(updated));
+                            return updated;
+                        });
+                    },
+                    setServer (value) {
+                        const obj = props.servers.find((item)=>item.url === value);
+                        if (!obj) return;
+                        const result = {
+                            url: value,
+                            variables: getDefaultValues(obj)
+                        };
+                        localStorage.setItem('apiBaseUrl', JSON.stringify(result));
+                        setServer(result);
+                    }
+                }), [
+                server,
+                props.servers
+            ]),
+            children: children
+        })
+    });
+}
+function getDefaultValues(server) {
+    return Object.fromEntries(Object.entries(server.variables ?? {}).map(([k, v])=>[
+            k,
+            v.default
+        ]));
+}
+
+const SchemaContext = /*#__PURE__*/ createContext(undefined);
+function useSchemaContext() {
+    const ctx = useContext(SchemaContext);
+    if (!ctx) throw new Error('Missing provider');
+    return ctx;
+}
+
+const APIPlayground = dynamic(()=>import('./index-client-CehDtJk-.js').then(function (n) { return n.i; }).then((mod)=>mod.APIPlayground));
+function Root({ children, baseUrl, className, shikiOptions, servers, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        className: cn('flex flex-col gap-24 text-sm text-fd-muted-foreground', className),
+        ...props,
+        children: /*#__PURE__*/ jsx(ApiProvider, {
+            servers: servers,
+            shikiOptions: shikiOptions,
+            defaultBaseUrl: baseUrl,
+            children: children
+        })
+    });
+}
+
+export { APIPlayground as A, Root as R, SchemaContext as S, useApiContext as a, useServerSelectContext as b, useSchemaContext as u };

package/dist/ui/{fetcher-BHk80ZFu.js → fetcher-Cey1qI8X.js}

@@ -1,4 +1,4 @@
-import { r as resolve } from './index-client-XPLtFTfD.js';
+import { r as resolve } from './index-client-CehDtJk-.js';
 
 /**
  * @param bodySchema - schema of body