fumadocs-openapi 6.0.1 → 6.0.2

package/dist/render/schema.js

@@ -0,0 +1,151 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isNullable } from '../utils/schema';
+import { combineSchema } from '../utils/combine-schema';
+import { Markdown } from './markdown';
+const keys = {
+    default: 'Default',
+    minimum: 'Minimum',
+    maximum: 'Maximum',
+    minLength: 'Minimum length',
+    maxLength: 'Maximum length',
+    pattern: 'Pattern',
+    format: 'Format',
+};
+function isObject(schema) {
+    return (schema.type === 'object' ||
+        schema.properties !== undefined ||
+        schema.additionalProperties !== undefined);
+}
+export function Schema({ name, schema, ctx, }) {
+    if ((schema.readOnly === true && !ctx.readOnly) ||
+        (schema.writeOnly === true && !ctx.writeOnly))
+        return null;
+    const parseObject = ctx.parseObject ?? true;
+    const stack = ctx.stack ?? [];
+    const { renderer } = ctx.render;
+    // object type
+    if (isObject(schema) &&
+        parseObject &&
+        (schema.additionalProperties || schema.properties)) {
+        let body = null;
+        let footer = null;
+        const { additionalProperties, properties } = schema;
+        if (additionalProperties === true) {
+            footer = _jsx(renderer.Property, { name: "[key: string]", type: "any" });
+        }
+        else if (additionalProperties) {
+            footer = (_jsx(Schema, { name: "[key: string]", schema: additionalProperties, ctx: {
+                    ...ctx,
+                    required: false,
+                    parseObject: false,
+                } }));
+        }
+        if (properties) {
+            body = Object.entries(properties).map(([key, value]) => {
+                return (_jsx(Schema, { name: key, schema: value, ctx: {
+                        ...ctx,
+                        required: schema.required?.includes(key) ?? false,
+                        parseObject: false,
+                    } }, key));
+            });
+        }
+        return (_jsxs("div", { className: "flex flex-col gap-4", children: [body, footer] }));
+    }
+    if (schema.allOf && parseObject) {
+        return (_jsx(Schema, { name: name, schema: combineSchema(schema.allOf), ctx: ctx }));
+    }
+    let footer = null;
+    const fields = [];
+    for (const [key, value] of Object.entries(keys)) {
+        if (key in schema) {
+            fields.push({
+                key: value,
+                value: JSON.stringify(schema[key]),
+            });
+        }
+    }
+    if (schema.enum) {
+        fields.push({
+            key: 'Value in',
+            value: schema.enum.map((value) => JSON.stringify(value)).join(' | '),
+        });
+    }
+    if (isObject(schema) && !parseObject && !stack.includes(schema)) {
+        footer = (_jsx(renderer.ObjectCollapsible, { name: "Show Attributes", children: _jsx(Schema, { name: name, schema: schema, ctx: {
+                    ...ctx,
+                    parseObject: true,
+                    required: false,
+                    stack: [schema, ...stack],
+                } }) }));
+    }
+    else {
+        const mentionedObjectTypes = [
+            ...(schema.anyOf ?? schema.oneOf ?? []),
+            ...(schema.not ? [schema.not] : []),
+            ...(schema.type === 'array' ? [schema.items] : []),
+        ].filter((s) => isComplexType(s) && !stack.includes(s));
+        footer = mentionedObjectTypes.map((s, idx) => {
+            return (_jsx(renderer.ObjectCollapsible, { name: s.title ??
+                    (mentionedObjectTypes.length === 1
+                        ? 'Show Attributes'
+                        : `Object ${idx + 1}`), children: _jsx(Schema, { name: "element", schema: s, ctx: {
+                        ...ctx,
+                        stack: [schema, ...stack],
+                        parseObject: true,
+                        required: false,
+                    } }) }, idx));
+        });
+    }
+    return (_jsxs(renderer.Property, { name: name, type: getSchemaType(schema, ctx), required: ctx.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] }));
+}
+/**
+ * Check if the schema needs another collapsible to explain
+ */
+function isComplexType(schema) {
+    if (schema.anyOf ?? schema.oneOf ?? schema.allOf)
+        return true;
+    return isObject(schema) || schema.type === 'array';
+}
+function getSchemaType(schema, ctx, isRoot = true) {
+    if (isNullable(schema) && isRoot) {
+        const type = getSchemaType(schema, ctx, false);
+        // null if schema only contains `nullable`
+        return type === 'unknown' ? 'null' : `${type} | null`;
+    }
+    if (schema.title)
+        return schema.title;
+    if (schema.type === 'array')
+        return `array<${getSchemaType(schema.items, ctx)}>`;
+    if (schema.oneOf)
+        return schema.oneOf
+            .map((one) => getSchemaType(one, ctx, false))
+            .filter((v) => v !== 'unknown')
+            .join(' | ');
+    if (schema.allOf) {
+        return schema.allOf
+            .map((one) => getSchemaType(one, ctx, false))
+            .filter((v) => v !== 'unknown')
+            .join(' & ');
+    }
+    if (schema.not)
+        return `not ${getSchemaType(schema.not, ctx, false)}`;
+    if (schema.anyOf) {
+        return `Any properties in ${schema.anyOf
+            .map((one) => getSchemaType(one, ctx, false))
+            .filter((v) => v !== 'unknown')
+            .join(', ')}`;
+    }
+    if (schema.type === 'string' && schema.format === 'binary' && ctx.allowFile)
+        return 'file';
+    if (schema.type && Array.isArray(schema.type)) {
+        const nonNullTypes = schema.type.filter((v) => v !== 'null');
+        if (nonNullTypes.length > 0)
+            return nonNullTypes.join(' | ');
+    }
+    else if (schema.type && schema.type !== 'null') {
+        return schema.type;
+    }
+    if (isObject(schema))
+        return 'object';
+    return 'unknown';
+}

package/dist/requests/curl.d.ts

@@ -0,0 +1,3 @@
+import { type EndpointSample } from '../utils/generate-sample';
+export declare function getSampleRequest(endpoint: EndpointSample): string;
+//# sourceMappingURL=curl.d.ts.map

package/dist/requests/curl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curl.d.ts","sourceRoot":"","sources":["../../src/requests/curl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CA0CjE"}

package/dist/requests/curl.js

@@ -0,0 +1,33 @@
+import { inputToString } from '../utils/input-to-string';
+export function getSampleRequest(endpoint) {
+    const s = [];
+    s.push(`curl -X ${endpoint.method} "${endpoint.url}"`);
+    for (const param of endpoint.parameters) {
+        if (param.in === 'header') {
+            const header = `${param.name}: ${param.sample}`;
+            s.push(`-H "${header}"`);
+        }
+        if (param.in === 'cookie') {
+            const cookie = JSON.stringify(`${param.name}=${param.sample}`);
+            s.push(`--cookie ${cookie}`);
+        }
+    }
+    if (endpoint.body?.mediaType === 'multipart/form-data') {
+        const sample = endpoint.body.sample;
+        if (sample && typeof sample === 'object') {
+            for (const [key, value] of Object.entries(sample)) {
+                s.push(`-F ${key}=${inputToString(value)}`);
+            }
+        }
+    }
+    else if (endpoint.body) {
+        s.push(`-H "Content-Type: ${endpoint.body.mediaType}"`);
+        s.push(`-d ${inputToString(endpoint.body.sample, endpoint.body.mediaType, 'single-quote')}`);
+    }
+    return s
+        .flatMap((v, i) => v
+        .split('\n')
+        .map((line) => (i > 0 ? `  ${line}` : line))
+        .join('\n'))
+        .join(' \\\n');
+}

package/dist/requests/go.d.ts

@@ -0,0 +1,3 @@
+import { type EndpointSample } from '../utils/generate-sample';
+export declare function getSampleRequest(endpoint: EndpointSample): string;
+//# sourceMappingURL=go.d.ts.map

package/dist/requests/go.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go.d.ts","sourceRoot":"","sources":["../../src/requests/go.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CA0EjE"}

package/dist/requests/go.js

@@ -0,0 +1,54 @@
+import { inputToString } from '../utils/input-to-string';
+export function getSampleRequest(endpoint) {
+    const imports = ['fmt', 'net/http', 'io/ioutil'];
+    const headers = new Map();
+    const variables = new Map();
+    // additional lines before initializing request
+    const additional = [];
+    for (const p of endpoint.parameters) {
+        if (p.in === 'header')
+            headers.set(p.name, JSON.stringify(p.sample));
+    }
+    const cookies = endpoint.parameters.filter((p) => p.in === 'cookie');
+    variables.set('url', JSON.stringify(endpoint.url));
+    if (cookies.length > 0)
+        headers.set('Cookie', JSON.stringify(cookies.map((p) => `${p.name}=${p.sample}`).join('; ')));
+    if (endpoint.body) {
+        headers.set('Content-Type', `"${endpoint.body.mediaType}"`);
+        if (endpoint.body.mediaType === 'multipart/form-data' &&
+            typeof endpoint.body.sample === 'object') {
+            imports.push('mime/multipart', 'bytes');
+            variables.set('payload', `new(bytes.Buffer)`);
+            variables.set('mp', 'multipart.NewWriter(payload)');
+            for (const [key, value] of Object.entries(endpoint.body.sample ?? {})) {
+                additional.push(`mp.WriteField("${key}", ${inputToString(value, undefined, 'backtick')})`);
+            }
+        }
+        else {
+            imports.push('strings');
+            variables.set('payload', `strings.NewReader(${inputToString(endpoint.body.sample, endpoint.body.mediaType, 'backtick').replaceAll('\n', '\n  ')})`);
+        }
+    }
+    return `package main
+
+import (
+${imports.map((v) => `  "${v}"`).join('\n')}
+)
+
+func main() {
+${Array.from(variables.entries())
+        .map(([k, v]) => `  ${k} := ${v}`)
+        .join('\n')}
+  ${additional.join('\n  ')}
+  req, _ := http.NewRequest("${endpoint.method}", url, ${variables.has('payload') ? 'payload' : 'nil'})
+  ${Array.from(headers.entries())
+        .map(([key, value]) => `req.Header.Add("${key}", ${value})`)
+        .join('\n  ')}
+  res, _ := http.DefaultClient.Do(req)
+  defer res.Body.Close()
+  body, _ := ioutil.ReadAll(res.Body)
+
+  fmt.Println(res)
+  fmt.Println(string(body))
+}`;
+}

package/dist/requests/javascript.d.ts

@@ -0,0 +1,3 @@
+import { type EndpointSample } from '../utils/generate-sample';
+export declare function getSampleRequest(endpoint: EndpointSample): string;
+//# sourceMappingURL=javascript.d.ts.map

package/dist/requests/javascript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../src/requests/javascript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CA4EjE"}

package/dist/requests/javascript.js

@@ -0,0 +1,49 @@
+import { inputToString } from '../utils/input-to-string';
+export function getSampleRequest(endpoint) {
+    const s = [];
+    const options = new Map();
+    const headers = new Map();
+    const cookies = new Map();
+    for (const param of endpoint.parameters) {
+        if (param.in === 'header') {
+            headers.set(param.name, param.sample);
+        }
+        if (param.in === 'cookie') {
+            cookies.set(param.name, param.sample);
+        }
+    }
+    if (cookies.size > 0) {
+        headers.set('cookie', Array.from(cookies.entries())
+            .map(([key, value]) => `${key}=${value}`)
+            .join('; '));
+    }
+    if (headers.size > 0) {
+        options.set('headers', JSON.stringify(Object.fromEntries(headers.entries()), null, 2).replaceAll('\n', '\n  '));
+    }
+    if (endpoint.body?.mediaType === 'multipart/form-data' &&
+        typeof endpoint.body.sample === 'object' &&
+        endpoint.body.sample) {
+        s.push(`const formData = new FormData();`);
+        for (const [key, value] of Object.entries(endpoint.body.sample))
+            s.push(`formData.set(${key}, ${inputToString(value)})`);
+        options.set('body', 'formData');
+    }
+    else if (endpoint.body) {
+        let code;
+        if (endpoint.body.mediaType === 'application/json') {
+            code =
+                typeof endpoint.body.sample === 'string'
+                    ? inputToString(endpoint.body.sample, endpoint.body.mediaType, 'backtick')
+                    : `JSON.stringify(${JSON.stringify(endpoint.body.sample, null, 2)})`;
+        }
+        else {
+            code = inputToString(endpoint.body.sample, endpoint.body.mediaType, 'backtick');
+        }
+        options.set('body', code.replaceAll('\n', '\n  '));
+    }
+    const optionsStr = Array.from(options.entries())
+        .map(([k, v]) => `  ${k}: ${v}`)
+        .join(',\n');
+    s.push(`fetch(${JSON.stringify(endpoint.url)}, {\n${optionsStr}\n});`);
+    return s.join('\n\n');
+}

package/dist/requests/python.d.ts

@@ -0,0 +1,3 @@
+import { type EndpointSample } from '../utils/generate-sample';
+export declare function getSampleRequest(endpoint: EndpointSample): string;
+//# sourceMappingURL=python.d.ts.map

package/dist/requests/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../src/requests/python.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CA8DjE"}

package/dist/requests/python.js

@@ -0,0 +1,45 @@
+import { inputToString } from '../utils/input-to-string';
+export function getSampleRequest(endpoint) {
+    const headers = new Map();
+    const cookies = new Map();
+    const variables = new Map();
+    for (const param of endpoint.parameters) {
+        if (param.in === 'header')
+            headers.set(param.name, param.sample);
+        if (param.in === 'cookie')
+            cookies.set(param.name, param.sample);
+    }
+    if (endpoint.body) {
+        switch (endpoint.body.mediaType) {
+            case 'application/json':
+                variables.set('json', JSON.stringify(endpoint.body.sample, null, 2));
+                break;
+            case 'multipart/form-data':
+                headers.set('Content-Type', endpoint.body.mediaType);
+                variables.set('data', JSON.stringify(endpoint.body.sample, null, 2));
+                break;
+            default:
+                headers.set('Content-Type', endpoint.body.mediaType);
+                variables.set('data', inputToString(endpoint.body.sample, endpoint.body.mediaType, 'backtick'));
+        }
+    }
+    if (headers.size > 0) {
+        variables.set('headers', JSON.stringify(Object.fromEntries(headers.entries()), null, 2));
+    }
+    if (cookies.size > 0) {
+        variables.set('cookies', JSON.stringify(Object.fromEntries(cookies.entries()), null, 2));
+    }
+    return `import requests
+
+url = ${JSON.stringify(endpoint.url)}
+${Array.from(variables.entries())
+        .map(([k, v]) => `${k} = ${v}`)
+        .join('\n')}
+response = requests.request("${endpoint.method}", url${variables.size > 0
+        ? `, ${Array.from(variables.keys())
+            .map((k) => `${k}=${k}`)
+            .join(', ')}`
+        : ''})
+
+print(response.text)`;
+}

package/dist/scalar/client.d.ts

@@ -0,0 +1,6 @@
+export default function ScalarPlayground({ path, method, spec, }: {
+    spec: object;
+    path: string;
+    method: string;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=client.d.ts.map

package/dist/scalar/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/scalar/client.tsx"],"names":[],"mappings":"AAYA,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EACvC,IAAI,EACJ,MAAM,EACN,IAAI,GACL,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,2CA+BA"}

package/dist/scalar/client.js

@@ -0,0 +1,25 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from 'fumadocs-ui/components/api';
+import { buttonVariants } from 'fumadocs-ui/components/ui/button';
+import { ApiClientModalProvider, useApiClientModal, } from '@scalar/api-client-react';
+import { MethodLabel } from '../ui/components/method-label';
+import { useTheme } from 'next-themes';
+import { useEffect, useState } from 'react';
+export default function ScalarPlayground({ path, method, spec, }) {
+    const { resolvedTheme } = useTheme();
+    const [mounted, setMounted] = useState(false);
+    useEffect(() => {
+        setMounted(true);
+    }, []);
+    return (_jsxs("div", { className: cn('flex flex-row items-center gap-2.5 p-3 rounded-xl border bg-fd-card text-fd-card-foreground not-prose', mounted ? `${resolvedTheme}-mode` : null), children: [_jsx(MethodLabel, { className: "text-xs", children: method }), _jsx("code", { className: "flex-1 overflow-auto text-nowrap text-[13px] text-fd-muted-foreground", children: path }), _jsx(ApiClientModalProvider, { configuration: {
+                    themeId: 'moon',
+                    spec: {
+                        content: spec,
+                    },
+                }, children: _jsx(Trigger, { path: path, method: method }) })] }));
+}
+function Trigger({ path, method }) {
+    const client = useApiClientModal();
+    return (_jsx("button", { type: "submit", className: cn(buttonVariants({ color: 'primary', size: 'sm' }), 'px-3 py-1.5'), onClick: () => client?.open({ path, method: method }), children: "Test" }));
+}

package/dist/scalar/index.d.ts

@@ -1,176 +1,7 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { OpenAPIV3_1 } from 'openapi-types';
-import Slugger from 'github-slugger';
-import { ComponentType, ReactNode } from 'react';
-import { CodeToHastOptionsCommon, CodeOptionsThemes, BuiltinTheme } from 'shiki';
-
-type NoReference<T> = T extends (infer I)[] ? NoReference<I>[] : T extends ReferenceObject ? Exclude<T, ReferenceObject> : T extends object ? {
-    [K in keyof T]: NoReference<T[K]>;
-} : T;
-type ParsedSchema = OpenAPIV3_1.SchemaObject;
-
-interface ResponsesProps {
-    items: string[];
-    children: ReactNode;
-}
-interface ResponseProps {
-    value: string;
-    children: ReactNode;
-}
-interface APIInfoProps {
-    method: string;
-    route: string;
-    head: ReactNode;
-    children: ReactNode;
-}
-interface PropertyProps {
-    name: string;
-    type: string;
-    required?: boolean;
-    deprecated?: boolean;
-    children?: ReactNode;
-}
-interface ObjectCollapsibleProps {
-    name: string;
-    children: ReactNode;
-}
-interface RequestProps {
-    language: string;
-    name: string;
-    code: string;
-}
-interface ResponseTypeProps {
-    lang: string;
-    code: string;
-    label: string;
-}
-interface RootProps {
-    baseUrl?: string;
-    servers: ServerObject[];
-    children: ReactNode;
-}
-interface Renderer {
-    Root: ComponentType<RootProps>;
-    API: ComponentType<{
-        children: ReactNode;
-    }>;
-    APIInfo: ComponentType<APIInfoProps>;
-    APIExample: ComponentType<{
-        children: ReactNode;
-    }>;
-    Responses: ComponentType<ResponsesProps>;
-    Response: ComponentType<ResponseProps>;
-    Requests: ComponentType<{
-        items: string[];
-        children: ReactNode;
-    }>;
-    Request: ComponentType<RequestProps>;
-    ResponseTypes: ComponentType<{
-        children: ReactNode;
-    }>;
-    ResponseType: ComponentType<ResponseTypeProps>;
-    /**
-     * Collapsible to show object schemas
-     */
-    ObjectCollapsible: ComponentType<ObjectCollapsibleProps>;
-    Property: ComponentType<PropertyProps>;
-    APIPlayground: ComponentType<{
-        path: string;
-        method: MethodInformation;
-        ctx: RenderContext;
-    }>;
-}
-
-/**
- * Sample info of endpoint
- */
-interface EndpointSample {
-    /**
-     * Request URL, including path and query parameters
-     */
-    url: string;
-    method: string;
-    body?: {
-        schema: ParsedSchema;
-        mediaType: string;
-        sample: unknown;
-    };
-    responses: Record<string, ResponseSample>;
-    parameters: ParameterSample[];
-}
-interface ResponseSample {
-    mediaType: string;
-    sample: unknown;
-    schema: ParsedSchema;
-}
-interface ParameterSample {
-    name: string;
-    in: string;
-    schema: ParsedSchema;
-    sample: unknown;
-}
-
-interface CodeSample {
-    lang: string;
-    label: string;
-    source: string | ((endpoint: EndpointSample) => string | undefined) | false;
-}
-
-type ProcessedDocument = {
-    document: NoReference<Document>;
-    dereferenceMap: DereferenceMap;
-    downloaded: Document;
-};
-
-type Document = OpenAPIV3_1.Document;
-type OperationObject = OpenAPIV3_1.OperationObject;
-type ReferenceObject = OpenAPIV3_1.ReferenceObject;
-type ServerObject = NoReference<OpenAPIV3_1.ServerObject>;
-type MethodInformation = NoReference<OperationObject> & {
-    method: string;
-};
-type Awaitable<T> = T | Promise<T>;
-/**
- * Dereferenced value and its original `$ref` value
- */
-type DereferenceMap = Map<unknown, string>;
-interface RenderContext {
-    /**
-     * The url of proxy to avoid CORS issues
-     */
-    proxyUrl?: string;
-    renderer: Renderer;
-    baseUrl: string;
-    servers: ServerObject[];
-    slugger: Slugger;
-    /**
-     * dereferenced schema
-     */
-    schema: ProcessedDocument;
-    /**
-     * Generate TypeScript definitions from response schema.
-     *
-     * Pass `false` to disable it.
-     *
-     * @param endpoint - the API endpoint
-     * @param code - status code
-     */
-    generateTypeScriptSchema?: ((endpoint: EndpointSample, code: string) => Awaitable<string>) | false;
-    /**
-     * Generate code samples for endpoint.
-     */
-    generateCodeSamples?: (endpoint: EndpointSample) => Awaitable<CodeSample[]>;
-    shikiOptions?: Omit<CodeToHastOptionsCommon, 'lang'> & CodeOptionsThemes<BuiltinTheme>;
-    /**
-     * Show full response schema instead of only example response & Typescript definitions
-     */
-    showResponseSchema?: boolean;
-}
-
-declare function APIPlayground({ path, method, ctx, }: {
+import type { MethodInformation, RenderContext } from '../types';
+export declare function APIPlayground({ path, method, ctx, }: {
     path: string;
     method: MethodInformation;
     ctx: RenderContext;
-}): react_jsx_runtime.JSX.Element;
-
-export { APIPlayground };
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scalar/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAKhE,wBAAgB,aAAa,CAAC,EAC5B,IAAI,EACJ,MAAM,EACN,GAAG,GACJ,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,iBAAiB,CAAC;IAC1B,GAAG,EAAE,aAAa,CAAC;CACpB,2CAIA"}

package/dist/scalar/index.js

@@ -1,13 +1,6 @@
-import { jsx } from 'react/jsx-runtime';
+import { jsx as _jsx } from "react/jsx-runtime";
 import dynamic from 'next/dynamic';
-
-const Client = dynamic(()=>import('./client-client-BXAjVueF.js'));
-function APIPlayground({ path, method, ctx }) {
-    return /*#__PURE__*/ jsx(Client, {
-        method: method.method,
-        path: path,
-        spec: ctx.schema.downloaded
-    });
+const Client = dynamic(() => import('./client'));
+export function APIPlayground({ path, method, ctx, }) {
+    return (_jsx(Client, { method: method.method, path: path, spec: ctx.schema.downloaded }));
 }
-
-export { APIPlayground };

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

@@ -0,0 +1,33 @@
+import type { RenderContext } from '../types';
+import { type Renderer } from '../render/renderer';
+import type { OpenAPIV3_1 } from 'openapi-types';
+import { type DocumentInput, type ProcessedDocument } from '../utils/process-document';
+type ApiPageContextProps = Pick<Partial<RenderContext>, 'shikiOptions' | 'generateTypeScriptSchema' | 'generateCodeSamples' | 'proxyUrl' | 'showResponseSchema'>;
+export interface ApiPageProps extends ApiPageContextProps {
+    document: DocumentInput;
+    hasHead: boolean;
+    renderer?: Partial<Renderer>;
+    /**
+     * An array of operations
+     */
+    operations?: OperationItem[];
+    webhooks?: WebhookItem[];
+    /**
+     * By default, it is disabled on dev mode
+     */
+    disableCache?: boolean;
+}
+export interface WebhookItem {
+    name: string;
+    method: OpenAPIV3_1.HttpMethods;
+}
+export interface OperationItem {
+    path: string;
+    method: OpenAPIV3_1.HttpMethods;
+}
+export declare function APIPage(props: ApiPageProps): Promise<import("react/jsx-runtime").JSX.Element>;
+export declare function getContext(schema: ProcessedDocument, options?: ApiPageContextProps & {
+    renderer?: Partial<Renderer>;
+}): Promise<RenderContext>;
+export {};
+//# sourceMappingURL=api-page.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api-page.d.ts","sourceRoot":"","sources":["../../src/server/api-page.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,EAAiB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,iBAAiB,EACvB,MAAM,0BAA0B,CAAC;AAGlC,KAAK,mBAAmB,GAAG,IAAI,CAC7B,OAAO,CAAC,aAAa,CAAC,EACpB,cAAc,GACd,0BAA0B,GAC1B,qBAAqB,GACrB,UAAU,GACV,oBAAoB,CACvB,CAAC;AAEF,MAAM,WAAW,YAAa,SAAQ,mBAAmB;IACvD,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IAEjB,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE7B;;OAEG;IACH,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAE7B,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IAEzB;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC;CACjC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC;CACjC;AAED,wBAAsB,OAAO,CAAC,KAAK,EAAE,YAAY,oDA0DhD;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,mBAAmB,GAAG;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CACzB,GACL,OAAO,CAAC,aAAa,CAAC,CA8BxB"}