fumadocs-openapi 8.1.12 → 9.0.1

package/dist/render/schema.js

@@ -1,115 +1,174 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment } from 'react';
 import { combineSchema } from '../utils/combine-schema.js';
 import { Markdown } from './markdown.js';
 import { schemaToString } from '../utils/schema-to-string.js';
+import { Tabs, TabsContent, TabsList, TabsTrigger, } from 'fumadocs-ui/components/tabs';
 const keys = {
     default: 'Default',
-    minimum: 'Minimum',
-    maximum: 'Maximum',
-    minLength: 'Minimum length',
-    maxLength: 'Maximum length',
     pattern: 'Pattern',
     format: 'Format',
+    multipleOf: 'Multiple of',
 };
-export function Schema({ name, schema, required = false, parseObject = true, ctx, }) {
-    const { render: { renderer }, stack = [], } = ctx;
-    if (schema === true) {
-        return _jsx(renderer.Property, { name: name, type: "any" });
-    }
-    else if (schema === false) {
-        return _jsx(renderer.Property, { name: name, type: "never" });
-    }
-    if ((schema.readOnly === true && !ctx.readOnly) ||
-        (schema.writeOnly === true && !ctx.writeOnly))
-        return null;
-    if (Array.isArray(schema.type) && schema.type.length === 1) {
-        return (_jsx(Schema, { name: name, required: required, parseObject: parseObject, schema: {
-                ...schema,
-                type: schema.type[0],
-            }, ctx: {
-                ...ctx,
-                stack: [schema, ...stack],
-            } }));
-    }
-    if (schema.allOf || schema.anyOf) {
-        return (_jsx(Schema, { name: name, parseObject: parseObject, required: required, schema: combineSchema([
-                ...(schema.allOf ?? []),
-                ...(schema.anyOf ?? []),
-            ]), ctx: {
-                ...ctx,
-                stack: [schema, ...stack],
-            } }));
-    }
-    // object type
-    if (schema.type === 'object' && parseObject) {
-        const { additionalProperties, patternProperties, properties } = schema;
-        return (_jsxs("div", { className: "flex flex-col gap-4", children: [properties &&
-                    Object.entries(properties).map(([key, value]) => {
-                        return (_jsx(Schema, { name: key, schema: value, parseObject: false, required: schema.required?.includes(key) ?? false, ctx: {
-                                ...ctx,
-                                stack: [schema, ...stack],
-                            } }, key));
-                    }), patternProperties &&
-                    Object.entries(patternProperties).map(([key, value]) => {
-                        return (_jsx(Schema, { name: key, schema: value, parseObject: false, ctx: {
-                                ...ctx,
-                                stack: [schema, ...stack],
-                            } }, key));
-                    }), additionalProperties && (_jsx(Schema, { name: "[key: string]", schema: additionalProperties, parseObject: false, ctx: {
-                        ...ctx,
-                        stack: [schema, ...stack],
-                    } }))] }));
+export function Schema({ name, schema, required = false, readOnly = false, writeOnly = false, as = 'property', ctx: { renderer }, }) {
+    function propertyBody(schema, renderPrimitive, ctx) {
+        if (Array.isArray(schema.type)) {
+            const items = schema.type.flatMap((type) => {
+                const composed = {
+                    ...schema,
+                    type,
+                };
+                if (!isComplexType(composed))
+                    return [];
+                return composed;
+            });
+            if (items.length === 0)
+                return;
+            if (items.length === 1)
+                return propertyBody(items[0], renderPrimitive, ctx);
+            return (_jsxs(Tabs, { defaultValue: items[0].type, children: [_jsx(TabsList, { children: items.map((item) => (_jsx(TabsTrigger, { value: item.type, children: schemaToString(item) }, item.type))) }), items.map((item) => (_jsxs(TabsContent, { value: item.type, children: [item.description && _jsx(Markdown, { text: item.description }), propertyInfo(item), renderPrimitive(item, ctx)] }, item.type)))] }));
+        }
+        if (schema.oneOf) {
+            const oneOf = schema.oneOf.filter((item) => isComplexType(item));
+            if (oneOf.length === 0)
+                return;
+            if (oneOf.length === 1) {
+                return propertyBody(oneOf[0], renderPrimitive, ctx);
+            }
+            return (_jsxs(Tabs, { defaultValue: "0", children: [_jsx(TabsList, { children: oneOf.map((item, i) => (_jsx(TabsTrigger, { value: i.toString(), children: schemaToString(item) }, i))) }), oneOf.map((item, i) => (_jsxs(TabsContent, { value: i.toString(), children: [item.description && _jsx(Markdown, { text: item.description }), propertyInfo(item), propertyBody(item, (child, ctx) => primitiveBody(child, ctx, false, true), ctx)] }, i)))] }));
+        }
+        const of = schema.allOf ?? schema.anyOf;
+        if (of) {
+            const arr = of.filter((item) => !ctx.stack.has(item));
+            if (arr.length === 0)
+                return;
+            const combined = combineSchema(arr);
+            if (typeof combined === 'boolean')
+                return;
+            return renderPrimitive(combined, ctx);
+        }
+        return renderPrimitive(schema, ctx);
     }
-    let footer;
-    const fields = [];
-    for (const [key, value] of Object.entries(keys)) {
-        if (key in schema) {
+    function propertyInfo(schema) {
+        const fields = [];
+        for (const key in keys) {
+            if (key in schema) {
+                fields.push({
+                    key: keys[key],
+                    value: JSON.stringify(schema[key]),
+                });
+            }
+        }
+        let range = getRange('value', schema.minimum, schema.exclusiveMinimum, schema.maximum, schema.exclusiveMaximum);
+        if (range)
+            fields.push({
+                key: 'Range',
+                value: range,
+            });
+        range = getRange('length', schema.minLength, undefined, schema.maxLength, undefined);
+        if (range)
+            fields.push({
+                key: 'Length',
+                value: range,
+            });
+        range = getRange('properties', schema.minProperties, undefined, schema.maxProperties, undefined);
+        if (range)
+            fields.push({
+                key: 'Properties',
+                value: range,
+            });
+        if (schema.enum) {
             fields.push({
-                key: value,
-                value: JSON.stringify(schema[key]),
+                key: 'Value in',
+                value: schema.enum.map((value) => JSON.stringify(value)).join(' | '),
             });
         }
+        if (fields.length === 0)
+            return;
+        return (_jsx("div", { className: "flex flex-col border divide-y divide-fd-border bg-fd-muted rounded-lg not-prose", children: fields.map((field) => (_jsxs("div", { className: "flex items-center text-[13px] px-3 py-2.5 justify-between gap-2", children: [_jsx("span", { className: "font-medium", children: field.key }), _jsx("code", { className: "texxt-xs text-fd-muted-foreground", children: field.value })] }, field.key))) }));
     }
-    if (schema.enum) {
-        fields.push({
-            key: 'Value in',
-            value: schema.enum.map((value) => JSON.stringify(value)).join(' | '),
-        });
-    }
-    if (schema.type === 'object' && !parseObject && !stack.includes(schema)) {
-        footer = (_jsx(renderer.ObjectCollapsible, { name: "Show Attributes", children: _jsx(Schema, { name: name, schema: schema, ctx: {
-                    ...ctx,
-                    stack: [schema, ...stack],
-                } }) }));
+    function primitiveBody(schema, ctx, collapsible, nested) {
+        if (schema.type === 'object') {
+            if (ctx.stack.has(schema))
+                return _jsx("p", { children: "Recursive" });
+            const props = Object.entries(schema.properties ?? {});
+            const patternProps = Object.entries(schema.patternProperties ?? {});
+            const next = {
+                ...ctx,
+                stack: ctx.stack.next(schema),
+            };
+            if (props.length === 0 && patternProps.length === 0)
+                return _jsx("p", { children: "Empty Object" });
+            const children = (_jsxs("div", { className: "flex flex-col gap-4", children: [props.map(([key, value]) => (_jsx(Fragment, { children: property(key, value, next, {
+                            required: schema.required?.includes(key) ?? false,
+                            nested,
+                        }) }, key))), patternProps.map(([key, value]) => (_jsx(Fragment, { children: property(key, value, next, { nested }) }, key))), schema.additionalProperties &&
+                        property('[key: string]', schema.additionalProperties, next, {
+                            nested,
+                        })] }));
+            if (!collapsible)
+                return children;
+            return (_jsx(renderer.ObjectCollapsible, { name: "Show Attributes", children: children }));
+        }
+        if (schema.type === 'array') {
+            const items = schema.items;
+            if (!items || !isComplexType(items) || ctx.stack.has(items))
+                return;
+            const children = (_jsxs("div", { className: "flex flex-col gap-4", children: [items.description && _jsx(Markdown, { text: items.description }), propertyBody(items, (child, ctx) => primitiveBody(child, ctx, false, true), {
+                        ...ctx,
+                        stack: ctx.stack.next(schema),
+                    })] }));
+            return (_jsx(renderer.ObjectCollapsible, { name: "Array Item", children: children }));
+        }
     }
-    else {
-        let mentionedObjectTypes = [];
-        if (Array.isArray(schema.type)) {
-            mentionedObjectTypes.push(...schema.type.map((type) => ({
-                ...schema,
-                type,
-            })));
+    function property(key, schema, ctx, props) {
+        if (schema === true) {
+            return _jsx(renderer.Property, { name: key, type: "any", ...props });
+        }
+        else if (schema === false) {
+            return _jsx(renderer.Property, { name: key, type: "never", ...props });
         }
-        if (schema.oneOf)
-            mentionedObjectTypes.push(...schema.oneOf);
-        if (schema.not)
-            mentionedObjectTypes.push(schema.not);
-        if (schema.type === 'array' && schema.items)
-            mentionedObjectTypes.push(schema.items);
-        mentionedObjectTypes = mentionedObjectTypes.filter((s) => isComplexType(s) && !stack.includes(s));
-        if (mentionedObjectTypes.length > 0)
-            footer = (_jsx("div", { className: "flex flex-col gap-2", children: mentionedObjectTypes.map((s, idx) => {
-                    let title = typeof s === 'object' ? s.title : null;
-                    title ?? (title = mentionedObjectTypes.length === 1
-                        ? 'Show Attributes'
-                        : `Object ${idx + 1}`);
-                    return (_jsx(renderer.ObjectCollapsible, { name: title, children: _jsx(Schema, { name: "element", schema: s, ctx: {
-                                ...ctx,
-                                stack: [schema, ...stack],
-                            } }) }, idx));
-                }) }));
+        if ((schema.readOnly && !readOnly) || (schema.writeOnly && !writeOnly))
+            return;
+        return (_jsxs(renderer.Property, { name: key, type: schemaToString(schema), deprecated: schema.deprecated, ...props, children: [schema.description && _jsx(Markdown, { text: schema.description }), propertyInfo(schema), propertyBody(schema, (child, ctx) => primitiveBody(child, ctx, true, true), ctx)] }));
     }
-    return (_jsxs(renderer.Property, { name: name, type: schemaToString(schema), required: required, deprecated: schema.deprecated, children: [schema.description ? _jsx(Markdown, { text: schema.description }) : null, fields.length > 0 ? (_jsx("div", { className: "flex flex-col gap-2", children: fields.map((field) => (_jsxs("span", { children: [field.key, ": ", _jsx("code", { children: field.value })] }, field.key))) })) : null, footer] }));
+    const context = {
+        stack: schemaStack(),
+    };
+    if (typeof schema === 'boolean' ||
+        as === 'property' ||
+        !isComplexType(schema))
+        return property(name, schema, context, { required });
+    return propertyBody(schema, (child, ctx) => primitiveBody(child, ctx, false, false), context);
+}
+function schemaStack(parent) {
+    const titles = new Set();
+    const history = new WeakSet();
+    return {
+        next(...schemas) {
+            const child = schemaStack(this);
+            for (const item of schemas) {
+                child.add(item);
+            }
+            return child;
+        },
+        add(schema) {
+            if (typeof schema !== 'object')
+                return;
+            if (schema.title)
+                titles.add(schema.title);
+            history.add(schema);
+        },
+        has(schema) {
+            if (typeof schema !== 'object')
+                return false;
+            if (parent && parent.has(schema))
+                return true;
+            if (schema.title && titles.has(schema.title))
+                return true;
+            return history.has(schema);
+        },
+    };
 }
 /**
  * Check if the schema needs another collapsible to explain
@@ -117,7 +176,29 @@ export function Schema({ name, schema, required = false, parseObject = true, ctx
 function isComplexType(schema) {
     if (typeof schema === 'boolean')
         return false;
-    if (schema.anyOf ?? schema.oneOf ?? schema.allOf)
+    const arr = schema.anyOf ?? schema.oneOf ?? schema.allOf;
+    if (arr && arr.some(isComplexType))
         return true;
-    return schema.type === 'object' || schema.type === 'array';
+    return (schema.type === 'object' ||
+        (schema.type === 'array' &&
+            schema.items != null &&
+            isComplexType(schema.items)));
+}
+function getRange(value, min, exclusiveMin, max, exclusiveMax) {
+    const out = [];
+    if (min) {
+        out.push(`${min} <=`);
+    }
+    else if (exclusiveMin) {
+        out.push(`${exclusiveMin} <`);
+    }
+    out.push(value);
+    if (max) {
+        out.push(`<= ${max}`);
+    }
+    else if (exclusiveMax) {
+        out.push(`< ${exclusiveMax}`);
+    }
+    if (out.length > 1)
+        return out.join(' ');
 }

package/dist/server/create.d.ts

@@ -1,12 +1,6 @@
 import type { ApiPageProps } from '../render/api-page.js';
-import type { DocumentInput } from '../utils/process-document.js';
 import { createProxy } from '../server/proxy.js';
-export interface OpenAPIOptions extends Omit<Partial<ApiPageProps>, 'document'> {
-    /**
-     * @deprecated Pass document to `APIPage` instead
-     */
-    documentOrPath?: DocumentInput;
-}
+export type OpenAPIOptions = Omit<Partial<ApiPageProps>, 'document'>;
 export interface OpenAPIServer {
     getAPIPageProps: (from: ApiPageProps) => ApiPageProps;
     createProxy: typeof createProxy;

package/dist/server/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/server/create.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC;IAC/C;;OAEG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC5B,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,YAAY,CAAC;IACtD,WAAW,EAAE,OAAO,WAAW,CAAC;CACjC;AAED,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,aAAa,CAUzE"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/server/create.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,CAAC;AAErE,MAAM,WAAW,aAAa;IAC5B,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,YAAY,CAAC;IACtD,WAAW,EAAE,OAAO,WAAW,CAAC;CACjC;AAED,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,aAAa,CAUzE"}

package/dist/server/proxy.d.ts

@@ -3,6 +3,16 @@ declare const keys: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"];
 type Proxy = {
     [K in (typeof keys)[number]]: (req: NextRequest) => Promise<Response>;
 };
-export declare function createProxy(allowedUrls?: string[]): Proxy;
+interface CreateProxyOptions {
+    allowedUrls?: string[];
+    /**
+     * Override original request/response with yours
+     */
+    overrides?: {
+        request?: (request: Request) => Request;
+        response?: (response: Response) => Response;
+    };
+}
+export declare function createProxy(options?: CreateProxyOptions): Proxy;
 export {};
 //# sourceMappingURL=proxy.d.ts.map

package/dist/server/proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/server/proxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,QAAA,MAAM,IAAI,4DAA6D,CAAC;AAExE,KAAK,KAAK,GAAG;KACV,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC;CACtE,CAAC;AAEF,wBAAgB,WAAW,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,CAoEzD"}
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/server/proxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,QAAA,MAAM,IAAI,4DAA6D,CAAC;AAExE,KAAK,KAAK,GAAG;KACV,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC;CACtE,CAAC;AAEF,UAAU,kBAAkB;IAC1B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAEvB;;OAEG;IACH,SAAS,CAAC,EAAE;QACV,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC;QACxC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,QAAQ,CAAC;KAC7C,CAAC;CACH;AAED,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,KAAK,CA8EnE"}

package/dist/server/proxy.js

@@ -1,5 +1,6 @@
 const keys = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'];
-export function createProxy(allowedUrls) {
+export function createProxy(options = {}) {
+    const { allowedUrls, overrides } = options;
     const handlers = {};
     async function handler(req) {
         const url = req.nextUrl.searchParams.get('url');
@@ -14,11 +15,14 @@ export function createProxy(allowedUrls) {
                 status: 400,
             });
         }
-        const clonedReq = new Request(url, {
+        let clonedReq = new Request(url, {
             ...req,
             cache: 'no-cache',
             mode: 'cors',
         });
+        if (overrides?.request) {
+            clonedReq = overrides.request(clonedReq);
+        }
         clonedReq.headers.forEach((_value, originalKey) => {
             const key = originalKey.toLowerCase();
             const notAllowed = key === 'origin';
@@ -26,12 +30,15 @@ export function createProxy(allowedUrls) {
                 clonedReq.headers.delete(originalKey);
             }
         });
-        const res = await fetch(clonedReq).catch((e) => new Error(e.toString()));
+        let res = await fetch(clonedReq).catch((e) => new Error(e.toString()));
         if (res instanceof Error) {
             return Response.json(`Failed to proxy request: ${res.message}`, {
                 status: 400,
             });
         }
+        if (overrides?.response) {
+            res = overrides.response(res);
+        }
         const headers = new Headers(res.headers);
         headers.forEach((_value, originalKey) => {
             const key = originalKey.toLowerCase();

package/dist/server/source-api.d.ts

@@ -1,8 +1,9 @@
-import type { BuildPageTreeOptions } from 'fumadocs-core/source';
+import type { FileSystem } from 'fumadocs-core/source';
+import type { PageTree } from 'fumadocs-core/server';
 /**
  * Source API Integration
  *
  * Add this to page tree builder options
  */
-export declare const attachFile: BuildPageTreeOptions['attachFile'];
+export declare const attachFile: (node: PageTree.Item, file: FileSystem.PageFile | undefined) => PageTree.Item;
 //# sourceMappingURL=source-api.d.ts.map

package/dist/server/source-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-api.d.ts","sourceRoot":"","sources":["../../src/server/source-api.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAGjE;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,oBAAoB,CAAC,YAAY,CAyBzD,CAAC"}
+{"version":3,"file":"source-api.d.ts","sourceRoot":"","sources":["../../src/server/source-api.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,UAAU,GACrB,MAAM,QAAQ,CAAC,IAAI,EACnB,MAAM,UAAU,CAAC,QAAQ,GAAG,SAAS,KACpC,QAAQ,CAAC,IAyBX,CAAC"}

package/dist/ui/client.js

@@ -8,7 +8,7 @@ export function CopyResponseTypeScript({ code }) {
     const [isChecked, onCopy] = useCopyButton(() => {
         void navigator.clipboard.writeText(code);
     });
-    return (_jsxs("div", { className: "flex items-start justify-between gap-2 bg-fd-card border rounded-xl p-3 not-prose mb-4 last:mb-0", children: [_jsxs("div", { children: [_jsx("p", { className: "font-medium text-fd-foreground mb-2", children: "TypeScript Definitions" }), _jsx("p", { className: "text-xs", children: "Use the response body type in TypeScript." })] }), _jsxs("button", { onClick: onCopy, className: cn(buttonVariants({
+    return (_jsxs("div", { className: "flex items-start justify-between gap-2 bg-fd-card text-fd-card-foreground border rounded-xl p-3 not-prose mb-4 last:mb-0", children: [_jsxs("div", { children: [_jsx("p", { className: "font-medium text-sm mb-2", children: "TypeScript Definitions" }), _jsx("p", { className: "text-xs text-fd-muted-foreground", children: "Use the response body type in TypeScript." })] }), _jsxs("button", { onClick: onCopy, className: cn(buttonVariants({
                     color: 'secondary',
                     className: 'p-2 gap-2',
                     size: 'sm',

package/dist/ui/index.d.ts

@@ -3,7 +3,7 @@ import type { PropertyProps, RootProps } from '../render/renderer.js';
 export declare function Root({ children, className, ctx, ...props }: RootProps & HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
 export declare function APIInfo({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
 export declare function API({ children, ...props }: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
-export declare function Property({ name, type, required, deprecated, children, }: PropertyProps): import("react/jsx-runtime").JSX.Element;
+export declare function Property({ name, type, required, deprecated, nested, ...props }: PropertyProps): import("react/jsx-runtime").JSX.Element;
 export declare function APIExample(props: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
 export declare function ObjectCollapsible(props: {
     name: string;

package/dist/ui/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ui/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAYlE,wBAAgB,IAAI,CAAC,EACnB,QAAQ,EACR,SAAS,EACT,GAAG,EACH,GAAG,KAAK,EACT,EAAE,SAAS,GAAG,cAAc,CAAC,cAAc,CAAC,2CAyB5C;AAED,wBAAgB,OAAO,CAAC,EACtB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,cAAc,CAAC,cAAc,CAAC,2CAMhC;AAED,wBAAgB,GAAG,CAAC,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,cAAc,CAAC,cAAc,CAAC,2CAmBzE;AAED,wBAAgB,QAAQ,CAAC,EACvB,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,QAAQ,GACT,EAAE,aAAa,2CAsBf;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,CAAC,cAAc,CAAC,2CAY/D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,CAAC;CACrB,2CAiBA;AAED,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ui/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAYlE,wBAAgB,IAAI,CAAC,EACnB,QAAQ,EACR,SAAS,EACT,GAAG,EACH,GAAG,KAAK,EACT,EAAE,SAAS,GAAG,cAAc,CAAC,cAAc,CAAC,2CAmB5C;AAED,wBAAgB,OAAO,CAAC,EACtB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,cAAc,CAAC,cAAc,CAAC,2CAMhC;AAED,wBAAgB,GAAG,CAAC,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,cAAc,CAAC,cAAc,CAAC,2CAmBzE;AAED,wBAAgB,QAAQ,CAAC,EACvB,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,MAAM,EACN,GAAG,KAAK,EACT,EAAE,aAAa,2CAyBf;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,CAAC,cAAc,CAAC,2CAY/D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,CAAC;CACrB,2CAmBA;AAED,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/ui/index.js

@@ -6,7 +6,7 @@ import { ApiProvider } from '../ui/lazy.js';
 import { cn } from 'fumadocs-ui/utils/cn';
 import { buttonVariants } from 'fumadocs-ui/components/ui/button';
 export function Root({ children, className, ctx, ...props }) {
-    return (_jsx("div", { className: cn('flex flex-col gap-24 text-sm text-fd-muted-foreground', className), ...props, children: _jsx(ApiProvider, { mediaAdapters: Object.fromEntries(Object.entries(ctx.mediaAdapters).filter(([_, v]) => typeof v !== 'boolean')), servers: ctx.servers, shikiOptions: ctx.shikiOptions, defaultBaseUrl: ctx.baseUrl, children: children }) }));
+    return (_jsx("div", { className: cn('flex flex-col gap-24 text-sm', className), ...props, children: _jsx(ApiProvider, { mediaAdapters: Object.fromEntries(Object.entries(ctx.mediaAdapters).filter(([_, v]) => typeof v !== 'boolean')), servers: ctx.servers, shikiOptions: ctx.shikiOptions, defaultBaseUrl: ctx.baseUrl, children: children }) }));
 }
 export function APIInfo({ className, ...props }) {
     return (_jsx("div", { className: cn('min-w-0 flex-1', className), ...props, children: props.children }));
@@ -17,13 +17,13 @@ export function API({ children, ...props }) {
             ...props.style,
         }, children: children }));
 }
-export function Property({ name, type, required, deprecated, children, }) {
-    return (_jsxs("div", { className: "rounded-xl border bg-fd-card p-3 prose-no-margin", children: [_jsxs("div", { className: "flex flex-row flex-wrap items-center gap-4 mb-2", children: [_jsx("code", { children: name }), required ? (_jsx(Badge, { color: "red", className: "text-xs", children: "Required" })) : null, deprecated ? (_jsx(Badge, { color: "yellow", className: "text-xs", children: "Deprecated" })) : null, _jsx("span", { className: "ms-auto text-xs font-mono text-fd-muted-foreground", children: type })] }), children] }));
+export function Property({ name, type, required, deprecated, nested, ...props }) {
+    return (_jsxs("div", { className: cn('flex flex-col gap-3 text-sm', !nested && 'p-3 border rounded-xl bg-fd-card'), children: [_jsxs("div", { className: "flex flex-wrap items-center gap-3 not-prose", children: [_jsxs("span", { className: "px-1 py-0.5 border rounded-md border-fd-primary/10 bg-fd-primary/10 font-mono text-xs text-fd-primary sm:text-[13px]", children: [name, required === false && '?'] }), _jsx("span", { className: "text-xs me-auto font-mono text-fd-muted-foreground", children: type }), deprecated && (_jsx(Badge, { color: "yellow", className: "text-xs", children: "Deprecated" }))] }), _jsx("div", { className: "prose-no-margin empty:hidden", children: props.children })] }));
 }
 export function APIExample(props) {
     return (_jsx("div", { ...props, className: cn('prose-no-margin md:sticky md:top-(--fd-api-info-top) xl:w-[400px]', props.className), children: props.children }));
 }
 export function ObjectCollapsible(props) {
-    return (_jsxs(Collapsible, { ...props, children: [_jsxs(CollapsibleTrigger, { className: cn(buttonVariants({ color: 'outline', size: 'sm' }), 'group rounded-full px-2 py-1.5 text-fd-muted-foreground'), children: [props.name, _jsx(ChevronDown, { className: "size-4 group-data-[state=open]:rotate-180" })] }), _jsx(CollapsibleContent, { className: "-mx-2", children: _jsx("div", { className: "flex flex-col gap-2 p-2", children: props.children }) })] }));
+    return (_jsxs(Collapsible, { ...props, children: [_jsxs(CollapsibleTrigger, { className: cn(buttonVariants({ color: 'secondary', size: 'sm' }), 'group px-3 py-2 data-[state=open]:rounded-b-none data-[state=open]:border-b-0'), children: [props.name, _jsx(ChevronDown, { className: "size-4 text-fd-muted-foreground group-data-[state=open]:rotate-180" })] }), _jsx(CollapsibleContent, { className: "-me-3", children: _jsx("div", { className: "border-s border-y rounded-b-lg p-3", children: props.children }) })] }));
 }
 export { APIPage } from '../render/api-page.js';

package/dist/utils/combine-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combine-schema.d.ts","sourceRoot":"","sources":["../../src/utils/combine-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CA+DlE"}
+{"version":3,"file":"combine-schema.d.ts","sourceRoot":"","sources":["../../src/utils/combine-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAuDlE"}

package/dist/utils/combine-schema.js

@@ -2,9 +2,9 @@
  * Combine multiple object schemas into one
  */
 export function combineSchema(schema) {
-    let result = {
-        type: undefined,
-    };
+    let result = {};
+    const types = new Set();
+    const title = new Set();
     function add(s) {
         if (typeof s === 'boolean') {
             result = s;
@@ -12,24 +12,23 @@ export function combineSchema(schema) {
         }
         if (typeof result === 'boolean')
             return;
+        if (s.title)
+            title.add(s.title);
         if (s.type) {
-            result.type ?? (result.type = []);
-            if (!Array.isArray(result.type)) {
-                result.type = [result.type];
-            }
             for (const v of Array.isArray(s.type) ? s.type : [s.type]) {
-                if (Array.isArray(result.type) && !result.type.includes(v)) {
-                    result.type.push(v);
-                }
+                types.add(v);
             }
         }
-        if (s.properties) {
-            result.properties ?? (result.properties = {});
-            Object.assign(result.properties, s.properties);
+        for (const key of ['oneOf', 'required', 'enum']) {
+            if (!s[key])
+                continue;
+            result[key] = [...s[key], ...(result[key] ?? [])];
         }
-        if (s.patternProperties) {
-            result.patternProperties ?? (result.patternProperties = {});
-            Object.assign(result.patternProperties, s.patternProperties);
+        for (const key of ['properties', 'patternProperties']) {
+            if (!s[key])
+                continue;
+            result[key] ?? (result[key] = {});
+            Object.assign(result[key], s[key]);
         }
         if (s.additionalProperties === true) {
             result.additionalProperties = true;
@@ -39,18 +38,14 @@ export function combineSchema(schema) {
             result.additionalProperties ?? (result.additionalProperties = {});
             Object.assign(result.additionalProperties, s.additionalProperties);
         }
-        if (s.required) {
-            result.required ?? (result.required = []);
-            result.required.push(...s.required);
-        }
-        if (s.enum && s.enum.length > 0) {
-            result.enum ?? (result.enum = []);
-            result.enum.push(...s.enum);
-        }
-        if (s.allOf) {
-            s.allOf.forEach(add);
-        }
+        (s.allOf ?? s.anyOf)?.forEach(add);
     }
     schema.forEach(add);
+    if (title.size > 0)
+        result.title = Array.from(title).join(' & ');
+    if (types.size > 0) {
+        const typeArr = Array.from(types.values());
+        result.type = typeArr.length === 1 ? typeArr[0] : typeArr;
+    }
     return result;
 }

package/dist/utils/generate-document.d.ts

@@ -1,7 +1,7 @@
 import type { ApiPageProps } from '../render/api-page.js';
 import type { GenerateOptions } from '../generate.js';
-import type { Document, TagObject } from '../types.js';
-import type { NoReference } from '../utils/schema.js';
+import type { TagObject } from '../types.js';
+import type { DocumentInput, ProcessedDocument } from '../utils/process-document.js';
 export type DocumentContext = {
     type: 'tag';
     tag: TagObject | undefined;
@@ -10,11 +10,8 @@ export type DocumentContext = {
 } | {
     type: 'file';
 };
-export declare function generateDocument(options: GenerateOptions & {
-    dereferenced: NoReference<Document>;
-    page: ApiPageProps;
+export declare function generateDocument(input: DocumentInput, processed: ProcessedDocument, pageProps: Omit<ApiPageProps, 'document'>, options: GenerateOptions & {
     title: string;
     description?: string;
-    context: DocumentContext;
-}): string;
+}, context: DocumentContext): string;
 //# sourceMappingURL=generate-document.d.ts.map

package/dist/utils/generate-document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-document.d.ts","sourceRoot":"","sources":["../../src/utils/generate-document.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAOlD,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,SAAS,GAAG,SAAS,CAAC;CAC5B,GACD;IACE,IAAI,EAAE,WAAW,CAAC;CACnB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,eAAe,GAAG;IACzB,YAAY,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,eAAe,CAAC;CAC1B,GACA,MAAM,CAkER"}
+{"version":3,"file":"generate-document.d.ts","sourceRoot":"","sources":["../../src/utils/generate-document.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AAOlC,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,SAAS,GAAG,SAAS,CAAC;CAC5B,GACD;IACE,IAAI,EAAE,WAAW,CAAC;CACnB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,iBAAiB,EAC5B,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,EACzC,OAAO,EAAE,eAAe,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,EACD,OAAO,EAAE,eAAe,GACvB,MAAM,CAkER"}

package/dist/utils/generate-document.js

@@ -1,19 +1,23 @@
 import { dump } from 'js-yaml';
 import Slugger from 'github-slugger';
 import { idToTitle } from '../utils/id-to-title.js';
-export function generateDocument(options) {
+export function generateDocument(input, processed, pageProps, options, context) {
     const { frontmatter, includeDescription = false, addGeneratedComment = true, } = options;
     const out = [];
-    const extend = frontmatter?.(options.title, options.description, options.context);
+    const extend = frontmatter?.(options.title, options.description, context);
+    const page = {
+        ...pageProps,
+        document: options.inlineDocument ? processed.downloaded : input,
+    };
     let meta;
-    if (options.page.operations?.length === 1) {
-        const operation = options.page.operations[0];
+    if (page.operations?.length === 1) {
+        const operation = page.operations[0];
         meta = {
             method: operation.method.toUpperCase(),
             route: operation.path,
         };
     }
-    const data = generateStaticData(options.dereferenced, options.page);
+    const data = generateStaticData(processed.document, page);
     const banner = dump({
         title: options.title,
         description: !includeDescription ? options.description : undefined,
@@ -43,7 +47,7 @@ export function generateDocument(options) {
     }
     if (options.description && includeDescription)
         out.push(options.description);
-    out.push(pageContent(options.page));
+    out.push(pageContent(page));
     return out.join('\n\n');
 }
 function generateStaticData(dereferenced, props) {

package/dist/utils/process-document.d.ts

@@ -10,5 +10,5 @@ export type ProcessedDocument = {
 /**
  * process & reference input document to a Fumadocs OpenAPI compatible format
  */
-export declare function processDocument(document: DocumentInput, disableCache?: boolean): Promise<ProcessedDocument>;
+export declare function processDocument(input: DocumentInput, disableCache?: boolean): Promise<ProcessedDocument>;
 //# sourceMappingURL=process-document.d.ts.map