fumadocs-openapi 5.11.8 → 6.0.0

package/dist/server/index.js

@@ -14,7 +14,7 @@ import { Tabs, Tab } from 'fumadocs-ui/components/tabs';
 import { Accordions, Accordion } from 'fumadocs-ui/components/accordion';
 import * as Base from 'fumadocs-ui/components/codeblock';
 import { highlight } from 'fumadocs-core/server';
-import { Root, API, APIInfo, APIExample as APIExample$1, Property, ObjectCollapsible, APIPlayground } from '../ui/index.js';
+import { APIPlayground, Root, API, APIInfo, APIExample as APIExample$1, Property, ObjectCollapsible } from '../ui/index.js';
 import { load, upgrade, dereference } from '@scalar/openapi-parser';
 import { fetchUrls } from '@scalar/openapi-parser/plugins/fetch-urls';
 import { readFiles } from '@scalar/openapi-parser/plugins/read-files';
@@ -54,7 +54,7 @@ function getSecurityPrefix(security) {
     if (security.type === 'oauth2') return 'Bearer';
 }
 
-function generateSample(path, method, { baseUrl, document }) {
+function generateSample(path, method, { baseUrl, schema: { document } }) {
     const params = [];
     const responses = {};
     for (const param of method.parameters ?? []){
@@ -328,173 +328,6 @@ async function getTypescriptSchema(endpoint, code, dereferenceMap) {
     }
 }
 
-function Playground({ path, method, ctx }) {
-    let currentId = 0;
-    const bodyContent = method.requestBody?.content;
-    const mediaType = bodyContent ? getPreferredType(bodyContent) : undefined;
-    const context = {
-        allowFile: mediaType === 'multipart/form-data',
-        references: {},
-        nextId () {
-            return String(currentId++);
-        },
-        registered: new WeakMap(),
-        render: ctx
-    };
-    const bodySchema = bodyContent && mediaType && bodyContent[mediaType].schema ? toSchema(bodyContent[mediaType].schema, true, context) : undefined;
-    const props = {
-        authorization: getAuthorizationField(method, ctx),
-        method: method.method,
-        route: path,
-        path: method.parameters?.filter((v)=>v.in === 'path').map((v)=>parameterToField(v, context)),
-        query: method.parameters?.filter((v)=>v.in === 'query').map((v)=>parameterToField(v, context)),
-        header: method.parameters?.filter((v)=>v.in === 'header').map((v)=>parameterToField(v, context)),
-        body: bodySchema && mediaType ? {
-            ...bodySchema,
-            mediaType: mediaType
-        } : undefined,
-        schemas: context.references,
-        proxyUrl: ctx.proxyUrl
-    };
-    return /*#__PURE__*/ jsx(ctx.renderer.APIPlayground, {
-        ...props
-    });
-}
-function getAuthorizationField(method, ctx) {
-    const security = method.security ?? ctx.document.security ?? [];
-    if (security.length === 0) return;
-    const singular = security.find((requirements)=>Object.keys(requirements).length === 1);
-    if (!singular) return;
-    const scheme = getSecurities(singular, ctx.document)[0];
-    return {
-        type: 'string',
-        name: scheme.type === 'apiKey' ? scheme.name : 'Authorization',
-        authType: scheme.type,
-        defaultValue: scheme.type === 'oauth2' || scheme.type === 'http' && scheme.scheme === 'bearer' ? 'Bearer' : 'Basic',
-        isRequired: security.every((requirements)=>Object.keys(requirements).length > 0),
-        description: 'The Authorization access token'
-    };
-}
-function getIdFromSchema(schema, required, ctx) {
-    const registered = ctx.registered.get(schema);
-    if (registered === undefined) {
-        const id = ctx.nextId();
-        ctx.registered.set(schema, id);
-        ctx.references[id] = toSchema(schema, required, ctx);
-        return id;
-    }
-    return registered;
-}
-function parameterToField(v, ctx) {
-    return {
-        name: v.name,
-        ...toSchema(v.schema ?? {
-            type: 'string'
-        }, v.required ?? false, ctx)
-    };
-}
-function toReference(schema, required, ctx) {
-    return {
-        type: 'ref',
-        isRequired: required,
-        schema: getIdFromSchema(schema, false, ctx)
-    };
-}
-function toSchema(schema, required, ctx) {
-    if (schema.type === 'array') {
-        return {
-            type: 'array',
-            description: schema.description ?? schema.title,
-            isRequired: required,
-            items: getIdFromSchema(schema.items, false, ctx)
-        };
-    }
-    if (schema.type === 'object' || schema.properties !== undefined || schema.allOf !== undefined) {
-        const properties = {};
-        Object.entries(schema.properties ?? {}).forEach(([key, prop])=>{
-            properties[key] = toReference(prop, schema.required?.includes(key) ?? false, ctx);
-        });
-        schema.allOf?.forEach((c)=>{
-            const field = toSchema(c, true, ctx);
-            if (field.type === 'object') Object.assign(properties, field.properties);
-        });
-        const additional = schema.additionalProperties;
-        let additionalProperties;
-        if (additional && typeof additional === 'object') {
-            if ((!additional.type || additional.type.length === 0) && !additional.anyOf && !additional.allOf && !additional.oneOf) {
-                additionalProperties = true;
-            } else {
-                additionalProperties = getIdFromSchema(additional, false, ctx);
-            }
-        } else {
-            additionalProperties = additional;
-        }
-        return {
-            type: 'object',
-            isRequired: required,
-            description: schema.description ?? schema.title,
-            properties,
-            additionalProperties
-        };
-    }
-    if (schema.type === undefined) {
-        const combine = schema.anyOf ?? schema.oneOf;
-        if (combine) {
-            return {
-                type: 'switcher',
-                description: schema.description ?? schema.title,
-                items: Object.fromEntries(combine.map((item, idx)=>{
-                    return [
-                        item.title ?? item.type ?? `Item ${idx.toString()}`,
-                        toReference(item, true, ctx)
-                    ];
-                })),
-                isRequired: required
-            };
-        }
-        return {
-            type: 'null',
-            isRequired: false
-        };
-    }
-    if (ctx.allowFile && schema.type === 'string' && schema.format === 'binary') {
-        return {
-            type: 'file',
-            isRequired: required,
-            description: schema.description ?? schema.title
-        };
-    }
-    if (Array.isArray(schema.type)) {
-        const items = {};
-        for (const type of schema.type){
-            if (type === 'array') {
-                items[type] = {
-                    type,
-                    items: 'items' in schema && schema.items ? toSchema(schema.items, false, ctx) : toSchema({}, required, ctx),
-                    isRequired: required
-                };
-            } else {
-                items[type] = toSchema({
-                    ...schema,
-                    type
-                }, true, ctx);
-            }
-        }
-        return {
-            type: 'switcher',
-            description: schema.description ?? schema.title,
-            items,
-            isRequired: required
-        };
-    }
-    return {
-        type: schema.type === 'integer' ? 'number' : schema.type,
-        defaultValue: schema.example ?? '',
-        isRequired: required,
-        description: schema.description ?? schema.title
-    };
-}
-
 function idToTitle(id) {
     let result = [];
     for (const c of id){
@@ -606,17 +439,18 @@ function Schema({ name, schema, ctx }) {
     const parseObject = ctx.parseObject ?? true;
     const stack = ctx.stack ?? [];
     const { renderer } = ctx.render;
-    const child = [];
     // object type
     if (isObject(schema) && parseObject && (schema.additionalProperties || schema.properties)) {
+        let body = null;
+        let footer = null;
         const { additionalProperties, properties } = schema;
         if (additionalProperties === true) {
-            child.push(/*#__PURE__*/ jsx(renderer.Property, {
+            footer = /*#__PURE__*/ jsx(renderer.Property, {
                 name: "[key: string]",
                 type: "any"
-            }, "additionalProperties"));
+            });
         } else if (additionalProperties) {
-            child.push(/*#__PURE__*/ jsx(Schema, {
+            footer = /*#__PURE__*/ jsx(Schema, {
                 name: "[key: string]",
                 schema: additionalProperties,
                 ctx: {
@@ -624,10 +458,10 @@ function Schema({ name, schema, ctx }) {
                     required: false,
                     parseObject: false
                 }
-            }, "additionalProperties"));
+            });
         }
         if (properties) {
-            const rendered = Object.entries(properties).map(([key, value])=>{
+            body = Object.entries(properties).map(([key, value])=>{
                 return /*#__PURE__*/ jsx(Schema, {
                     name: key,
                     schema: value,
@@ -638,9 +472,14 @@ function Schema({ name, schema, ctx }) {
                     }
                 }, key);
             });
-            child.push(...rendered);
         }
-        return child;
+        return /*#__PURE__*/ jsxs("div", {
+            className: "flex flex-col gap-4",
+            children: [
+                body,
+                footer
+            ]
+        });
     }
     if (schema.allOf && parseObject) {
         return /*#__PURE__*/ jsx(Schema, {
@@ -649,9 +488,7 @@ function Schema({ name, schema, ctx }) {
             ctx: ctx
         });
     }
-    if (schema.description) child.push(/*#__PURE__*/ jsx(Markdown, {
-        text: schema.description
-    }, "description"));
+    let footer = null;
     const fields = [];
     for (const [key, value] of Object.entries(keys$1)){
         if (key in schema) {
@@ -667,21 +504,9 @@ function Schema({ name, schema, ctx }) {
             value: schema.enum.map((value)=>JSON.stringify(value)).join(' | ')
         });
     }
-    if (fields.length > 0) child.push(/*#__PURE__*/ jsx("div", {
-        className: "flex flex-col gap-2",
-        children: fields.map((field)=>/*#__PURE__*/ jsxs("span", {
-                children: [
-                    field.key,
-                    ": ",
-                    /*#__PURE__*/ jsx("code", {
-                        children: field.value
-                    })
-                ]
-            }, field.key))
-    }, "fields"));
     if (isObject(schema) && !parseObject && !stack.includes(schema)) {
-        child.push(/*#__PURE__*/ jsx(renderer.ObjectCollapsible, {
-            name: "Attributes",
+        footer = /*#__PURE__*/ jsx(renderer.ObjectCollapsible, {
+            name: "Show Attributes",
             children: /*#__PURE__*/ jsx(Schema, {
                 name: name,
                 schema: schema,
@@ -695,7 +520,7 @@ function Schema({ name, schema, ctx }) {
                     ]
                 }
             })
-        }, "attributes"));
+        });
     } else {
         const mentionedObjectTypes = [
             ...schema.anyOf ?? schema.oneOf ?? [],
@@ -706,9 +531,9 @@ function Schema({ name, schema, ctx }) {
                 schema.items
             ] : []
         ].filter((s)=>isComplexType(s) && !stack.includes(s));
-        const renderedMentionedTypes = mentionedObjectTypes.map((s, idx)=>{
+        footer = mentionedObjectTypes.map((s, idx)=>{
             return /*#__PURE__*/ jsx(renderer.ObjectCollapsible, {
-                name: s.title ?? `Object ${(idx + 1).toString()}`,
+                name: s.title ?? (mentionedObjectTypes.length === 1 ? 'Show Attributes' : `Object ${idx + 1}`),
                 children: /*#__PURE__*/ jsx(Schema, {
                     name: "element",
                     schema: s,
@@ -722,16 +547,32 @@ function Schema({ name, schema, ctx }) {
                         required: false
                     }
                 })
-            }, `mentioned:${idx.toString()}`);
+            }, idx);
         });
-        child.push(...renderedMentionedTypes);
     }
-    return /*#__PURE__*/ jsx(renderer.Property, {
+    return /*#__PURE__*/ jsxs(renderer.Property, {
         name: name,
         type: getSchemaType(schema, ctx),
         required: ctx.required,
         deprecated: schema.deprecated,
-        children: child
+        children: [
+            schema.description ? /*#__PURE__*/ jsx(Markdown, {
+                text: schema.description
+            }) : null,
+            fields.length > 0 ? /*#__PURE__*/ jsx("div", {
+                className: "flex flex-col gap-2",
+                children: fields.map((field)=>/*#__PURE__*/ jsxs("span", {
+                        children: [
+                            field.key,
+                            ": ",
+                            /*#__PURE__*/ jsx("code", {
+                                children: field.value
+                            })
+                        ]
+                    }, field.key))
+            }) : null,
+            footer
+        ]
     });
 }
 /**
@@ -793,7 +634,7 @@ const methodKeys = [
 
 function Operation({ type = 'operation', path, method, ctx, hasHead, headingLevel = 2 }) {
     const body = method.requestBody;
-    const security = method.security ?? ctx.document.security;
+    const security = method.security ?? ctx.schema.document.security;
     let headNode = null;
     let bodyNode = null;
     let responseNode = null;
@@ -923,7 +764,7 @@ function Operation({ type = 'operation', path, method, ctx, hasHead, headingLeve
         method: method.method,
         route: path,
         children: [
-            type === 'operation' ? /*#__PURE__*/ jsx(Playground, {
+            type === 'operation' ? /*#__PURE__*/ jsx(ctx.renderer.APIPlayground, {
                 path: path,
                 method: method,
                 ctx: ctx
@@ -1053,7 +894,7 @@ function WebhookCallback({ callback, ctx, headingLevel }) {
     }
     return out;
 }
-function AuthSection({ ctx: { document, renderer }, requirements }) {
+function AuthSection({ ctx: { schema: { document }, renderer }, requirements }) {
     let id = 0;
     const info = [];
     for (const requirement of requirements){
@@ -1125,7 +966,7 @@ function AuthSection({ ctx: { document, renderer }, requirements }) {
     }
     return info;
 }
-async function ResponseTabs({ endpoint, operation, ctx: { renderer, generateTypeScriptSchema, dereferenceMap } }) {
+async function ResponseTabs({ endpoint, operation, ctx: { renderer, generateTypeScriptSchema, schema } }) {
     const items = [];
     const children = [];
     if (!operation.responses) return null;
@@ -1144,7 +985,7 @@ async function ResponseTabs({ endpoint, operation, ctx: { renderer, generateType
         if (generateTypeScriptSchema) {
             ts = await generateTypeScriptSchema(endpoint, code);
         } else if (generateTypeScriptSchema === undefined) {
-            ts = await getTypescriptSchema(endpoint, code, dereferenceMap);
+            ts = await getTypescriptSchema(endpoint, code, schema.dereferenceMap);
         }
         if (ts) {
             types.push({
@@ -1192,6 +1033,165 @@ async function CodeBlock({ code, lang, options, ...rest }) {
     });
 }
 
+function Playground({ path, method, ctx }) {
+    let currentId = 0;
+    const bodyContent = method.requestBody?.content;
+    const mediaType = bodyContent ? getPreferredType(bodyContent) : undefined;
+    const context = {
+        allowFile: mediaType === 'multipart/form-data',
+        references: {},
+        nextId () {
+            return String(currentId++);
+        },
+        registered: new WeakMap(),
+        render: ctx
+    };
+    const bodySchema = bodyContent && mediaType && bodyContent[mediaType].schema ? toSchema(bodyContent[mediaType].schema, true, context) : undefined;
+    const props = {
+        authorization: getAuthorizationField(method, ctx),
+        method: method.method,
+        route: path,
+        path: method.parameters?.filter((v)=>v.in === 'path').map((v)=>parameterToField(v, context)),
+        query: method.parameters?.filter((v)=>v.in === 'query').map((v)=>parameterToField(v, context)),
+        header: method.parameters?.filter((v)=>v.in === 'header').map((v)=>parameterToField(v, context)),
+        body: bodySchema && mediaType ? {
+            ...bodySchema,
+            mediaType: mediaType
+        } : undefined,
+        schemas: context.references,
+        proxyUrl: ctx.proxyUrl
+    };
+    return /*#__PURE__*/ jsx(APIPlayground, {
+        ...props
+    });
+}
+function getAuthorizationField(method, { schema: { document } }) {
+    const security = method.security ?? document.security ?? [];
+    if (security.length === 0) return;
+    const singular = security.find((requirements)=>Object.keys(requirements).length === 1);
+    if (!singular) return;
+    return getSecurities(singular, document)[0];
+}
+function getIdFromSchema(schema, required, ctx) {
+    const registered = ctx.registered.get(schema);
+    if (registered === undefined) {
+        const id = ctx.nextId();
+        ctx.registered.set(schema, id);
+        ctx.references[id] = toSchema(schema, required, ctx);
+        return id;
+    }
+    return registered;
+}
+function parameterToField(v, ctx) {
+    return {
+        name: v.name,
+        ...toSchema(v.schema ?? {
+            type: 'string'
+        }, v.required ?? false, ctx)
+    };
+}
+function toReference(schema, required, ctx) {
+    return {
+        type: 'ref',
+        isRequired: required,
+        schema: getIdFromSchema(schema, false, ctx)
+    };
+}
+function toSchema(schema, required, ctx) {
+    if (schema.type === 'array') {
+        return {
+            type: 'array',
+            description: schema.description ?? schema.title,
+            isRequired: required,
+            items: getIdFromSchema(schema.items, false, ctx)
+        };
+    }
+    if (schema.type === 'object' || schema.properties !== undefined || schema.allOf !== undefined) {
+        const properties = {};
+        Object.entries(schema.properties ?? {}).forEach(([key, prop])=>{
+            properties[key] = toReference(prop, schema.required?.includes(key) ?? false, ctx);
+        });
+        schema.allOf?.forEach((c)=>{
+            const field = toSchema(c, true, ctx);
+            if (field.type === 'object') Object.assign(properties, field.properties);
+        });
+        const additional = schema.additionalProperties;
+        let additionalProperties;
+        if (additional && typeof additional === 'object') {
+            if ((!additional.type || additional.type.length === 0) && !additional.anyOf && !additional.allOf && !additional.oneOf) {
+                additionalProperties = true;
+            } else {
+                additionalProperties = getIdFromSchema(additional, false, ctx);
+            }
+        } else {
+            additionalProperties = additional;
+        }
+        return {
+            type: 'object',
+            isRequired: required,
+            description: schema.description ?? schema.title,
+            properties,
+            additionalProperties
+        };
+    }
+    if (schema.type === undefined) {
+        const combine = schema.anyOf ?? schema.oneOf;
+        if (combine) {
+            return {
+                type: 'switcher',
+                description: schema.description ?? schema.title,
+                items: Object.fromEntries(combine.map((item, idx)=>{
+                    return [
+                        item.title ?? item.type ?? `Item ${idx.toString()}`,
+                        toReference(item, true, ctx)
+                    ];
+                })),
+                isRequired: required
+            };
+        }
+        return {
+            type: 'null',
+            isRequired: false
+        };
+    }
+    if (ctx.allowFile && schema.type === 'string' && schema.format === 'binary') {
+        return {
+            type: 'file',
+            isRequired: required,
+            description: schema.description ?? schema.title
+        };
+    }
+    if (Array.isArray(schema.type)) {
+        const items = {};
+        for (const type of schema.type){
+            if (type === 'array') {
+                items[type] = {
+                    type,
+                    items: 'items' in schema && schema.items ? toSchema(schema.items, false, ctx) : toSchema({}, required, ctx),
+                    isRequired: required
+                };
+            } else {
+                items[type] = toSchema({
+                    ...schema,
+                    type
+                }, required, ctx);
+            }
+        }
+        return {
+            type: 'switcher',
+            description: schema.description ?? schema.title,
+            items,
+            isRequired: required
+        };
+    }
+    return {
+        type: schema.type === 'integer' ? 'number' : schema.type,
+        defaultValue: schema.example ?? '',
+        isRequired: required,
+        description: schema.description ?? schema.title
+    };
+}
+
 function createRenders(shikiOptions) {
     return {
         Root: (props)=>/*#__PURE__*/ jsx(Root, {
@@ -1200,7 +1200,12 @@ function createRenders(shikiOptions) {
                 children: props.children
             }),
         API,
-        APIInfo,
+        APIInfo: ({ children, head })=>/*#__PURE__*/ jsxs(APIInfo, {
+                children: [
+                    head,
+                    children
+                ]
+            }),
         APIExample: APIExample$1,
         Responses: Tabs,
         Response: Tab,
@@ -1232,7 +1237,7 @@ function createRenders(shikiOptions) {
                     options: shikiOptions
                 })
             }),
-        APIPlayground
+        APIPlayground: Playground
     };
 }
 
@@ -1258,7 +1263,8 @@ const cache = new Map();
     });
     const processed = {
         document: dereferenced,
-        dereferenceMap
+        dereferenceMap,
+        downloaded: loaded.specification
     };
     if (!disableCache && typeof document === 'string') {
         cache.set(document, processed);
@@ -1316,7 +1322,8 @@ async function APIPage(props) {
         ]
     });
 }
-async function getContext({ document, dereferenceMap }, options = {}) {
+async function getContext(schema, options = {}) {
+    const document = schema.document;
     const servers = document.servers && document.servers.length > 0 ? document.servers : [
         {
             url: 'https://example.com'
@@ -1324,8 +1331,7 @@ async function getContext({ document, dereferenceMap }, options = {}) {
     ];
     const server = servers[0];
     return {
-        document: document,
-        dereferenceMap,
+        schema,
         proxyUrl: options.proxyUrl,
         showResponseSchema: options.showResponseSchema,
         renderer: {

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

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