fumadocs-openapi 10.0.11 → 10.1.0

package/dist/ui/schema/index.js

@@ -1,14 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { FormatFlags, schemaToString } from '../../utils/schema-to-string.js';
-import { combineSchema } from '../../utils/combine-schema.js';
+import { mergeAllOf } from '../../utils/merge-schema.js';
 import { SchemaUILazy } from '../../ui/schema/lazy.js';
-export function Schema({ ctx, root, ...props }) {
+export function Schema({ ctx, ...options }) {
     if (ctx.schemaUI?.render) {
-        return ctx.schemaUI.render({ root, ...props }, ctx);
+        return ctx.schemaUI.render(options, ctx);
     }
-    return (_jsx(SchemaUILazy, { ...props, generated: generateSchemaUI({ ctx, root }) }));
+    return (_jsx(SchemaUILazy, { ...options.client, generated: generateSchemaUI(options, ctx) }));
 }
-export function generateSchemaUI({ ctx, root, }) {
+export function generateSchemaUI({ root, readOnly, writeOnly }, ctx) {
     const refs = {};
     const { showExample = false } = ctx.schemaUI ?? {};
     function generateInfoTags(schema) {
@@ -65,6 +65,15 @@ export function generateSchemaUI({ ctx, root, }) {
         autoIds.set(schema, generated);
         return generated;
     }
+    function isVisible(schema) {
+        if (typeof schema === 'boolean')
+            return true;
+        if (schema.writeOnly)
+            return writeOnly ?? false;
+        if (schema.readOnly)
+            return readOnly ?? false;
+        return true;
+    }
     function base(schema) {
         if (typeof schema === 'boolean') {
             const name = schema ? 'any' : 'never';
@@ -79,8 +88,6 @@ export function generateSchemaUI({ ctx, root, }) {
             typeName: schemaToString(schema, ctx.schema),
             aliasName: schemaToString(schema, ctx.schema, FormatFlags.UseAlias),
             deprecated: schema.deprecated,
-            readOnly: schema.readOnly,
-            writeOnly: schema.writeOnly,
         };
     }
     function scanRefs(id, schema) {
@@ -101,12 +108,11 @@ export function generateSchemaUI({ ctx, root, }) {
             };
             refs[id] = out;
             for (const type of schema.type) {
-                const item = {
+                const key = `${id}_type:${type}`;
+                scanRefs(key, {
                     ...schema,
                     type,
-                };
-                const key = `${id}_type:${type}`;
-                scanRefs(key, item);
+                });
                 out.items.push({
                     name: type,
                     $type: key,
@@ -114,34 +120,64 @@ export function generateSchemaUI({ ctx, root, }) {
             }
             return;
         }
-        if (schema.oneOf) {
+        if (schema.oneOf && schema.anyOf) {
+            const out = {
+                type: 'and',
+                items: [],
+                ...base(schema),
+            };
+            refs[id] = out;
+            const $oneOf = `${id}_oneOf`;
+            const $anyOf = `${id}_anyOf`;
+            scanRefs($oneOf, {
+                ...schema,
+                anyOf: undefined,
+            });
+            scanRefs($anyOf, {
+                ...schema,
+                oneOf: undefined,
+            });
+            out.items.push({
+                name: refs[$oneOf].aliasName,
+                $type: $oneOf,
+            }, {
+                name: refs[$anyOf].aliasName,
+                $type: $anyOf,
+            });
+            return;
+        }
+        // display both `oneOf` & `anyOf` as OR for simplified overview
+        const union = schema.oneOf ?? schema.anyOf;
+        if (union) {
             const out = {
                 type: 'or',
                 items: [],
                 ...base(schema),
             };
             refs[id] = out;
-            for (const item of schema.oneOf) {
-                if (typeof item !== 'object')
+            for (const item of union) {
+                if (typeof item !== 'object' || !isVisible(item))
                     continue;
                 const key = `${id}_extends:${getSchemaId(item)}`;
-                const extended = {
+                scanRefs(key, {
                     ...schema,
+                    oneOf: undefined,
+                    anyOf: undefined,
                     ...item,
-                };
-                delete extended['oneOf'];
-                scanRefs(key, extended);
+                    properties: {
+                        ...schema.properties,
+                        ...item.properties,
+                    },
+                });
                 out.items.push({
                     $type: key,
-                    name: schemaToString(extended, ctx.schema, FormatFlags.UseAlias),
+                    name: refs[key].aliasName,
                 });
             }
             return;
         }
-        const of = schema.allOf ?? schema.anyOf;
-        if (of) {
-            const combined = combineSchema(of);
-            scanRefs(id, combined);
+        if (schema.allOf) {
+            scanRefs(id, mergeAllOf(schema));
             return;
         }
         if (schema.type === 'object') {
@@ -151,10 +187,13 @@ export function generateSchemaUI({ ctx, root, }) {
                 ...base(schema),
             };
             refs[id] = out;
-            const props = Object.entries(schema.properties ?? {});
-            if (schema.patternProperties)
-                props.push(...Object.entries(schema.patternProperties));
+            const { properties = {}, patternProperties, additionalProperties, } = schema;
+            const props = Object.entries(properties);
+            if (patternProperties)
+                props.push(...Object.entries(patternProperties));
             for (const [key, prop] of props) {
+                if (!isVisible(prop))
+                    continue;
                 const $type = getSchemaId(prop);
                 scanRefs($type, prop);
                 out.props.push({
@@ -163,9 +202,10 @@ export function generateSchemaUI({ ctx, root, }) {
                     required: schema.required?.includes(key) ?? false,
                 });
             }
-            if (schema.additionalProperties) {
-                const $type = getSchemaId(schema.additionalProperties);
-                scanRefs($type, schema.additionalProperties);
+            if (additionalProperties !== undefined &&
+                isVisible(additionalProperties)) {
+                const $type = getSchemaId(additionalProperties);
+                scanRefs($type, additionalProperties);
                 out.props.push({
                     $type,
                     name: '[key: string]',

package/dist/utils/deep-equal.d.ts

@@ -0,0 +1,2 @@
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=deep-equal.d.ts.map

package/dist/utils/deep-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-equal.d.ts","sourceRoot":"","sources":["../../src/utils/deep-equal.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAuCzD"}

package/dist/utils/deep-equal.js

@@ -0,0 +1,27 @@
+export function deepEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a == null || b == null) {
+        return false;
+    }
+    if (typeof a !== 'object' || typeof b !== 'object') {
+        return false;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        return a.every((item, index) => deepEqual(item, b[index]));
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return false;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    return keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) &&
+        deepEqual(a[key], b[key]));
+}

package/dist/utils/merge-schema.d.ts

@@ -0,0 +1,7 @@
+import { type ParsedSchema } from '../utils/schema.js';
+/**
+ * Merge `allOf` object schema
+ */
+export declare function mergeAllOf(schema: ParsedSchema): ParsedSchema;
+export declare function intersection(a: ParsedSchema, b: ParsedSchema): ParsedSchema;
+//# sourceMappingURL=merge-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge-schema.d.ts","sourceRoot":"","sources":["../../src/utils/merge-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAS7D;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY,CAgJ3E"}

package/dist/utils/merge-schema.js

@@ -0,0 +1,179 @@
+import { deepEqual } from './deep-equal.js';
+/**
+ * Merge `allOf` object schema
+ */
+export function mergeAllOf(schema) {
+    if (typeof schema === 'boolean' || !schema.allOf)
+        return schema;
+    const { allOf, ...rest } = schema;
+    let result = rest;
+    for (const item of allOf) {
+        result = intersection(result, item);
+    }
+    return result;
+}
+export function intersection(a, b) {
+    a = mergeAllOf(a);
+    b = mergeAllOf(b);
+    if (typeof a === 'boolean' && typeof b === 'boolean')
+        return a && b;
+    if (typeof a === 'boolean')
+        return a;
+    if (typeof b === 'boolean')
+        return b;
+    const result = { ...a };
+    for (const _k in b) {
+        const key = _k;
+        switch (key) {
+            case '$id':
+            case '$comment':
+            case 'description':
+            case 'additionalItems':
+            case 'examples':
+            case 'allOf':
+            case 'writeOnly':
+            case 'readOnly':
+                // ignored
+                break;
+            case 'title': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                if (result[key]) {
+                    result[key] = `${result[key]} & ${value}`;
+                }
+                else {
+                    result[key] = value;
+                }
+                break;
+            }
+            case 'minItems':
+            case 'minimum':
+            case 'exclusiveMinimum':
+            case 'minProperties':
+            case 'minContains':
+            case 'minLength': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                result[key] =
+                    result[key] === undefined ? value : Math.max(result[key], value);
+                break;
+            }
+            case 'maxContains':
+            case 'maxItems':
+            case 'maxLength':
+            case 'maxProperties':
+            case 'maximum':
+            case 'exclusiveMaximum': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                result[key] =
+                    result[key] === undefined ? value : Math.min(result[key], value);
+                break;
+            }
+            // intersection
+            case 'enum':
+            case 'anyOf':
+            case 'oneOf': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                result[key] =
+                    result[key] === undefined
+                        ? value
+                        : intersectArray(result[key], value);
+                break;
+            }
+            // require same
+            case 'format':
+            case 'const':
+            case 'type': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                result[key] ?? (result[key] = value);
+                if (!deepEqual(result[key], value))
+                    return false;
+                break;
+            }
+            // add
+            case 'required': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                result[key] = [...(result[key] ?? []), ...value];
+                break;
+            }
+            case 'properties':
+            case 'patternProperties': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                if (result[key] === undefined) {
+                    result[key] = value;
+                    break;
+                }
+                const out = {};
+                const allProps = new Set();
+                for (const k in result[key])
+                    allProps.add(k);
+                for (const k in value)
+                    allProps.add(k);
+                for (const prop of allProps) {
+                    const aProp = result[key][prop];
+                    const bProp = value[prop];
+                    if (aProp === undefined) {
+                        out[prop] = bProp;
+                    }
+                    else if (bProp === undefined) {
+                        out[prop] = aProp;
+                    }
+                    else {
+                        out[prop] = intersection(aProp, bProp);
+                    }
+                }
+                result[key] = out;
+                break;
+            }
+            case 'additionalProperties':
+            case 'contains':
+            case 'items': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                result[key] =
+                    result[key] === undefined ? value : intersection(result[key], value);
+                break;
+            }
+            case 'not': {
+                const value = b[key];
+                if (value === undefined)
+                    break;
+                if (result[key] && value) {
+                    result.not = { anyOf: [result[key], value] };
+                }
+                else if (value) {
+                    result.not = value;
+                }
+                break;
+            }
+            default:
+                result[key] = b[key];
+        }
+    }
+    return result;
+}
+function intersectArray(a, b) {
+    const out = new Set();
+    for (const item of a) {
+        if (b.includes(item))
+            out.add(item);
+    }
+    for (const item of b) {
+        if (a.includes(item))
+            out.add(item);
+    }
+    return Array.from(out);
+}

package/dist/utils/pages/to-body.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-body.d.ts","sourceRoot":"","sources":["../../../src/utils/pages/to-body.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAoBvD"}
+{"version":3,"file":"to-body.d.ts","sourceRoot":"","sources":["../../../src/utils/pages/to-body.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAmBvD"}

package/dist/utils/pages/to-body.js

@@ -1,18 +1,17 @@
 export function toBody(entry) {
     if (entry.type === 'operation')
         return {
-            hasHead: false,
             document: entry.schemaId,
             operations: [entry.item],
         };
     if (entry.type === 'webhook')
         return {
-            hasHead: false,
             document: entry.schemaId,
             webhooks: [entry.item],
         };
     return {
-        hasHead: true,
+        showTitle: true,
+        showDescription: true,
         document: entry.schemaId,
         operations: entry.operations,
         webhooks: entry.webhooks,

package/dist/utils/pages/to-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-text.d.ts","sourceRoot":"","sources":["../../../src/utils/pages/to-text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,SAAS,CAAC;AAKnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;KACd,EAAE,CAAC;IAEJ;;;;OAIG;IACH,WAAW,CAAC,EAAE,CACZ,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,OAAO,EAAE,eAAe,KACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE7B;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACxC;AAED,wBAAgB,MAAM,CACpB,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,GAAE,kBAAuB,UAuEjC;AAED,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,OAAO,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,kBAAkB,GAC1B,MAAM,CA+BR;AAOD,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"}
+{"version":3,"file":"to-text.d.ts","sourceRoot":"","sources":["../../../src/utils/pages/to-text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,SAAS,CAAC;AAKnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;KACd,EAAE,CAAC;IAEJ;;;;OAIG;IACH,WAAW,CAAC,EAAE,CACZ,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,OAAO,EAAE,eAAe,KACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE7B;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACxC;AAED,wBAAgB,MAAM,CACpB,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,GAAE,kBAAuB,UAqEjC;AAED,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,OAAO,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,kBAAkB,GAC1B,MAAM,CA+BR;AAOD,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"}

package/dist/utils/pages/to-text.js

@@ -7,7 +7,6 @@ export function toText(entry, processed, options = {}) {
         case 'operation':
             return generatePage(entry.schemaId, processed, {
                 operations: [entry.item],
-                hasHead: false,
             }, {
                 ...options,
                 ...entry.info,
@@ -18,7 +17,7 @@ export function toText(entry, processed, options = {}) {
             return generatePage(entry.schemaId, processed, {
                 operations: entry.operations,
                 webhooks: entry.webhooks,
-                hasHead: true,
+                showTitle: true,
             }, {
                 ...options,
                 ...entry.info,
@@ -29,7 +28,7 @@ export function toText(entry, processed, options = {}) {
             return generatePage(entry.schemaId, processed, {
                 operations: entry.operations,
                 webhooks: entry.webhooks,
-                hasHead: true,
+                showTitle: true,
             }, {
                 ...options,
                 ...entry.info,
@@ -40,7 +39,6 @@ export function toText(entry, processed, options = {}) {
         case 'webhook':
             return generatePage(entry.schemaId, processed, {
                 webhooks: [entry.item],
-                hasHead: false,
             }, {
                 ...options,
                 ...entry.info,
@@ -83,7 +81,13 @@ function generatePage(schemaId, processed, pageProps, options, context) {
         const operation = page.operations[0];
         meta = {
             method: operation.method.toUpperCase(),
-            route: operation.path,
+        };
+    }
+    else if (page.webhooks?.length === 1) {
+        const webhook = page.webhooks[0];
+        meta = {
+            method: webhook.method.toUpperCase(),
+            webhook: true,
         };
     }
     const data = generateStaticData(processed.dereferenced, page);
@@ -111,7 +115,7 @@ function generateStaticData(dereferenced, props) {
         const operation = dereferenced.paths?.[item.path]?.[item.method];
         if (!operation)
             continue;
-        if (props.hasHead && operation.operationId) {
+        if (props.showTitle && operation.operationId) {
             const title = operation.summary ??
                 (operation.operationId ? idToTitle(operation.operationId) : item.path);
             const id = slugger.slug(title);
@@ -133,15 +137,26 @@ function generateStaticData(dereferenced, props) {
     }
     return { toc, structuredData };
 }
-function pageContent(props) {
+function pageContent({ showTitle, showDescription, document, webhooks, operations, }) {
+    const propStrs = [`document={${JSON.stringify(document)}}`];
     // filter extra properties in props
-    const operations = (props.operations ?? []).map((item) => ({
-        path: item.path,
-        method: item.method,
-    }));
-    const webhooks = (props.webhooks ?? []).map((item) => ({
-        name: item.name,
-        method: item.method,
-    }));
-    return `<APIPage document={${JSON.stringify(props.document)}} operations={${JSON.stringify(operations)}} webhooks={${JSON.stringify(webhooks)}} hasHead={${JSON.stringify(props.hasHead)}} />`;
+    if (webhooks) {
+        propStrs.push(`webhooks={${JSON.stringify(webhooks.map((item) => ({
+            name: item.name,
+            method: item.method,
+        })))}}`);
+    }
+    if (operations) {
+        propStrs.push(`operations={${JSON.stringify(operations.map((item) => ({
+            path: item.path,
+            method: item.method,
+        })))}}`);
+    }
+    if (showTitle) {
+        propStrs.push(`showTitle={${JSON.stringify(showTitle)}}`);
+    }
+    if (showDescription) {
+        propStrs.push(`showDescription={${JSON.stringify(showDescription)}}`);
+    }
+    return `<APIPage ${propStrs.join(' ')} />`;
 }

package/dist/utils/schema-to-string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-to-string.d.ts","sourceRoot":"","sources":["../../src/utils/schema-to-string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,oBAAY,WAAW;IACrB,IAAI,IAAI;IACR,QAAQ,IAAS;CAClB;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,cAAc,EACrB,GAAG,CAAC,EAAE,iBAAiB,EACvB,KAAK,GAAE,WAA8B,GACpC,MAAM,CAwER"}
+{"version":3,"file":"schema-to-string.d.ts","sourceRoot":"","sources":["../../src/utils/schema-to-string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,oBAAY,WAAW;IACrB,IAAI,IAAI;IACR,QAAQ,IAAS;CAClB;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,cAAc,EACrB,GAAG,CAAC,EAAE,iBAAiB,EACvB,KAAK,GAAE,WAA8B,GACpC,MAAM,CA0ER"}

package/dist/utils/schema-to-string.js

@@ -39,12 +39,15 @@ export function schemaToString(value, ctx, flags = FormatFlags.None) {
         }
         if (schema.type === 'array')
             return `array<${schema.items ? run(schema.items, flags | FormatFlags.UseAlias) : 'unknown'}>`;
-        if (schema.oneOf) {
-            return union(schema.oneOf, ' | ', flags);
+        const or = schema.oneOf ?? schema.anyOf;
+        if (schema.oneOf && schema.anyOf) {
+            return `(${union(schema.oneOf, ' | ', flags)}) & (${union(schema.anyOf, ' | ', flags)})`;
         }
-        const combinedOf = schema.anyOf ?? schema.allOf;
-        if (combinedOf) {
-            return union(combinedOf, ' & ', flags);
+        else if (or) {
+            return union(or, ' | ', flags);
+        }
+        if (schema.allOf) {
+            return union(schema.allOf, ' & ', flags);
         }
         if (schema.not)
             return `not ${run(schema.not, flags)}`;

package/dist/utils/use-query.d.ts

@@ -1,5 +1,6 @@
 export declare function useQuery<I extends unknown[], T>(fn: (...input: I) => Promise<T>): {
     start: (...input: I) => void;
+    reset: () => void;
     data?: T;
     error?: unknown;
     isLoading: boolean;

package/dist/utils/use-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-query.d.ts","sourceRoot":"","sources":["../../src/utils/use-query.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAC7C,EAAE,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAC9B;IACD,KAAK,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC7B,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACpB,CAgCA"}
+{"version":3,"file":"use-query.d.ts","sourceRoot":"","sources":["../../src/utils/use-query.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAC7C,EAAE,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAC9B;IACD,KAAK,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC7B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACpB,CAqCA"}

package/dist/utils/use-query.js

@@ -25,5 +25,10 @@ export function useQuery(fn) {
                 setLoading(false);
             });
         },
+        reset() {
+            setData(undefined);
+            setError(undefined);
+            setLoading(false);
+        },
     }), [error, data, loading]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-openapi",
-  "version": "10.0.11",
+  "version": "10.1.0",
   "description": "Generate MDX docs for your OpenAPI spec",
   "keywords": [
     "NextJs",
@@ -59,7 +59,6 @@
     "ajv": "^8.17.1",
     "class-variance-authority": "^0.7.1",
     "github-slugger": "^2.0.0",
-    "gray-matter": "^4.0.3",
     "hast-util-to-jsx-runtime": "^2.3.6",
     "js-yaml": "^4.1.1",
     "next-themes": "^0.4.6",
@@ -67,10 +66,7 @@
     "react-hook-form": "^7.66.0",
     "remark": "^15.0.1",
     "remark-rehype": "^11.1.2",
-    "tinyglobby": "^0.2.15",
-    "xml-js": "^1.6.11",
-    "fumadocs-core": "16.1.0",
-    "fumadocs-ui": "16.1.0"
+    "xml-js": "^1.6.11"
   },
   "devDependencies": {
     "@scalar/api-client-react": "^1.3.50",
@@ -82,10 +78,14 @@
     "openapi-types": "^12.1.3",
     "tailwindcss": "^4.1.17",
     "tsc-alias": "^1.8.16",
-    "tsconfig": "0.0.0",
-    "eslint-config-custom": "0.0.0"
+    "fumadocs-core": "16.2.0",
+    "fumadocs-ui": "16.2.0",
+    "eslint-config-custom": "0.0.0",
+    "tsconfig": "0.0.0"
   },
   "peerDependencies": {
+    "fumadocs-core": "^16.2.0",
+    "fumadocs-ui": "^16.2.0",
     "@scalar/api-client-react": "*",
     "@types/react": "*",
     "react": "^19.2.0",

package/dist/ui/contexts/operation.d.ts

@@ -1,20 +0,0 @@
-import { type ReactNode } from 'react';
-import type { APIExampleItem } from '../../ui/operation/example-panel/index.js';
-import type { RawRequestData, RequestData } from '../../requests/types.js';
-export type ExampleUpdateListener = (data: RawRequestData, encoded: RequestData) => void;
-export declare function OperationProvider({ route, examples, defaultExampleId, children, }: {
-    route: string;
-    examples: APIExampleItem[];
-    defaultExampleId?: string;
-    children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
-export declare function useOperationContext(): {
-    route: string;
-    examples: APIExampleItem[];
-    example: string | undefined;
-    setExample: (id: string) => void;
-    setExampleData: (data: RawRequestData, encoded: RequestData) => void;
-    addListener: (listener: ExampleUpdateListener) => void;
-    removeListener: (listener: ExampleUpdateListener) => void;
-};
-//# sourceMappingURL=operation.d.ts.map

package/dist/ui/contexts/operation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/ui/contexts/operation.tsx"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpE,MAAM,MAAM,qBAAqB,GAAG,CAClC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,WAAW,KACjB,IAAI,CAAC;AAaV,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,SAAS,CAAC;CACrB,2CAwDA;AAED,wBAAgB,mBAAmB;WA9E1B,MAAM;cACH,cAAc,EAAE;aACjB,MAAM,GAAG,SAAS;gBACf,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI;oBAChB,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,KAAK,IAAI;iBAEvD,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI;oBACtC,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI;EAyE1D"}