@heymantle/litho 0.0.10 → 0.0.12

package/dist/esm/components/Pane.js

@@ -46,35 +46,504 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { CancelMajor, ArrowLeftMinor, MaximizeMajor, MinimizeMajor } from "@shopify/polaris-icons";
+import { ArrowLeftMinor, ChevronLeftMinor, ChevronRightMinor } from "@shopify/polaris-icons";
 import { tv } from "tailwind-variants";
-import { createContext, useContext, useEffect, Children, useState } from "react";
+import React, { createContext, useEffect, useLayoutEffect, useState, useMemo, useRef, useCallback } from "react";
 import Text from "./Text.js";
 import Button from "./Button.js";
 import Popover from "./Popover.js";
 import ActionList from "./ActionList.js";
+import TabNavigation from "./TabNavigation.js";
 import { useFrame } from "./Frame.js";
+import Icon from "./Icon.js";
+import { usePaneState } from "../utilities/usePaneState.js";
+import { useMobile } from "../utilities/useMobile.js";
+import { useBodyScrollLock } from "../utilities/useBodyScrollLock.js";
+import { useKeyboardAction } from "../utilities/useKeyboardAction.js";
+import Tooltip from "./Tooltip.js";
+// Reference counter for pane open state (shared across all Pane components)
+var paneOpenCount = 0;
+var MIN_PANE_WIDTH = 360;
+var MAX_PANE_WIDTH = 800;
+var COLLAPSED_WIDTH = 28;
+var MOBILE_BREAKPOINT = 768;
+var ZERO_WIDTH = '0px';
+var COLLAPSED_WIDTH_STR = "".concat(COLLAPSED_WIDTH, "px");
+var calculatePaneWidth = function(open, isMobile, isCollapsed, paneWidth) {
+    // Early returns for common cases (ordered by frequency/likelihood)
+    if (!open) return ZERO_WIDTH;
+    if (isCollapsed) return COLLAPSED_WIDTH_STR;
+    if (isMobile) return ZERO_WIDTH; // Full screen on mobile when expanded
+    // Only format paneWidth when actually needed
+    return "".concat(paneWidth, "px");
+};
 var styles = tv({
-    base: "Litho-Pane hidden md:block fixed inset-0 w-full md:left-auto md:max-w-[var(--litho-pane-width)] block bg-surface-lowest shadow-pane-inner pointer-events-auto"
+    base: "Litho-Pane fixed right-0 w-full md:w-[var(--litho-pane-width)] bg-surface-lowest shadow-pane-inner pointer-events-auto transition-all duration-200",
+    variants: {
+        collapsed: {
+            true: "md:w-7 md:h-screen md:flex-shrink-0"
+        },
+        isMobile: {
+            true: "top-0 bottom-0",
+            false: "top-0 h-full"
+        }
+    },
+    defaultVariants: {
+        isMobile: false
+    }
 });
 var innerStyles = tv({
-    base: "relative flex flex-col overflow-y-auto h-full"
+    base: "relative flex flex-col h-full",
+    variants: {
+        collapsed: {
+            true: "bg-surface-lowest cursor-pointer overflow-visible",
+            false: "overflow-hidden"
+        }
+    }
 });
-var dragHandleStyles = tv({
-    base: "cursor-col-resize absolute top-0 left-0 w-1 h-full transition-colors duration-300 hover-delay hover:bg-tint-3"
+// Content styles will be applied inline with dynamic width
+var getContentStyles = function(collapsed, width) {
+    return {
+        width: width,
+        transition: 'opacity 200ms ease-in-out',
+        pointerEvents: collapsed ? 'none' : 'auto',
+        opacity: collapsed ? 0 : 1
+    };
+};
+var resizeHandleStyles = tv({
+    base: "absolute top-0 left-0 w-1 h-full transition-colors duration-300 hover-delay hover:bg-tint-3 cursor-col-resize z-10",
+    variants: {
+        resizing: {
+            true: "bg-tint-3"
+        }
+    }
+});
+var collapseHandleStyles = tv({
+    base: "group/collapse-handle bg-surface-normal w-5 hover:w-6 h-10 flex-shrink-0 flex items-center justify-center cursor-pointer transition-all duration-200 ease-in-out rounded-r-sm",
+    variants: {
+        variant: {
+            expanded: "",
+            collapsed: "hover:bg-surface-lower"
+        }
+    },
+    defaultVariants: {
+        variant: "expanded"
+    }
 });
-var PaneContext = /*#__PURE__*/ createContext({});
+export var PaneContext = /*#__PURE__*/ createContext({});
+// Collapse button component to reduce duplication
+function CollapseButton(param) {
+    var variant = param.variant, icon = param.icon, label = param.label, onClick = param.onClick, onKeyDown = param.onKeyDown, _param_stopPropagation = param.stopPropagation, stopPropagation = _param_stopPropagation === void 0 ? false : _param_stopPropagation;
+    return /*#__PURE__*/ _jsx("div", {
+        className: "absolute left-0 top-1/2 -translate-y-1/2",
+        children: /*#__PURE__*/ _jsx(Tooltip, {
+            content: label,
+            preferredPosition: "above",
+            alignment: "right",
+            children: /*#__PURE__*/ _jsx("div", {
+                className: collapseHandleStyles({
+                    variant: variant
+                }),
+                onClick: function(e) {
+                    if (stopPropagation) e.stopPropagation();
+                    onClick(e);
+                },
+                role: "button",
+                tabIndex: 0,
+                onKeyDown: onKeyDown,
+                "aria-label": label,
+                children: /*#__PURE__*/ _jsx(Icon, {
+                    source: icon,
+                    color: "subdued"
+                })
+            })
+        })
+    });
+}
 function Pane() {
     var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    var open = props.open, onClose = props.onClose, children = props.children;
+    var _tabStorage_tabs;
+    var open = props.open, onClose = props.onClose, onOpen = props.onOpen, children = props.children, tabStorage = props.tabStorage, onTabRemove = props.onTabRemove, onExpandRef = props.onExpandRef, // Generic tab configuration
+    tabId = props.tabId, tabTitle = props.tabTitle, tabKey = props.tabKey, orgId = props.orgId;
     var setPaneIsOpen = useFrame().setPaneIsOpen;
-    var classes = styles();
+    var paneRef = useRef(null);
+    var resizeHandleRef = useRef(null);
+    var paneWidthRef = useRef(null);
+    var resizeHandlersRef = useRef({
+        mouseMove: null,
+        mouseUp: null
+    });
+    var isMountedRef = useRef(true);
+    var hasRegisteredRef = useRef(false);
+    var previousTabCountRef = useRef(0);
+    var _useState = _sliced_to_array(useState(false), 2), isTransitioning = _useState[0], setIsTransitioning = _useState[1];
+    var isPastInitialMountRef = useRef(false);
+    var previousOpenPropRef = useRef(open);
+    // Get orgId from prop or tabStorage (tabStorage always has orgId set, either passed or 'default')
+    var currentOrgId = orgId || (tabStorage === null || tabStorage === void 0 ? void 0 : tabStorage.orgId);
+    // Use consolidated pane state hook with orgId
+    var _usePaneState = usePaneState(currentOrgId), paneState = _usePaneState.state, setPaneWidth = _usePaneState.setWidth, setIsCollapsed = _usePaneState.setCollapsed, setPaneOpen = _usePaneState.setOpen, refreshFromStorage = _usePaneState.refreshFromStorage;
+    var isCollapsed = paneState.collapsed;
+    var paneWidth = paneState.width;
+    // Helper to open the pane (updates localStorage and notifies parent)
+    var openPane = useCallback(function() {
+        setPaneOpen(true);
+        onOpen === null || onOpen === void 0 ? void 0 : onOpen();
+    }, [
+        setPaneOpen,
+        onOpen
+    ]);
+    // Helper to close the pane (updates localStorage and resets collapsed state)
+    var closePane = useCallback(function() {
+        setPaneOpen(false);
+        setIsCollapsed(false);
+    }, [
+        setPaneOpen,
+        setIsCollapsed
+    ]);
+    // Helper to close pane and notify parent (consolidates common pattern)
+    var closePaneAndNotify = useCallback(function() {
+        closePane();
+        onClose === null || onClose === void 0 ? void 0 : onClose();
+    }, [
+        closePane,
+        onClose
+    ]);
+    // Read from localStorage when pane opens (user action, not page load)
+    useEffect(function() {
+        if (open && refreshFromStorage && currentOrgId) {
+            refreshFromStorage();
+        }
+    }, [
+        open,
+        refreshFromStorage,
+        currentOrgId
+    ]);
+    // Update pane open state in localStorage when open prop changes
+    // The setPaneOpen setter will handle first-time state creation automatically
+    useEffect(function() {
+        if (!currentOrgId) return;
+        // Only update if open prop actually changed (not on every render)
+        if (previousOpenPropRef.current === open) return;
+        previousOpenPropRef.current = open;
+        if (open) {
+            // Set open to true when pane opens (creates state if it doesn't exist)
+            setPaneOpen(true);
+        } else {
+            // Set open to false when pane closes, and reset collapsed state
+            closePane();
+        }
+    }, [
+        open,
+        currentOrgId,
+        setPaneOpen,
+        closePane
+    ]);
+    var _useState1 = _sliced_to_array(useState(false), 2), isResizing = _useState1[0], setIsResizing = _useState1[1];
+    // Use mobile detection hook
+    var isMobile = useMobile(MOBILE_BREAKPOINT);
+    // Keep ref in sync with state
+    useEffect(function() {
+        paneWidthRef.current = paneWidth;
+    }, [
+        paneWidth
+    ]);
+    // Get the active tab data
+    var activeTab = useMemo(function() {
+        if (!(tabStorage === null || tabStorage === void 0 ? void 0 : tabStorage.activeTabId)) return null;
+        return tabStorage.tabs.find(function(tab) {
+            return tab.id === tabStorage.activeTabId;
+        }) || null;
+    }, [
+        tabStorage === null || tabStorage === void 0 ? void 0 : tabStorage.tabs,
+        tabStorage === null || tabStorage === void 0 ? void 0 : tabStorage.activeTabId
+    ]);
+    // Handle tab creation, activation, and ensure active tab exists when pane opens
+    useEffect(function() {
+        if (!open || !tabStorage) return;
+        // If tabId and tabTitle are provided, create/update/activate that tab
+        if (tabId && tabTitle) {
+            var existingTab = tabStorage.tabs.find(function(tab) {
+                return tab.id === tabId;
+            });
+            var wasAlreadyActive = existingTab && tabStorage.activeTabId === tabId;
+            if (existingTab) {
+                // Tab exists - switch to it if not already active
+                if (!wasAlreadyActive) {
+                    tabStorage.setActiveTab(tabId);
+                }
+                // Update title/key if changed
+                if (existingTab.title !== tabTitle) {
+                    tabStorage.updateTab(tabId, {
+                        title: tabTitle
+                    });
+                }
+                if (tabKey !== undefined && existingTab.key !== tabKey) {
+                    tabStorage.updateTab(tabId, {
+                        key: tabKey
+                    });
+                }
+            } else {
+                // Create new tab
+                tabStorage.addTab({
+                    id: tabId,
+                    title: tabTitle,
+                    key: tabKey
+                });
+            }
+        }
+        // Ensure an active tab is set (fallback if tabId/tabTitle not provided or if active tab doesn't exist)
+        if (tabStorage.tabs.length > 0) {
+            var activeTabExists = tabStorage.activeTabId && tabStorage.tabs.some(function(tab) {
+                return tab.id === tabStorage.activeTabId;
+            });
+            if (!activeTabExists) {
+                var firstTab = tabStorage.tabs[0];
+                if (firstTab) {
+                    tabStorage.setActiveTab(firstTab.id);
+                }
+            }
+        }
+    }, [
+        open,
+        tabStorage,
+        tabId,
+        tabTitle,
+        tabKey
+    ]);
+    // Auto-open pane when tabs are added (user action, not page load)
+    useEffect(function() {
+        var _tabStorage_tabs;
+        if (!tabStorage || !currentOrgId) {
+            previousTabCountRef.current = 0;
+            return;
+        }
+        var currentTabCount = ((_tabStorage_tabs = tabStorage.tabs) === null || _tabStorage_tabs === void 0 ? void 0 : _tabStorage_tabs.length) || 0;
+        var previousTabCount = previousTabCountRef.current;
+        // Skip on initial mount - only react to tab count changes after mount
+        if (!isPastInitialMountRef.current) {
+            previousTabCountRef.current = currentTabCount;
+            isPastInitialMountRef.current = true;
+            return;
+        }
+        // If tab count increased (user added a tab) and pane is closed, open it
+        if (currentTabCount > previousTabCount && !open) {
+            openPane();
+        }
+        previousTabCountRef.current = currentTabCount;
+    }, [
+        tabStorage === null || tabStorage === void 0 ? void 0 : (_tabStorage_tabs = tabStorage.tabs) === null || _tabStorage_tabs === void 0 ? void 0 : _tabStorage_tabs.length,
+        currentOrgId,
+        open,
+        openPane
+    ]);
+    // Update frame context when pane opens/closes
+    // Uses reference counting to coordinate between multiple Pane components
+    useEffect(function() {
+        if (open && !hasRegisteredRef.current) {
+            paneOpenCount++;
+            if (paneOpenCount === 1) {
+                setPaneIsOpen(true);
+            }
+            hasRegisteredRef.current = true;
+        } else if (!open && hasRegisteredRef.current) {
+            paneOpenCount = Math.max(0, paneOpenCount - 1);
+            if (paneOpenCount === 0) {
+                setPaneIsOpen(false);
+            }
+            hasRegisteredRef.current = false;
+        }
+        return function() {
+            if (hasRegisteredRef.current) {
+                paneOpenCount = Math.max(0, paneOpenCount - 1);
+                if (paneOpenCount === 0) {
+                    setPaneIsOpen(false);
+                }
+                hasRegisteredRef.current = false;
+            }
+        };
+    }, [
+        open,
+        setPaneIsOpen
+    ]);
+    // Uses shared utility with reference counting to coordinate with other components
+    useBodyScrollLock(open && isMobile && !isCollapsed);
+    // Memoize calculated width to avoid unnecessary recalculations
+    var calculatedWidth = useMemo(function() {
+        return calculatePaneWidth(open, isMobile, isCollapsed, paneWidth);
+    }, [
+        open,
+        isMobile,
+        isCollapsed,
+        paneWidth
+    ]);
+    // Calculate content width - keep width at paneWidth when collapsed so translateX works
+    var contentWidth = useMemo(function() {
+        if (!open) return '0px';
+        // On mobile, use full width when expanded; on desktop, use paneWidth
+        // Keep width at paneWidth even when collapsed so translateX(100%) can slide it off-screen
+        if (isMobile) return '100%';
+        return "".concat(paneWidth, "px");
+    }, [
+        open,
+        isMobile,
+        paneWidth
+    ]);
+    // Update CSS variable for pane width
+    useEffect(function() {
+        document.documentElement.style.setProperty('--litho-pane-width', calculatedWidth);
+    }, [
+        calculatedWidth
+    ]);
+    // Cleanup resize handlers on unmount
+    useEffect(function() {
+        isMountedRef.current = true;
+        return function() {
+            isMountedRef.current = false;
+            // Clean up any active resize handlers if component unmounts during drag
+            var _resizeHandlersRef_current = resizeHandlersRef.current, mouseMove = _resizeHandlersRef_current.mouseMove, mouseUp = _resizeHandlersRef_current.mouseUp;
+            if (mouseMove) {
+                document.removeEventListener('mousemove', mouseMove);
+            }
+            if (mouseUp) {
+                document.removeEventListener('mouseup', mouseUp);
+            }
+            resizeHandlersRef.current = {
+                mouseMove: null,
+                mouseUp: null
+            };
+        };
+    }, []);
+    // Handle resize drag with improved performance
+    // Updates CSS variable directly during drag for smooth performance
+    var handleResizeStart = useCallback(function(e) {
+        e.preventDefault();
+        if (!isMountedRef.current) return;
+        setIsResizing(true);
+        var startX = e.clientX;
+        // Use ref to get current width to avoid stale closure
+        var startWidth = paneWidthRef.current || paneWidth;
+        var currentWidth = startWidth;
+        // Disable transitions during drag for immediate response
+        var paneElement = paneRef.current;
+        var originalTransition = paneElement === null || paneElement === void 0 ? void 0 : paneElement.style.transition;
+        if (paneElement) {
+            paneElement.style.transition = 'none';
+        }
+        var handleMouseMove = function(e) {
+            // Check if component is still mounted before updating
+            if (!isMountedRef.current) return;
+            // Calculate new width directly without RAF for immediate response
+            var diff = startX - e.clientX; // Inverted because we're dragging from the left edge
+            var newWidth = Math.max(MIN_PANE_WIDTH, Math.min(MAX_PANE_WIDTH, startWidth + diff));
+            currentWidth = newWidth;
+            // Update CSS variable directly for immediate visual feedback (no re-render)
+            document.documentElement.style.setProperty('--litho-pane-width', "".concat(newWidth, "px"));
+        };
+        var handleMouseUp = function() {
+            // Check if component is still mounted before updating state
+            if (!isMountedRef.current) {
+                // Clean up listeners even if unmounted
+                document.removeEventListener('mousemove', handleMouseMove);
+                document.removeEventListener('mouseup', handleMouseUp);
+                resizeHandlersRef.current = {
+                    mouseMove: null,
+                    mouseUp: null
+                };
+                return;
+            }
+            // Restore transitions
+            if (paneElement) {
+                paneElement.style.transition = originalTransition || '';
+            }
+            // Sync final width to state (triggers re-render and localStorage save)
+            setPaneWidth(currentWidth);
+            setIsResizing(false);
+            document.removeEventListener('mousemove', handleMouseMove);
+            document.removeEventListener('mouseup', handleMouseUp);
+            resizeHandlersRef.current = {
+                mouseMove: null,
+                mouseUp: null
+            };
+        };
+        // Store handlers in ref for cleanup
+        resizeHandlersRef.current = {
+            mouseMove: handleMouseMove,
+            mouseUp: handleMouseUp
+        };
+        document.addEventListener('mousemove', handleMouseMove);
+        document.addEventListener('mouseup', handleMouseUp);
+    }, [
+        paneWidth,
+        setPaneWidth,
+        setIsResizing
+    ]);
+    var toggleCollapsed = useCallback(function() {
+        setIsCollapsed(function(prev) {
+            var newValue = !prev;
+            // Track transition start to prevent hover flash
+            setIsTransitioning(true);
+            // Clear transition flag after animation completes
+            setTimeout(function() {
+                setIsTransitioning(false);
+            }, 200); // Match transition duration
+            return newValue;
+        });
+    }, [
+        setIsCollapsed
+    ]);
+    // Expand pane function - exposed to parent via ref and tabStorage
+    var expandPane = useCallback(function() {
+        setIsCollapsed(false);
+    }, [
+        setIsCollapsed
+    ]);
+    // Expose expand function to parent via ref and tabStorage
+    useEffect(function() {
+        // Expose to parent ref if provided
+        if (onExpandRef) {
+            onExpandRef.current = expandPane;
+        }
+        // Expose to tabStorage for hooks to use
+        if (tabStorage) {
+            if (!tabStorage.expandPaneRef) {
+                tabStorage.expandPaneRef = {
+                    current: null
+                };
+            }
+            tabStorage.expandPaneRef.current = expandPane;
+        }
+        // Cleanup: clear refs when component unmounts or refs change
+        return function() {
+            if (onExpandRef) {
+                onExpandRef.current = null;
+            }
+            if (tabStorage === null || tabStorage === void 0 ? void 0 : tabStorage.expandPaneRef) {
+                tabStorage.expandPaneRef.current = null;
+            }
+        };
+    }, [
+        onExpandRef,
+        tabStorage,
+        expandPane
+    ]);
+    // Expose isCollapsed synchronously using useLayoutEffect (runs before paint)
+    useLayoutEffect(function() {
+        if (tabStorage) {
+            tabStorage.isCollapsed = isCollapsed;
+        }
+    }, [
+        tabStorage,
+        isCollapsed
+    ]);
+    // Handle keyboard interactions
+    var handleKeyboardAction = useKeyboardAction();
+    // Handle Escape key to close
     useEffect(function() {
-        setPaneIsOpen(open);
         if (!open || !onClose) return;
         var handleKeyDown = function(event) {
             if (event.key === "Escape") {
-                onClose();
+                closePaneAndNotify();
             }
         };
         document.addEventListener("keydown", handleKeyDown);
@@ -83,36 +552,121 @@ function Pane() {
         };
     }, [
         open,
-        onClose
+        onClose,
+        closePaneAndNotify
     ]);
+    var handleTabClick = useCallback(function(tabId) {
+        if (!tabStorage) return;
+        tabStorage.setActiveTab(tabId);
+    // Don't expand when clicking tabs - collapsed state should not be changed
+    }, [
+        tabStorage
+    ]);
+    var handleTabClose = useCallback(function(tabId) {
+        if (!tabStorage) return;
+        var tabToRemove = tabStorage.tabs.find(function(tab) {
+            return tab.id === tabId;
+        });
+        var remainingTabsCount = tabStorage.tabs.length - 1;
+        // Remove the tab first
+        tabStorage.removeTab(tabId);
+        // Only close the pane if this was the last tab
+        if (remainingTabsCount === 0 && open && onClose) {
+            closePaneAndNotify();
+        }
+        // Notify parent about the removed tab
+        if (onTabRemove) {
+            onTabRemove(tabId, tabToRemove);
+        }
+    }, [
+        tabStorage,
+        open,
+        onClose,
+        onTabRemove,
+        closePane
+    ]);
+    // Memoize style object to avoid recreating on every render
+    // Must be called before early return to maintain hook order
+    var paneStyle = useMemo(function() {
+        return isCollapsed ? {
+            width: "".concat(COLLAPSED_WIDTH, "px")
+        } : undefined;
+    }, [
+        isCollapsed
+    ]);
+    var classes = styles({
+        collapsed: isCollapsed,
+        isMobile: isMobile
+    });
+    var innerClasses = innerStyles({
+        collapsed: isCollapsed
+    });
     if (!open) {
         return null;
     }
     return /*#__PURE__*/ _jsx(PaneContext.Provider, {
         value: {
-            onClose: onClose
+            activeTab: activeTab,
+            onClose: onClose,
+            isCollapsed: isCollapsed,
+            toggleCollapsed: toggleCollapsed
         },
         children: /*#__PURE__*/ _jsx("div", {
+            ref: paneRef,
             className: classes,
-            children: /*#__PURE__*/ _jsx("div", {
-                className: innerStyles(),
-                children: children
+            style: paneStyle,
+            children: /*#__PURE__*/ _jsxs("div", {
+                className: "".concat(innerClasses, " ").concat(isCollapsed && !isTransitioning ? 'hover:bg-[#D5D3D1]' : ''),
+                onClick: isCollapsed ? toggleCollapsed : undefined,
+                children: [
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "flex flex-col overflow-y-auto overflow-x-hidden h-full",
+                        style: getContentStyles(isCollapsed, contentWidth),
+                        children: [
+                            tabStorage && tabStorage.tabs.length > 0 && /*#__PURE__*/ _jsx(TabNavigation, {
+                                tabs: tabStorage.tabs,
+                                activeTabId: tabStorage.activeTabId,
+                                onTabClick: handleTabClick,
+                                onTabClose: handleTabClose
+                            }),
+                            children,
+                            /*#__PURE__*/ _jsx("div", {
+                                ref: resizeHandleRef,
+                                className: resizeHandleStyles({
+                                    resizing: isResizing
+                                }),
+                                onMouseDown: handleResizeStart
+                            }),
+                            /*#__PURE__*/ _jsx(CollapseButton, {
+                                variant: "expanded",
+                                icon: ChevronRightMinor,
+                                label: "Collapse pane",
+                                onClick: toggleCollapsed,
+                                onKeyDown: function(e) {
+                                    return handleKeyboardAction(e, toggleCollapsed);
+                                }
+                            })
+                        ]
+                    }),
+                    isCollapsed && /*#__PURE__*/ _jsx(CollapseButton, {
+                        variant: "collapsed",
+                        icon: ChevronLeftMinor,
+                        label: "Expand pane",
+                        onClick: toggleCollapsed,
+                        onKeyDown: function(e) {
+                            return handleKeyboardAction(e, toggleCollapsed);
+                        },
+                        stopPropagation: true
+                    })
+                ]
             })
         })
     });
 }
 function Header() {
     var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    var title = props.title, subtitle = props.subtitle, _props_actions = props.actions, actions = _props_actions === void 0 ? [] : _props_actions, _props_showCloseButton = props.showCloseButton, showCloseButton = _props_showCloseButton === void 0 ? true : _props_showCloseButton, _props_bottomBorder = props.bottomBorder, bottomBorder = _props_bottomBorder === void 0 ? true : _props_bottomBorder, subHeader = props.subHeader, tmp = props.backAction, _backAction = tmp === void 0 ? null : tmp, _props_expanded = props.expanded, expanded = _props_expanded === void 0 ? false : _props_expanded, _props_onToggleExpand = props.onToggleExpand, onToggleExpand = _props_onToggleExpand === void 0 ? function() {} : _props_onToggleExpand, _props_allowExpand = props.allowExpand, allowExpand = _props_allowExpand === void 0 ? true : _props_allowExpand;
-    var onClose = useContext(PaneContext).onClose;
-    var showActionsOrClose = actions.length > 0 || showCloseButton;
+    var title = props.title, subtitle = props.subtitle, _props_actions = props.actions, actions = _props_actions === void 0 ? [] : _props_actions, _props_bottomBorder = props.bottomBorder, bottomBorder = _props_bottomBorder === void 0 ? true : _props_bottomBorder, subHeader = props.subHeader, tmp = props.backAction, _backAction = tmp === void 0 ? null : tmp;
     var _useState = _sliced_to_array(useState(null), 2), showActionsPopover = _useState[0], setShowActionsPopover = _useState[1];
-    useEffect(function() {
-        var width = expanded ? 'var(--litho-pane-width-expanded)' : 'var(--litho-pane-width-default)';
-        document.documentElement.style.setProperty('--litho-pane-width', width);
-    }, [
-        expanded
-    ]);
     var backAction = _backAction ? /*#__PURE__*/ _jsx("div", {
         className: "Litho-Page__Header--BackAction",
         children: /*#__PURE__*/ _jsx(Button, {
@@ -128,10 +682,10 @@ function Header() {
         className: "Litho-Pane__Header",
         children: [
             /*#__PURE__*/ _jsxs("div", {
-                className: "flex items-center justify-between gap-2 min-h-14 px-2 border-edge-subdued ".concat(bottomBorder ? "border-b" : ""),
+                className: "flex items-center justify-between px-2 border-edge-subdued min-h-14 ".concat(bottomBorder ? "border-b" : ""),
                 children: [
                     /*#__PURE__*/ _jsxs("div", {
-                        className: "flex items-center gap-2 flex-1",
+                        className: "flex items-center gap-2",
                         children: [
                             backAction,
                             /*#__PURE__*/ _jsxs("div", {
@@ -153,62 +707,43 @@ function Header() {
                             })
                         ]
                     }),
-                    showActionsOrClose && /*#__PURE__*/ _jsxs("div", {
+                    /*#__PURE__*/ _jsx("div", {
                         className: "flex items-center justify-end",
-                        children: [
-                            actions.map(function(action, index) {
-                                var showPopover = action.subActions || action.subSections;
-                                var innerContent = /*#__PURE__*/ _jsx(Button, {
-                                    plain: !action.destructive,
-                                    onClick: showPopover ? function() {
-                                        return setShowActionsPopover(index);
-                                    } : action.onAction || action.onClick,
-                                    disabled: action.disabled,
-                                    icon: action.icon,
-                                    loading: action.loading,
-                                    external: action.external,
-                                    url: action.url,
-                                    destructive: action.destructive,
-                                    tooltip: action.tooltip && showActionsPopover !== index ? action.tooltip : undefined,
-                                    tooltipPosition: "below"
-                                }, index);
-                                if (showPopover) {
-                                    return /*#__PURE__*/ _jsx(Popover, {
-                                        active: showActionsPopover === index,
-                                        onClose: function() {
-                                            return setShowActionsPopover(null);
-                                        },
-                                        activator: innerContent,
-                                        preferredAlignment: "left",
-                                        children: /*#__PURE__*/ _jsx(ActionList, {
-                                            sections: action.subSections,
-                                            items: action.subActions,
-                                            onActionAnyItem: function() {
-                                                return setShowActionsPopover(null);
-                                            }
-                                        })
-                                    });
-                                }
-                                return innerContent;
-                            }),
-                            allowExpand && /*#__PURE__*/ _jsx("div", {
-                                className: "hidden xl:block",
-                                children: /*#__PURE__*/ _jsx(Button, {
-                                    plain: true,
-                                    icon: expanded ? MinimizeMajor : MaximizeMajor,
-                                    onClick: onToggleExpand,
-                                    tooltip: expanded ? "Minimize" : "Expand",
-                                    tooltipPosition: "below"
-                                })
-                            }),
-                            showCloseButton && /*#__PURE__*/ _jsx(Button, {
-                                plain: true,
-                                icon: CancelMajor,
-                                onClick: onClose,
-                                tooltip: "Close",
+                        children: actions.length > 0 && actions.map(function(action, index) {
+                            var showPopover = action.subActions || action.subSections;
+                            var innerContent = /*#__PURE__*/ _jsx(Button, {
+                                plain: !action.destructive,
+                                onClick: showPopover ? function() {
+                                    return setShowActionsPopover(index);
+                                } : action.onAction || action.onClick,
+                                disabled: action.disabled,
+                                icon: action.icon,
+                                loading: action.loading,
+                                external: action.external,
+                                url: action.url,
+                                destructive: action.destructive,
+                                tooltip: action.tooltip && showActionsPopover !== index ? action.tooltip : undefined,
                                 tooltipPosition: "below"
-                            })
-                        ]
+                            }, index);
+                            if (showPopover) {
+                                return /*#__PURE__*/ _jsx(Popover, {
+                                    active: showActionsPopover === index,
+                                    onClose: function() {
+                                        return setShowActionsPopover(null);
+                                    },
+                                    activator: innerContent,
+                                    preferredAlignment: "left",
+                                    children: /*#__PURE__*/ _jsx(ActionList, {
+                                        sections: action.subSections,
+                                        items: action.subActions,
+                                        onActionAnyItem: function() {
+                                            return setShowActionsPopover(null);
+                                        }
+                                    })
+                                });
+                            }
+                            return innerContent;
+                        })
                     })
                 ]
             }),
@@ -224,7 +759,7 @@ function Content() {
     var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     var children = props.children, _props_padded = props.padded, padded = _props_padded === void 0 ? true : _props_padded, className = props.className;
     return /*#__PURE__*/ _jsx("div", {
-        className: "Litho-Pane__Content flex-1 overflow-auto ".concat(padded ? "p-2" : "", " ").concat(className),
+        className: "Litho-Pane__Content flex-1 overflow-auto ".concat(padded ? "p-2" : "", " ").concat(className || ""),
         children: children
     });
 }
@@ -232,8 +767,9 @@ Pane.Content = Content;
 function Footer() {
     var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     var children = props.children, _props_topBorder = props.topBorder, topBorder = _props_topBorder === void 0 ? true : _props_topBorder;
+    var isMobile = useMobile(MOBILE_BREAKPOINT);
     return /*#__PURE__*/ _jsx("div", {
-        className: "Litho-Pane__Footer min-h-12 ".concat(topBorder ? "border-t border-edge-subdued" : ""),
+        className: "Litho-Pane__Footer min-h-12 ".concat(topBorder ? "border-t border-edge-subdued" : "", " ").concat(isMobile ? "sticky bottom-0 bg-surface-lowest z-10" : ""),
         children: children
     });
 }