react-resizable-panels 2.0.13 → 2.0.14

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 2.0.14
+
+- Better account for high-precision `collapsedSize` values (#325)
+
 ## 2.0.13
 
 - Fix potential cycle in stacking-order logic for an unmounted node (#317)

package/dist/react-resizable-panels.browser.cjs.js

@@ -687,15 +687,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1702,7 +1702,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1741,11 +1741,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1810,7 +1810,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1825,7 +1826,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -2034,8 +2035,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

package/dist/react-resizable-panels.browser.development.cjs.js

@@ -693,15 +693,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1808,7 +1808,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1847,11 +1847,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1916,7 +1916,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1931,7 +1932,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -2140,8 +2141,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

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

@@ -669,15 +669,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1784,7 +1784,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1823,11 +1823,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1892,7 +1892,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1907,7 +1908,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -2116,8 +2117,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

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

@@ -663,15 +663,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1678,7 +1678,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1717,11 +1717,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1786,7 +1786,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1801,7 +1802,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -2010,8 +2011,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

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

@@ -689,15 +689,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1704,7 +1704,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1743,11 +1743,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1812,7 +1812,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1827,7 +1828,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -2036,8 +2037,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

package/dist/react-resizable-panels.development.cjs.js

@@ -700,15 +700,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1815,7 +1815,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1854,11 +1854,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1923,7 +1923,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1938,7 +1939,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -2147,8 +2148,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

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

@@ -676,15 +676,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1791,7 +1791,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1830,11 +1830,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1899,7 +1899,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1914,7 +1915,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -2123,8 +2124,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

package/dist/react-resizable-panels.development.node.cjs.js

@@ -662,15 +662,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1639,7 +1639,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1678,11 +1678,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1747,7 +1747,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1762,7 +1763,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -1915,8 +1916,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

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

@@ -638,15 +638,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1615,7 +1615,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1654,11 +1654,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1723,7 +1723,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1738,7 +1739,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -1891,8 +1892,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

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

@@ -665,15 +665,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1680,7 +1680,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1719,11 +1719,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1788,7 +1788,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1803,7 +1804,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -2012,8 +2013,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

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

@@ -651,15 +651,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1538,7 +1538,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1577,11 +1577,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1646,7 +1646,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1661,7 +1662,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -1814,8 +1815,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

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

@@ -627,15 +627,15 @@ function assert(expectedCondition, message) {
 const PRECISION = 10;
 
 function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
 
 function fuzzyNumbersEqual(actual, expected, fractionDigits) {
   return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
@@ -1514,7 +1514,7 @@ function PanelGroupWithForwardedRef({
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
       assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -1553,11 +1553,11 @@ function PanelGroupWithForwardedRef({
       const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);
         const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;
@@ -1622,7 +1622,8 @@ function PanelGroupWithForwardedRef({
       collapsible,
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
-    return collapsible === true && panelSize === collapsedSize;
+    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
+    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -1637,7 +1638,7 @@ function PanelGroupWithForwardedRef({
       panelSize
     } = panelDataHelper(panelDataArray, panelData, layout);
     assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
   const registerPanel = useCallback(panelData => {
     const {
@@ -1790,8 +1791,8 @@ function PanelGroupWithForwardedRef({
       // It's possible that the panels in this group have changed since the last render
       return;
     }
-    if (prevCollapsible && nextCollapsible && prevPanelSize === prevCollapsedSize) {
-      if (prevCollapsedSize !== nextCollapsedSize) {
+    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {
+      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {
         resizePanel(panelData, nextCollapsedSize);
       }
     } else if (prevPanelSize < nextMinSize) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-resizable-panels",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "description": "React components for resizable panel groups/layouts",
   "author": "Brian Vaughn <brian.david.vaughn@gmail.com>",
   "license": "MIT",
@@ -60,6 +60,12 @@
     }
   },
   "types": "dist/react-resizable-panels.cjs.d.ts",
+  "scripts": {
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "test": "jest --config=jest.config.js",
+    "test:watch": "jest --config=jest.config.js --watch",
+    "watch": "parcel watch --port=2345"
+  },
   "devDependencies": {
     "@babel/plugin-proposal-nullish-coalescing-operator": "7.18.6",
     "@babel/plugin-proposal-optional-chaining": "7.21.0",
@@ -77,11 +83,5 @@
   },
   "browserslist": [
     "Chrome 79"
-  ],
-  "scripts": {
-    "lint": "eslint \"src/**/*.{ts,tsx}\"",
-    "test": "jest --config=jest.config.js",
-    "test:watch": "jest --config=jest.config.js --watch",
-    "watch": "parcel watch --port=2345"
-  }
-}
+  ]
+}

package/src/Panel.test.tsx

@@ -144,6 +144,55 @@ describe("PanelGroup", () => {
         });
         verifyExpandedPanelGroupLayout(mostRecentLayout, [30, 70]);
       });
+
+      it("should report the correct state with collapsedSizes that have many decimal places", () => {
+        act(() => {
+          root.render(
+            <PanelGroup direction="horizontal">
+              <Panel
+                collapsedSize={3.8764385221078133}
+                collapsible
+                defaultSize={50}
+                minSize={15}
+                ref={leftPanelRef}
+              />
+              <PanelResizeHandle />
+              <Panel collapsible defaultSize={50} ref={rightPanelRef} />
+            </PanelGroup>
+          );
+        });
+
+        act(() => {
+          leftPanelRef.current?.collapse();
+        });
+        expect(leftPanelRef.current?.isCollapsed()).toBe(true);
+        expect(leftPanelRef.current?.isExpanded()).toBe(false);
+
+        act(() => {
+          root.render(
+            <PanelGroup direction="horizontal">
+              <Panel
+                collapsedSize={3.8764385221078132}
+                collapsible
+                defaultSize={50}
+                minSize={15}
+                ref={leftPanelRef}
+              />
+              <PanelResizeHandle />
+              <Panel collapsible defaultSize={50} ref={rightPanelRef} />
+            </PanelGroup>
+          );
+        });
+
+        expect(leftPanelRef.current?.isCollapsed()).toBe(true);
+        expect(leftPanelRef.current?.isExpanded()).toBe(false);
+
+        act(() => {
+          leftPanelRef.current?.expand();
+        });
+        expect(leftPanelRef.current?.isCollapsed()).toBe(false);
+        expect(leftPanelRef.current?.isExpanded()).toBe(true);
+      });
     });
 
     describe("resize", () => {

package/src/PanelGroup.ts

@@ -31,6 +31,10 @@ import { getResizeHandleElement } from "./utils/dom/getResizeHandleElement";
 import { isKeyDown, isMouseEvent, isTouchEvent } from "./utils/events";
 import { getResizeEventCursorPosition } from "./utils/events/getResizeEventCursorPosition";
 import { initializeDefaultStorage } from "./utils/initializeDefaultStorage";
+import {
+  fuzzyCompareNumbers,
+  fuzzyNumbersEqual,
+} from "./utils/numbers/fuzzyCompareNumbers";
 import {
   loadPanelGroupState,
   savePanelGroupState,
@@ -341,7 +345,7 @@ function PanelGroupWithForwardedRef({
         `Panel size not found for panel "${panelData.id}"`
       );
 
-      if (panelSize !== collapsedSize) {
+      if (!fuzzyNumbersEqual(panelSize, collapsedSize)) {
         // Store size before collapse;
         // This is the size that gets restored if the expand() API is used.
         panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
@@ -393,12 +397,12 @@ function PanelGroupWithForwardedRef({
 
       const {
         collapsedSize = 0,
-        panelSize,
+        panelSize = 0,
         minSize = 0,
         pivotIndices,
       } = panelDataHelper(panelDataArray, panelData, prevLayout);
 
-      if (panelSize === collapsedSize) {
+      if (fuzzyNumbersEqual(panelSize, collapsedSize)) {
         // Restore this panel to the size it was before it was collapsed, if possible.
         const prevPanelSize = panelSizeBeforeCollapseRef.current.get(
           panelData.id
@@ -484,7 +488,12 @@ function PanelGroupWithForwardedRef({
       panelSize,
     } = panelDataHelper(panelDataArray, panelData, layout);
 
-    return collapsible === true && panelSize === collapsedSize;
+    assert(
+      panelSize != null,
+      `Panel size not found for panel "${panelData.id}"`
+    );
+
+    return collapsible === true && fuzzyNumbersEqual(panelSize, collapsedSize);
   }, []);
 
   // External APIs are safe to memoize via committed values ref
@@ -502,7 +511,7 @@ function PanelGroupWithForwardedRef({
       `Panel size not found for panel "${panelData.id}"`
     );
 
-    return !collapsible || panelSize > collapsedSize;
+    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;
   }, []);
 
   const registerPanel = useCallback((panelData: PanelData) => {
@@ -780,9 +789,9 @@ function PanelGroupWithForwardedRef({
       if (
         prevCollapsible &&
         nextCollapsible &&
-        prevPanelSize === prevCollapsedSize
+        fuzzyNumbersEqual(prevPanelSize, prevCollapsedSize)
       ) {
-        if (prevCollapsedSize !== nextCollapsedSize) {
+        if (!fuzzyNumbersEqual(prevCollapsedSize, nextCollapsedSize)) {
           resizePanel(panelData, nextCollapsedSize);
         } else {
           // Stay collapsed

package/src/utils/numbers/fuzzyCompareNumbers.ts

@@ -5,13 +5,17 @@ export function fuzzyCompareNumbers(
   expected: number,
   fractionDigits: number = PRECISION
 ): number {
-  actual = parseFloat(actual.toFixed(fractionDigits));
-  expected = parseFloat(expected.toFixed(fractionDigits));
-
-  const delta = actual - expected;
-  if (delta === 0) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
     return 0;
   } else {
-    return delta > 0 ? 1 : -1;
+    return actual > expected ? 1 : -1;
   }
 }
+
+export function fuzzyNumbersEqual(
+  actual: number,
+  expected: number,
+  fractionDigits: number = PRECISION
+): boolean {
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}

package/.parcel-cache/13776de4870b0ae4.txt

@@ -1,2 +0,0 @@
-114864213
-1680459541679979000

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Brian Vaughn
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.