@redocly/openapi-docs 3.12.0-rc.7 → 3.12.1

package/lib/components/PropertyDetails/cycleColorsByLevel.js

@@ -1 +1,18 @@
-const C=e=>{if(e===void 0)return;const n=["#9D00FF","#615CEA","#147DF5","#08BFCC","#08CC7A","#81CC08","#E5BE00","#FF8700","#FF00B8"];return n[e%n.length]};export{C as cycleColorsByLevel};
+export const cycleColorsByLevel = (level) => {
+    if (level === undefined) {
+        return undefined;
+    }
+    const levelColors = [
+        '#9D00FF',
+        '#615CEA',
+        '#147DF5',
+        '#08BFCC',
+        '#08CC7A',
+        '#81CC08',
+        '#E5BE00',
+        '#FF8700',
+        '#FF00B8',
+    ];
+    return levelColors[level % levelColors.length];
+};
+//# sourceMappingURL=cycleColorsByLevel.js.map

package/lib/components/PropertyDetails/index.js

@@ -1 +1,4 @@
-import{PropertyDetails as r}from"./PropertyDetails.js";import{FieldDetails as i}from"./FieldDetails.js";import{Extensions as s}from"./Extensions.js";export{s as Extensions,i as FieldDetails,r as PropertyDetails};
+export { PropertyDetails } from './PropertyDetails.js';
+export { FieldDetails } from './FieldDetails.js';
+export { Extensions } from './Extensions.js';
+//# sourceMappingURL=index.js.map

package/lib/components/PropertyDetails/styled.js

@@ -1,22 +1,30 @@
-import{Markdown as o}from"@redocly/theme/components/Markdown/Markdown";import{styled as e}from"../../styled-components.js";const i=e(o)`
+import { Markdown as MarkdownWrapper } from '@redocly/theme/components/Markdown/Markdown';
+import { styled } from '../../styled-components.js';
+export const DescriptionEnumsBlock = styled(MarkdownWrapper) `
   table.md {
     margin: var(--spacing-xs) 0 0;
   }
-`,p=e.div`
+`;
+export const TypeWrapper = styled.div `
   line-height: 20px;
-`,a=e.label`
+`;
+export const ExampleSummary = styled.label `
   display: block;
   font-size: inherit;
   margin-bottom: 0.2em;
   font-weight: var(--font-weight-bold);
-`,n=e.div`
+`;
+export const ExampleWrap = styled.div `
   margin-top: 1em;
   font-size: var(--field-name-font-size);
-`,m=e.div`
+`;
+export const ExamplesList = styled.div `
   padding-left: 1.5em;
   margin-bottom: 1em;
-`,s=e.div`
+`;
+export const FieldDescriptionWrapper = styled.div `
   p {
     overflow-wrap: anywhere;
   }
-`;export{i as DescriptionEnumsBlock,a as ExampleSummary,n as ExampleWrap,m as ExamplesList,s as FieldDescriptionWrapper,p as TypeWrapper};
+`;
+//# sourceMappingURL=styled.js.map

package/lib/components/PropertyDetails/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/components/RedoclyOpenAPIDocs/Providers.js

@@ -1 +1,114 @@
-import{jsx as d}from"react/jsx-runtime";import{memo as v,useCallback as b,useEffect as g,useMemo as y}from"react";import S from"@markdoc/markdoc";import{LayoutVariant as O}from"@redocly/config";import{createStore as E,Provider as A}from"jotai";import{Heading as N}from"@redocly/theme/markdoc/components/Heading/Heading";import{normalizeOptions as D,OpenAPIParser as j}from"../../services/index.js";import{getMarkdownHeaderId as k}from"./utils.js";import{normalizeServers as x}from"../../utils/index.js";import{SchemaDefinition as C}from"../SchemaDefinition/index.js";import{appStore as P,appStoreOverrideAtom as M,environmentAtom as H,layoutAtom as l,userClaimsAtom as I}from"../../jotai/app.js";import{mapObject as L}from"../../utils/object.js";import{mergeInMockServer as R}from"../../models/operation.js";import{getDefaultOperationStore as T,operationStore as V}from"../../jotai/operation.js";import{getServerEnvName as z}from"../../utils/environments.js";import{globalStoreAtom as _}from"../../jotai/store.js";const q={ignoreNamedSchemas:["java.io.ObjectStreamField"],maxDisplayedEnumValues:10,markdocOptions:{tags:{schemaDefinition:{render:"SchemaDefinition",attributes:{schemaRef:{type:String},exampleRef:{type:String},showReadOnly:{type:Boolean},showWriteOnly:{type:Boolean},htmlWrap:{type:String,default:!1}}}},nodes:{heading:{children:["inline"],attributes:{id:{type:String},level:{type:Number,required:!0,default:1}},transform(n,i){const t=n.transformAttributes(i),m=n.transformChildren(i),e=typeof t.id=="string"?t.id:k(m);return new S.Tag("Heading",{...t,id:e,level:n.attributes.level},m)}}},components:{SchemaDefinition:C,Heading:N}}},oe=v(({children:n,options:i,definitionUrl:t,definition:m,withState:e})=>{const p=b(()=>{const r=D(i,q),o=new j(m,t,r);return{options:r,parser:o}},[m,t,i]),a=y(()=>{const r=E(),o=p();r.set(_,o);const u=x(o.parser.definitionUrl,R(o.parser.definition?.servers||[],o.options.mockServer)),f=Object.fromEntries(u.map(s=>[z(s),{server:s.url,...L(s.variables||{},c=>c.default||"")}]));if(r.sub(P,()=>{}),r.set(l,o.options?.layout||O.THREE_PANEL),r.set(H,{environments:f}),r.set(I,e?.userClaims||{}),e&&r.set(M,{environment:e.environment,environments:e.environments,activeMimeName:e.activeMimeName,userClaims:e.userClaims}),e?.operation){const s=T(e.operation.pointer,e.operation.state.requestValues,e.operation.state.activeExampleName);r.set(V(e.operation.pointer),s)}return r},[p,e]);return g(()=>{e?.layout&&a.set(l,e?.layout)},[a,e?.layout]),d(A,{store:a,children:n})});export{oe as StoreProvider};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useCallback, useEffect, useMemo } from 'react';
+import markdocLib from '@markdoc/markdoc';
+import { LayoutVariant } from '@redocly/config';
+import { createStore, Provider } from 'jotai';
+import { Heading } from '@redocly/theme/markdoc/components/Heading/Heading';
+import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
+import { getMarkdownHeaderId } from './utils.js';
+import { normalizeServers } from '../../utils/index.js';
+import { SchemaDefinition } from '../SchemaDefinition/index.js';
+import { appStore, appStoreOverrideAtom, environmentAtom, layoutAtom, userClaimsAtom, } from '../../jotai/app.js';
+import { mapObject } from '../../utils/object.js';
+import { mergeInMockServer } from '../../models/operation.js';
+import { getDefaultOperationStore, operationStore } from '../../jotai/operation.js';
+import { getServerEnvName } from '../../utils/environments.js';
+import { globalStoreAtom } from '../../jotai/store.js';
+const DEFAULT_OPTIONS = {
+    // java.io.ObjectStreamField is something generated from java code which is too deep so our docs build crash because of RAM
+    ignoreNamedSchemas: ['java.io.ObjectStreamField'],
+    maxDisplayedEnumValues: 10,
+    markdocOptions: {
+        tags: {
+            schemaDefinition: {
+                render: 'SchemaDefinition',
+                attributes: {
+                    schemaRef: {
+                        type: String,
+                    },
+                    exampleRef: {
+                        type: String,
+                    },
+                    showReadOnly: {
+                        type: Boolean,
+                    },
+                    showWriteOnly: {
+                        type: Boolean,
+                    },
+                    htmlWrap: {
+                        type: String,
+                        default: false,
+                    },
+                },
+            },
+        },
+        nodes: {
+            heading: {
+                children: ['inline'],
+                attributes: {
+                    id: { type: String },
+                    level: { type: Number, required: true, default: 1 },
+                },
+                transform(node, config) {
+                    const attributes = node.transformAttributes(config);
+                    const children = node.transformChildren(config);
+                    const id = typeof attributes.id === 'string' ? attributes.id : getMarkdownHeaderId(children);
+                    return new markdocLib.Tag('Heading', {
+                        ...attributes,
+                        id,
+                        level: node.attributes.level,
+                    }, children);
+                },
+            },
+        },
+        components: {
+            SchemaDefinition: SchemaDefinition,
+            Heading,
+        },
+    },
+};
+export const StoreProvider = memo(({ children, options: rawOptions, definitionUrl, definition, withState, }) => {
+    const createGlobalStore = useCallback(() => {
+        const options = normalizeOptions(rawOptions, DEFAULT_OPTIONS);
+        const parser = new OpenAPIParser(definition, definitionUrl, options);
+        return { options, parser };
+    }, [definition, definitionUrl, rawOptions]);
+    const initializedStore = useMemo(() => {
+        const store = createStore();
+        const globalStoreValue = createGlobalStore();
+        store.set(globalStoreAtom, globalStoreValue);
+        // fixme: move into separate function + collect all servers from all operations/paths
+        const globalServers = normalizeServers(globalStoreValue.parser.definitionUrl, mergeInMockServer(globalStoreValue.parser.definition?.servers || [], globalStoreValue.options.mockServer));
+        const serverEnvs = Object.fromEntries(globalServers.map((server) => [
+            getServerEnvName(server),
+            {
+                server: server.url,
+                ...mapObject(server.variables || {}, (variable) => variable.default || ''),
+            },
+        ]));
+        store.sub(appStore, () => undefined); // force mount so init data is read from storage
+        store.set(layoutAtom, globalStoreValue.options?.layout || LayoutVariant.THREE_PANEL); // set layout atom to update appStore atom with correct layout value
+        store.set(environmentAtom, { environments: serverEnvs });
+        store.set(userClaimsAtom, withState?.userClaims || {});
+        if (withState) {
+            store.set(appStoreOverrideAtom, {
+                environment: withState.environment,
+                environments: withState.environments,
+                activeMimeName: withState.activeMimeName,
+                userClaims: withState.userClaims,
+            });
+        }
+        if (withState?.operation) {
+            const defaultStore = getDefaultOperationStore(withState.operation.pointer, withState.operation.state.requestValues, withState.operation.state.activeExampleName);
+            store.set(operationStore(withState.operation.pointer), defaultStore);
+        }
+        return store;
+    }, [createGlobalStore, withState]);
+    useEffect(() => {
+        if (!withState?.layout)
+            return;
+        initializedStore.set(layoutAtom, withState?.layout);
+    }, [initializedStore, withState?.layout]);
+    return _jsx(Provider, { store: initializedStore, children: children });
+});
+//# sourceMappingURL=Providers.js.map

package/lib/components/RedoclyOpenAPIDocs/RedoclyOpenAPIDocs.js

@@ -1 +1,57 @@
-import{jsx as o,jsxs as n,Fragment as E}from"react/jsx-runtime";import{memo as O,useRef as T}from"react";import{LayoutVariant as p}from"@redocly/config";import{useSetAtom as w}from"jotai";import{ThreePanelLayout as A}from"@redocly/theme/layouts/ThreePanelLayout";import{SidebarLogo as _}from"@redocly/theme/components/SidebarLogo/SidebarLogo";import{GlobalStyle as I,useMount as j}from"@redocly/theme/core/openapi";import{StoreProvider as N}from"./Providers.js";import{Overlay as v}from"../Overlay.js";import{RedocWrap as D}from"./styled.js";import{StickyResponsiveSidebar as k}from"../StickySidebar/index.js";import{SideMenu as B}from"../SideMenu/index.js";import{Content as K}from"../Content/index.js";import{useContentItems as M,useUppercase2LowercaseRedirect as V,useTelemetry as F,usePerformanceMetrics as H}from"../../hooks/index.js";import{withRouter as U}from"../../hoc/withRouter.js";import{withStore as Y}from"../../hoc/withStore.js";import{compose as G}from"../../utils/index.js";import{useLicense as W}from"../../hooks/useLicense.js";import{allOperationsAtom as q}from"../../jotai/replay.js";const z=G(U,Y,O)(({licenseKey:s,onLoaded:m,children:e,options:t,layout:f,collapsedSidebar:d,parser:a,withCommonStyles:h})=>{const b=T(null),{isValid:c,licenseInfo:R}=W(s),S=w(q),u=F();V();const{contentItems:y,flatItems:g}=M({parser:a,options:t});H({sendTelemetry:l=>{const r=Object.fromEntries(Object.entries(l).map(([x,C])=>[x.toLowerCase(),C]));u.send({type:"openapi_docs.performance_metrics",payload:{cls:r.cls,lcp:r.lcp,fcp:r.fcp,ttfb:r.ttfb}})}}),j(()=>{if(m?.(),u.send({type:"openapi_docs.viewed",payload:{layout:f}}),!t.hideReplay){const l=g.filter(r=>r.type==="operation");S(l)}});const{hideSidebar:L,scrollYOffset:P}=t||{},i=a.definition?.info?.["x-logo"];return n(E,{children:[h&&o(I,{}),n(D,{className:"redoc-wrap",ref:b,children:[!c&&o(v,{licenseInfo:R}),!L&&n(k,{scrollYOffset:P,className:"menu-content",collapsedSidebar:!d,children:[o(_,{imageUrl:i?.url,href:i?.href||a.definition?.info?.contact?.url,altText:i?.altText,backgroundColor:i?.backgroundColor}),o(B,{items:c?y:[]})]}),n(A,{className:"api-content",id:"api-content",layout:f===p.THREE_PANEL?p.THREE_PANEL:p.STACKED,collapsedSidebar:d,children:[o(K,{items:c?y:[],routingBasePath:t.routingBasePath}),e]})]})]})});function ue({onLoaded:s,children:m,store:e,withCommonStyles:t}){return e?.definition?o(N,{...e,children:o(z,{onLoaded:s,basePath:e.options?.routingBasePath,licenseKey:e.options?.licenseKey,disableRouter:e.options?.disableRouter,withCommonStyles:t,children:m})}):null}export{ue as RedoclyOpenAPIDocs};
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo, useRef } from 'react';
+import { LayoutVariant } from '@redocly/config';
+import { useSetAtom } from 'jotai';
+import { ThreePanelLayout } from '@redocly/theme/layouts/ThreePanelLayout';
+import { SidebarLogo } from '@redocly/theme/components/SidebarLogo/SidebarLogo';
+import { GlobalStyle as ThemeCommonStyle, useMount } from '@redocly/theme/core/openapi';
+import { StoreProvider } from './Providers.js';
+import { Overlay } from '../Overlay.js';
+import { RedocWrap } from './styled.js';
+import { StickyResponsiveSidebar } from '../StickySidebar/index.js';
+import { SideMenu } from '../SideMenu/index.js';
+import { Content } from '../Content/index.js';
+import { useContentItems, useUppercase2LowercaseRedirect, useTelemetry, usePerformanceMetrics, } from '../../hooks/index.js';
+import { withRouter } from '../../hoc/withRouter.js';
+import { withStore } from '../../hoc/withStore.js';
+import { compose } from '../../utils/index.js';
+import { useLicense } from '../../hooks/useLicense.js'; // we need a full import path for overriding license in portal
+import { allOperationsAtom } from '../../jotai/replay.js';
+const RedoclyOpenAPIDocsComponent = compose(withRouter, withStore, memo)(({ licenseKey, onLoaded, children, options, layout, collapsedSidebar, parser, withCommonStyles, }) => {
+    const rootElementRef = useRef(null);
+    const { isValid: hasValidLicense, licenseInfo } = useLicense(licenseKey);
+    const setAllOperations = useSetAtom(allOperationsAtom);
+    const telemetry = useTelemetry();
+    // remove this when no more warnings are logged (https://github.com/Redocly/redocly/issues/6778)
+    useUppercase2LowercaseRedirect();
+    const { contentItems, flatItems } = useContentItems({ parser, options });
+    usePerformanceMetrics({
+        sendTelemetry: (data) => {
+            const lowercaseData = Object.fromEntries(Object.entries(data).map(([key, value]) => [key.toLowerCase(), value]));
+            telemetry.send({
+                type: 'openapi_docs.performance_metrics',
+                payload: {
+                    cls: lowercaseData.cls,
+                    lcp: lowercaseData.lcp,
+                    fcp: lowercaseData.fcp,
+                    ttfb: lowercaseData.ttfb,
+                },
+            });
+        },
+    });
+    useMount(() => {
+        onLoaded?.();
+        telemetry.send({ type: 'openapi_docs.viewed', payload: { layout: layout } });
+        if (!options.hideReplay) {
+            const operations = flatItems.filter((item) => item.type === 'operation');
+            setAllOperations(operations);
+        }
+    });
+    const { hideSidebar, scrollYOffset } = options || {};
+    const xLogo = parser.definition?.info?.['x-logo'];
+    return (_jsxs(_Fragment, { children: [withCommonStyles && _jsx(ThemeCommonStyle, {}), _jsxs(RedocWrap, { className: "redoc-wrap", ref: rootElementRef, children: [!hasValidLicense && _jsx(Overlay, { licenseInfo: licenseInfo }), !hideSidebar && (_jsxs(StickyResponsiveSidebar, { scrollYOffset: scrollYOffset, className: "menu-content", collapsedSidebar: !collapsedSidebar, children: [_jsx(SidebarLogo, { imageUrl: xLogo?.url, href: xLogo?.href || parser.definition?.info?.contact?.url, altText: xLogo?.altText, backgroundColor: xLogo?.backgroundColor }), _jsx(SideMenu, { items: hasValidLicense ? contentItems : [] })] })), _jsxs(ThreePanelLayout, { className: "api-content", id: "api-content", layout: layout === LayoutVariant.THREE_PANEL ? LayoutVariant.THREE_PANEL : LayoutVariant.STACKED, collapsedSidebar: collapsedSidebar, children: [_jsx(Content, { items: hasValidLicense ? contentItems : [], routingBasePath: options.routingBasePath }), children] })] })] }));
+});
+export function RedoclyOpenAPIDocs({ onLoaded, children, store, withCommonStyles, }) {
+    return store?.definition ? (_jsx(StoreProvider, { ...store, children: _jsx(RedoclyOpenAPIDocsComponent, { onLoaded: onLoaded, basePath: store.options?.routingBasePath, licenseKey: store.options?.licenseKey, disableRouter: store.options?.disableRouter, withCommonStyles: withCommonStyles, children: children }) })) : null;
+}
+//# sourceMappingURL=RedoclyOpenAPIDocs.js.map

package/lib/components/RedoclyOpenAPIDocs/RedoclyOpenAPIDocsStandalone.js

@@ -1 +1,86 @@
-import{jsx as s}from"react/jsx-runtime";import{cloneElement as S,isValidElement as w,useEffect as f,useMemo as x,useState as d}from"react";import{Loading as y}from"@redocly/theme/components/Loaders/Loading";import{useDeepCompareMemoize as v,fixSpec as A}from"./utils.js";import{argValueToBoolean as D}from"../../utils/index.js";import{RedoclyOpenAPIDocs as I}from"./RedoclyOpenAPIDocs.js";import{loadAndBundleDefinition as u}from"../../utils/loadAndBundleSpec.js";async function k(e,n,t){let o;if(t?.skipBundle){if(!e)throw new Error('spec must be specified when using "skipBundleAndConvert"');o=e}else o=await u(e||n);try{A(o)}catch{}return o}function _(e,n){return e.endsWith(".md")?u({openapi:"3.0.0",info:{title:n||"",version:"1.0",description:{$ref:e}},paths:{}}):u(e)}const B=({options:e,definitionUrl:n,definition:t,activeSampleLanguage:o,children:r})=>{const[,l]=d(),[m,c]=d(!0),[i,p]=d(null);f(()=>{async function h(){c(!0);try{p(await k(t,n,e))}catch(g){l(()=>{throw g})}}h()},[t,n,e]);const a=x(()=>{if(i)return e?.unstable_hooks?.onInit&&e.unstable_hooks?.onInit?.({store:{definition:i,options:e,definitionUrl:n,activeSampleLanguage:o}}),{definition:i,options:e,definitionUrl:n,activeSampleLanguage:o}},v([i,e,n]));return f(()=>{a&&c(!1)},[a]),a?m?D(e?.hideLoading,!1)?null:s(y,{color:"--loading-spinner-color"}):w(r)?S(r,{store:a}):null:null};function j({definition:e,definitionUrl:n,options:t={},activeItemId:o,activeSampleLanguage:r,activeDeepLink:l}){return s(B,{definition:e,definitionUrl:n,options:t,activeItemId:o,activeSampleLanguage:r,activeDeepLink:l,children:s(I,{withCommonStyles:!0})})}export{B as AppProvider,j as RedoclyOpenAPIDocsStandalone,_ as loadAndBundleSpecOrMd,k as loadSingle};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cloneElement, isValidElement, useEffect, useMemo, useState } from 'react';
+import { Loading } from '@redocly/theme/components/Loaders/Loading';
+import { useDeepCompareMemoize, fixSpec } from './utils.js';
+import { argValueToBoolean } from '../../utils/index.js';
+import { RedoclyOpenAPIDocs } from './RedoclyOpenAPIDocs.js';
+import { loadAndBundleDefinition } from '../../utils/loadAndBundleSpec.js';
+export async function loadSingle(spec, specUrl, options) {
+    let resolvedDefinition;
+    if (options?.skipBundle) {
+        if (!spec) {
+            throw new Error('spec must be specified when using "skipBundleAndConvert"');
+        }
+        resolvedDefinition = spec;
+    }
+    else {
+        resolvedDefinition = await loadAndBundleDefinition(spec || specUrl);
+    }
+    try {
+        fixSpec(resolvedDefinition);
+    }
+    catch {
+        // nope
+    }
+    return resolvedDefinition;
+}
+export function loadAndBundleSpecOrMd(url, title) {
+    if (url.endsWith('.md')) {
+        return loadAndBundleDefinition({
+            openapi: '3.0.0',
+            info: {
+                title: title || '',
+                version: '1.0',
+                description: { $ref: url },
+            },
+            paths: {},
+        });
+    }
+    else {
+        return loadAndBundleDefinition(url);
+    }
+}
+export const AppProvider = ({ options, definitionUrl, definition, activeSampleLanguage, children, }) => {
+    const [, setError] = useState();
+    const [loading, setLoading] = useState(true);
+    const [loadedSpec, setLoadedSpec] = useState(null);
+    useEffect(() => {
+        async function load() {
+            setLoading(true);
+            try {
+                setLoadedSpec(await loadSingle(definition, definitionUrl, options));
+            }
+            catch (e) {
+                setError(() => {
+                    throw e;
+                });
+            }
+        }
+        load();
+    }, [definition, definitionUrl, options]); // do not reload based on options
+    const store = useMemo(() => {
+        if (!loadedSpec)
+            return undefined;
+        if (options?.unstable_hooks?.onInit) {
+            options.unstable_hooks?.onInit?.({
+                store: { definition: loadedSpec, options, definitionUrl, activeSampleLanguage },
+            });
+        }
+        return { definition: loadedSpec, options, definitionUrl, activeSampleLanguage };
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    useDeepCompareMemoize([loadedSpec, options, definitionUrl]));
+    useEffect(() => {
+        if (!store)
+            return;
+        setLoading(false);
+    }, [store]);
+    if (!store) {
+        return null;
+    }
+    return !loading ? (isValidElement(children) ? (cloneElement(children, { store })) : null) : argValueToBoolean(options?.hideLoading, false) ? null : (_jsx(Loading, { color: "--loading-spinner-color" }));
+};
+export function RedoclyOpenAPIDocsStandalone({ definition, definitionUrl, options = {}, activeItemId, activeSampleLanguage, activeDeepLink, }) {
+    return (_jsx(AppProvider, { definition: definition, definitionUrl: definitionUrl, options: options, activeItemId: activeItemId, activeSampleLanguage: activeSampleLanguage, activeDeepLink: activeDeepLink, children: _jsx(RedoclyOpenAPIDocs, { withCommonStyles: true }) }));
+}
+//# sourceMappingURL=RedoclyOpenAPIDocsStandalone.js.map

package/lib/components/RedoclyOpenAPIDocs/index.js

@@ -1 +1,5 @@
-import{RedoclyOpenAPIDocs as r}from"./RedoclyOpenAPIDocs.js";import{StoreProvider as m}from"./Providers.js";export*from"./types.js";import{fixSpec as f,useDeepCompareMemoize as x,getMarkdownHeaderId as a}from"./utils.js";export{r as RedoclyOpenAPIDocs,m as StoreProvider,f as fixSpec,a as getMarkdownHeaderId,x as useDeepCompareMemoize};
+export { RedoclyOpenAPIDocs } from './RedoclyOpenAPIDocs.js';
+export { StoreProvider } from './Providers.js';
+export * from './types.js';
+export { fixSpec, useDeepCompareMemoize, getMarkdownHeaderId } from './utils.js';
+//# sourceMappingURL=index.js.map

package/lib/components/RedoclyOpenAPIDocs/styled.js

@@ -1,4 +1,5 @@
-import{styled as t}from"../../styled-components.js";const e=t.div`
+import { styled } from '../../styled-components.js';
+export const RedocWrap = styled.div `
   display: flex;
   position: relative;
   text-align: left;
@@ -18,4 +19,5 @@ import{styled as t}from"../../styled-components.js";const e=t.div`
     box-sizing: border-box;
     -webkit-tap-highlight-color: rgba(255, 255, 255, 0);
   }
-`;export{e as RedocWrap};
+`;
+//# sourceMappingURL=styled.js.map

package/lib/components/RedoclyOpenAPIDocs/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/components/RedoclyOpenAPIDocs/utils.js

@@ -1 +1,33 @@
-import{useRef as n}from"react";import s from"fast-deep-equal";import{safeSlugify as c}from"../../utils/string.js";function u(e){const o=e.components&&e.components.securitySchemes||{};for(const r of Object.keys(o)){const t=o[r];t["x-type"]&&(t.type=t["x-type"]),t["x-scheme"]&&(t.scheme=t["x-scheme"])}}function x(e){const o=n(null),r=n(0);return s(e,o.current)||(o.current=e,r.current+=1),[r.current]}function f(e){if(typeof e[0]=="string")return`section/${c(e[0])}`;if(e.children)return f(e[0])}export{u as fixSpec,f as getMarkdownHeaderId,x as useDeepCompareMemoize};
+import { useRef } from 'react';
+import isDeepEqual from 'fast-deep-equal';
+import { safeSlugify } from '../../utils/string.js';
+export function fixSpec(resolvedSpec) {
+    const schemas = (resolvedSpec.components && resolvedSpec.components.securitySchemes) || {};
+    for (const s of Object.keys(schemas)) {
+        const scheme = schemas[s];
+        if (scheme['x-type']) {
+            scheme.type = scheme['x-type'];
+        }
+        if (scheme['x-scheme']) {
+            scheme.scheme = scheme['x-scheme'];
+        }
+    }
+}
+export function useDeepCompareMemoize(value) {
+    const ref = useRef(null);
+    const signalRef = useRef(0);
+    if (!isDeepEqual(value, ref.current)) {
+        ref.current = value;
+        signalRef.current += 1;
+    }
+    return [signalRef.current];
+}
+export function getMarkdownHeaderId(children) {
+    if (typeof children[0] === 'string') {
+        return `section/${safeSlugify(children[0])}`;
+    }
+    else if (children.children) {
+        return getMarkdownHeaderId(children[0]);
+    }
+}
+//# sourceMappingURL=utils.js.map

package/lib/components/RenderHook/RenderHook.js

@@ -1 +1,17 @@
-import{jsx as o}from"react/jsx-runtime";function l(e){if(!e.Hook)return null;const n=e.Hook(e.props),t=n&&n.html;return t?o("span",{dangerouslySetInnerHTML:{__html:t}}):n}function u(e){return e.readOnly&&"read-only"||e.writeOnly&&"write-only"||null}export{l as RenderHook,u as getAccessModeLabelText};
+import { jsx as _jsx } from "react/jsx-runtime";
+export function RenderHook(props) {
+    if (!props.Hook)
+        return null;
+    const hookResult = props.Hook(props.props);
+    const html = hookResult && hookResult.html;
+    if (html) {
+        return _jsx("span", { dangerouslySetInnerHTML: { __html: html } });
+    }
+    else {
+        return hookResult;
+    }
+}
+export function getAccessModeLabelText(schema) {
+    return (schema.readOnly && 'read-only') || (schema.writeOnly && 'write-only') || null;
+}
+//# sourceMappingURL=RenderHook.js.map

package/lib/components/RenderHook/index.js

@@ -1 +1,2 @@
-import{RenderHook as r,getAccessModeLabelText as t}from"./RenderHook.js";export{r as RenderHook,t as getAccessModeLabelText};
+export { RenderHook, getAccessModeLabelText } from './RenderHook.js';
+//# sourceMappingURL=index.js.map

package/lib/components/Replay/EmbeddedReplay.js

@@ -1,10 +1,48 @@
-import{jsx as e}from"react/jsx-runtime";import{Suspense as b,lazy as h,memo as S,useEffect as x,useState as E}from"react";import{useAtomValue as o}from"jotai";import{globalOptionsAtom as O}from"../../jotai/store.js";import{operationStore as R}from"../../jotai/operation.js";import{appStore as C,environmentsAtom as L}from"../../jotai/app.js";import{useTranslate as T}from"../../hooks/index.js";import{convertOperationToReplayValue as V}from"./utils.js";import{getDefaultCollectorUrl as j}from"../../utils/telemetry.js";import{styled as i}from"../../styled-components.js";const A=h(async()=>import("@redocly/replay").then(r=>({default:r.EmbeddedReplay})));function k({activeOperationId:r,corsProxyUrl:d,fullOpenApi:l,pointer:t}){const n=T(),{mockServer:m}=o(O),s=o(R(t)),a=o(C),c=o(L),[f,u]=E(!1);return x(()=>{u(!0)},[]),e(U,{children:f?e(b,{fallback:e(p,{children:n("openapi.loading","Loading...")}),children:e(A,{activeOperationId:r,activeOperationPointer:t,api:l,settings:{environment:a.environment,predefinedEnvValues:c,corsProxyUrl:d,mockServer:m,disableCollectionsTab:!0,telemetry:{tracerName:"replay-openapi",collectorUrl:j()},convertOperationToReplayValue:(v,y,g)=>V(v,y,g,void 0,s,a)}})}):e(p,{children:n("openapi.loading","Loading...")})})}const F=S(k),p=i.div`
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, lazy, memo, useEffect, useState } from 'react';
+import { useAtomValue } from 'jotai';
+import { globalOptionsAtom } from '../../jotai/store.js';
+import { operationStore } from '../../jotai/operation.js';
+import { appStore, environmentsAtom } from '../../jotai/app.js';
+import { useTranslate } from '../../hooks/index.js';
+import { convertOperationToReplayValue } from './utils.js';
+import { getDefaultCollectorUrl } from '../../utils/telemetry.js';
+import { styled } from '../../styled-components.js';
+const EmbeddedReplayOrig = lazy(async () => import('@redocly/replay').then((module) => ({ default: module.EmbeddedReplay })));
+function EmbeddedReplayComponent({ activeOperationId, corsProxyUrl, fullOpenApi, pointer, }) {
+    const translate = useTranslate();
+    const { mockServer } = useAtomValue(globalOptionsAtom);
+    const operationState = useAtomValue(operationStore(pointer));
+    const appState = useAtomValue(appStore);
+    const envs = useAtomValue(environmentsAtom);
+    // do not render on the server, it produces some SSR Suspense error
+    const [loaded, setLoaded] = useState(false);
+    useEffect(() => {
+        setLoaded(true);
+    }, []);
+    return (_jsx(CompactWrapper, { children: loaded ? (_jsx(Suspense, { fallback: _jsx(LoadingWrapper, { children: translate('openapi.loading', 'Loading...') }), children: _jsx(EmbeddedReplayOrig, { activeOperationId: activeOperationId, activeOperationPointer: pointer, api: fullOpenApi, settings: {
+                    environment: appState.environment,
+                    predefinedEnvValues: envs,
+                    corsProxyUrl,
+                    mockServer,
+                    disableCollectionsTab: true,
+                    telemetry: {
+                        tracerName: 'replay-openapi',
+                        collectorUrl: getDefaultCollectorUrl(),
+                    },
+                    convertOperationToReplayValue: (path, method, openAPI) => convertOperationToReplayValue(path, method, openAPI, undefined, operationState, appState),
+                } }) })) : (_jsx(LoadingWrapper, { children: translate('openapi.loading', 'Loading...') })) }));
+}
+export const EmbeddedReplay = memo(EmbeddedReplayComponent);
+const LoadingWrapper = styled.div `
   display: flex;
   justify-content: center;
   align-items: center;
   min-height: 100px;
-`,U=i.div`
+`;
+const CompactWrapper = styled.div `
   border: 1px solid var(--border-color-primary);
   border-radius: var(--border-radius-lg);
   padding: 0;
-`;export{F as EmbeddedReplay};
+`;
+//# sourceMappingURL=EmbeddedReplay.js.map

package/lib/components/Replay/Replay.js

@@ -1 +1,99 @@
-import{jsx as r,Fragment as U,jsxs as F}from"react/jsx-runtime";import{lazy as B,memo as z,Suspense as J,useCallback as u,useRef as K,useState as M}from"react";import{useAtom as f,useAtomValue as p}from"jotai";import w from"deepmerge";const H=B(async()=>import("@redocly/replay").then(t=>({default:t.ReplayOverlay})));import{Button as Q}from"@redocly/theme/components/Button/Button";import{useFocusTrap as W,useModalScrollLock as X}from"@redocly/theme/core/openapi";import{RocketIcon as Y}from"@redocly/theme/icons/RocketIcon/RocketIcon";import{CircleDashIcon as Z}from"@redocly/theme/icons/CircleDashIcon/CircleDashIcon";import{Portal as $}from"@redocly/theme/components/Portal/Portal";import{globalOptionsAtom as ee,globalStoreAtom as te}from"../../jotai/store.js";import{allOperationsAtom as oe,replayStateAtom as re}from"../../jotai/replay.js";import{allOperations as ne,getDefaultOperationStore as ae}from"../../jotai/operation.js";import{LOADING_STATE as a}from"../../constants.js";import{environmentAtom as se,userClaimsAtom as ie}from"../../jotai/app.js";import{convertOperationToReplayValueForRedoc as le}from"./utils.js";import{useTranslate as me,useTelemetry as pe}from"../../hooks/index.js";import{JsonPointer as ce}from"../../utils/index.js";import{getDefaultCollectorUrl as ue}from"../../utils/telemetry.js";import{createTryItOpenEvent as fe,createTryItSentEvent as de}from"../../events/index.js";function ye({operation:t,corsProxyUrl:D,fullOpenApi:d}){const y=me(),C=pe(),O=K(null),{mockServer:L,oAuth2RedirectURI:b,routingBasePath:c}=p(ee),I=p(oe),{parser:P,options:{events:s}}=p(te),N=p(ie),[l,E]=M(!1),[m,h]=f(re),[g,v]=f(ne),[[,V],A]=f(se);W(O),X(l);const _=u(({operations:e,environment:o,environments:i})=>{const j=e.reduce((S,n)=>{n.requestValues.body=n.requestValues.body instanceof URLSearchParams?Object.fromEntries(n.requestValues.body.entries()):n.requestValues.body;const{path:k,method:G}=n.apiPath,T=ce.compile(["paths",k,G]);return S[T]=w(ae(T),n),S},{});v({...g,...j}),A({environment:o,environments:i})},[g,v,A]),R=()=>{if(m!==a.LOADING){if(!l&&(C.send({type:"openapi_docs.try_it.opened"}),s?.tryItOpen&&t)){const e=fe({operation:t});s.tryItOpen(e)}E(!l)}m===a.NOT_LOADED&&h(a.LOADING)},q=u(e=>{if(s?.tryItSent&&t){const o=de({operation:t,isSuccess:e});s.tryItSent(o)}},[s,t]),x=u(e=>{if(!e)return;const o=I.find(i=>i.operationId===e);return c+o?.href},[I,c]);return d?F(U,{children:[r(Q,{onClick:R,variant:"primary",iconPosition:"left",icon:m===a.LOADING?r(Z,{}):r(Y,{}),children:m===a.LOADING?y("openapi.loading","Loading..."):y("openapi.tryIt","Try it")}),l&&r(J,{children:r($,{mountId:"api-content",children:r("div",{ref:O,children:r(H,{activeOperationId:t.operationId||t.pointer,api:d,onRequestChange:_,onClose:R,onLoad:()=>h(a.LOADED),settings:{corsProxyUrl:D,mockServer:L,environment:V,apiId:P?.definition.info?.["x-metadata"]?.apiId,oAuth2RedirectURI:b,disableCollectionsTab:!0,storageKey:c,telemetry:{tracerName:"try-it",collectorUrl:ue()},convertOperationToReplayValue:(e,o,i)=>le(N)(e,o,i),getOperationUrl:x},onRequestSent:q})})})})]}):null}const xe=z(ye);export{xe as Replay};
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { lazy, memo, Suspense, useCallback, useRef, useState } from 'react';
+import { useAtom, useAtomValue } from 'jotai';
+import merge from 'deepmerge';
+const ReplayOverlay = lazy(async () => import('@redocly/replay').then((module) => ({ default: module.ReplayOverlay })));
+import { Button } from '@redocly/theme/components/Button/Button';
+import { useFocusTrap, useModalScrollLock } from '@redocly/theme/core/openapi';
+import { RocketIcon } from '@redocly/theme/icons/RocketIcon/RocketIcon';
+import { CircleDashIcon } from '@redocly/theme/icons/CircleDashIcon/CircleDashIcon';
+import { Portal } from '@redocly/theme/components/Portal/Portal';
+import { globalOptionsAtom, globalStoreAtom } from '../../jotai/store.js';
+import { allOperationsAtom, replayStateAtom } from '../../jotai/replay.js';
+import { allOperations, getDefaultOperationStore } from '../../jotai/operation.js';
+import { LOADING_STATE } from '../../constants.js';
+import { environmentAtom, userClaimsAtom } from '../../jotai/app.js';
+import { convertOperationToReplayValueForRedoc } from './utils.js';
+import { useTranslate, useTelemetry } from '../../hooks/index.js';
+import { JsonPointer } from '../../utils/index.js';
+import { getDefaultCollectorUrl } from '../../utils/telemetry.js';
+import { createTryItOpenEvent, createTryItSentEvent } from '../../events/index.js';
+function ReplayComponent({ operation, corsProxyUrl, fullOpenApi }) {
+    const translate = useTranslate();
+    const telemetry = useTelemetry();
+    const replayRef = useRef(null);
+    const { mockServer, oAuth2RedirectURI, routingBasePath } = useAtomValue(globalOptionsAtom);
+    const operations = useAtomValue(allOperationsAtom);
+    const { parser, options: { events }, } = useAtomValue(globalStoreAtom);
+    const userClaims = useAtomValue(userClaimsAtom);
+    const [isOpened, setIsOpened] = useState(false);
+    const [replayState, setReplayState] = useAtom(replayStateAtom);
+    const [allOperationsData, setAllOperations] = useAtom(allOperations);
+    const [[, envName], setEnvironment] = useAtom(environmentAtom);
+    useFocusTrap(replayRef);
+    useModalScrollLock(isOpened);
+    const handleReplayParamChange = useCallback(({ operations, environment, environments }) => {
+        const changedOperations = operations.reduce((acc, op) => {
+            op.requestValues.body =
+                op.requestValues.body instanceof URLSearchParams
+                    ? Object.fromEntries(op.requestValues.body.entries())
+                    : op.requestValues.body;
+            const { path, method } = op.apiPath;
+            const pointer = JsonPointer.compile(['paths', path, method]);
+            acc[pointer] = merge(getDefaultOperationStore(pointer), op);
+            return acc;
+        }, {});
+        setAllOperations({ ...allOperationsData, ...changedOperations });
+        setEnvironment({ environment, environments });
+    }, [allOperationsData, setAllOperations, setEnvironment]);
+    const handleToggle = () => {
+        if (replayState !== LOADING_STATE.LOADING) {
+            if (!isOpened) {
+                telemetry.send({ type: 'openapi_docs.try_it.opened' });
+                if (events?.tryItOpen && operation) {
+                    const eventPayload = createTryItOpenEvent({
+                        operation: operation,
+                    });
+                    events.tryItOpen(eventPayload);
+                }
+            }
+            setIsOpened(!isOpened);
+        }
+        if (replayState === LOADING_STATE.NOT_LOADED) {
+            setReplayState(LOADING_STATE.LOADING);
+        }
+    };
+    const handleTryItSent = useCallback((isSuccess) => {
+        if (events?.tryItSent && operation) {
+            const eventPayload = createTryItSentEvent({ operation, isSuccess });
+            events.tryItSent(eventPayload);
+        }
+    }, [events, operation]);
+    const getOperationUrl = useCallback((operationId) => {
+        if (!operationId)
+            return;
+        const operation = operations.find((op) => op.operationId === operationId);
+        return routingBasePath + operation?.href;
+    }, [operations, routingBasePath]);
+    if (!fullOpenApi)
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { onClick: handleToggle, variant: "primary", iconPosition: "left", icon: replayState === LOADING_STATE.LOADING ? _jsx(CircleDashIcon, {}) : _jsx(RocketIcon, {}), children: replayState === LOADING_STATE.LOADING
+                    ? translate('openapi.loading', 'Loading...')
+                    : translate('openapi.tryIt', 'Try it') }), isOpened && (_jsx(Suspense, { children: _jsx(Portal, { mountId: "api-content", children: _jsx("div", { ref: replayRef, children: _jsx(ReplayOverlay, { activeOperationId: operation.operationId || operation.pointer, api: fullOpenApi, onRequestChange: handleReplayParamChange, onClose: handleToggle, onLoad: () => setReplayState(LOADING_STATE.LOADED), settings: {
+                                corsProxyUrl,
+                                mockServer,
+                                environment: envName,
+                                apiId: parser?.definition.info?.['x-metadata']?.apiId,
+                                oAuth2RedirectURI,
+                                disableCollectionsTab: true,
+                                storageKey: routingBasePath,
+                                telemetry: {
+                                    tracerName: 'try-it',
+                                    collectorUrl: getDefaultCollectorUrl(),
+                                },
+                                convertOperationToReplayValue: (path, method, openAPI) => convertOperationToReplayValueForRedoc(userClaims)(path, method, openAPI),
+                                getOperationUrl,
+                            }, ...{ onRequestSent: handleTryItSent } }) }) }) }))] }));
+}
+export const Replay = memo(ReplayComponent);
+//# sourceMappingURL=Replay.js.map

package/lib/components/Replay/index.js

@@ -1 +1,3 @@
-import{Replay as p}from"./Replay.js";import{EmbeddedReplay as d}from"./EmbeddedReplay.js";export{d as EmbeddedReplay,p as Replay};
+export { Replay } from './Replay.js';
+export { EmbeddedReplay } from './EmbeddedReplay.js';
+//# sourceMappingURL=index.js.map