@redocly/theme 0.58.0-next.9 → 0.59.0-next.0

package/src/core/hooks/use-tabs.ts

@@ -1,115 +1,59 @@
-import { useCallback, useRef, useState, useEffect } from 'react';
+import { useCallback, useRef, useState, useEffect, useMemo } from 'react';
+import { useSearchParams } from 'react-router-dom';
 
 type UseTabsProps = {
-  initialTab: string;
+  activeTab: string;
+  onTabChange: (tab: string) => void;
   totalTabs: number;
   containerRef?: React.RefObject<HTMLElement | null>;
 };
 
-export function useTabs({ initialTab, totalTabs, containerRef }: UseTabsProps) {
-  const [activeTab, setActiveTab] = useState(initialTab);
-  const [visibleTabs, setVisibleTabs] = useState<number[]>(
-    Array.from({ length: totalTabs }, (_, i) => i),
-  );
-  const [overflowTabs, setOverflowTabs] = useState<number[]>([]);
-  const [allTabsHidden, setAllTabsHidden] = useState<boolean>(false);
+type Tabs = {
+  visible: number[];
+  overflow: number[];
+};
+
+const MORE_BUTTON_WIDTH = 80;
+const TABS_GAP = 8;
+
+export function useTabs({ activeTab, onTabChange, totalTabs, containerRef }: UseTabsProps) {
+  const [tabs, setTabs] = useState<Tabs>({
+    visible: Array.from({ length: totalTabs }, (_, i) => i),
+    overflow: [],
+  });
+
   const tabRefs = useRef<(HTMLButtonElement | null)[]>([]);
+  const tabWidthsRef = useRef<number[]>([]);
   const tabLabelsRef = useRef<string[]>([]);
-  const resizeTimeoutRef = useRef<number | undefined>(undefined);
-  const [ready, setReady] = useState<boolean>(false);
-  const hasCalculatedOnce = useRef(false);
-  const lastWidthRef = useRef<number>(0);
-  const originalOrderRef = useRef<number[]>([]);
 
-  useEffect(() => {
-    originalOrderRef.current = Array.from({ length: totalTabs }, (_, i) => i);
-  }, [totalTabs]);
+  const allTabsHidden = useMemo(() => tabs.visible.length === 0, [tabs.visible]);
 
   const setTabRef = useCallback((element: HTMLButtonElement | null, index: number) => {
     tabRefs.current[index] = element;
-    if (element) {
-      const label = element.getAttribute('data-label');
-      if (label) {
-        tabLabelsRef.current[index] = label;
-      }
+
+    const width = element?.offsetWidth;
+    if (width) {
+      tabWidthsRef.current[index] = width;
     }
-  }, []);
 
-  const getTabId = useCallback((label: string, index: number) => {
-    const cleanLabel = label.replace(/\s+/g, '-').toLowerCase();
-    return `${cleanLabel}-${index}`;
+    const label = element?.getAttribute('data-label');
+    if (label) {
+      tabLabelsRef.current[index] = label;
+    }
   }, []);
 
   const focusTab = (index: number) => {
     const currentElement = tabRefs.current[index];
-    if (currentElement) {
-      currentElement.focus();
-    }
+    currentElement?.focus();
   };
 
-  const onTabSelect = useCallback((index: number) => {
-    focusTab(index);
-    const label = tabRefs.current[index]?.getAttribute('data-label');
-    if (label) setActiveTab(label);
-  }, []);
-
-  const onTabClick = useCallback(
-    (labelOrIndex: string | number) => {
-      let clickedIndex: number;
-
-      if (typeof labelOrIndex === 'string') {
-        clickedIndex = tabRefs.current.findIndex(
-          (ref) => ref?.getAttribute('data-label') === labelOrIndex,
-        );
-        if (clickedIndex === -1) return;
-      } else {
-        clickedIndex = labelOrIndex;
-      }
-
-      if (allTabsHidden) {
-        const label = tabLabelsRef.current[clickedIndex];
-        if (label) {
-          setActiveTab(label);
-          focusTab(clickedIndex);
-        }
-        return;
-      }
-
-      if (overflowTabs.includes(clickedIndex)) {
-        const newVisibleTabs = [...visibleTabs];
-        const newOverflowTabs = [...overflowTabs];
-
-        const clickedIdxInOverflow = newOverflowTabs.indexOf(clickedIndex);
-        if (clickedIdxInOverflow !== -1) {
-          newOverflowTabs.splice(clickedIdxInOverflow, 1);
-        }
-
-        const lastVisible = newVisibleTabs.pop();
-        if (lastVisible !== undefined) {
-          newOverflowTabs.unshift(lastVisible);
-        }
-
-        newVisibleTabs.push(clickedIndex);
-
-        setVisibleTabs(newVisibleTabs);
-        setOverflowTabs(newOverflowTabs);
-
-        requestAnimationFrame(() => {
-          const label = tabRefs.current[clickedIndex]?.getAttribute('data-label');
-          if (label) {
-            setActiveTab(label);
-            focusTab(clickedIndex);
-          }
-        });
-      } else {
-        const label = tabRefs.current[clickedIndex]?.getAttribute('data-label');
-        if (label) {
-          setActiveTab(label);
-          focusTab(clickedIndex);
-        }
-      }
+  const onTabSelect = useCallback(
+    (index: number) => {
+      focusTab(index);
+      const label = tabRefs.current[index]?.getAttribute('data-label');
+      if (label) onTabChange(label);
     },
-    [visibleTabs, overflowTabs, allTabsHidden],
+    [onTabChange],
   );
 
   const handleKeyboard = useCallback(
@@ -133,196 +77,174 @@ export function useTabs({ initialTab, totalTabs, containerRef }: UseTabsProps) {
     [totalTabs, onTabSelect],
   );
 
-  const calculateVisibleTabs = useCallback(() => {
-    const container = containerRef?.current;
-    if (!container) return;
+  const replaceLastVisibleTabWithClickedOverflowTab = useCallback(
+    (clickedIndex: number) => {
+      const { visible: visibleTabs, overflow: overflowTabs } = tabs;
+
+      // Indexes of visible tabs should be sorted(asc), to replace the last visible tab with the clicked tab
+      const newVisibleTabs = [...visibleTabs].sort((a, b) => a - b);
+      const newOverflowTabs = [...overflowTabs];
+
+      const clickedIdxInOverflow = newOverflowTabs.indexOf(clickedIndex);
+      if (clickedIdxInOverflow !== -1) {
+        const lastVisible = newVisibleTabs[newVisibleTabs.length - 1];
+        newOverflowTabs.splice(clickedIdxInOverflow, 1);
+        newOverflowTabs.unshift(lastVisible);
+        newVisibleTabs.splice(newVisibleTabs.length - 1, 1);
+        newVisibleTabs.unshift(clickedIndex);
+      }
 
-    const contentWrapper = container.closest('div');
-    if (!contentWrapper) {
-      setVisibleTabs(Array.from({ length: totalTabs }, (_, i) => i));
-      setOverflowTabs([]);
-      setAllTabsHidden(false);
-      return;
-    }
+      setTabs({
+        visible: newVisibleTabs,
+        overflow: newOverflowTabs,
+      });
+    },
+    [tabs],
+  );
 
-    const containerWidth = container.offsetWidth - 60;
-    const tabElements = container.querySelectorAll('[role="tab"]');
-    const moreButtonWidth = 80;
-    const safetyMargin = 20;
+  const onTabClick = useCallback(
+    (labelOrIndex: string | number) => {
+      const clickedIndex =
+        typeof labelOrIndex === 'string'
+          ? tabRefs.current.findIndex((ref) => ref?.getAttribute('data-label') === labelOrIndex)
+          : labelOrIndex;
+
+      if (clickedIndex === -1) return;
+
+      const hasOverflowTabs = tabs.overflow.length > 0;
+      if (hasOverflowTabs && !allTabsHidden && tabs.overflow.includes(clickedIndex)) {
+        replaceLastVisibleTabWithClickedOverflowTab(clickedIndex);
+      }
 
-    const tabWidths = Array.from(tabElements).map((el) => (el as HTMLElement).offsetWidth);
-    const tabLabels = Array.from(tabElements).map((el) => el.getAttribute('data-label') || '');
-    const tabTypes = Array.from(tabElements).map((el) => el.getAttribute('data-type') || '');
+      const label = tabLabelsRef.current[clickedIndex];
+      if (label) {
+        onTabChange(label);
+        focusTab(clickedIndex);
+      }
+    },
+    [allTabsHidden, tabs.overflow, onTabChange, replaceLastVisibleTabWithClickedOverflowTab],
+  );
 
-    const hasLongLabels = tabLabels.some((label) => label.length > 30);
-    const minVisibleTabs = hasLongLabels ? 1 : 2;
+  const calculateVisibleTabs = useCallback(() => {
+    const container = containerRef?.current;
+    if (!container) return;
 
+    const containerWidth = container.offsetWidth;
+    const tabWidths = tabWidthsRef.current;
     const activeTabIndex = tabRefs.current.findIndex(
       (ref) => ref?.getAttribute('data-label') === activeTab,
     );
 
-    let currentWidth = 0;
-    const visible: number[] = [];
-    const overflow: number[] = [];
+    // Active tab should always be visible, so we include it at the beginning of the array
+    let tabsWidth = activeTabIndex !== -1 ? tabWidths[activeTabIndex] : 0;
+    const visible = activeTabIndex !== -1 ? [activeTabIndex] : [];
+    const overflow = [];
 
-    let minTabsWidth = 0;
-    Array.from({ length: minVisibleTabs }).forEach((_, i) => {
-      if (i < tabWidths.length) {
-        minTabsWidth += tabWidths[i] + (i > 0 ? moreButtonWidth + safetyMargin : 0);
+    for (let i = 0; i < tabWidths.length; i++) {
+      // Skip active tab, it was added initially
+      if (i === activeTabIndex) {
+        continue;
       }
-    });
 
-    if (minTabsWidth > containerWidth) {
-      setVisibleTabs([]);
-      setOverflowTabs(Array.from({ length: totalTabs }, (_, i) => i));
-      setAllTabsHidden(true);
-      return;
-    }
+      const tabWidthWithGap = tabWidths[i] + TABS_GAP;
+      const projectedWidth = tabsWidth + tabWidthWithGap;
 
-    const tabsByType = new Map<string, number[]>();
-    Array.from({ length: totalTabs }).forEach((_, i) => {
-      const type = tabTypes[i] || 'default';
-      if (!tabsByType.has(type)) {
-        tabsByType.set(type, []);
+      if (projectedWidth <= containerWidth) {
+        visible.push(i);
+        tabsWidth += tabWidthWithGap;
+      } else {
+        overflow.push(i);
       }
-      tabsByType.get(type)?.push(i);
-    });
-
-    tabsByType.forEach((tabIndices) => {
-      let typeCurrentWidth = currentWidth;
-      const typeVisible: number[] = [];
-      const typeOverflow: number[] = [];
-
-      tabIndices.slice(0, minVisibleTabs).forEach((tabIndex) => {
-        const tabWidth = tabWidths[tabIndex];
-        const projectedWidth =
-          typeCurrentWidth +
-          tabWidth +
-          (typeVisible.length > 0 ? moreButtonWidth + safetyMargin : 0);
-
-        if (projectedWidth <= containerWidth) {
-          typeVisible.push(tabIndex);
-          typeCurrentWidth += tabWidth;
-        } else {
-          typeOverflow.push(tabIndex);
-        }
-      });
-
-      tabIndices.slice(minVisibleTabs).forEach((tabIndex) => {
-        const tabWidth = tabWidths[tabIndex];
-        const projectedWidth = typeCurrentWidth + tabWidth + moreButtonWidth + safetyMargin;
-
-        if (projectedWidth <= containerWidth) {
-          typeVisible.push(tabIndex);
-          typeCurrentWidth += tabWidth;
-        } else {
-          typeOverflow.push(tabIndex);
-        }
-      });
+    }
 
-      visible.push(...typeVisible);
-      overflow.push(...typeOverflow);
-      currentWidth = typeCurrentWidth;
-    });
+    if (overflow.length > 0) {
+      tabsWidth += MORE_BUTTON_WIDTH;
 
-    if (activeTabIndex !== -1 && !visible.includes(activeTabIndex)) {
-      if (visible.length > 0) {
+      // Remove tabs starting from the end of the array until the width of the visible tabs is less than the container width
+      while (tabsWidth > containerWidth && visible.length) {
         const removed = visible.pop();
         if (removed !== undefined) {
           overflow.unshift(removed);
+          tabsWidth -= tabWidths[removed];
         }
       }
-
-      visible.push(activeTabIndex);
-      const activeOverflowIndex = overflow.indexOf(activeTabIndex);
-      if (activeOverflowIndex !== -1) overflow.splice(activeOverflowIndex, 1);
     }
 
-    setVisibleTabs(visible);
-    setOverflowTabs(overflow);
-    setAllTabsHidden(visible.length === 0);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [containerRef, totalTabs]);
+    setTabs({
+      visible,
+      overflow,
+    });
+  }, [containerRef, activeTab]);
 
   useEffect(() => {
     if (!containerRef?.current) return;
 
-    const ensureTabsReady = () => {
-      const allTabsReady =
-        tabRefs.current.length === totalTabs && tabRefs.current.every((tab) => tab?.offsetWidth);
-
-      if (!allTabsReady) {
-        resizeTimeoutRef.current = requestAnimationFrame(ensureTabsReady);
-        return;
-      }
-
-      calculateVisibleTabs();
-      hasCalculatedOnce.current = true;
-    };
-
-    resizeTimeoutRef.current = requestAnimationFrame(ensureTabsReady);
-
-    let resizeTimeout: number;
+    let resizeTimeout = requestAnimationFrame(calculateVisibleTabs);
     const handleResize = () => {
-      if (!hasCalculatedOnce.current) return;
-
       if (resizeTimeout) {
         cancelAnimationFrame(resizeTimeout);
       }
-
-      resizeTimeout = requestAnimationFrame(() => {
-        if (resizeTimeoutRef.current) {
-          cancelAnimationFrame(resizeTimeoutRef.current);
-        }
-        resizeTimeoutRef.current = requestAnimationFrame(() => {
-          const container = containerRef?.current;
-          if (!container) return;
-
-          const currentWidth = container.offsetWidth;
-
-          if (Math.abs(lastWidthRef.current - currentWidth) > 5) {
-            lastWidthRef.current = currentWidth;
-            calculateVisibleTabs();
-          }
-        });
-      });
+      resizeTimeout = requestAnimationFrame(calculateVisibleTabs);
     };
 
-    const resizeObserver = new ResizeObserver(handleResize);
-    resizeObserver.observe(containerRef.current);
     window.addEventListener('resize', handleResize);
-
     return () => {
-      resizeObserver.disconnect();
       window.removeEventListener('resize', handleResize);
-      if (resizeTimeoutRef.current) {
-        cancelAnimationFrame(resizeTimeoutRef.current);
-      }
-      if (resizeTimeout) {
-        cancelAnimationFrame(resizeTimeout);
-      }
+      cancelAnimationFrame(resizeTimeout);
     };
   }, [containerRef, totalTabs, calculateVisibleTabs]);
 
-  useEffect(() => {
-    const raf = requestAnimationFrame(() => {
-      setReady(true);
-      calculateVisibleTabs();
-    });
-
-    return () => cancelAnimationFrame(raf);
-  }, [calculateVisibleTabs]);
-
   return {
-    activeTab,
-    setActiveTab,
     setTabRef,
     onTabClick,
     handleKeyboard,
-    getTabId,
-    visibleTabs,
-    overflowTabs,
-    ready,
+    visibleTabs: tabs.visible,
+    overflowTabs: tabs.overflow,
     allTabsHidden,
   };
 }
+
+type UseActiveTabProps = {
+  initialTab: string;
+  tabsId?: string;
+};
+
+export const useActiveTab = ({ initialTab, tabsId }: UseActiveTabProps) => {
+  const [searchParams, setSearchParams] = useSearchParams();
+  const [activeTab, setActiveTab] = useState(getInitialTab({ initialTab, searchParams, tabsId }));
+  const prevActiveTabRef = useRef(activeTab);
+
+  useEffect(() => {
+    const hasActiveTabChanged = prevActiveTabRef.current !== activeTab;
+    if (!tabsId || !hasActiveTabChanged) {
+      return;
+    }
+
+    prevActiveTabRef.current = activeTab;
+
+    setSearchParams((searchParams) => {
+      searchParams.set(tabsId, activeTab);
+      return searchParams;
+    });
+  }, [activeTab, setSearchParams, tabsId]);
+
+  return {
+    activeTab,
+    setActiveTab,
+  };
+};
+
+type GetInitialTabProps = {
+  initialTab: string;
+  searchParams: URLSearchParams;
+  tabsId?: string;
+};
+
+const getInitialTab = ({ initialTab, searchParams, tabsId }: GetInitialTabProps) => {
+  let resultTab = initialTab;
+  if (tabsId) {
+    const tabFromUrl = searchParams.get(tabsId);
+    resultTab = tabFromUrl ? tabFromUrl : resultTab;
+  }
+  return resultTab;
+};

package/src/core/openapi/index.ts

@@ -17,6 +17,7 @@ export {
   addTrailingSlash,
   withPathPrefix,
 } from '../utils/urls';
+export { capitalize } from '../utils/string';
 export { typedMemo } from '../hoc/typedMemo';
 export { useMount } from '../hooks/use-mount';
 export { GlobalStyle } from '../styles/global';

package/src/core/types/l10n.ts

@@ -206,6 +206,9 @@ export type TranslationKey =
   | 'page.actions.claudeTitle'
   | 'page.actions.claudeButtonText'
   | 'page.actions.claudeDescription'
+  | 'page.actions.cursorMcpButtonText'
+  | 'page.actions.cursorMcpTitle'
+  | 'page.actions.cursorMcpDescription'
   | 'openapi.download.description.title'
   | 'openapi.info.title'
   | 'openapi.info.contact.url'
@@ -283,6 +286,16 @@ export type TranslationKey =
   | 'openapi.schemaCatalogLink.title'
   | 'openapi.schemaCatalogLink.copyButtonTooltip'
   | 'openapi.schemaCatalogLink.copiedTooltip'
+  | 'openapi.mcp.title'
+  | 'openapi.mcp.endpoint'
+  | 'openapi.mcp.tools'
+  | 'openapi.mcp.protocolVersion'
+  | 'openapi.mcp.capabilities'
+  | 'openapi.mcp.experimentalCapabilities'
+  | 'openapi.mcp.inputSchema'
+  | 'openapi.mcp.inputExample'
+  | 'openapi.mcp.outputSchema'
+  | 'openapi.mcp.outputExample'
   | 'asyncapi.download.description.title'
   | 'asyncapi.info.title'
   | 'graphql.queries'

package/src/core/types/open-api-server.ts

@@ -1,6 +1,7 @@
 export type OpenAPIServer = {
   url: string;
   description?: string;
+  name?: string;
   variables?: Record<
     string,
     {

package/src/core/utils/index.ts

@@ -37,3 +37,4 @@ export * from './lang-to-name';
 export * from './enhanced-smoothstep';
 export * from './icon-resolver';
 export * from './dynamic';
+export * from './tabs';

package/src/core/utils/tabs.ts

@@ -0,0 +1,4 @@
+export function getTabId(label: string, index: number) {
+  const cleanLabel = label.replace(/\s+/g, '-').toLowerCase();
+  return `${cleanLabel}-${index}`;
+}

package/src/icons/CursorIcon/CursorIcon.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+import styled from 'styled-components';
+
+import type { IconProps } from '@redocly/theme/icons/types';
+
+const Icon = (props: IconProps) => (
+  <svg
+    width="16"
+    height="16"
+    viewBox="0 0 16 16"
+    fill="none"
+    xmlns="http://www.w3.org/2000/svg"
+    {...props}
+  >
+    <path d="M7.99956 15V8.0001L2 11.4999L7.99956 15Z" fill="#939393" />
+    <path d="M14 4.49979L7.99956 15V8.0001L14 4.49979Z" fill="#E3E3E3" />
+    <path d="M2 4.49979H14L7.99956 8.0001L2 4.49979Z" fill="white" />
+    <path d="M8.00025 1V4.49995L14 4.49979L8.00025 1Z" fill="#444444" />
+    <path
+      d="M2 4.49979L8.00025 4.49995V1L2 4.49979ZM13.9999 11.4998L10.9999 9.74987L7.99956 15L13.9999 11.4998Z"
+      fill="#939393"
+    />
+    <path
+      d="M14 4.49979L10.9999 9.74987L13.9999 11.4998L14 4.49979ZM7.99956 8.0001L2 11.4999V4.49979L7.99956 8.0001Z"
+      fill="#444444"
+    />
+  </svg>
+);
+
+export const CursorIcon = styled(Icon).attrs(() => ({
+  'data-component-name': 'icons/CursorIcon/CursorIcon',
+}))<IconProps>`
+  height: ${({ size }) => size || '16px'};
+  width: ${({ size }) => size || '16px'};
+`;

package/src/layouts/DocumentationLayout.tsx

@@ -9,12 +9,7 @@ import { breakpoints } from '@redocly/theme/core/utils';
 import { PageNavigation } from '@redocly/theme/components/PageNavigation/PageNavigation';
 import { LastUpdated } from '@redocly/theme/components/LastUpdated/LastUpdated';
 import { Breadcrumbs as ThemeBreadcrumbs } from '@redocly/theme/components/Breadcrumbs/Breadcrumbs';
-
-import {
-  CodeSnippetContext,
-  CODE_GROUP_SNIPPET_NAME_KEY,
-} from '../core/contexts/CodeSnippetContext';
-import { useLocalState } from '../core/hooks/use-local-state';
+import { CodeSnippetProvider } from '@redocly/theme/core/contexts/CodeSnippetContext';
 
 type DocumentationLayoutProps = {
   tableOfContent: React.ReactNode;
@@ -44,10 +39,8 @@ export function DocumentationLayout({
   const { editPage: themeEditPage } = config || {};
   const mergedConf = editPage ? { ...themeEditPage, ...editPage } : undefined;
 
-  const [activeSnippetName, setActiveSnippetName] = useLocalState(CODE_GROUP_SNIPPET_NAME_KEY, '');
-
   return (
-    <CodeSnippetContext.Provider value={{ activeSnippetName, setActiveSnippetName }}>
+    <CodeSnippetProvider>
       <LayoutWrapper data-component-name="Layout/DocumentationLayout" className={className}>
         <ContentWrapper withToc={!config?.toc?.hide}>
           <Breadcrumbs />
@@ -61,7 +54,7 @@ export function DocumentationLayout({
         </ContentWrapper>
         {tableOfContent}
       </LayoutWrapper>
-    </CodeSnippetContext.Provider>
+    </CodeSnippetProvider>
   );
 }