@redocly/theme 0.59.0-next.1 → 0.59.0-next.3

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/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;
@@ -142,6 +146,7 @@ export type ThemeHooks = {
     | undefined;
   useCatalog: (
     config?: CatalogEntityConfig,
+    serverFilters?: Record<string, { value: string; count: number }[]>,
     entitiesCounterInitial?: number,
     initialViewMode?: CatalogViewMode,
   ) => UseCatalogResponse;

package/src/core/types/l10n.ts

@@ -146,6 +146,7 @@ export type TranslationKey =
   | 'catalog.entity.metadata.title'
   | 'catalog.entity.schema.title'
   | 'catalog.entity.properties.apiDescription.title'
+  | 'catalog.backToAllLabel'
   | 'sidebar.menu.backLabel'
   | 'sidebar.menu.backToLabel'
   | 'sidebar.actions.show'

package/src/icons/AiStarsIcon/AiStarsIcon.tsx

@@ -35,19 +35,28 @@ export const AiStarsIcon = styled(Icon).attrs(() => ({
   height: ${({ size }) => size || '16px'};
   width: ${({ size }) => size || '16px'};
 
-  ${({ background, borderRadius, margin }) =>
+  ${({ background, borderRadius, margin, padding, size }) =>
     background &&
     `
       display: flex;
       align-items: center;
       justify-content: center;
+      flex-shrink: 0;
 
       background: ${getCssColorVariable(background)};
+      width: ${size || '16px'};
+      height: ${size || '16px'};
 
-      padding: var(--spacing-xs);
+      padding: ${padding || 'var(--spacing-xs)'};
       margin: ${margin || '0'};
       
       border-radius: ${background && borderRadius ? borderRadius : 'none'};
+      
+      svg {
+        width: calc(${size || '16px'} - 2 * (${padding || 'var(--spacing-xs)'}));
+        height: calc(${size || '16px'} - 2 * (${padding || 'var(--spacing-xs)'}));
+        flex-shrink: 0;
+      }
     `}
 
   color: ${({ color }) => color && getCssColorVariable(color)};

package/src/icons/RedoclyIcon/RedoclyIcon.tsx

@@ -6,29 +6,11 @@ import type { IconProps } from '@redocly/theme/icons/types';
 import { getCssColorVariable } from '@redocly/theme/core/utils';
 
 const Icon = (props: IconProps) => (
-  <svg
-    width="18"
-    height="18"
-    viewBox="0 0 18 18"
-    fill="none"
-    xmlns="http://www.w3.org/2000/svg"
-    {...props}
-  >
-    <g clipPath="url(#clip0_4053_1165)">
-      <path
-        d="M14.625 6.19973C14.625 8.69176 12.6173 10.712 10.1406 10.712H2.8125V10.2717C5.04753 10.2717 6.85938 8.44864 6.85938 6.19973C6.85938 3.95082 5.04753 2.12772 2.8125 2.12772V1.6875H10.1406C12.6173 1.6875 14.625 3.70769 14.625 6.19973Z"
-        fill="#2467F2"
-      />
-      <path
-        d="M14.625 16.875C14.625 14.383 12.6173 12.3628 10.1406 12.3628H2.8125V12.803C5.04753 12.803 6.85938 14.6261 6.85938 16.875H14.625Z"
-        fill="#2467F2"
-      />
+  <svg viewBox="0 0 18 18" xmlns="http://www.w3.org/2000/svg" {...props}>
+    <g>
+      <path d="M14.625 6.19973C14.625 8.69176 12.6173 10.712 10.1406 10.712H2.8125V10.2717C5.04753 10.2717 6.85938 8.44864 6.85938 6.19973C6.85938 3.95082 5.04753 2.12772 2.8125 2.12772V1.6875H10.1406C12.6173 1.6875 14.625 3.70769 14.625 6.19973Z" />
+      <path d="M14.625 16.875C14.625 14.383 12.6173 12.3628 10.1406 12.3628H2.8125V12.803C5.04753 12.803 6.85938 14.6261 6.85938 16.875H14.625Z" />
     </g>
-    <defs>
-      <clipPath id="clip0_4053_1165">
-        <rect width="18" height="18" fill="white" />
-      </clipPath>
-    </defs>
   </svg>
 );