react-resizable-panels 1.0.7 → 1.0.9

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

@@ -65,6 +65,7 @@ function PanelWithForwardedRef({
     getPanelStyle,
     groupId,
     isPanelCollapsed,
+    reevaluatePanelConstraints,
     registerPanel,
     resizePanel,
     unregisterPanel
@@ -430,41 +431,48 @@ function adjustLayoutByDelta({
   return nextLayout;
 }
 
-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;
@@ -479,25 +487,29 @@ function useWindowSplitterPanelGroupBehavior({
   groupId,
   layout,
   panelDataArray,
+  panelGroupElement,
   setLayout
 }) {
   useRef({
     didWarnAboutMissingResizeHandle: false
   });
   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 () => {};
       }
@@ -524,7 +536,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) {
@@ -544,7 +556,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) {
@@ -582,9 +594,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);
@@ -592,7 +604,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;
@@ -602,7 +614,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;
@@ -639,7 +651,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);
   }
 }
 
@@ -944,6 +956,7 @@ function PanelGroupWithForwardedRef({
   ...rest
 }) {
   const groupId = useUniqueId(idFromProps);
+  const panelGroupElementRef = useRef(null);
   const [dragState, setDragState] = useState(null);
   const [layout, setLayout] = useState([]);
   const panelIdToLastNotifiedSizeMapRef = useRef({});
@@ -1004,7 +1017,8 @@ function PanelGroupWithForwardedRef({
     groupId,
     layout,
     panelDataArray: eagerValuesRef.current.panelDataArray,
-    setLayout
+    setLayout,
+    panelGroupElement: panelGroupElementRef.current
   });
   useEffect(() => {
     const {
@@ -1199,6 +1213,10 @@ function PanelGroupWithForwardedRef({
   const registerResizeHandle = useCallback(dragHandleId => {
     return function resizeHandler(event) {
       event.preventDefault();
+      const panelGroupElement = panelGroupElementRef.current;
+      if (!panelGroupElement) {
+        return () => null;
+      }
       const {
         direction,
         dragState,
@@ -1213,8 +1231,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;
       }
@@ -1302,6 +1320,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
@@ -1309,7 +1358,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({
@@ -1349,13 +1401,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",
@@ -1373,6 +1427,7 @@ function PanelGroupWithForwardedRef({
       ...style,
       ...styleFromProps
     },
+    ref: panelGroupElementRef,
     // CSS selectors
     "data-panel-group": "",
     "data-panel-group-direction": direction,
@@ -1389,14 +1444,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
   };
@@ -1407,13 +1460,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;
     }
@@ -1438,8 +1492,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];
@@ -1452,7 +1506,7 @@ function useWindowSplitterResizeHandlerBehavior({
     return () => {
       handleElement.removeEventListener("keydown", onKeyDown);
     };
-  }, [disabled, handleId, resizeHandler]);
+  }, [panelGroupElement, disabled, handleId, resizeHandler]);
 }
 
 function PanelResizeHandle({
@@ -1485,7 +1539,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;
@@ -1544,7 +1599,8 @@ function PanelResizeHandle({
   useWindowSplitterResizeHandlerBehavior({
     disabled,
     handleId: resizeHandleId,
-    resizeHandler
+    resizeHandler,
+    panelGroupElement
   });
   const style = {
     cursor: getCursorStyle(direction),
@@ -1600,52 +1656,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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-resizable-panels",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "React components for resizable panel groups/layouts",
   "author": "Brian Vaughn <brian.david.vaughn@gmail.com>",
   "license": "MIT",

package/src/Panel.test.tsx

@@ -12,6 +12,7 @@ import { createRef } from "./vendor/react";
 describe("PanelGroup", () => {
   let expectedWarnings: string[] = [];
   let root: Root;
+  let container: HTMLElement;
   let uninstallMockOffsetWidthAndHeight: () => void;
 
   function expectWarning(expectedMessage: string) {
@@ -24,7 +25,7 @@ describe("PanelGroup", () => {
 
     uninstallMockOffsetWidthAndHeight = mockPanelGroupOffsetWidthAndHeight();
 
-    const container = document.createElement("div");
+    container = document.createElement("div");
     document.body.appendChild(container);
 
     expectedWarnings = [];
@@ -258,13 +259,147 @@ describe("PanelGroup", () => {
       );
     });
 
-    const element = getPanelElement("panel");
+    const element = getPanelElement("panel", container);
     assert(element);
     expect(element.tabIndex).toBe(123);
     expect(element.getAttribute("data-test-name")).toBe("foo");
     expect(element.title).toBe("bar");
   });
 
+  describe("constraints", () => {
+    it("should resize a collapsed panel if the collapsedSize prop changes", () => {
+      act(() => {
+        root.render(
+          <PanelGroup direction="horizontal">
+            <Panel
+              id="left"
+              collapsedSize={10}
+              collapsible
+              defaultSize={10}
+              minSize={25}
+            />
+            <PanelResizeHandle />
+            <Panel id="middle" />
+            <PanelResizeHandle />
+            <Panel
+              id="right"
+              collapsedSize={10}
+              collapsible
+              defaultSize={10}
+              minSize={25}
+            />
+          </PanelGroup>
+        );
+      });
+
+      let leftElement = getPanelElement("left", container);
+      let middleElement = getPanelElement("middle", container);
+      let rightElement = getPanelElement("right", container);
+      assert(leftElement);
+      assert(middleElement);
+      assert(rightElement);
+      expect(leftElement.getAttribute("data-panel-size")).toBe("10.0");
+      expect(middleElement.getAttribute("data-panel-size")).toBe("80.0");
+      expect(rightElement.getAttribute("data-panel-size")).toBe("10.0");
+
+      act(() => {
+        root.render(
+          <PanelGroup direction="horizontal">
+            <Panel id="left" collapsedSize={5} collapsible minSize={25} />
+            <PanelResizeHandle />
+            <Panel id="middle" />
+            <PanelResizeHandle />
+            <Panel id="right" collapsedSize={5} collapsible minSize={25} />
+          </PanelGroup>
+        );
+      });
+
+      expect(leftElement.getAttribute("data-panel-size")).toBe("5.0");
+      expect(middleElement.getAttribute("data-panel-size")).toBe("90.0");
+      expect(rightElement.getAttribute("data-panel-size")).toBe("5.0");
+    });
+
+    it("should resize a panel if the minSize prop changes", () => {
+      act(() => {
+        root.render(
+          <PanelGroup direction="horizontal">
+            <Panel id="left" defaultSize={15} minSize={10} />
+            <PanelResizeHandle />
+            <Panel id="middle" />
+            <PanelResizeHandle />
+            <Panel id="right" defaultSize={15} minSize={10} />
+          </PanelGroup>
+        );
+      });
+
+      let leftElement = getPanelElement("left", container);
+      let middleElement = getPanelElement("middle", container);
+      let rightElement = getPanelElement("right", container);
+      assert(leftElement);
+      assert(middleElement);
+      assert(rightElement);
+      expect(leftElement.getAttribute("data-panel-size")).toBe("15.0");
+      expect(middleElement.getAttribute("data-panel-size")).toBe("70.0");
+      expect(rightElement.getAttribute("data-panel-size")).toBe("15.0");
+
+      act(() => {
+        root.render(
+          <PanelGroup direction="horizontal">
+            <Panel id="left" minSize={20} />
+            <PanelResizeHandle />
+            <Panel id="middle" />
+            <PanelResizeHandle />
+            <Panel id="right" minSize={20} />
+          </PanelGroup>
+        );
+      });
+
+      expect(leftElement.getAttribute("data-panel-size")).toBe("20.0");
+      expect(middleElement.getAttribute("data-panel-size")).toBe("60.0");
+      expect(rightElement.getAttribute("data-panel-size")).toBe("20.0");
+    });
+
+    it("should resize a panel if the maxSize prop changes", () => {
+      act(() => {
+        root.render(
+          <PanelGroup direction="horizontal">
+            <Panel id="left" defaultSize={25} maxSize={30} />
+            <PanelResizeHandle />
+            <Panel id="middle" />
+            <PanelResizeHandle />
+            <Panel id="right" defaultSize={25} maxSize={30} />
+          </PanelGroup>
+        );
+      });
+
+      let leftElement = getPanelElement("left", container);
+      let middleElement = getPanelElement("middle", container);
+      let rightElement = getPanelElement("right", container);
+      assert(leftElement);
+      assert(middleElement);
+      assert(rightElement);
+      expect(leftElement.getAttribute("data-panel-size")).toBe("25.0");
+      expect(middleElement.getAttribute("data-panel-size")).toBe("50.0");
+      expect(rightElement.getAttribute("data-panel-size")).toBe("25.0");
+
+      act(() => {
+        root.render(
+          <PanelGroup direction="horizontal">
+            <Panel id="left" maxSize={20} />
+            <PanelResizeHandle />
+            <Panel id="middle" />
+            <PanelResizeHandle />
+            <Panel id="right" maxSize={20} />
+          </PanelGroup>
+        );
+      });
+
+      expect(leftElement.getAttribute("data-panel-size")).toBe("20.0");
+      expect(middleElement.getAttribute("data-panel-size")).toBe("60.0");
+      expect(rightElement.getAttribute("data-panel-size")).toBe("20.0");
+    });
+  });
+
   describe("callbacks", () => {
     describe("onCollapse", () => {
       it("should be called on mount if a panels initial size is 0", () => {

package/src/Panel.ts

@@ -7,7 +7,7 @@ import {
   ForwardedRef,
   HTMLAttributes,
   PropsWithChildren,
-  ReactNode,
+  ReactElement,
   createElement,
   forwardRef,
   useContext,
@@ -93,7 +93,7 @@ export function PanelWithForwardedRef({
   ...rest
 }: PanelProps & {
   forwardedRef: ForwardedRef<ImperativePanelHandle>;
-}): ReactNode {
+}): ReactElement {
   const context = useContext(PanelGroupContext);
   if (context === null) {
     throw Error(
@@ -108,6 +108,7 @@ export function PanelWithForwardedRef({
     getPanelStyle,
     groupId,
     isPanelCollapsed,
+    reevaluatePanelConstraints,
     registerPanel,
     resizePanel,
     unregisterPanel,
@@ -155,6 +156,8 @@ export function PanelWithForwardedRef({
   useIsomorphicLayoutEffect(() => {
     const { callbacks, constraints } = panelDataRef.current;
 
+    const prevConstraints = { ...constraints };
+
     panelDataRef.current.id = panelId;
     panelDataRef.current.idIsFromProps = idFromProps !== undefined;
     panelDataRef.current.order = order;
@@ -168,6 +171,17 @@ export 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(() => {

package/src/PanelGroup.test.tsx

@@ -15,6 +15,7 @@ import { createRef } from "./vendor/react";
 describe("PanelGroup", () => {
   let expectedWarnings: string[] = [];
   let root: Root;
+  let container: HTMLElement;
   let uninstallMockOffsetWidthAndHeight: () => void;
 
   function expectWarning(expectedMessage: string) {
@@ -28,7 +29,7 @@ describe("PanelGroup", () => {
     // JSDom doesn't support element sizes
     uninstallMockOffsetWidthAndHeight = mockPanelGroupOffsetWidthAndHeight();
 
-    const container = document.createElement("div");
+    container = document.createElement("div");
     document.body.appendChild(container);
 
     expectedWarnings = [];
@@ -124,7 +125,7 @@ describe("PanelGroup", () => {
       );
     });
 
-    const element = getPanelGroupElement("group");
+    const element = getPanelGroupElement("group", container);
     assert(element);
     expect(element.tabIndex).toBe(123);
     expect(element.getAttribute("data-test-name")).toBe("foo");