@redocly/theme 0.59.0-rc.3 → 0.60.0-custom.2

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

@@ -13,39 +13,75 @@ type Tabs = {
   overflow: number[];
 };
 
+type UseTabsReturn = {
+  setTabRef: (element: HTMLButtonElement | null, index: number) => void;
+  onTabClick: (labelOrIndex: string | number) => void;
+  handleKeyboard: (event: React.KeyboardEvent, index: number) => void;
+  visibleTabs: number[];
+  overflowTabs: number[];
+  isReady: boolean;
+};
+
+type UseActiveTabProps = {
+  initialTab: string;
+  tabsId?: string;
+};
+
 const MORE_BUTTON_WIDTH = 80;
 const TABS_GAP = 8;
 
-export function useTabs({ activeTab, onTabChange, totalTabs, containerRef }: UseTabsProps) {
+export function useTabs({
+  activeTab,
+  onTabChange,
+  totalTabs,
+  containerRef,
+}: UseTabsProps): UseTabsReturn {
   const [tabs, setTabs] = useState<Tabs>({
     visible: Array.from({ length: totalTabs }, (_, i) => i),
     overflow: [],
   });
-
+  const [isReady, setIsReady] = useState(false);
+  const isFirstCalculation = useRef(true);
   const tabRefs = useRef<(HTMLButtonElement | null)[]>([]);
   const tabWidthsRef = useRef<number[]>([]);
   const tabLabelsRef = useRef<string[]>([]);
+  const activeTabRef = useRef(activeTab);
+  const calculateVisibleTabsRef = useRef<(() => void) | null>(null);
 
-  const allTabsHidden = useMemo(() => tabs.visible.length === 0, [tabs.visible]);
+  // Synchronously update ref before any callbacks or effects run
+  activeTabRef.current = activeTab;
 
-  const setTabRef = useCallback((element: HTMLButtonElement | null, index: number) => {
-    tabRefs.current[index] = element;
+  const setTabRef = useCallback(
+    (element: HTMLButtonElement | null, index: number) => {
+      tabRefs.current[index] = element;
 
-    const width = element?.offsetWidth;
-    if (width) {
-      tabWidthsRef.current[index] = width;
-    }
+      const width = element?.offsetWidth;
+      if (width) {
+        tabWidthsRef.current[index] = width;
+      }
 
-    const label = element?.getAttribute('data-label');
-    if (label) {
-      tabLabelsRef.current[index] = label;
-    }
-  }, []);
+      const label = element?.getAttribute('data-label');
+      if (label) {
+        tabLabelsRef.current[index] = label;
+      }
 
-  const focusTab = (index: number) => {
+      // Trigger calculation once all tabs are registered
+      if (
+        isFirstCalculation.current &&
+        tabWidthsRef.current.length >= totalTabs &&
+        tabLabelsRef.current.length >= totalTabs &&
+        calculateVisibleTabsRef.current
+      ) {
+        requestAnimationFrame(calculateVisibleTabsRef.current);
+      }
+    },
+    [totalTabs],
+  );
+
+  const focusTab = useCallback((index: number) => {
     const currentElement = tabRefs.current[index];
     currentElement?.focus();
-  };
+  }, []);
 
   const onTabSelect = useCallback(
     (index: number) => {
@@ -53,7 +89,7 @@ export function useTabs({ activeTab, onTabChange, totalTabs, containerRef }: Use
       const label = tabRefs.current[index]?.getAttribute('data-label');
       if (label) onTabChange(label);
     },
-    [onTabChange],
+    [onTabChange, focusTab],
   );
 
   const handleKeyboard = useCallback(
@@ -77,30 +113,19 @@ export function useTabs({ activeTab, onTabChange, totalTabs, containerRef }: Use
     [totalTabs, onTabSelect],
   );
 
-  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 replaceLastVisibleTabWithClickedOverflowTab = useCallback((clickedIndex: number) => {
+    setTabs((prevTabs) => {
+      const { visible: visibleTabs, overflow: overflowTabs } = prevTabs;
 
-      setTabs({
-        visible: newVisibleTabs,
-        overflow: newOverflowTabs,
-      });
-    },
-    [tabs],
-  );
+      const sortedVisible = [...visibleTabs].sort((a, b) => a - b);
+      const lastVisible = sortedVisible[sortedVisible.length - 1];
+
+      return {
+        visible: visibleTabs.map((idx) => (idx === lastVisible ? clickedIndex : idx)),
+        overflow: overflowTabs.map((idx) => (idx === clickedIndex ? lastVisible : idx)),
+      };
+    });
+  }, []);
 
   const onTabClick = useCallback(
     (labelOrIndex: string | number) => {
@@ -111,18 +136,18 @@ export function useTabs({ activeTab, onTabChange, totalTabs, containerRef }: Use
 
       if (clickedIndex === -1) return;
 
-      const hasOverflowTabs = tabs.overflow.length > 0;
-      if (hasOverflowTabs && !allTabsHidden && tabs.overflow.includes(clickedIndex)) {
+      const label = tabLabelsRef.current[clickedIndex];
+      if (!label) return;
+
+      // If this is an overflow tab, replace it with a visible one
+      if (tabs.overflow.includes(clickedIndex)) {
         replaceLastVisibleTabWithClickedOverflowTab(clickedIndex);
       }
 
-      const label = tabLabelsRef.current[clickedIndex];
-      if (label) {
-        onTabChange(label);
-        focusTab(clickedIndex);
-      }
+      onTabChange(label);
+      focusTab(clickedIndex);
     },
-    [allTabsHidden, tabs.overflow, onTabChange, replaceLastVisibleTabWithClickedOverflowTab],
+    [tabs.overflow, onTabChange, replaceLastVisibleTabWithClickedOverflowTab, focusTab],
   );
 
   const calculateVisibleTabs = useCallback(() => {
@@ -131,87 +156,141 @@ export function useTabs({ activeTab, onTabChange, totalTabs, containerRef }: Use
 
     const containerWidth = container.offsetWidth;
     const tabWidths = tabWidthsRef.current;
-    const activeTabIndex = tabRefs.current.findIndex(
-      (ref) => ref?.getAttribute('data-label') === activeTab,
-    );
+    const tabLabels = tabLabelsRef.current;
+
+    // Wait until all tabs are registered before calculating
+    if (tabWidths.length < totalTabs || tabLabels.length < totalTabs) {
+      return;
+    }
+
+    // Check if container has proper width (not zero)
+    if (containerWidth === 0) {
+      return;
+    }
+
+    // Find active tab index by label in tabLabelsRef, not by DOM element
+    // because tab might not be rendered if it's in overflow
+    const activeTabIndex = tabLabels.findIndex((label) => label === activeTabRef.current);
 
-    // 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 = [];
+    const visibleTabs = activeTabIndex !== -1 ? [activeTabIndex] : [];
+    const overflowTabs = [];
 
     for (let i = 0; i < tabWidths.length; i++) {
-      // Skip active tab, it was added initially
-      if (i === activeTabIndex) {
-        continue;
-      }
+      if (i === activeTabIndex) continue;
 
       const tabWidthWithGap = tabWidths[i] + TABS_GAP;
       const projectedWidth = tabsWidth + tabWidthWithGap;
 
       if (projectedWidth <= containerWidth) {
-        visible.push(i);
+        visibleTabs.push(i);
         tabsWidth += tabWidthWithGap;
       } else {
-        overflow.push(i);
+        overflowTabs.push(i);
       }
     }
 
-    if (overflow.length > 0) {
+    if (overflowTabs.length > 0) {
       tabsWidth += MORE_BUTTON_WIDTH;
 
-      // 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);
+      while (tabsWidth > containerWidth && visibleTabs.length > 1) {
+        const removed = visibleTabs.pop();
+        // Never remove the active tab - it should always stay visible or be the last one
+        if (removed !== undefined && removed !== activeTabIndex) {
+          overflowTabs.unshift(removed);
           tabsWidth -= tabWidths[removed];
+        } else if (removed === activeTabIndex) {
+          // Put it back if we accidentally removed the active tab
+          visibleTabs.push(removed);
+          break;
         }
       }
+
+      // If even with only the active tab visible, it doesn't fit with More button,
+      // move all tabs to overflow (show only dropdown)
+      if (tabsWidth > containerWidth && visibleTabs.length === 1) {
+        overflowTabs.unshift(...visibleTabs);
+        visibleTabs.length = 0;
+      }
     }
 
     setTabs({
-      visible,
-      overflow,
+      visible: visibleTabs,
+      overflow: overflowTabs,
     });
-  }, [containerRef, activeTab]);
 
+    // Set ready state on first calculation
+    if (isFirstCalculation.current) {
+      isFirstCalculation.current = false;
+      setIsReady(true);
+    }
+  }, [containerRef, totalTabs]);
+
+  // Store calculateVisibleTabs in ref for use in setTabRef
+  calculateVisibleTabsRef.current = calculateVisibleTabs;
+
+  // Reset isFirstCalculation when totalTabs changes (new page/tabs)
+  useEffect(() => {
+    isFirstCalculation.current = true;
+    setIsReady(false);
+    // Clear refs so we wait for new tabs to register
+    tabWidthsRef.current = [];
+    tabLabelsRef.current = [];
+  }, [totalTabs]);
+
+  // Call calculateVisibleTabs on first render and resize
   useEffect(() => {
-    if (!containerRef?.current) return;
+    const container = containerRef?.current;
+    if (!container) return;
+
+    let resizeTimeout: number | null = null;
+
+    // Use ResizeObserver to wait until container has proper size
+    const resizeObserver = new ResizeObserver(() => {
+      if (resizeTimeout) cancelAnimationFrame(resizeTimeout);
+      resizeTimeout = requestAnimationFrame(calculateVisibleTabs);
+    });
+
+    resizeObserver.observe(container);
 
-    let resizeTimeout = requestAnimationFrame(calculateVisibleTabs);
     const handleResize = () => {
-      if (resizeTimeout) {
-        cancelAnimationFrame(resizeTimeout);
-      }
+      if (resizeTimeout) cancelAnimationFrame(resizeTimeout);
       resizeTimeout = requestAnimationFrame(calculateVisibleTabs);
     };
 
     window.addEventListener('resize', handleResize);
+
     return () => {
+      resizeObserver.disconnect();
       window.removeEventListener('resize', handleResize);
-      cancelAnimationFrame(resizeTimeout);
+      if (resizeTimeout) cancelAnimationFrame(resizeTimeout);
     };
   }, [containerRef, totalTabs, calculateVisibleTabs]);
 
+  // Recalculate when activeTab changes to ensure it's visible
+  useEffect(() => {
+    if (!containerRef?.current || isFirstCalculation.current) return;
+    requestAnimationFrame(calculateVisibleTabs);
+  }, [activeTab, containerRef, calculateVisibleTabs]);
+
   return {
     setTabRef,
     onTabClick,
     handleKeyboard,
     visibleTabs: tabs.visible,
     overflowTabs: tabs.overflow,
-    allTabsHidden,
+    isReady,
   };
 }
 
-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 initialTabValue = useMemo(
+    () => getInitialTab({ initialTab, searchParams, tabsId }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [],
+  );
+  const [activeTab, setActiveTab] = useState(initialTabValue);
   const prevActiveTabRef = useRef(activeTab);
 
   useEffect(() => {
@@ -228,10 +307,13 @@ export const useActiveTab = ({ initialTab, tabsId }: UseActiveTabProps) => {
     });
   }, [activeTab, setSearchParams, tabsId]);
 
-  return {
-    activeTab,
-    setActiveTab,
-  };
+  return useMemo(
+    () => ({
+      activeTab,
+      setActiveTab,
+    }),
+    [activeTab],
+  );
 };
 
 type GetInitialTabProps = {

package/src/core/hooks/use-telemetry-fallback.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line no-warning-comments
 // TODO we need to create some common way to do this.
 export const useTelemetryFallback = () => ({
   send: () => {},
@@ -37,20 +38,22 @@ export const useTelemetryFallback = () => ({
   sendLanguagePickerLocaleChangedMessage: () => {},
   sendSearchOpenedMessage: () => {},
   sendSearchQueryMessage: () => {},
+  sendSearchAiOpenedMessage: () => {},
   sendSearchAIQueryMessage: () => {},
+  sendSearchAIFeedbackMessage: () => {},
   sendFeedbackMessage: () => {},
   sendSearchResultClickedMessage: () => {},
   sendRedirectMessage: () => {},
   sendOpenapiDocsMessage: () => {},
   sendCopyCodeSnippetClickedMessage: () => {},
-  sendOpenapiDocsViewedMessage: () => {},
-  sendOpenapiDocsPerformanceMetricsMessage: () => {},
-  sendOpenapiDocsDownloadDefinitionClickedMessage: () => {},
-  sendOpenapiDocsSelectLanguageClickedMessage: () => {},
-  sendOpenapiDocsExpandCollapseAllClickedMessage: () => {},
-  sendOpenapiDocsSwitchServersClickedMessage: () => {},
-  sendOpenapiDocsExamplesSwitcherClickedMessage: () => {},
-  sendOpenapiDocsTryItOpenedMessage: () => {},
+  sendViewedMessage: () => {},
+  sendPerformanceMetricsMessage: () => {},
+  sendDownloadDefinitionClickedMessage: () => {},
+  sendSelectLanguageClickedMessage: () => {},
+  sendExpandCollapseAllClickedMessage: () => {},
+  sendSwitchServersClickedMessage: () => {},
+  sendExamplesSwitcherClickedMessage: () => {},
+  sendTryItOpenedMessage: () => {},
   sendAsyncapiDocsViewedMessage: () => {},
   sendAsyncapiDocsPerformanceMetricsMessage: () => {},
   sendAsyncapiDocsSwitchMessageClickedMessage: () => {},

package/src/core/hooks/use-theme-config.ts

@@ -4,6 +4,7 @@ import type { UiAccessibleConfig } from '../../config';
 
 import { ThemeDataContext } from '../contexts/ThemeDataContext';
 
+// eslint-disable-next-line no-warning-comments
 // TODO: rename and additionally export as alias for backward compatibility
 export function useThemeConfig<T extends Record<string, unknown>>(
   useProductConfig: boolean = true,

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

@@ -22,6 +22,7 @@ const fallbacks = {
   usePageData: () => null,
   usePageProps: () => ({}),
   usePageSharedData: () => null,
+  useMcpData: () => ({ docs: { enabled: false } }),
 };
 
 export const useThemeHooks = () => {
@@ -30,7 +31,7 @@ export const useThemeHooks = () => {
   return new Proxy({} as ThemeHooks, {
     get(_, prop) {
       if (context && prop in context.hooks) {
-        return (context.hooks as any)[prop];
+        return (context.hooks as Record<string, unknown>)[prop as string];
       } else if (prop in fallbacks) {
         return fallbacks[prop as keyof typeof fallbacks];
       } else {

package/src/core/openapi/index.ts

@@ -8,6 +8,7 @@ export type { UserClaims } from '../types/user-claims';
 export type { OperationParameter, ParameterHighlight } from '../types/search';
 export type { TFunction, TOptions } from '../types/l10n';
 export type { SelectOption, SelectProps } from '../types/select';
+export type { SegmentedOption, SegmentedProps } from '../types/segmented';
 export { IS_BROWSER } from '../utils/dom';
 export {
   addLeadingSlash,
@@ -18,11 +19,12 @@ export {
   withPathPrefix,
 } from '../utils/urls';
 export { capitalize } from '../utils/string';
-export { typedMemo } from '../hoc/typedMemo';
+export { typedMemo } from '../hoc/typed-memo';
 export { useMount } from '../hooks/use-mount';
 export { GlobalStyle } from '../styles/global';
 export { breakpoints } from '../utils/media-css';
 export { isPrimitive } from '../utils/args-typecheck';
+export { getOperationColor } from '../utils/get-operation-color';
 export { ClipboardService } from '../utils/clipboard-service';
 export { getUserAgent } from '../utils/get-user-agent';
 export { useFocusTrap } from '../hooks/use-focus-trap';

package/src/core/styles/dark.ts

@@ -36,6 +36,10 @@ const replayDarkMode = css`
   --replay-server-variable-bg-color-hover: rgba(31, 10, 144, 0.4); // @presenter Color
   --replay-path-parameter-bg-color-hover: rgba(5, 88, 99, 0.4); // @presenter Color
 
+  --replay-runtime-expression-color:  rgba(147, 166, 249, 1); // @presenter Color
+  --replay-runtime-expression-bg-color: rgba(147, 166, 249, 0.16); // @presenter Color
+  --replay-operators-color: rgba(168, 143, 88, 1); // @presenter Color
+
   // @tokens End
 `;
 

package/src/core/styles/global.ts

@@ -19,7 +19,7 @@ import { checkbox } from '@redocly/theme/icons/CheckboxIcon/variables';
 import { admonition } from '@redocly/theme/components/Admonition/variables';
 import { footer } from '@redocly/theme/components/Footer/variables';
 import { button } from '@redocly/theme/components/Button/variables';
-import { aiAssistantButton } from '@redocly/theme/components/Buttons/variables';
+import { aiAssistantButton, connectMCPButton } from '@redocly/theme/components/Buttons/variables';
 import { navbar } from '@redocly/theme/components/Navbar/variables';
 import { search } from '@redocly/theme/components/Search/variables';
 import { menu, mobileMenu } from '@redocly/theme/components/Menu/variables';
@@ -1224,6 +1224,10 @@ const replay = css`
   --replay-server-variable-bg-color-hover: rgba(119, 45, 240, 0.16); // @presenter Color
   --replay-path-parameter-bg-color-hover: rgba(4, 117, 161, 0.16); // @presenter Color
 
+  --replay-runtime-expression-color: rgba(54, 90, 249, 1); // @presenter Color
+  --replay-runtime-expression-bg-color: rgba(54, 90, 249, 0.08); // @presenter Color
+  --replay-operators-color: rgba(193, 142, 31, 1); // @presenter Color
+
   // @tokens End
 `;
 
@@ -1239,6 +1243,7 @@ export const styles = css`
     ${breadcrumbs}
     ${button}
     ${aiAssistantButton}
+    ${connectMCPButton}
     ${cards}
     ${catalog}
     ${catalogClassic}

package/src/core/templates/Markdown.tsx

@@ -43,6 +43,7 @@ export default function ({ pageProps, children }: React.PropsWithChildren<Markdo
       }
       setWrapperElement(node);
     },
+    // eslint-disable-next-line no-warning-comments
     // TODO: is this correct?
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [pageProps.headings],

package/src/core/types/catalog.ts

@@ -130,7 +130,7 @@ export type CatalogSwitcherItem = {
   slug: string;
   selected: boolean;
 };
-
+/* eslint-disable-next-line no-warning-comments */
 // TODO: remove this types after we make api-sdk package public and will be able import them from there
 export type BffCatalogRelatedEntity = {
   readonly id: string;
@@ -142,6 +142,7 @@ export type BffCatalogRelatedEntity = {
   relationRole: 'source' | 'target';
   relationType: EntityRelationType;
   sourceFile?: string | null;
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   metadata?: Record<string, any>;
   readonly createdAt: string | null;
   readonly updatedAt: string | null;
@@ -159,6 +160,7 @@ export type BffCatalogEntity = {
   owners?: Array<BffCatalogRelatedEntity>;
   summary?: string | null;
   tags?: Array<string>;
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   metadata?: Record<string, any>;
   git?: Array<string>;
   contact?: {

package/src/core/types/filter.ts

@@ -2,6 +2,7 @@ import type { ResolvedFilter } from './catalog';
 import type { RedoclyConfig } from '@redocly/config';
 
 export type FilterProps = {
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   filter: ResolvedFilter & { selectedOptions: any };
   filterValuesCasing?:
     | NonNullable<RedoclyConfig['catalog']>[string]['filterValuesCasing']

package/src/core/types/hooks.ts

@@ -86,6 +86,7 @@ export type ThemeHooks = {
   useSearch: (
     product?: string,
     autoSearchDisabled?: boolean,
+    searchSessionId?: string,
   ) => {
     query: string;
     setQuery: React.Dispatch<React.SetStateAction<string>>;
@@ -107,7 +108,10 @@ export type ThemeHooks = {
     advancedSearch?: boolean;
     askAi?: boolean;
   };
-  useAiSearch: (options?: { filter?: SearchFilterItem[] }) => {
+  useAiSearch: (
+    options?: { filter?: SearchFilterItem[] },
+    searchSessionId?: string,
+  ) => {
     askQuestion: (question: string, history?: AiSearchConversationItem[]) => void;
     isGeneratingResponse: boolean;
     question: string;
@@ -127,6 +131,12 @@ export type ThemeHooks = {
     setSearchFacet: React.Dispatch<React.SetStateAction<SearchFacet | null>>;
     setSearchFacetQuery: React.Dispatch<React.SetStateAction<SearchFacetQuery | null>>;
   };
+  useMcpData: () => {
+    docs: {
+      enabled: boolean;
+      name?: string;
+    };
+  };
   useSidebarItems: (activeVersion?: Version | null) => {
     currentItems: ItemState[];
     allSidebarItems: ItemState[];

package/src/core/types/index.ts

@@ -1,19 +1,21 @@
-export * from './breadcrumb';
-export * from './catalog';
-export * from './l10n';
-export * from './feedback';
-export * from './hooks';
-export * from './markdown';
-export * from './navbar';
+export type * from './breadcrumb';
+export type * from './catalog';
+export type * from './l10n';
+export type * from './mcp';
+export type * from './feedback';
+export type * from './hooks';
+export type * from './markdown';
+export type * from './navbar';
 export * from './search';
-export * from './select';
-export * from './sidebar';
-export * from './filter';
-export * from './user-menu';
-export * from './user-claims';
-export * from './common';
-export * from './open-api-server';
-export * from './marker';
-export * from './code-walkthrough';
-export * from './page-actions';
-export * from './open-api-info';
+export type * from './select';
+export type * from './sidebar';
+export type * from './filter';
+export type * from './user-menu';
+export type * from './user-claims';
+export type * from './common';
+export type * from './open-api-server';
+export type * from './marker';
+export type * from './code-walkthrough';
+export type * from './page-actions';
+export type * from './open-api-info';
+export type * from './segmented';