@pisell/materials 6.7.4 → 6.8.2

package/lib/components/PisellProcedure/hooks/useElementSize.js

@@ -0,0 +1,175 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/PisellProcedure/hooks/useElementSize.ts
+var useElementSize_exports = {};
+__export(useElementSize_exports, {
+  useElementSize: () => useElementSize
+});
+module.exports = __toCommonJS(useElementSize_exports);
+var import_react = require("react");
+var useElementSize = ({
+  selector,
+  enabled = true,
+  defaultWidth = 0,
+  defaultHeight = 0,
+  threshold = 1,
+  debounceMs = 100
+}) => {
+  const [size, setSize] = (0, import_react.useState)({
+    width: defaultWidth,
+    height: defaultHeight
+  });
+  const previousSizeRef = (0, import_react.useRef)({
+    width: defaultWidth,
+    height: defaultHeight
+  });
+  const debounceTimerRef = (0, import_react.useRef)(null);
+  const resizeObserverRef = (0, import_react.useRef)(null);
+  const elementRef = (0, import_react.useRef)(null);
+  const calculateSize = (0, import_react.useCallback)(() => {
+    if (!enabled || typeof window === "undefined" || typeof document === "undefined") {
+      setSize({ width: defaultWidth, height: defaultHeight });
+      return;
+    }
+    if (!selector || !selector.trim()) {
+      setSize({ width: defaultWidth, height: defaultHeight });
+      return;
+    }
+    try {
+      const element = document.querySelector(selector);
+      if (element) {
+        const rect = element.getBoundingClientRect();
+        const newWidth = rect.width;
+        const newHeight = rect.height;
+        const previousSize = previousSizeRef.current;
+        const widthDiff = Math.abs(newWidth - previousSize.width);
+        const heightDiff = Math.abs(newHeight - previousSize.height);
+        if (widthDiff >= threshold || heightDiff >= threshold) {
+          const newSize = {
+            width: newWidth,
+            height: newHeight
+          };
+          previousSizeRef.current = newSize;
+          setSize(newSize);
+        }
+      } else {
+        if (previousSizeRef.current.width !== defaultWidth || previousSizeRef.current.height !== defaultHeight) {
+          const newSize = {
+            width: defaultWidth,
+            height: defaultHeight
+          };
+          previousSizeRef.current = newSize;
+          setSize(newSize);
+        }
+      }
+    } catch (error) {
+      console.warn(`Invalid selector in useElementSize: ${selector}`, error);
+      if (previousSizeRef.current.width !== defaultWidth || previousSizeRef.current.height !== defaultHeight) {
+        const newSize = {
+          width: defaultWidth,
+          height: defaultHeight
+        };
+        previousSizeRef.current = newSize;
+        setSize(newSize);
+      }
+    }
+  }, [selector, enabled, defaultWidth, defaultHeight, threshold]);
+  const debouncedCalculateSize = (0, import_react.useCallback)(() => {
+    if (debounceTimerRef.current) {
+      clearTimeout(debounceTimerRef.current);
+    }
+    debounceTimerRef.current = setTimeout(() => {
+      calculateSize();
+    }, debounceMs);
+  }, [calculateSize, debounceMs]);
+  (0, import_react.useEffect)(() => {
+    if (!enabled || typeof window === "undefined" || typeof document === "undefined") {
+      return;
+    }
+    if (!selector || !selector.trim()) {
+      setSize({ width: defaultWidth, height: defaultHeight });
+      previousSizeRef.current = { width: defaultWidth, height: defaultHeight };
+      return;
+    }
+    let element = null;
+    try {
+      element = document.querySelector(selector);
+    } catch (error) {
+      console.warn(`Invalid selector in useElementSize: ${selector}`, error);
+      setSize({ width: defaultWidth, height: defaultHeight });
+      previousSizeRef.current = { width: defaultWidth, height: defaultHeight };
+      return;
+    }
+    if (!element) {
+      setSize({ width: defaultWidth, height: defaultHeight });
+      previousSizeRef.current = { width: defaultWidth, height: defaultHeight };
+      return;
+    }
+    elementRef.current = element;
+    calculateSize();
+    const initialTimer = setTimeout(() => {
+      debouncedCalculateSize();
+    }, 200);
+    if (typeof ResizeObserver !== "undefined") {
+      resizeObserverRef.current = new ResizeObserver(() => {
+        debouncedCalculateSize();
+      });
+      resizeObserverRef.current.observe(element);
+    } else {
+      const mutationObserver = new MutationObserver(() => {
+        debouncedCalculateSize();
+      });
+      mutationObserver.observe(element, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ["style", "class"]
+      });
+      const handleResize = () => {
+        debouncedCalculateSize();
+      };
+      window.addEventListener("resize", handleResize);
+      return () => {
+        clearTimeout(initialTimer);
+        if (debounceTimerRef.current) {
+          clearTimeout(debounceTimerRef.current);
+        }
+        mutationObserver.disconnect();
+        if (typeof window !== "undefined") {
+          window.removeEventListener("resize", handleResize);
+        }
+      };
+    }
+    return () => {
+      clearTimeout(initialTimer);
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+      if (resizeObserverRef.current && elementRef.current) {
+        resizeObserverRef.current.unobserve(elementRef.current);
+        resizeObserverRef.current.disconnect();
+      }
+    };
+  }, [selector, enabled, defaultWidth, defaultHeight, calculateSize, debouncedCalculateSize]);
+  return size;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useElementSize
+});

package/lib/components/PisellProcedure/hooks/useOverflowActions.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { MenuProps } from 'antd';
+/**
+ * useOverflowActions Hook 配置
+ */
+export interface UseOverflowActionsOptions {
+    /** 操作按钮子元素 */
+    children?: React.ReactNode;
+    /** 按钮间距 */
+    gap?: number;
+    /** More 按钮文案 */
+    moreText?: string;
+}
+/**
+ * useOverflowActions Hook 返回值
+ */
+export interface UseOverflowActionsReturn {
+    /** 容器 ref */
+    containerRef: React.RefObject<HTMLDivElement>;
+    /** 测量容器 ref */
+    measureRef: React.RefObject<HTMLDivElement>;
+    /** More 按钮测量 ref */
+    moreButtonRef: React.RefObject<HTMLDivElement>;
+    /** 左侧插槽 ref（用于测量宽度） */
+    leftSlotRef: React.RefObject<HTMLDivElement>;
+    /** 所有操作项 */
+    actionItems: React.ReactNode[];
+    /** 可见的操作项 */
+    visibleActions: React.ReactNode[];
+    /** 溢出的操作项 */
+    overflowActions: React.ReactNode[];
+    /** 是否有溢出 */
+    hasOverflow: boolean;
+    /** More 菜单项 */
+    moreMenuItems: MenuProps['items'];
+    /** 可用宽度（用于调试） */
+    availableWidth: number;
+}
+/**
+ * 溢出收纳 Hook
+ * @description 处理操作按钮的溢出收纳逻辑，支持左侧自定义内容
+ */
+export declare const useOverflowActions: (options: UseOverflowActionsOptions) => UseOverflowActionsReturn;

package/lib/components/PisellProcedure/hooks/useOverflowActions.js

@@ -0,0 +1,219 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/PisellProcedure/hooks/useOverflowActions.ts
+var useOverflowActions_exports = {};
+__export(useOverflowActions_exports, {
+  useOverflowActions: () => useOverflowActions
+});
+module.exports = __toCommonJS(useOverflowActions_exports);
+var import_react = require("react");
+var import_extractText = require("../utils/extractText");
+var useOverflowActions = (options) => {
+  const { children, gap = 16, moreText = "More" } = options;
+  const containerRef = (0, import_react.useRef)(null);
+  const measureRef = (0, import_react.useRef)(null);
+  const moreButtonRef = (0, import_react.useRef)(null);
+  const leftSlotRef = (0, import_react.useRef)(null);
+  const [itemWidths, setItemWidths] = (0, import_react.useState)([]);
+  const [moreButtonWidth, setMoreButtonWidth] = (0, import_react.useState)(80);
+  const [availableWidth, setAvailableWidth] = (0, import_react.useState)(0);
+  const actionItems = (0, import_react.useMemo)(() => {
+    const items = [];
+    import_react.Children.forEach(children, (child, index) => {
+      if ((0, import_react.isValidElement)(child)) {
+        items.push(
+          (0, import_react.cloneElement)(child, {
+            key: child.key ?? index
+          })
+        );
+      }
+    });
+    return items;
+  }, [children]);
+  const measureWidths = (0, import_react.useCallback)(() => {
+    if (typeof window === "undefined" || !measureRef.current || !moreButtonRef.current) return;
+    try {
+      const buttons = measureRef.current.querySelectorAll("[data-measure-item]");
+      const widths = [];
+      buttons.forEach((btn) => {
+        const rect = btn.getBoundingClientRect();
+        if (rect) {
+          widths.push(Math.ceil(rect.width));
+        }
+      });
+      setItemWidths(widths);
+      const moreBtnRect = moreButtonRef.current.getBoundingClientRect();
+      if (moreBtnRect) {
+        const moreBtnWidth = Math.ceil(moreBtnRect.width);
+        setMoreButtonWidth(moreBtnWidth);
+      }
+    } catch (error) {
+      console.warn("Failed to measure button widths:", error);
+    }
+  }, []);
+  const updateAvailableWidth = (0, import_react.useCallback)(() => {
+    if (!containerRef.current || typeof window === "undefined") return;
+    const parent = containerRef.current.parentElement;
+    if (!parent) {
+      const containerRect = containerRef.current.getBoundingClientRect();
+      setAvailableWidth(Math.floor(containerRect.width));
+      return;
+    }
+    const parentStyle = window.getComputedStyle(parent);
+    const parentRect = parent.getBoundingClientRect();
+    const scale = parent.offsetWidth > 0 ? parentRect.width / parent.offsetWidth : 1;
+    const paddingLeft = (parseFloat(parentStyle.paddingLeft) || 0) * scale;
+    const paddingRight = (parseFloat(parentStyle.paddingRight) || 0) * scale;
+    const parentGap = (parseFloat(parentStyle.gap) || gap) * scale;
+    let leftSlotWidth = 0;
+    if (leftSlotRef.current) {
+      leftSlotWidth = Math.ceil(leftSlotRef.current.getBoundingClientRect().width);
+      if (leftSlotWidth > 0) {
+        leftSlotWidth += parentGap;
+      }
+    }
+    let otherSiblingWidth = 0;
+    const siblings = parent.children;
+    for (let i = 0; i < siblings.length; i++) {
+      const sibling = siblings[i];
+      if (sibling !== containerRef.current && sibling !== leftSlotRef.current && !sibling.hasAttribute("aria-hidden")) {
+        const siblingWidth = Math.ceil(sibling.getBoundingClientRect().width);
+        if (siblingWidth > 0) {
+          otherSiblingWidth += siblingWidth + parentGap;
+        }
+      }
+    }
+    const totalWidth = parentRect.width - paddingLeft - paddingRight;
+    const width = Math.floor(totalWidth - leftSlotWidth - otherSiblingWidth);
+    setAvailableWidth(Math.max(0, width));
+  }, [gap]);
+  (0, import_react.useEffect)(() => {
+    const rafId = requestAnimationFrame(() => {
+      measureWidths();
+      updateAvailableWidth();
+    });
+    return () => cancelAnimationFrame(rafId);
+  }, [actionItems, measureWidths, updateAvailableWidth]);
+  (0, import_react.useEffect)(() => {
+    var _a;
+    if (typeof window === "undefined") return;
+    const handleResize = () => {
+      measureWidths();
+      updateAvailableWidth();
+    };
+    window.addEventListener("resize", handleResize);
+    const parent = (_a = containerRef.current) == null ? void 0 : _a.parentElement;
+    let resizeObserver = null;
+    if (parent && typeof ResizeObserver !== "undefined") {
+      try {
+        resizeObserver = new ResizeObserver(() => {
+          measureWidths();
+          updateAvailableWidth();
+        });
+        resizeObserver.observe(parent);
+      } catch (error) {
+        console.warn("Failed to create ResizeObserver:", error);
+      }
+    }
+    if (leftSlotRef.current && typeof ResizeObserver !== "undefined") {
+      try {
+        const leftObserver = new ResizeObserver(() => updateAvailableWidth());
+        leftObserver.observe(leftSlotRef.current);
+        return () => {
+          window.removeEventListener("resize", handleResize);
+          resizeObserver == null ? void 0 : resizeObserver.disconnect();
+          leftObserver.disconnect();
+        };
+      } catch (error) {
+        console.warn("Failed to create ResizeObserver for leftSlot:", error);
+      }
+    }
+    return () => {
+      window.removeEventListener("resize", handleResize);
+      resizeObserver == null ? void 0 : resizeObserver.disconnect();
+    };
+  }, [measureWidths, updateAvailableWidth]);
+  const visibleCount = (0, import_react.useMemo)(() => {
+    if (itemWidths.length === 0 || availableWidth === 0) {
+      return actionItems.length;
+    }
+    const totalItems = itemWidths.length;
+    const totalButtonsWidth = itemWidths.reduce((sum, w) => sum + w, 0);
+    const totalGapsWidth = (totalItems - 1) * gap;
+    const allButtonsWidth = totalButtonsWidth + totalGapsWidth;
+    if (allButtonsWidth <= availableWidth) {
+      return totalItems;
+    }
+    const spaceForButtons = availableWidth - moreButtonWidth - gap;
+    if (spaceForButtons <= 0) {
+      return 0;
+    }
+    let usedWidth = 0;
+    let count = 0;
+    for (let i = totalItems - 1; i >= 0; i--) {
+      const itemWidth = itemWidths[i];
+      const gapWidth = count > 0 ? gap : 0;
+      const requiredWidth = itemWidth + gapWidth;
+      if (usedWidth + requiredWidth <= spaceForButtons) {
+        usedWidth += requiredWidth;
+        count++;
+      } else {
+        break;
+      }
+    }
+    return count;
+  }, [itemWidths, availableWidth, gap, moreButtonWidth, actionItems.length]);
+  const overflowCount = Math.max(0, actionItems.length - visibleCount);
+  const overflowActions = actionItems.slice(0, overflowCount);
+  const visibleActions = actionItems.slice(overflowCount);
+  const hasOverflow = overflowCount > 0;
+  const moreMenuItems = (0, import_react.useMemo)(() => {
+    return overflowActions.map((action, index) => {
+      if (!(0, import_react.isValidElement)(action)) return null;
+      const buttonProps = action.props;
+      const label = (0, import_extractText.extractButtonLabel)(buttonProps, `操作 ${index + 1}`);
+      const originalOnClick = buttonProps == null ? void 0 : buttonProps.onClick;
+      return {
+        key: `overflow-${index}`,
+        label,
+        onClick: originalOnClick ? () => originalOnClick({}) : void 0,
+        disabled: (buttonProps == null ? void 0 : buttonProps.disabled) || (buttonProps == null ? void 0 : buttonProps.loading),
+        danger: buttonProps == null ? void 0 : buttonProps.danger,
+        icon: buttonProps == null ? void 0 : buttonProps.icon,
+        title: buttonProps == null ? void 0 : buttonProps.title
+      };
+    }).filter(Boolean);
+  }, [overflowActions]);
+  return {
+    containerRef,
+    measureRef,
+    moreButtonRef,
+    leftSlotRef,
+    actionItems,
+    visibleActions,
+    overflowActions,
+    hasOverflow,
+    moreMenuItems,
+    availableWidth
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useOverflowActions
+});

package/lib/components/PisellProcedure/hooks/useResponsiveClass.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 使用响应式类名的 Hook
+ *
+ * @description 根据容器宽度计算响应式类名，延迟应用以避免宽度抖动
+ */
+export declare const useResponsiveClass: (containerWidth: number) => string;

package/lib/components/PisellProcedure/hooks/useResponsiveClass.js

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/PisellProcedure/hooks/useResponsiveClass.ts
+var useResponsiveClass_exports = {};
+__export(useResponsiveClass_exports, {
+  useResponsiveClass: () => useResponsiveClass
+});
+module.exports = __toCommonJS(useResponsiveClass_exports);
+var import_react = require("react");
+var RESPONSIVE_BREAKPOINTS = {
+  lg: 1133,
+  // ≥1133px: 默认样式（405px）
+  md: 960,
+  // 960px-1133px: 376px ~ 405px 线性插值
+  sm: 744
+  // 744px-960px: 290px ~ 376px 线性插值
+};
+var RESPONSIVE_CLASSES = {
+  md: "pisell-procedure-sidebar--responsive-md",
+  sm: "pisell-procedure-sidebar--responsive-sm",
+  xs: "pisell-procedure-sidebar--responsive-xs"
+  // 最小宽度（< 744px）
+};
+var getResponsiveClass = (width) => {
+  if (width === 0) return "";
+  if (width >= RESPONSIVE_BREAKPOINTS.lg) {
+    return "";
+  }
+  if (width >= RESPONSIVE_BREAKPOINTS.md) {
+    return RESPONSIVE_CLASSES.md;
+  }
+  if (width >= RESPONSIVE_BREAKPOINTS.sm) {
+    return RESPONSIVE_CLASSES.sm;
+  }
+  return RESPONSIVE_CLASSES.xs;
+};
+var useResponsiveClass = (containerWidth) => {
+  const [responsiveCls, setResponsiveCls] = (0, import_react.useState)("");
+  const previousWidthRef = (0, import_react.useRef)(0);
+  const rafIdRef = (0, import_react.useRef)(null);
+  const stableCheckCountRef = (0, import_react.useRef)(0);
+  (0, import_react.useEffect)(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (containerWidth === 0) {
+      setResponsiveCls("");
+      previousWidthRef.current = 0;
+      stableCheckCountRef.current = 0;
+      return;
+    }
+    if (rafIdRef.current !== null) {
+      cancelAnimationFrame(rafIdRef.current);
+    }
+    const checkStability = () => {
+      const currentWidth = containerWidth;
+      const previousWidth = previousWidthRef.current;
+      if (Math.abs(currentWidth - previousWidth) >= 5) {
+        stableCheckCountRef.current = 0;
+        previousWidthRef.current = currentWidth;
+      }
+      stableCheckCountRef.current += 1;
+      if (stableCheckCountRef.current >= 3) {
+        const newCls = getResponsiveClass(currentWidth);
+        setResponsiveCls(newCls);
+        previousWidthRef.current = currentWidth;
+        stableCheckCountRef.current = 0;
+      } else {
+        rafIdRef.current = requestAnimationFrame(checkStability);
+      }
+    };
+    rafIdRef.current = requestAnimationFrame(checkStability);
+    return () => {
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = null;
+      }
+    };
+  }, [containerWidth]);
+  return responsiveCls;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useResponsiveClass
+});

package/lib/components/PisellProcedure/hooks/useSidebarHeight.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 尺寸值接口
+ */
+interface SizeValues {
+    containerSelector?: string;
+    containerHeight?: number;
+    headerHeight?: number;
+    footerHeight: number;
+}
+/**
+ * 使用 Sidebar 高度的 Hook
+ *
+ * @description 计算并管理 Sidebar 的高度，确保在尺寸稳定后才应用
+ */
+export declare const useSidebarHeight: (isSizeStable: boolean, sizeValues: SizeValues) => number | undefined;
+export {};

package/lib/components/PisellProcedure/hooks/useSidebarHeight.js

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/PisellProcedure/hooks/useSidebarHeight.ts
+var useSidebarHeight_exports = {};
+__export(useSidebarHeight_exports, {
+  useSidebarHeight: () => useSidebarHeight
+});
+module.exports = __toCommonJS(useSidebarHeight_exports);
+var import_react = require("react");
+var useSidebarHeight = (isSizeStable, sizeValues) => {
+  const [siderHeight, setSiderHeight] = (0, import_react.useState)(void 0);
+  const hasInitializedRef = (0, import_react.useRef)(false);
+  const rafIdRef = (0, import_react.useRef)(null);
+  const stableCheckCountRef = (0, import_react.useRef)(0);
+  const previousSiderHeightRef = (0, import_react.useRef)(void 0);
+  const sizeValuesRef = (0, import_react.useRef)(sizeValues);
+  (0, import_react.useEffect)(() => {
+    sizeValuesRef.current = sizeValues;
+  }, [sizeValues]);
+  const calculateHeight = (0, import_react.useCallback)(() => {
+    const {
+      containerSelector,
+      containerHeight,
+      headerHeight,
+      footerHeight
+    } = sizeValuesRef.current;
+    let baseHeight;
+    if (containerSelector && containerSelector.trim() && containerHeight && containerHeight > 0) {
+      baseHeight = containerHeight;
+    } else {
+      baseHeight = typeof window !== "undefined" ? window.innerHeight : 0;
+    }
+    const bodyPadding = 16 * 2;
+    const headerHeightValue = headerHeight || 0;
+    const calculatedHeight = baseHeight - headerHeightValue - footerHeight - bodyPadding;
+    return calculatedHeight;
+  }, []);
+  (0, import_react.useEffect)(() => {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return;
+    }
+    if (!isSizeStable) {
+      hasInitializedRef.current = false;
+      stableCheckCountRef.current = 0;
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = null;
+      }
+      return;
+    }
+    if (rafIdRef.current !== null) {
+      cancelAnimationFrame(rafIdRef.current);
+    }
+    const checkStability = () => {
+      if (!isSizeStable) {
+        stableCheckCountRef.current = 0;
+        return;
+      }
+      const calculatedHeight = calculateHeight();
+      if (calculatedHeight <= 0) {
+        stableCheckCountRef.current = 0;
+        return;
+      }
+      const previousHeight = previousSiderHeightRef.current;
+      if (hasInitializedRef.current && previousHeight !== void 0 && Math.abs(calculatedHeight - previousHeight) < 10) {
+        return;
+      }
+      stableCheckCountRef.current += 1;
+      if (stableCheckCountRef.current >= 3) {
+        previousSiderHeightRef.current = calculatedHeight;
+        setSiderHeight(calculatedHeight);
+        hasInitializedRef.current = true;
+        stableCheckCountRef.current = 0;
+      } else {
+        rafIdRef.current = requestAnimationFrame(checkStability);
+      }
+    };
+    rafIdRef.current = requestAnimationFrame(checkStability);
+    return () => {
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = null;
+      }
+    };
+  }, [isSizeStable, calculateHeight]);
+  return siderHeight;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSidebarHeight
+});