fumadocs-openapi 6.0.1 → 6.0.2

package/dist/render/operation.js

@@ -0,0 +1,230 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment } from 'react';
+import { generateSample } from '../utils/generate-sample';
+import * as CURL from '../requests/curl';
+import * as JS from '../requests/javascript';
+import * as Go from '../requests/go';
+import * as Python from '../requests/python';
+import { getPreferredType } from '../utils/schema';
+import { getTypescriptSchema } from '../utils/get-typescript-schema';
+import { getSecurities, getSecurityPrefix } from '../utils/get-security';
+import { idToTitle } from '../utils/id-to-title';
+import { Markdown } from './markdown';
+import { heading } from './heading';
+import { Schema } from './schema';
+import { createMethod } from '../server/create-method';
+import { methodKeys } from '../build-routes';
+export function Operation({ type = 'operation', path, method, ctx, hasHead, headingLevel = 2, }) {
+    const body = method.requestBody;
+    const security = method.security ?? ctx.schema.document.security;
+    let headNode = null;
+    let bodyNode = null;
+    let responseNode = null;
+    let callbacksNode = null;
+    if (hasHead) {
+        const title = method.summary ??
+            (method.operationId ? idToTitle(method.operationId) : path);
+        headNode = (_jsxs(_Fragment, { children: [heading(headingLevel, title, ctx), method.description ? (_jsx(Markdown, { text: method.description }, "description")) : null] }));
+        headingLevel++;
+    }
+    if (body) {
+        const type = getPreferredType(body.content);
+        if (!type)
+            throw new Error(`No supported media type for body content: ${path}`);
+        bodyNode = (_jsxs(_Fragment, { children: [heading(headingLevel, 'Request Body', ctx), _jsxs("div", { className: "mb-8 flex flex-row items-center justify-between gap-2", children: [_jsx("code", { children: type }), _jsx("span", { children: body.required ? 'Required' : 'Optional' })] }), body.description ? _jsx(Markdown, { text: body.description }) : null, _jsx(Schema, { name: "body", schema: body.content[type].schema ?? {}, ctx: {
+                        readOnly: method.method === 'GET',
+                        writeOnly: method.method !== 'GET',
+                        required: body.required ?? false,
+                        render: ctx,
+                        allowFile: type === 'multipart/form-data',
+                    } })] }));
+    }
+    if (method.responses && ctx.showResponseSchema) {
+        responseNode = (_jsxs(_Fragment, { children: [heading(headingLevel, 'Response Body', ctx), Object.entries(method.responses).map(([status, response]) => {
+                    if (!response.content)
+                        return;
+                    const mediaType = getPreferredType(response.content);
+                    if (!mediaType)
+                        return null;
+                    const content = response.content[mediaType];
+                    if (!content.schema)
+                        return null;
+                    return (_jsxs(Fragment, { children: [heading(headingLevel + 1, status, ctx), _jsx(Markdown, { text: response.description }), _jsx(Schema, { name: "response", schema: content.schema, ctx: {
+                                    render: ctx,
+                                    writeOnly: false,
+                                    readOnly: true,
+                                    required: true,
+                                } })] }, status));
+                })] }));
+    }
+    const parameterGroups = new Map();
+    const endpoint = generateSample(path, method, ctx);
+    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(_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);
+    }
+    if (method.callbacks) {
+        callbacksNode = (_jsxs(_Fragment, { children: [heading(headingLevel, 'Webhooks', ctx), Object.entries(method.callbacks).map(([name, callback]) => (_jsx(WebhookCallback, { callback: callback, ctx: ctx, headingLevel: headingLevel }, name)))] }));
+    }
+    const info = (_jsxs(ctx.renderer.APIInfo, { head: headNode, method: method.method, route: path, children: [type === 'operation' ? (_jsx(ctx.renderer.APIPlayground, { path: path, method: method, ctx: ctx })) : null, security ? (_jsxs(_Fragment, { children: [heading(headingLevel, 'Authorization', ctx), _jsx(AuthSection, { requirements: security, ctx: ctx })] })) : null, bodyNode, Array.from(parameterGroups.entries()).map(([group, params]) => {
+                return (_jsxs(Fragment, { children: [heading(headingLevel, group, ctx), params] }, group));
+            }), responseNode, callbacksNode] }));
+    if (type === 'operation') {
+        return (_jsxs(ctx.renderer.API, { children: [info, _jsx(APIExample, { method: method, endpoint: endpoint, ctx: ctx })] }));
+    }
+    else {
+        return info;
+    }
+}
+const defaultSamples = [
+    {
+        label: 'cURL',
+        source: CURL.getSampleRequest,
+        lang: 'bash',
+    },
+    {
+        label: 'JavaScript',
+        source: JS.getSampleRequest,
+        lang: 'js',
+    },
+    {
+        label: 'Go',
+        source: Go.getSampleRequest,
+        lang: 'go',
+    },
+    {
+        label: 'Python',
+        source: Python.getSampleRequest,
+        lang: 'python',
+    },
+];
+async function APIExample({ method, endpoint, ctx, }) {
+    const renderer = ctx.renderer;
+    const children = [];
+    const samples = dedupe([
+        ...defaultSamples,
+        ...(ctx.generateCodeSamples ? await ctx.generateCodeSamples(endpoint) : []),
+        ...(method['x-codeSamples'] ?? []),
+    ]).flatMap((sample) => {
+        if (sample.source === false)
+            return [];
+        const result = typeof sample.source === 'function'
+            ? sample.source(endpoint)
+            : sample.source;
+        if (result === undefined)
+            return [];
+        return {
+            ...sample,
+            source: result,
+        };
+    });
+    if (samples.length > 0) {
+        children.push(_jsx(renderer.Requests, { items: samples.map((s) => s.label), children: samples.map((s) => (_jsx(renderer.Request, { name: s.label, code: s.source, language: s.lang }, s.label))) }, "requests"));
+    }
+    children.push(_jsx(ResponseTabs, { operation: method, ctx: ctx, endpoint: endpoint }, "responses"));
+    return _jsx(renderer.APIExample, { children: children });
+}
+function WebhookCallback({ callback, ctx, headingLevel, }) {
+    return Object.entries(callback).map(([path, pathItem]) => {
+        const pathNodes = methodKeys.map((method) => {
+            const operation = pathItem[method];
+            if (!operation)
+                return null;
+            return (_jsx(Operation, { type: "webhook", hasHead: true, path: path, headingLevel: headingLevel + 1, method: createMethod(method, pathItem, operation), ctx: ctx }, method));
+        });
+        return _jsx(Fragment, { children: pathNodes }, path);
+    });
+}
+/**
+ * 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: { schema: { document }, renderer, }, requirements, }) {
+    let id = 0;
+    const info = [];
+    for (const requirement of requirements) {
+        for (const schema of getSecurities(requirement, document)) {
+            const prefix = getSecurityPrefix(schema);
+            const scopeElement = schema.scopes.length > 0 ? (_jsxs("p", { children: ["Scope: ", _jsx("code", { children: schema.scopes.join(', ') })] })) : null;
+            if (schema.type === 'http' || schema.type === 'oauth2') {
+                info.push(_jsxs(renderer.Property, { name: "Authorization", type: prefix ? `${prefix} <token>` : '<token>', required: true, children: [schema.description ? _jsx(Markdown, { text: schema.description }) : null, _jsxs("p", { children: ["In: ", _jsx("code", { children: "header" })] }), scopeElement] }, id++));
+            }
+            if (schema.type === 'apiKey') {
+                info.push(_jsxs(renderer.Property, { name: schema.name, type: "<token>", children: [schema.description ? _jsx(Markdown, { text: schema.description }) : null, _jsxs("p", { children: ["In: ", _jsx("code", { children: schema.in }), scopeElement] })] }, id++));
+            }
+            if (schema.type === 'openIdConnect') {
+                info.push(_jsxs(renderer.Property, { name: "OpenID Connect", type: "<token>", required: true, children: [schema.description ? _jsx(Markdown, { text: schema.description }) : null, scopeElement] }, id++));
+            }
+        }
+    }
+    return info;
+}
+async function ResponseTabs({ endpoint, operation, ctx: { renderer, generateTypeScriptSchema, schema }, }) {
+    const items = [];
+    const children = [];
+    if (!operation.responses)
+        return null;
+    for (const code of Object.keys(operation.responses)) {
+        const types = [];
+        let description = 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, schema.dereferenceMap);
+        }
+        if (ts) {
+            types.push({
+                code: ts,
+                lang: 'ts',
+                label: 'TypeScript',
+            });
+        }
+        items.push(code);
+        children.push(_jsxs(renderer.Response, { value: code, children: [_jsx(Markdown, { text: description }), types.length > 0 ? (_jsx(renderer.ResponseTypes, { children: types.map((type) => (_jsx(renderer.ResponseType, { ...type }, type.lang))) })) : null] }, code));
+    }
+    if (items.length === 0)
+        return null;
+    return _jsx(renderer.Responses, { items: items, children: children });
+}

package/dist/render/playground.d.ts

@@ -0,0 +1,66 @@
+import type { ReactNode } from 'react';
+import type { MethodInformation, RenderContext } from '../types';
+import { type Security } from '../utils/get-security';
+interface BaseRequestField {
+    name: string;
+    description?: string;
+}
+interface BaseSchema {
+    description?: string;
+    isRequired: boolean;
+}
+export type PrimitiveRequestField = BaseRequestField & PrimitiveSchema;
+interface PrimitiveSchema extends BaseSchema {
+    type: 'boolean' | 'string' | 'number';
+    defaultValue: string;
+}
+export interface ReferenceSchema extends BaseSchema {
+    type: 'ref';
+    schema: string;
+}
+interface ArraySchema extends BaseSchema {
+    type: 'array';
+    /**
+     * Reference to item schema or the schema
+     */
+    items: string | RequestSchema;
+}
+interface FileSchema extends BaseSchema {
+    type: 'file';
+}
+interface ObjectSchema extends BaseSchema {
+    type: 'object';
+    properties: Record<string, RequestSchema | ReferenceSchema>;
+    /**
+     * Reference to schema, or true if it's `any`
+     */
+    additionalProperties?: boolean | string;
+}
+interface SwitcherSchema extends BaseSchema {
+    type: 'switcher';
+    items: Record<string, ReferenceSchema | RequestSchema>;
+}
+interface NullSchema extends BaseSchema {
+    type: 'null';
+}
+export type RequestSchema = PrimitiveSchema | ArraySchema | ObjectSchema | SwitcherSchema | NullSchema | FileSchema;
+export interface APIPlaygroundProps {
+    route: string;
+    method: string;
+    authorization?: Security;
+    path?: PrimitiveRequestField[];
+    query?: PrimitiveRequestField[];
+    header?: PrimitiveRequestField[];
+    body?: RequestSchema & {
+        mediaType: string;
+    };
+    schemas: Record<string, RequestSchema>;
+    proxyUrl?: string;
+}
+export declare function Playground({ path, method, ctx, }: {
+    path: string;
+    method: MethodInformation;
+    ctx: RenderContext;
+}): ReactNode;
+export {};
+//# sourceMappingURL=playground.d.ts.map

package/dist/render/playground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../../src/render/playground.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EACV,iBAAiB,EAEjB,aAAa,EACd,MAAM,SAAS,CAAC;AAMjB,OAAO,EAAiB,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGpE,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,UAAU;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAEvE,UAAU,eAAgB,SAAQ,UAAU;IAC1C,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACtC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,IAAI,EAAE,KAAK,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,WAAY,SAAQ,UAAU;IACtC,IAAI,EAAE,OAAO,CAAC;IACd;;OAEG;IACH,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC;CAC/B;AAED,UAAU,UAAW,SAAQ,UAAU;IACrC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,YAAa,SAAQ,UAAU;IACvC,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe,CAAC,CAAC;IAE5D;;OAEG;IACH,oBAAoB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACzC;AAED,UAAU,cAAe,SAAQ,UAAU;IACzC,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,aAAa,CAAC,CAAC;CACxD;AAED,UAAU,UAAW,SAAQ,UAAU;IACrC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,aAAa,GACrB,eAAe,GACf,WAAW,GACX,YAAY,GACZ,cAAc,GACd,UAAU,GACV,UAAU,CAAC;AAUf,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,QAAQ,CAAC;IACzB,IAAI,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAC/B,KAAK,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAChC,MAAM,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACjC,IAAI,CAAC,EAAE,aAAa,GAAG;QACrB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,UAAU,CAAC,EACzB,IAAI,EACJ,MAAM,EACN,GAAG,GACJ,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,iBAAiB,CAAC;IAC1B,GAAG,EAAE,aAAa,CAAC;CACpB,GAAG,SAAS,CA6CZ"}

package/dist/render/playground.js

@@ -0,0 +1,181 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getPreferredType, } from '../utils/schema';
+import { getSecurities } from '../utils/get-security';
+import { APIPlayground } from '../ui';
+export 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 _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,
+    };
+}

package/dist/render/renderer.d.ts

@@ -0,0 +1,76 @@
+import type { ComponentType, ReactNode } from 'react';
+import type { MethodInformation, RenderContext, ServerObject } from '../types';
+export interface ResponsesProps {
+    items: string[];
+    children: ReactNode;
+}
+export interface ResponseProps {
+    value: string;
+    children: ReactNode;
+}
+export interface APIInfoProps {
+    method: string;
+    route: string;
+    head: ReactNode;
+    children: ReactNode;
+}
+export interface PropertyProps {
+    name: string;
+    type: string;
+    required?: boolean;
+    deprecated?: boolean;
+    children?: ReactNode;
+}
+export interface ObjectCollapsibleProps {
+    name: string;
+    children: ReactNode;
+}
+export interface RequestProps {
+    language: string;
+    name: string;
+    code: string;
+}
+export interface ResponseTypeProps {
+    lang: string;
+    code: string;
+    label: string;
+}
+export interface RootProps {
+    baseUrl?: string;
+    servers: ServerObject[];
+    children: ReactNode;
+}
+export interface Renderer {
+    Root: ComponentType<RootProps>;
+    API: ComponentType<{
+        children: ReactNode;
+    }>;
+    APIInfo: ComponentType<APIInfoProps>;
+    APIExample: ComponentType<{
+        children: ReactNode;
+    }>;
+    Responses: ComponentType<ResponsesProps>;
+    Response: ComponentType<ResponseProps>;
+    Requests: ComponentType<{
+        items: string[];
+        children: ReactNode;
+    }>;
+    Request: ComponentType<RequestProps>;
+    ResponseTypes: ComponentType<{
+        children: ReactNode;
+    }>;
+    ResponseType: ComponentType<ResponseTypeProps>;
+    /**
+     * Collapsible to show object schemas
+     */
+    ObjectCollapsible: ComponentType<ObjectCollapsibleProps>;
+    Property: ComponentType<PropertyProps>;
+    APIPlayground: ComponentType<{
+        path: string;
+        method: MethodInformation;
+        ctx: RenderContext;
+    }>;
+}
+export type { APIPlaygroundProps, RequestSchema, PrimitiveRequestField, ReferenceSchema, } from '../render/playground';
+export declare function createRenders(shikiOptions: RenderContext['shikiOptions']): Renderer;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/render/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/render/renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAYtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG9E,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IAEd,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IAC/B,GAAG,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;IAC5C,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACrC,UAAU,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;IAEnD,SAAS,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACzC,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IACvC,QAAQ,EAAE,aAAa,CAAC;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;IAClE,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACrC,aAAa,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;IACtD,YAAY,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAE/C;;OAEG;IACH,iBAAiB,EAAE,aAAa,CAAC,sBAAsB,CAAC,CAAC;IACzD,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IACvC,aAAa,EAAE,aAAa,CAAC;QAC3B,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,iBAAiB,CAAC;QAC1B,GAAG,EAAE,aAAa,CAAC;KACpB,CAAC,CAAC;CACJ;AAED,YAAY,EACV,kBAAkB,EAClB,aAAa,EACb,qBAAqB,EACrB,eAAe,GAChB,MAAM,qBAAqB,CAAC;AAE7B,wBAAgB,aAAa,CAC3B,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,GAC1C,QAAQ,CA+CV"}

package/dist/render/renderer.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
+import { Accordion, Accordions } from 'fumadocs-ui/components/accordion';
+import { CodeBlock } from '../render/codeblock';
+import { API, Root, APIInfo, APIExample, Property, ObjectCollapsible, } from '../ui';
+import { Playground } from '../render/playground';
+export function createRenders(shikiOptions) {
+    return {
+        Root: (props) => (_jsx(Root, { shikiOptions: shikiOptions, ...props, children: props.children })),
+        API,
+        APIInfo: ({ children, head }) => (_jsxs(APIInfo, { children: [head, children] })),
+        APIExample,
+        Responses: Tabs,
+        Response: Tab,
+        ResponseTypes: (props) => (_jsx(Accordions, { type: "single", className: "!-m-4 border-none pt-2", defaultValue: "Response", children: props.children })),
+        ResponseType: (props) => (_jsx(Accordion, { title: props.label, children: _jsx(CodeBlock, { code: props.code, lang: props.lang, options: shikiOptions }) })),
+        Property,
+        ObjectCollapsible,
+        Requests: (props) => (_jsx(Tabs, { groupId: "fumadocs_openapi_requests", ...props })),
+        Request: (props) => (_jsx(Tab, { value: props.name, children: _jsx(CodeBlock, { lang: props.language, code: props.code, options: shikiOptions }) })),
+        APIPlayground: Playground,
+    };
+}

package/dist/render/schema.d.ts

@@ -0,0 +1,29 @@
+import { type ReactNode } from 'react';
+import { NoReference, type ParsedSchema } from '../utils/schema';
+import type { RenderContext } from '../types';
+interface Context {
+    readOnly: boolean;
+    writeOnly: boolean;
+    required: boolean;
+    /**
+     * Render the full object
+     *
+     * @defaultValue true
+     * */
+    parseObject?: boolean;
+    /**
+     * Parse binary format string to be files
+     *
+     * @defaultValue false
+     */
+    allowFile?: boolean;
+    stack?: ParsedSchema[];
+    render: RenderContext;
+}
+export declare function Schema({ name, schema, ctx, }: {
+    name: string;
+    schema: NoReference<ParsedSchema>;
+    ctx: Context;
+}): ReactNode;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/render/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/render/schema.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAc,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAgB7C,UAAU,OAAO;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IAEnB,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;SAIK;IACL,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IAEvB,MAAM,EAAE,aAAa,CAAC;CACvB;AAUD,wBAAgB,MAAM,CAAC,EACrB,IAAI,EACJ,MAAM,EACN,GAAG,GACJ,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IAClC,GAAG,EAAE,OAAO,CAAC;CACd,GAAG,SAAS,CA8JZ"}