fumadocs-openapi 4.4.2 → 5.0.1

package/dist/server/index.js

@@ -0,0 +1,1094 @@
+import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
+import Parser from '@apidevtools/json-schema-ref-parser';
+import Slugger from 'github-slugger';
+import { createElement, Fragment, useMemo } from 'react';
+import { sample } from 'openapi-sampler';
+import { compile } from 'json-schema-to-typescript';
+import { createProcessor } from '@mdx-js/mdx';
+import { remarkGfm, rehypeCode } from 'fumadocs-core/mdx-plugins';
+import defaultMdxComponents from 'fumadocs-ui/mdx';
+import { Heading } from 'fumadocs-ui/components/heading';
+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 { createHighlighter, bundledThemes, bundledLanguages } from 'shiki';
+import { Root, API, APIInfo, APIExample as APIExample$1, Property, ObjectCollapsible, APIPlayground } from '../ui/index.js';
+import { cva } from 'class-variance-authority';
+
+function noRef(v) {
+    return v;
+}
+function getPreferredType(body) {
+    if ('application/json' in body) return 'application/json';
+    return Object.keys(body)[0];
+}
+/**
+ * Convert to JSON string if necessary
+ */ function toSampleInput(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+}
+
+function generateSample(path, method, baseUrl) {
+    const params = [];
+    const responses = {};
+    for (const param of method.parameters){
+        if (param.schema) {
+            params.push({
+                name: param.name,
+                in: param.in,
+                schema: noRef(param.schema),
+                sample: param.example ?? sample(param.schema)
+            });
+        } else if (param.content) {
+            const key = getPreferredType(param.content);
+            const content = key ? param.content[key] : undefined;
+            if (!key || !content?.schema) throw new Error(`Cannot find parameter schema for ${param.name} in ${path} ${method.method}`);
+            params.push({
+                name: param.name,
+                in: param.in,
+                schema: noRef(content.schema),
+                sample: content.example ?? param.example ?? sample(content.schema)
+            });
+        }
+    }
+    let bodyOutput;
+    if (method.requestBody) {
+        const body = noRef(method.requestBody).content;
+        const type = getPreferredType(body);
+        const schema = type ? noRef(body[type].schema) : undefined;
+        if (!type || !schema) throw new Error(`Cannot find body schema for ${path} ${method.method}`);
+        bodyOutput = {
+            schema,
+            mediaType: type,
+            sample: body[type].example ?? generateBody(method.method, schema)
+        };
+    }
+    for (const [code, value] of Object.entries(method.responses)){
+        const content = noRef(value).content;
+        if (!content) continue;
+        const mediaType = getPreferredType(content);
+        if (!mediaType) continue;
+        const responseSchema = noRef(content[mediaType].schema);
+        if (!responseSchema) continue;
+        responses[code] = {
+            mediaType,
+            sample: content[mediaType].example ?? generateBody(method.method, responseSchema),
+            schema: responseSchema
+        };
+    }
+    let pathWithParameters = path;
+    const queryParams = new URLSearchParams();
+    for (const param of params){
+        const value = generateBody(method.method, param.schema);
+        if (param.in === 'query') queryParams.append(param.name, toSampleInput(value));
+        if (param.in === 'path') pathWithParameters = pathWithParameters.replace(`{${param.name}}`, toSampleInput(value));
+    }
+    if (queryParams.size > 0) pathWithParameters = `${pathWithParameters}?${queryParams.toString()}`;
+    return {
+        url: new URL(`${baseUrl}${pathWithParameters}`).toString(),
+        body: bodyOutput,
+        responses,
+        method: method.method,
+        parameters: params
+    };
+}
+function generateBody(method, schema) {
+    return sample(schema, {
+        skipReadOnly: method !== 'GET',
+        skipWriteOnly: method === 'GET'
+    });
+}
+
+function getSampleRequest$2(endpoint) {
+    const s = [];
+    s.push(`curl -X ${endpoint.method} "${endpoint.url}"`);
+    for (const param of endpoint.parameters){
+        if (param.in === 'header') {
+            const header = `${param.name}: ${toSampleInput(param.sample)}`;
+            s.push(`-H "${header}"`);
+        }
+        if (param.in === 'cookie') {
+            const cookie = JSON.stringify(`${param.name}=${toSampleInput(param.sample)}`);
+            s.push(`--cookie ${cookie}`);
+        }
+    }
+    if (endpoint.body?.mediaType === 'multipart/form-data') {
+        const sample = endpoint.body.sample;
+        if (sample && typeof sample === 'object') {
+            for (const [key, value] of Object.entries(sample)){
+                s.push(`-F ${key}=${JSON.stringify(value, null, 2)}`);
+            }
+        }
+    } else if (endpoint.body) {
+        s.push(`-H "Content-Type: application/json"`);
+        s.push(`-d '${toSampleInput(endpoint.body.sample)}'`);
+    }
+    return s.flatMap((v, i)=>v.split('\n').map((line)=>i > 0 ? `  ${line}` : line).join('\n')).join(' \\\n');
+}
+
+function getSampleRequest$1(endpoint) {
+    const s = [];
+    const options = new Map();
+    const headers = new Map();
+    const cookies = new Map();
+    for (const param of endpoint.parameters){
+        if (param.in === 'header') {
+            headers.set(param.name, param.sample);
+        }
+        if (param.in === 'cookie') {
+            cookies.set(param.name, param.sample);
+        }
+    }
+    if (cookies.size > 0) {
+        headers.set('cookie', Array.from(cookies.entries()).map(([key, value])=>`${key}=${toSampleInput(value)}`).join('; '));
+    }
+    if (headers.size > 0) {
+        options.set('headers', JSON.stringify(Object.fromEntries(headers.entries()), undefined, 2).replaceAll('\n', '\n  '));
+    }
+    if (endpoint.body?.mediaType === 'multipart/form-data' && typeof endpoint.body.sample === 'object' && endpoint.body.sample) {
+        s.push(`const formData = new FormData();`);
+        for (const [key, value] of Object.entries(endpoint.body.sample))s.push(`formData.set(${key}, ${JSON.stringify(value)})`);
+        options.set('body', 'formData');
+    } else if (endpoint.body) {
+        options.set('body', `JSON.stringify(${JSON.stringify(endpoint.body.sample, null, 2).replaceAll('\n', '\n  ')})`);
+    }
+    const optionsStr = Array.from(options.entries()).map(([k, v])=>`  ${k}: ${v}`).join(',\n');
+    s.push(`fetch(${JSON.stringify(endpoint.url)}, {\n${optionsStr}\n});`);
+    return s.join('\n\n');
+}
+
+function getSampleRequest(endpoint) {
+    const imports = [
+        'fmt',
+        'net/http',
+        'io/ioutil'
+    ];
+    const headers = new Map();
+    const cookies = new Map();
+    const variables = new Map();
+    // additional lines before initializing request
+    const additional = [];
+    for (const p of endpoint.parameters){
+        if (p.in === 'header') headers.set(p.name, JSON.stringify(p.sample));
+        if (p.in === 'cookie') cookies.set(p.name, toSampleInput(p.sample));
+    }
+    variables.set('url', JSON.stringify(endpoint.url));
+    if (cookies.size > 0) headers.set('Cookie', JSON.stringify(Array.from(cookies.entries()).map(([key, value])=>`${key}=${value}`).join('; ')));
+    if (endpoint.body) {
+        headers.set('Content-Type', `"${endpoint.body.mediaType}"`);
+        if (endpoint.body.mediaType === 'application/json') {
+            imports.push('strings');
+            variables.set('payload', `strings.NewReader(\`${JSON.stringify(endpoint.body.sample, null, 2).replaceAll('\n', '\n  ')}\`)`);
+        }
+        if (endpoint.body.mediaType === 'multipart/form-data' && typeof endpoint.body.sample === 'object') {
+            imports.push('mime/multipart', 'bytes');
+            variables.set('payload', `new(bytes.Buffer)`);
+            variables.set('mp', 'multipart.NewWriter(payload)');
+            for (const [key, value] of Object.entries(endpoint.body.sample ?? {})){
+                additional.push(`mp.WriteField("${key}", ${JSON.stringify(toSampleInput(value))})`);
+            }
+        }
+    }
+    return `package main
+
+import (
+${imports.map((v)=>`  "${v}"`).join('\n')}
+)
+
+func main() {
+${Array.from(variables.entries()).map(([k, v])=>`  ${k} := ${v}`).join('\n')}
+  ${additional.join('\n  ')}
+  req, _ := http.NewRequest("${endpoint.method}", url, ${variables.has('payload') ? 'payload' : 'nil'})
+  ${Array.from(headers.entries()).map(([key, value])=>`req.Header.Add("${key}", ${value})`).join('\n')}
+  res, _ := http.DefaultClient.Do(req)
+  defer res.Body.Close()
+  body, _ := ioutil.ReadAll(res.Body)
+
+  fmt.Println(res)
+  fmt.Println(string(body))
+}`;
+}
+
+async function getTypescriptSchema(endpoint, code) {
+    if (code in endpoint.responses) {
+        return compile(endpoint.responses[code].schema, 'Response', {
+            bannerComment: '',
+            additionalProperties: false,
+            format: true,
+            enableConstEnums: false
+        });
+    }
+}
+
+function getScheme(requirement, document) {
+    const results = [];
+    const schemas = document.components?.securitySchemes ?? {};
+    for (const [key, scopes] of Object.entries(requirement)){
+        if (!(key in schemas)) return [];
+        const schema = noRef(schemas[key]);
+        results.push({
+            ...schema,
+            scopes
+        });
+    }
+    return results;
+}
+
+function Playground({ path, method, ctx }) {
+    let currentId = 0;
+    const bodyContent = noRef(method.requestBody)?.content;
+    const mediaType = bodyContent ? getPreferredType(bodyContent) : undefined;
+    const context = {
+        allowFile: mediaType === 'multipart/form-data',
+        schema: {},
+        nextId () {
+            return String(currentId++);
+        },
+        registered: new WeakMap()
+    };
+    const props = {
+        authorization: getAuthorizationField(method, ctx),
+        method: method.method,
+        route: path,
+        bodyType: mediaType === 'multipart/form-data' ? 'form-data' : 'json',
+        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: bodyContent && mediaType && bodyContent[mediaType].schema ? toSchema(noRef(bodyContent[mediaType].schema), true, context) : undefined,
+        schemas: context.schema
+    };
+    return /*#__PURE__*/ jsx(ctx.renderer.APIPlayground, {
+        ...props
+    });
+}
+function getAuthorizationField(method, ctx) {
+    const security = method.security ?? ctx.document.security ?? [];
+    if (security.length === 0) return;
+    const singular = security.find((requirements)=>Object.keys(requirements).length === 1);
+    if (!singular) return;
+    const scheme = getScheme(singular, ctx.document)[0];
+    return {
+        type: 'string',
+        name: 'Authorization',
+        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.schema[id] = toSchema(schema, required, ctx);
+        return id;
+    }
+    return registered;
+}
+function parameterToField(v, ctx) {
+    return {
+        name: v.name,
+        ...toSchema(noRef(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(noRef(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(noRef(prop), schema.required?.includes(key) ?? false, ctx);
+        });
+        schema.allOf?.forEach((c)=>{
+            const field = toSchema(noRef(c), true, ctx);
+            if (field.type === 'object') Object.assign(properties, field.properties);
+        });
+        const additional = noRef(schema.additionalProperties);
+        let additionalProperties;
+        if (additional && typeof additional === 'object') {
+            if (!additional.type && !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((c, idx)=>{
+                    const item = noRef(c);
+                    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
+        };
+    }
+    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){
+        if (result.length === 0) result.push(c.toLocaleUpperCase());
+        else if (c === '.') result = [];
+        else if (/^[A-Z]$/.test(c) && result.at(-1) !== ' ') result.push(' ', c);
+        else if (c === '-') result.push(' ');
+        else result.push(c);
+    }
+    return result.join('');
+}
+
+const processor = createProcessor({
+    remarkPlugins: [
+        remarkGfm
+    ],
+    rehypePlugins: [
+        rehypeCode
+    ],
+    outputFormat: 'function-body',
+    development: process.env.NODE_ENV === 'development'
+});
+async function Markdown({ text }) {
+    const result = await processor.process({
+        value: text
+    });
+    const jsxRuntime = process.env.NODE_ENV === 'development' ? await import('react/jsx-dev-runtime') : await import('react/jsx-runtime');
+    const fullScope = {
+        opts: jsxRuntime
+    };
+    const keys = Object.keys(fullScope);
+    const values = Object.values(fullScope);
+    const hydrateFn = Reflect.construct(Function, keys.concat(String(result.value)));
+    const rendered = hydrateFn.apply(hydrateFn, values);
+    return /*#__PURE__*/ createElement(rendered.default, {
+        components: defaultMdxComponents
+    });
+}
+
+function heading(depth, child, ctx) {
+    const id = ctx.slugger.slug(child);
+    return /*#__PURE__*/ jsx(Heading, {
+        id: id,
+        as: `h${depth.toString()}`,
+        children: child.trim()
+    }, id);
+}
+
+const keys = {
+    example: 'Example',
+    default: 'Default',
+    minimum: 'Minimum',
+    maximum: 'Maximum',
+    minLength: 'Minimum length',
+    maxLength: 'Maximum length',
+    pattern: 'Pattern',
+    format: 'Format'
+};
+function isObject(schema) {
+    return schema.type === 'object' || schema.properties !== undefined || schema.additionalProperties !== undefined;
+}
+function Schema({ name, schema, ctx }) {
+    if (schema.readOnly === true && !ctx.readOnly || schema.writeOnly === true && !ctx.writeOnly) return null;
+    const parseObject = ctx.parseObject ?? true;
+    const stack = ctx.stack ?? [];
+    const { renderer } = ctx.render;
+    const child = [];
+    function field(key, value) {
+        child.push(/*#__PURE__*/ jsxs("span", {
+            children: [
+                key,
+                ": ",
+                /*#__PURE__*/ jsx("code", {
+                    children: value
+                })
+            ]
+        }, key));
+    }
+    // object type
+    if (isObject(schema) && parseObject) {
+        const { additionalProperties, properties } = schema;
+        if (additionalProperties === true) {
+            child.push(/*#__PURE__*/ jsx(renderer.Property, {
+                name: "[key: string]",
+                type: "any"
+            }, "additionalProperties"));
+        } else if (additionalProperties) {
+            child.push(/*#__PURE__*/ jsx(Schema, {
+                name: "[key: string]",
+                schema: noRef(additionalProperties),
+                ctx: {
+                    ...ctx,
+                    required: false,
+                    parseObject: false
+                }
+            }, "additionalProperties"));
+        }
+        if (properties) {
+            const rendered = Object.entries(properties).map(([key, value])=>{
+                return /*#__PURE__*/ jsx(Schema, {
+                    name: key,
+                    schema: noRef(value),
+                    ctx: {
+                        ...ctx,
+                        required: schema.required?.includes(key) ?? false,
+                        parseObject: false
+                    }
+                }, key);
+            });
+            child.push(...rendered);
+        }
+        return child;
+    }
+    if (schema.description) child.push(/*#__PURE__*/ jsx(Markdown, {
+        text: schema.description
+    }, "description"));
+    for (const [key, value] of Object.entries(keys)){
+        if (key in schema) {
+            field(value, JSON.stringify(schema[key]));
+        }
+    }
+    // enum types
+    if (schema.enum) {
+        field('Value in', schema.enum.map((value)=>JSON.stringify(value)).join(' | '));
+    }
+    if (isObject(schema) && !parseObject) {
+        child.push(/*#__PURE__*/ jsx(renderer.ObjectCollapsible, {
+            name: "Attributes",
+            children: /*#__PURE__*/ jsx(Schema, {
+                name: name,
+                schema: schema,
+                ctx: {
+                    ...ctx,
+                    parseObject: true,
+                    required: false
+                }
+            })
+        }, "attributes"));
+    } else if (schema.allOf) {
+        child.push(/*#__PURE__*/ jsx(renderer.ObjectCollapsible, {
+            name: name,
+            children: /*#__PURE__*/ jsx(Schema, {
+                name: name,
+                schema: combineSchema(schema.allOf.map(noRef)),
+                ctx: {
+                    ...ctx,
+                    parseObject: true,
+                    required: false
+                }
+            })
+        }, "attributes"));
+    } else {
+        const mentionedObjectTypes = [
+            ...schema.anyOf ?? schema.oneOf ?? [],
+            ...schema.not ? [
+                schema.not
+            ] : [],
+            ...schema.type === 'array' ? [
+                schema.items
+            ] : []
+        ].map(noRef).filter((s)=>isComplexType(s) && !stack.includes(s));
+        const renderedMentionedTypes = mentionedObjectTypes.map((s, idx)=>{
+            return /*#__PURE__*/ jsx(renderer.ObjectCollapsible, {
+                name: s.title ?? `Object ${(idx + 1).toString()}`,
+                children: /*#__PURE__*/ jsx(Schema, {
+                    name: "element",
+                    schema: noRef(s),
+                    ctx: {
+                        ...ctx,
+                        stack: [
+                            schema,
+                            ...stack
+                        ],
+                        parseObject: true,
+                        required: false
+                    }
+                })
+            }, `mentioned:${idx.toString()}`);
+        });
+        child.push(...renderedMentionedTypes);
+    }
+    return /*#__PURE__*/ jsx(renderer.Property, {
+        name: name,
+        type: getSchemaType(schema, ctx),
+        deprecated: schema.deprecated,
+        children: child
+    });
+}
+/**
+ * Combine multiple object schemas into one
+ */ function combineSchema(schema) {
+    const result = {
+        type: 'object'
+    };
+    function add(s) {
+        var _result, _result1;
+        (_result = result).properties ?? (_result.properties = {});
+        if (s.properties) {
+            Object.assign(result.properties, s.properties);
+        }
+        (_result1 = result).additionalProperties ?? (_result1.additionalProperties = {});
+        if (s.additionalProperties === true) {
+            result.additionalProperties = true;
+        } else if (s.additionalProperties && typeof result.additionalProperties !== 'boolean') {
+            Object.assign(result.additionalProperties, s.additionalProperties);
+        }
+        if (s.allOf) {
+            add(combineSchema(s.allOf.map(noRef)));
+        }
+    }
+    schema.forEach(add);
+    return result;
+}
+/**
+ * Check if the schema needs another collapsible to explain
+ */ function isComplexType(schema) {
+    if (schema.anyOf ?? schema.oneOf ?? schema.allOf) return true;
+    return isObject(schema) || schema.type === 'array';
+}
+function getSchemaType(schema, ctx) {
+    if (schema.nullable) {
+        const type = getSchemaType({
+            ...schema,
+            nullable: false
+        }, ctx);
+        // null if schema only contains `nullable`
+        return type === 'unknown' ? 'null' : `${type} | null`;
+    }
+    if (schema.title) return schema.title;
+    if (schema.type === 'array') return `array<${getSchemaType(noRef(schema.items), ctx)}>`;
+    if (schema.oneOf) return schema.oneOf.map((one)=>getSchemaType(noRef(one), ctx)).join(' | ');
+    if (schema.allOf) return schema.allOf.map((one)=>getSchemaType(noRef(one), ctx)).join(' & ');
+    if (schema.not) return `not ${getSchemaType(noRef(schema.not), ctx)}`;
+    if (schema.anyOf) {
+        return `Any properties in ${schema.anyOf.map((one)=>getSchemaType(noRef(one), ctx)).join(', ')}`;
+    }
+    if (schema.type === 'string' && schema.format === 'binary' && ctx.allowFile) return 'file';
+    if (schema.type) return schema.type;
+    if (isObject(schema)) return 'object';
+    return 'unknown';
+}
+
+function Operation({ path, method, ctx, hasHead }) {
+    let level = 2;
+    const body = noRef(method.requestBody);
+    const security = method.security ?? ctx.document.security;
+    const info = [];
+    if (hasHead) {
+        info.push(heading(level, method.summary ?? (method.operationId ? idToTitle(method.operationId) : path), ctx));
+        level++;
+        if (method.description) {
+            info.push(/*#__PURE__*/ jsx(Markdown, {
+                text: method.description
+            }, "description"));
+        }
+    }
+    info.push(/*#__PURE__*/ jsx(Playground, {
+        path: path,
+        method: method,
+        ctx: ctx
+    }, "playground"));
+    if (security) {
+        info.push(heading(level, 'Authorization', ctx));
+        info.push(/*#__PURE__*/ jsx(AuthSection, {
+            requirements: security,
+            ctx: ctx
+        }, "auth"));
+    }
+    if (body) {
+        const type = getPreferredType(body.content);
+        if (!type) throw new Error(`No supported media type for body content: ${path}`);
+        info.push(/*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                heading(level, 'Request Body', ctx),
+                /*#__PURE__*/ jsxs("div", {
+                    className: "mb-8 flex flex-row items-center justify-between gap-2",
+                    children: [
+                        /*#__PURE__*/ jsx("code", {
+                            children: type
+                        }),
+                        /*#__PURE__*/ jsx("span", {
+                            children: body.required ? 'Required' : 'Optional'
+                        })
+                    ]
+                }),
+                body.description ? /*#__PURE__*/ jsx(Markdown, {
+                    text: body.description
+                }) : null,
+                /*#__PURE__*/ jsx(Schema, {
+                    name: "body",
+                    schema: noRef(body.content[type].schema ?? {}),
+                    ctx: {
+                        readOnly: method.method === 'GET',
+                        writeOnly: method.method !== 'GET',
+                        required: body.required ?? false,
+                        render: ctx,
+                        allowFile: type === 'multipart/form-data'
+                    }
+                })
+            ]
+        }, "body"));
+    }
+    const parameterGroups = new Map();
+    const endpoint = generateSample(path, method, ctx.baseUrl);
+    for (const param of method.parameters){
+        const pInfo = endpoint.parameters.find((item)=>item.name === param.name && item.in === param.in);
+        if (!pInfo) continue;
+        const schema = pInfo.schema;
+        const groupName = {
+            path: 'Path Parameters',
+            query: 'Query Parameters',
+            header: 'Header Parameters',
+            cookie: 'Cookie Parameters'
+        }[param.in] ?? 'Other Parameters';
+        const group = parameterGroups.get(groupName) ?? [];
+        group.push(/*#__PURE__*/ jsx(Schema, {
+            name: param.name,
+            schema: {
+                ...schema,
+                description: param.description ?? schema.description,
+                deprecated: (param.deprecated ?? false) || (schema.deprecated ?? false)
+            },
+            ctx: {
+                parseObject: false,
+                readOnly: method.method === 'GET',
+                writeOnly: method.method !== 'GET',
+                required: param.required ?? false,
+                render: ctx
+            }
+        }, param.name));
+        parameterGroups.set(groupName, group);
+    }
+    for (const [group, parameters] of Array.from(parameterGroups.entries())){
+        info.push(heading(level, group, ctx), ...parameters);
+    }
+    return /*#__PURE__*/ jsxs(ctx.renderer.API, {
+        children: [
+            /*#__PURE__*/ jsx(ctx.renderer.APIInfo, {
+                method: method.method,
+                route: path,
+                children: info
+            }),
+            /*#__PURE__*/ jsx(APIExample, {
+                method: method,
+                endpoint: endpoint,
+                ctx: ctx
+            })
+        ]
+    });
+}
+async function APIExample({ method, endpoint, ctx }) {
+    const renderer = ctx.renderer;
+    const children = [];
+    const samples = dedupe([
+        {
+            label: 'cURL',
+            source: getSampleRequest$2(endpoint),
+            lang: 'bash'
+        },
+        {
+            label: 'JavaScript',
+            source: getSampleRequest$1(endpoint),
+            lang: 'js'
+        },
+        {
+            label: 'Go',
+            source: getSampleRequest(endpoint),
+            lang: 'go'
+        },
+        ...ctx.generateCodeSamples ? await ctx.generateCodeSamples(endpoint) : [],
+        ...method['x-codeSamples'] ?? []
+    ]);
+    children.push(/*#__PURE__*/ jsx(renderer.Requests, {
+        items: samples.map((s)=>s.label),
+        children: samples.map((s)=>/*#__PURE__*/ jsx(renderer.Request, {
+                name: s.label,
+                code: s.source,
+                language: s.lang
+            }, s.label))
+    }, "requests"));
+    children.push(/*#__PURE__*/ jsx(ResponseTabs, {
+        operation: method,
+        ctx: ctx,
+        endpoint: endpoint
+    }, "responses"));
+    return /*#__PURE__*/ jsx(renderer.APIExample, {
+        children: children
+    });
+}
+/**
+ * Remove duplicated labels
+ */ function dedupe(samples) {
+    const set = new Set();
+    const out = [];
+    for(let i = samples.length - 1; i >= 0; i--){
+        if (set.has(samples[i].label)) continue;
+        set.add(samples[i].label);
+        out.unshift(samples[i]);
+    }
+    return out;
+}
+function AuthSection({ ctx: { document, renderer }, requirements }) {
+    let id = 0;
+    const info = [];
+    for (const requirement of requirements){
+        if (info.length > 0) info.push(`---`);
+        for (const schema of getScheme(requirement, document)){
+            if (schema.type === 'http') {
+                info.push(/*#__PURE__*/ jsxs(renderer.Property, {
+                    name: "Authorization",
+                    type: {
+                        basic: 'Basic <token>',
+                        bearer: 'Bearer <token>'
+                    }[schema.scheme] ?? '<token>',
+                    required: true,
+                    children: [
+                        schema.description ? /*#__PURE__*/ jsx(Markdown, {
+                            text: schema.description
+                        }) : null,
+                        /*#__PURE__*/ jsxs("p", {
+                            children: [
+                                "In: ",
+                                /*#__PURE__*/ jsx("code", {
+                                    children: "header"
+                                })
+                            ]
+                        })
+                    ]
+                }, id++));
+            }
+            if (schema.type === 'oauth2') {
+                info.push(/*#__PURE__*/ jsxs(renderer.Property, {
+                    name: "Authorization",
+                    type: "Bearer <token>",
+                    required: true,
+                    children: [
+                        schema.description ? /*#__PURE__*/ jsx(Markdown, {
+                            text: schema.description
+                        }) : null,
+                        /*#__PURE__*/ jsxs("p", {
+                            children: [
+                                "In: ",
+                                /*#__PURE__*/ jsx("code", {
+                                    children: "header"
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ jsxs("p", {
+                            children: [
+                                "Scope:",
+                                ' ',
+                                /*#__PURE__*/ jsx("code", {
+                                    children: schema.scopes.length > 0 ? schema.scopes.join(', ') : 'none'
+                                })
+                            ]
+                        })
+                    ]
+                }, id++));
+            }
+            if (schema.type === 'apiKey') {
+                info.push(/*#__PURE__*/ jsxs(renderer.Property, {
+                    name: schema.name,
+                    type: "<token>",
+                    children: [
+                        schema.description ? /*#__PURE__*/ jsx(Markdown, {
+                            text: schema.description
+                        }) : null,
+                        /*#__PURE__*/ jsxs("p", {
+                            children: [
+                                "In: ",
+                                /*#__PURE__*/ jsx("code", {
+                                    children: schema.in
+                                })
+                            ]
+                        })
+                    ]
+                }, id++));
+            }
+            if (schema.type === 'openIdConnect') {
+                info.push(/*#__PURE__*/ jsx(renderer.Property, {
+                    name: "OpenID Connect",
+                    type: "<token>",
+                    required: true,
+                    children: schema.description ? /*#__PURE__*/ jsx(Markdown, {
+                        text: schema.description
+                    }) : null
+                }, id++));
+            }
+        }
+    }
+    return info;
+}
+async function ResponseTabs({ endpoint, operation, ctx: { renderer, generateTypeScriptSchema } }) {
+    const items = [];
+    const children = [];
+    for (const code of Object.keys(operation.responses)){
+        const types = [];
+        let description = noRef(operation.responses[code]).description;
+        if (!description && code in endpoint.responses) description = endpoint.responses[code].schema.description ?? '';
+        if (code in endpoint.responses) {
+            types.push({
+                lang: 'json',
+                label: 'Response',
+                code: JSON.stringify(endpoint.responses[code].sample, null, 2)
+            });
+        }
+        let ts;
+        if (generateTypeScriptSchema) {
+            ts = await generateTypeScriptSchema(endpoint, code);
+        } else if (generateTypeScriptSchema === undefined) {
+            ts = await getTypescriptSchema(endpoint, code);
+        }
+        if (ts) {
+            types.push({
+                code: ts,
+                lang: 'ts',
+                label: 'TypeScript'
+            });
+        }
+        items.push(code);
+        children.push(/*#__PURE__*/ jsxs(renderer.Response, {
+            value: code,
+            children: [
+                /*#__PURE__*/ jsx(Markdown, {
+                    text: description
+                }),
+                types.length > 0 ? /*#__PURE__*/ jsx(renderer.ResponseTypes, {
+                    children: types.map((type)=>/*#__PURE__*/ jsx(renderer.ResponseType, {
+                            ...type
+                        }, type.lang))
+                }) : null
+            ]
+        }, code));
+    }
+    if (items.length === 0) return null;
+    return /*#__PURE__*/ jsx(renderer.Responses, {
+        items: items,
+        children: children
+    });
+}
+
+function createMethod(method, operation) {
+    return {
+        ...operation,
+        parameters: operation.parameters ?? [],
+        method: method.toUpperCase()
+    };
+}
+
+const highlighter = await createHighlighter({
+    themes: Object.values(bundledThemes),
+    langs: Object.values(bundledLanguages)
+});
+function CodeBlock({ code, lang, ...props }) {
+    const html = useMemo(()=>{
+        return highlighter.codeToHtml(code, {
+            lang,
+            defaultColor: false,
+            themes: {
+                light: 'github-light',
+                dark: 'github-dark'
+            }
+        });
+    }, [
+        code,
+        lang
+    ]);
+    return /*#__PURE__*/ jsx(Base.CodeBlock, {
+        className: "my-0",
+        children: /*#__PURE__*/ jsx(Base.Pre, {
+            ...props,
+            dangerouslySetInnerHTML: {
+                __html: html
+            }
+        })
+    });
+}
+
+const defaultRenderer = {
+    Root,
+    API,
+    APIInfo,
+    APIExample: APIExample$1,
+    Responses: Tabs,
+    Response: Tab,
+    ResponseTypes: (props)=>/*#__PURE__*/ jsx(Accordions, {
+            type: "single",
+            className: "!-m-4 border-none pt-2",
+            defaultValue: "Response",
+            children: props.children
+        }),
+    ResponseType: (props)=>/*#__PURE__*/ jsx(Accordion, {
+            title: props.label,
+            children: /*#__PURE__*/ jsx(CodeBlock, {
+                code: props.code,
+                lang: props.lang
+            })
+        }),
+    Property,
+    ObjectCollapsible,
+    Requests: Tabs,
+    Request: (props)=>/*#__PURE__*/ jsx(Tab, {
+            value: props.name,
+            children: /*#__PURE__*/ jsx(CodeBlock, {
+                lang: props.language,
+                code: props.code
+            })
+        }),
+    APIPlayground
+};
+
+function APIPage(props) {
+    const { operations, document, hasHead = true } = props;
+    const ctx = getContext(document, props);
+    return /*#__PURE__*/ jsx(ctx.renderer.Root, {
+        baseUrl: ctx.baseUrl,
+        children: operations.map((item)=>{
+            const operation = document.paths[item.path]?.[item.method];
+            if (!operation) return null;
+            const method = createMethod(item.method, operation);
+            return /*#__PURE__*/ jsx(Operation, {
+                method: method,
+                path: item.path,
+                ctx: ctx,
+                hasHead: hasHead
+            }, `${item.path}:${item.method}`);
+        })
+    });
+}
+function getContext(document, options) {
+    return {
+        document,
+        renderer: {
+            ...defaultRenderer,
+            ...options.renderer
+        },
+        generateTypeScriptSchema: options.generateTypeScriptSchema,
+        generateCodeSamples: options.generateCodeSamples,
+        baseUrl: document.servers?.[0].url ?? 'https://example.com',
+        slugger: new Slugger()
+    };
+}
+
+function createOpenAPI(options) {
+    const document = Parser.dereference(options.documentOrPath);
+    return {
+        APIPage: async (props)=>{
+            return /*#__PURE__*/ jsx(APIPage, {
+                document: await document,
+                ...props
+            });
+        }
+    };
+}
+
+cva('rounded border px-1.5 py-1 text-xs font-medium leading-[12px]', {
+    variants: {
+        color: {
+            green: 'border-green-400/50 bg-green-400/20 text-green-600 dark:text-green-400',
+            yellow: 'border-yellow-400/50 bg-yellow-400/20 text-yellow-600 dark:text-yellow-400',
+            red: 'border-red-400/50 bg-red-400/20 text-red-600 dark:text-red-400',
+            blue: 'border-blue-400/50 bg-blue-400/20 text-blue-600 dark:text-blue-400',
+            orange: 'border-orange-400/50 bg-orange-400/20 text-orange-600 dark:text-orange-400'
+        }
+    }
+});
+function getBadgeColor(method) {
+    switch(method){
+        case 'PUT':
+            return 'yellow';
+        case 'PATCH':
+            return 'orange';
+        case 'POST':
+            return 'blue';
+        case 'DELETE':
+            return 'red';
+        default:
+            return 'green';
+    }
+}
+
+/**
+ * Source API Integration
+ *
+ * Add this to page tree builder options
+ */ const attachFile = (node, file)=>{
+    if (!file) return node;
+    const data = file.data.data;
+    if ('method' in data && typeof data.method === 'string') {
+        const color = getBadgeColor(data.method);
+        node.name = /*#__PURE__*/ jsxs(Fragment$1, {
+            children: [
+                node.name,
+                ' ',
+                /*#__PURE__*/ jsx("span", {
+                    className: badgeVariants({
+                        className: 'ms-auto text-nowrap',
+                        color
+                    }),
+                    children: data.method
+                })
+            ]
+        });
+    }
+    return node;
+};
+const badgeVariants = cva('rounded-full border px-1.5 text-xs font-medium', {
+    variants: {
+        color: {
+            green: 'bg-green-400/20 text-green-600 dark:text-green-400',
+            yellow: 'bg-yellow-400/20 text-yellow-600 dark:text-yellow-400',
+            red: 'bg-red-400/20 text-red-600 dark:text-red-400',
+            blue: 'bg-blue-400/20 text-blue-600 dark:text-blue-400',
+            orange: 'bg-orange-400/20 text-orange-600 dark:text-orange-400'
+        }
+    }
+});
+
+export { attachFile, createOpenAPI };