react-resizable-panels 1.0.7 → 1.0.9

package/dist/react-resizable-panels.esm.js

@@ -69,6 +69,7 @@ function PanelWithForwardedRef({
     getPanelStyle,
     groupId,
     isPanelCollapsed,
+    reevaluatePanelConstraints,
     registerPanel,
     resizePanel,
     unregisterPanel
@@ -99,6 +100,9 @@ function PanelWithForwardedRef({
       callbacks,
       constraints
     } = panelDataRef.current;
+    const prevConstraints = {
+      ...constraints
+    };
     panelDataRef.current.id = panelId;
     panelDataRef.current.idIsFromProps = idFromProps !== undefined;
     panelDataRef.current.order = order;
@@ -110,6 +114,12 @@ function PanelWithForwardedRef({
     constraints.defaultSize = defaultSize;
     constraints.maxSize = maxSize;
     constraints.minSize = minSize;
+
+    // If constraints have changed, we should revisit panel sizes.
+    // This is uncommon but may happen if people are trying to implement pixel based constraints.
+    if (prevConstraints.collapsedSize !== constraints.collapsedSize || prevConstraints.collapsible !== constraints.collapsible || prevConstraints.maxSize !== constraints.maxSize || prevConstraints.minSize !== constraints.minSize) {
+      reevaluatePanelConstraints(panelDataRef.current, prevConstraints);
+    }
   });
   useIsomorphicLayoutEffect(() => {
     const panelData = panelDataRef.current;
@@ -497,41 +507,48 @@ function calculateAriaValues({
   };
 }
 
-function getResizeHandleElementsForGroup(groupId) {
-  return Array.from(document.querySelectorAll(`[data-panel-resize-handle-id][data-panel-group-id="${groupId}"]`));
+function getResizeHandleElementsForGroup(groupId, scope = document) {
+  return Array.from(scope.querySelectorAll(`[data-panel-resize-handle-id][data-panel-group-id="${groupId}"]`));
 }
 
-function getResizeHandleElementIndex(groupId, id) {
-  const handles = getResizeHandleElementsForGroup(groupId);
+function getResizeHandleElementIndex(groupId, id, scope = document) {
+  const handles = getResizeHandleElementsForGroup(groupId, scope);
   const index = handles.findIndex(handle => handle.getAttribute("data-panel-resize-handle-id") === id);
   return index !== null && index !== void 0 ? index : null;
 }
 
-function determinePivotIndices(groupId, dragHandleId) {
-  const index = getResizeHandleElementIndex(groupId, dragHandleId);
+function determinePivotIndices(groupId, dragHandleId, panelGroupElement) {
+  const index = getResizeHandleElementIndex(groupId, dragHandleId, panelGroupElement);
   return index != null ? [index, index + 1] : [-1, -1];
 }
 
-function getPanelGroupElement(id) {
-  const element = document.querySelector(`[data-panel-group][data-panel-group-id="${id}"]`);
+function getPanelGroupElement(id, rootElement = document) {
+  var _dataset;
+  //If the root element is the PanelGroup
+  if (rootElement instanceof HTMLElement && (rootElement === null || rootElement === void 0 ? void 0 : (_dataset = rootElement.dataset) === null || _dataset === void 0 ? void 0 : _dataset.panelGroupId) == id) {
+    return rootElement;
+  }
+
+  //Else query children
+  const element = rootElement.querySelector(`[data-panel-group][data-panel-group-id="${id}"]`);
   if (element) {
     return element;
   }
   return null;
 }
 
-function getResizeHandleElement(id) {
-  const element = document.querySelector(`[data-panel-resize-handle-id="${id}"]`);
+function getResizeHandleElement(id, scope = document) {
+  const element = scope.querySelector(`[data-panel-resize-handle-id="${id}"]`);
   if (element) {
     return element;
   }
   return null;
 }
 
-function getResizeHandlePanelIds(groupId, handleId, panelsArray) {
+function getResizeHandlePanelIds(groupId, handleId, panelsArray, scope = document) {
   var _panelsArray$index$id, _panelsArray$index, _panelsArray$id, _panelsArray;
-  const handle = getResizeHandleElement(handleId);
-  const handles = getResizeHandleElementsForGroup(groupId);
+  const handle = getResizeHandleElement(handleId, scope);
+  const handles = getResizeHandleElementsForGroup(groupId, scope);
   const index = handle ? handles.indexOf(handle) : -1;
   const idBefore = (_panelsArray$index$id = (_panelsArray$index = panelsArray[index]) === null || _panelsArray$index === void 0 ? void 0 : _panelsArray$index.id) !== null && _panelsArray$index$id !== void 0 ? _panelsArray$index$id : null;
   const idAfter = (_panelsArray$id = (_panelsArray = panelsArray[index + 1]) === null || _panelsArray === void 0 ? void 0 : _panelsArray.id) !== null && _panelsArray$id !== void 0 ? _panelsArray$id : null;
@@ -546,13 +563,17 @@ function useWindowSplitterPanelGroupBehavior({
   groupId,
   layout,
   panelDataArray,
+  panelGroupElement,
   setLayout
 }) {
   useRef({
     didWarnAboutMissingResizeHandle: false
   });
   useIsomorphicLayoutEffect(() => {
-    const resizeHandleElements = getResizeHandleElementsForGroup(groupId);
+    if (!panelGroupElement) {
+      return;
+    }
+    const resizeHandleElements = getResizeHandleElementsForGroup(groupId, panelGroupElement);
     for (let index = 0; index < panelDataArray.length - 1; index++) {
       const {
         valueMax,
@@ -581,21 +602,24 @@ function useWindowSplitterPanelGroupBehavior({
         resizeHandleElement.removeAttribute("aria-valuenow");
       });
     };
-  }, [groupId, layout, panelDataArray]);
+  }, [groupId, layout, panelDataArray, panelGroupElement]);
   useEffect(() => {
+    if (!panelGroupElement) {
+      return;
+    }
     const eagerValues = eagerValuesRef.current;
     assert(eagerValues);
     const {
       panelDataArray
     } = eagerValues;
-    const groupElement = getPanelGroupElement(groupId);
+    const groupElement = getPanelGroupElement(groupId, panelGroupElement);
     assert(groupElement != null, `No group found for id "${groupId}"`);
-    const handles = getResizeHandleElementsForGroup(groupId);
+    const handles = getResizeHandleElementsForGroup(groupId, panelGroupElement);
     assert(handles);
     const cleanupFunctions = handles.map(handle => {
       const handleId = handle.getAttribute("data-panel-resize-handle-id");
       assert(handleId);
-      const [idBefore, idAfter] = getResizeHandlePanelIds(groupId, handleId, panelDataArray);
+      const [idBefore, idAfter] = getResizeHandlePanelIds(groupId, handleId, panelDataArray, panelGroupElement);
       if (idBefore == null || idAfter == null) {
         return () => {};
       }
@@ -622,7 +646,7 @@ function useWindowSplitterPanelGroupBehavior({
                     delta: fuzzyNumbersEqual(size, collapsedSize) ? minSize - collapsedSize : collapsedSize - size,
                     layout,
                     panelConstraints: panelDataArray.map(panelData => panelData.constraints),
-                    pivotIndices: determinePivotIndices(groupId, handleId),
+                    pivotIndices: determinePivotIndices(groupId, handleId, panelGroupElement),
                     trigger: "keyboard"
                   });
                   if (layout !== nextLayout) {
@@ -642,7 +666,7 @@ function useWindowSplitterPanelGroupBehavior({
     return () => {
       cleanupFunctions.forEach(cleanupFunction => cleanupFunction());
     };
-  }, [committedValuesRef, eagerValuesRef, groupId, layout, panelDataArray, setLayout]);
+  }, [panelGroupElement, committedValuesRef, eagerValuesRef, groupId, layout, panelDataArray, setLayout]);
 }
 
 function areEqual(arrayA, arrayB) {
@@ -680,9 +704,9 @@ function getResizeEventCursorPosition(direction, event) {
   }
 }
 
-function calculateDragOffsetPercentage(event, dragHandleId, direction, initialDragState) {
+function calculateDragOffsetPercentage(event, dragHandleId, direction, initialDragState, panelGroupElement) {
   const isHorizontal = direction === "horizontal";
-  const handleElement = getResizeHandleElement(dragHandleId);
+  const handleElement = getResizeHandleElement(dragHandleId, panelGroupElement);
   assert(handleElement);
   const groupId = handleElement.getAttribute("data-panel-group-id");
   assert(groupId);
@@ -690,7 +714,7 @@ function calculateDragOffsetPercentage(event, dragHandleId, direction, initialDr
     initialCursorPosition
   } = initialDragState;
   const cursorPosition = getResizeEventCursorPosition(direction, event);
-  const groupElement = getPanelGroupElement(groupId);
+  const groupElement = getPanelGroupElement(groupId, panelGroupElement);
   assert(groupElement);
   const groupRect = groupElement.getBoundingClientRect();
   const groupSizeInPixels = isHorizontal ? groupRect.width : groupRect.height;
@@ -700,7 +724,7 @@ function calculateDragOffsetPercentage(event, dragHandleId, direction, initialDr
 }
 
 // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementX
-function calculateDeltaPercentage(event, dragHandleId, direction, initialDragState, keyboardResizeBy) {
+function calculateDeltaPercentage(event, dragHandleId, direction, initialDragState, keyboardResizeBy, panelGroupElement) {
   if (isKeyDown(event)) {
     const isHorizontal = direction === "horizontal";
     let delta = 0;
@@ -737,7 +761,7 @@ function calculateDeltaPercentage(event, dragHandleId, direction, initialDragSta
     if (initialDragState == null) {
       return 0;
     }
-    return calculateDragOffsetPercentage(event, dragHandleId, direction, initialDragState);
+    return calculateDragOffsetPercentage(event, dragHandleId, direction, initialDragState, panelGroupElement);
   }
 }
 
@@ -1089,6 +1113,7 @@ function PanelGroupWithForwardedRef({
   ...rest
 }) {
   const groupId = useUniqueId(idFromProps);
+  const panelGroupElementRef = useRef(null);
   const [dragState, setDragState] = useState(null);
   const [layout, setLayout] = useState([]);
   const panelIdToLastNotifiedSizeMapRef = useRef({});
@@ -1157,7 +1182,8 @@ function PanelGroupWithForwardedRef({
     groupId,
     layout,
     panelDataArray: eagerValuesRef.current.panelDataArray,
-    setLayout
+    setLayout,
+    panelGroupElement: panelGroupElementRef.current
   });
   useEffect(() => {
     const {
@@ -1400,6 +1426,10 @@ function PanelGroupWithForwardedRef({
   const registerResizeHandle = useCallback(dragHandleId => {
     return function resizeHandler(event) {
       event.preventDefault();
+      const panelGroupElement = panelGroupElementRef.current;
+      if (!panelGroupElement) {
+        return () => null;
+      }
       const {
         direction,
         dragState,
@@ -1414,8 +1444,8 @@ function PanelGroupWithForwardedRef({
       const {
         initialLayout
       } = dragState !== null && dragState !== void 0 ? dragState : {};
-      const pivotIndices = determinePivotIndices(groupId, dragHandleId);
-      let delta = calculateDeltaPercentage(event, dragHandleId, direction, dragState, keyboardResizeBy);
+      const pivotIndices = determinePivotIndices(groupId, dragHandleId, panelGroupElement);
+      let delta = calculateDeltaPercentage(event, dragHandleId, direction, dragState, keyboardResizeBy, panelGroupElement);
       if (delta === 0) {
         return;
       }
@@ -1503,6 +1533,37 @@ function PanelGroupWithForwardedRef({
       callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current);
     }
   }, []);
+  const reevaluatePanelConstraints = useCallback((panelData, prevConstraints) => {
+    const {
+      layout,
+      panelDataArray
+    } = eagerValuesRef.current;
+    const {
+      collapsedSize: prevCollapsedSize = 0,
+      collapsible: prevCollapsible,
+      defaultSize: prevDefaultSize,
+      maxSize: prevMaxSize = 100,
+      minSize: prevMinSize = 0
+    } = prevConstraints;
+    const {
+      collapsedSize: nextCollapsedSize = 0,
+      collapsible: nextCollapsible,
+      defaultSize: nextDefaultSize,
+      maxSize: nextMaxSize = 100,
+      minSize: nextMinSize = 0
+    } = panelData.constraints;
+    const {
+      panelSize: prevPanelSize
+    } = panelDataHelper(panelDataArray, panelData, layout);
+    assert(prevPanelSize != null);
+    if (prevCollapsible && nextCollapsible && prevCollapsedSize !== nextCollapsedSize && prevPanelSize === prevCollapsedSize) {
+      resizePanel(panelData, nextCollapsedSize);
+    } else if (prevPanelSize < nextMinSize) {
+      resizePanel(panelData, nextMinSize);
+    } else if (prevPanelSize > nextMaxSize) {
+      resizePanel(panelData, nextMaxSize);
+    }
+  }, [resizePanel]);
   const startDragging = useCallback((dragHandleId, event) => {
     const {
       direction
@@ -1510,7 +1571,10 @@ function PanelGroupWithForwardedRef({
     const {
       layout
     } = eagerValuesRef.current;
-    const handleElement = getResizeHandleElement(dragHandleId);
+    if (!panelGroupElementRef.current) {
+      return;
+    }
+    const handleElement = getResizeHandleElement(dragHandleId, panelGroupElementRef.current);
     assert(handleElement);
     const initialCursorPosition = getResizeEventCursorPosition(direction, event);
     setDragState({
@@ -1550,13 +1614,15 @@ function PanelGroupWithForwardedRef({
     groupId,
     isPanelCollapsed,
     isPanelExpanded,
+    reevaluatePanelConstraints,
     registerPanel,
     registerResizeHandle,
     resizePanel,
     startDragging,
     stopDragging,
-    unregisterPanel
-  }), [collapsePanel, dragState, direction, expandPanel, getPanelSize, getPanelStyle, groupId, isPanelCollapsed, isPanelExpanded, registerPanel, registerResizeHandle, resizePanel, startDragging, stopDragging, unregisterPanel]);
+    unregisterPanel,
+    panelGroupElement: panelGroupElementRef.current
+  }), [collapsePanel, dragState, direction, expandPanel, getPanelSize, getPanelStyle, groupId, isPanelCollapsed, isPanelExpanded, reevaluatePanelConstraints, registerPanel, registerResizeHandle, resizePanel, startDragging, stopDragging, unregisterPanel]);
   const style = {
     display: "flex",
     flexDirection: direction === "horizontal" ? "row" : "column",
@@ -1574,6 +1640,7 @@ function PanelGroupWithForwardedRef({
       ...style,
       ...styleFromProps
     },
+    ref: panelGroupElementRef,
     // CSS selectors
     "data-panel-group": "",
     "data-panel-group-direction": direction,
@@ -1590,14 +1657,12 @@ function findPanelDataIndex(panelDataArray, panelData) {
   return panelDataArray.findIndex(prevPanelData => prevPanelData === panelData || prevPanelData.id === panelData.id);
 }
 function panelDataHelper(panelDataArray, panelData, layout) {
-  const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
   const panelIndex = findPanelDataIndex(panelDataArray, panelData);
-  const panelConstraints = panelConstraintsArray[panelIndex];
   const isLastPanel = panelIndex === panelDataArray.length - 1;
   const pivotIndices = isLastPanel ? [panelIndex - 1, panelIndex] : [panelIndex, panelIndex + 1];
   const panelSize = layout[panelIndex];
   return {
-    ...panelConstraints,
+    ...panelData.constraints,
     panelSize,
     pivotIndices
   };
@@ -1608,13 +1673,14 @@ function panelDataHelper(panelDataArray, panelData, layout) {
 function useWindowSplitterResizeHandlerBehavior({
   disabled,
   handleId,
-  resizeHandler
+  resizeHandler,
+  panelGroupElement
 }) {
   useEffect(() => {
-    if (disabled || resizeHandler == null) {
+    if (disabled || resizeHandler == null || panelGroupElement == null) {
       return;
     }
-    const handleElement = getResizeHandleElement(handleId);
+    const handleElement = getResizeHandleElement(handleId, panelGroupElement);
     if (handleElement == null) {
       return;
     }
@@ -1639,8 +1705,8 @@ function useWindowSplitterResizeHandlerBehavior({
             event.preventDefault();
             const groupId = handleElement.getAttribute("data-panel-group-id");
             assert(groupId);
-            const handles = getResizeHandleElementsForGroup(groupId);
-            const index = getResizeHandleElementIndex(groupId, handleId);
+            const handles = getResizeHandleElementsForGroup(groupId, panelGroupElement);
+            const index = getResizeHandleElementIndex(groupId, handleId, panelGroupElement);
             assert(index !== null);
             const nextIndex = event.shiftKey ? index > 0 ? index - 1 : handles.length - 1 : index + 1 < handles.length ? index + 1 : 0;
             const nextHandle = handles[nextIndex];
@@ -1653,7 +1719,7 @@ function useWindowSplitterResizeHandlerBehavior({
     return () => {
       handleElement.removeEventListener("keydown", onKeyDown);
     };
-  }, [disabled, handleId, resizeHandler]);
+  }, [panelGroupElement, disabled, handleId, resizeHandler]);
 }
 
 function PanelResizeHandle({
@@ -1686,7 +1752,8 @@ function PanelResizeHandle({
     groupId,
     registerResizeHandle,
     startDragging,
-    stopDragging
+    stopDragging,
+    panelGroupElement
   } = panelGroupContext;
   const resizeHandleId = useUniqueId(idFromProps);
   const isDragging = (dragState === null || dragState === void 0 ? void 0 : dragState.dragHandleId) === resizeHandleId;
@@ -1745,7 +1812,8 @@ function PanelResizeHandle({
   useWindowSplitterResizeHandlerBehavior({
     disabled,
     handleId: resizeHandleId,
-    resizeHandler
+    resizeHandler,
+    panelGroupElement
   });
   const style = {
     cursor: getCursorStyle(direction),
@@ -1801,52 +1869,16 @@ function PanelResizeHandle({
 }
 PanelResizeHandle.displayName = "PanelResizeHandle";
 
-function calculateAvailablePanelSizeInPixels(groupId) {
-  const panelGroupElement = getPanelGroupElement(groupId);
-  if (panelGroupElement == null) {
-    return NaN;
-  }
-  const direction = panelGroupElement.getAttribute("data-panel-group-direction");
-  const resizeHandles = getResizeHandleElementsForGroup(groupId);
-  if (direction === "horizontal") {
-    return panelGroupElement.offsetWidth - resizeHandles.reduce((accumulated, handle) => {
-      return accumulated + handle.offsetWidth;
-    }, 0);
-  } else {
-    return panelGroupElement.offsetHeight - resizeHandles.reduce((accumulated, handle) => {
-      return accumulated + handle.offsetHeight;
-    }, 0);
-  }
-}
-
-function getAvailableGroupSizePixels(groupId) {
-  const panelGroupElement = getPanelGroupElement(groupId);
-  if (panelGroupElement == null) {
-    return NaN;
-  }
-  const direction = panelGroupElement.getAttribute("data-panel-group-direction");
-  const resizeHandles = getResizeHandleElementsForGroup(groupId);
-  if (direction === "horizontal") {
-    return panelGroupElement.offsetWidth - resizeHandles.reduce((accumulated, handle) => {
-      return accumulated + handle.offsetWidth;
-    }, 0);
-  } else {
-    return panelGroupElement.offsetHeight - resizeHandles.reduce((accumulated, handle) => {
-      return accumulated + handle.offsetHeight;
-    }, 0);
-  }
-}
-
-function getPanelElement(id) {
-  const element = document.querySelector(`[data-panel-id="${id}"]`);
+function getPanelElement(id, scope = document) {
+  const element = scope.querySelector(`[data-panel-id="${id}"]`);
   if (element) {
     return element;
   }
   return null;
 }
 
-function getPanelElementsForGroup(groupId) {
-  return Array.from(document.querySelectorAll(`[data-panel][data-panel-group-id="${groupId}"]`));
+function getPanelElementsForGroup(groupId, scope = document) {
+  return Array.from(scope.querySelectorAll(`[data-panel][data-panel-group-id="${groupId}"]`));
 }
 
-export { Panel, PanelGroup, PanelResizeHandle, assert, calculateAvailablePanelSizeInPixels, getAvailableGroupSizePixels, getPanelElement, getPanelElementsForGroup, getPanelGroupElement, getResizeHandleElement, getResizeHandleElementIndex, getResizeHandleElementsForGroup, getResizeHandlePanelIds };
+export { Panel, PanelGroup, PanelResizeHandle, assert, getPanelElement, getPanelElementsForGroup, getPanelGroupElement, getResizeHandleElement, getResizeHandleElementIndex, getResizeHandleElementsForGroup, getResizeHandlePanelIds };