baseui 10.9.0 → 10.9.1

package/data-table/measure-column-widths.js

@@ -19,6 +19,14 @@ function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -31,61 +39,50 @@ function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-// Measures the column header + sampled data
-function MeasureColumn(_ref) {
-  var sampleIndexes = _ref.sampleIndexes,
-      column = _ref.column,
-      columnIndex = _ref.columnIndex,
-      rows = _ref.rows,
-      isSelectable = _ref.isSelectable,
-      onLayout = _ref.onLayout;
+// https://github.com/Swizec/useDimensions
+function useDimensions() {
+  var _React$useState = React.useState({}),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      dimensions = _React$useState2[0],
+      setDimensions = _React$useState2[1];
 
-  var _useStyletron = (0, _index.useStyletron)(),
-      _useStyletron2 = _slicedToArray(_useStyletron, 1),
-      css = _useStyletron2[0];
+  var _React$useState3 = React.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      node = _React$useState4[0],
+      setNode = _React$useState4[1];
 
-  var ref = (0, React.useRef)();
+  var ref = React.useCallback(function (node) {
+    setNode(node);
+  }, []);
   React.useEffect(function () {
-    if (ref.current) {
-      onLayout(columnIndex, ref.current.getBoundingClientRect());
+    if (typeof document !== 'undefined') {
+      if (node) {
+        window.requestAnimationFrame(function () {
+          setDimensions(node.getBoundingClientRect());
+        });
+      }
     }
-  }, []);
-  return /*#__PURE__*/React.createElement("div", {
-    ref: ref,
-    className: css({
-      display: 'flex',
-      flexDirection: 'column',
-      width: 'fit-content'
-    })
-  }, /*#__PURE__*/React.createElement(_headerCell.default, {
-    index: columnIndex,
-    isHovered: true,
-    isMeasured: true,
-    isSelectedAll: false,
-    isSelectedIndeterminate: false,
-    onMouseEnter: function onMouseEnter() {},
-    onMouseLeave: function onMouseLeave() {},
-    onSelectAll: function onSelectAll() {},
-    onSelectNone: function onSelectNone() {},
-    onSort: function onSort(i) {},
-    sortable: column.sortable,
-    sortDirection: null,
-    title: column.title,
-    isSelectable: isSelectable
-  }), sampleIndexes.map(function (rowIndex, i) {
-    var Cell = column.renderCell;
-    return /*#__PURE__*/React.createElement(Cell, {
-      key: "measure-".concat(i),
-      value: column.mapDataToValue(rows[rowIndex].data),
-      isSelectable: isSelectable,
-      isMeasured: true,
-      sortable: column.sortable,
-      x: 0,
-      y: rowIndex
-    });
-  }));
+  }, [node]);
+  return [ref, dimensions];
+}
+
+function ElementMeasurer(props) {
+  var onDimensionsChange = props.onDimensionsChange;
+
+  var _useDimensions = useDimensions(),
+      _useDimensions2 = _slicedToArray(_useDimensions, 2),
+      ref = _useDimensions2[0],
+      dimensions = _useDimensions2[1];
+
+  React.useEffect(function () {
+    onDimensionsChange(dimensions);
+  }, [dimensions, onDimensionsChange]);
+  return /*#__PURE__*/React.cloneElement(props.item, {
+    ref: ref
+  });
 }
 
+// sample size could likely be generated based on row count, to have higher confidence
 var MAX_SAMPLE_SIZE = 50;
 
 function generateSampleIndices(inputMin, inputMax, maxSamples) {
@@ -117,46 +114,57 @@ function generateSampleIndices(inputMin, inputMax, maxSamples) {
   return indices;
 }
 
-function MeasureColumnWidths(_ref2) {
-  var columns = _ref2.columns,
-      rows = _ref2.rows,
-      widths = _ref2.widths,
-      isSelectable = _ref2.isSelectable,
-      onWidthsChange = _ref2.onWidthsChange;
+function MeasureColumnWidths(_ref) {
+  var columns = _ref.columns,
+      rows = _ref.rows,
+      widths = _ref.widths,
+      isSelectable = _ref.isSelectable,
+      onWidthsChange = _ref.onWidthsChange;
 
-  var _useStyletron3 = (0, _index.useStyletron)(),
-      _useStyletron4 = _slicedToArray(_useStyletron3, 1),
-      css = _useStyletron4[0];
+  var _useStyletron = (0, _index.useStyletron)(),
+      _useStyletron2 = _slicedToArray(_useStyletron, 1),
+      css = _useStyletron2[0];
 
-  var widthMap = React.useMemo(function () {
-    return new Map();
-  }, []);
+  var measurementCount = React.useRef(0);
+  var dimensionsCache = React.useRef(widths);
   var sampleSize = rows.length < MAX_SAMPLE_SIZE ? rows.length : MAX_SAMPLE_SIZE;
   var finishedMeasurementCount = (sampleSize + 1) * columns.length;
-  var sampleIndexes = React.useMemo(function () {
-    return generateSampleIndices(0, rows.length - 1, sampleSize);
+  var sampleRowIndicesByColumn = React.useMemo(function () {
+    measurementCount.current = 0;
+    dimensionsCache.current = widths;
+    var indices = generateSampleIndices(0, rows.length - 1, sampleSize);
+    return columns.map(function () {
+      return indices;
+    });
   }, [columns, rows, widths, sampleSize]);
-  var handleDimensionsChange = React.useCallback(function (columnIndex, dimensions) {
-    var nextWidth = Math.min(Math.max(columns[columnIndex].minWidth || 0, widthMap.get(columnIndex) || 0, dimensions.width + 1), columns[columnIndex].maxWidth || Infinity);
+  var handleDimensionsChange = React.useCallback(function (columnIndex, rowIndex, dimensions) {
+    if (dimensions.width === undefined) return;
 
-    if (nextWidth !== widthMap.get(columnIndex)) {
-      widthMap.set(columnIndex, nextWidth);
+    if (columns[columnIndex] === undefined || dimensionsCache.current[columnIndex] === undefined) {
+      return;
     }
 
-    if ( // Refresh at 100% of done
-    widthMap.size === columns.length || // ...50%
-    widthMap.size === Math.floor(columns.length / 2) || // ...25%
-    widthMap.size === Math.floor(columns.length / 4)) {
-      onWidthsChange(Array.from(widthMap.values()));
+    measurementCount.current += 1;
+    var nextWidth = Math.min(Math.max(columns[columnIndex].minWidth || 0, dimensionsCache.current[columnIndex], dimensions.width + 1), columns[columnIndex].maxWidth || Infinity);
+
+    if (nextWidth !== dimensionsCache.current[columnIndex]) {
+      var nextWidths = _toConsumableArray(dimensionsCache.current);
+
+      nextWidths[columnIndex] = nextWidth;
+      dimensionsCache.current = nextWidths;
+    }
+
+    if (measurementCount.current >= finishedMeasurementCount) {
+      onWidthsChange(dimensionsCache.current);
     }
   }, [columns, finishedMeasurementCount, onWidthsChange]);
   var hiddenStyle = css({
     position: 'absolute',
     overflow: 'hidden',
     height: 0
-  }); // Remove the measurement nodes after we are done updating our column width
+  });
 
-  if (widthMap.size === columns.length) {
+  if (measurementCount.current >= finishedMeasurementCount) {
     return null;
   }
 
@@ -167,15 +175,45 @@ function MeasureColumnWidths(_ref2) {
       className: hiddenStyle,
       "aria-hidden": true,
       role: "none"
-    }, columns.map(function (column, i) {
-      return /*#__PURE__*/React.createElement(MeasureColumn, {
-        key: column.title + i,
-        column: column,
-        rows: rows,
-        isSelectable: isSelectable,
-        onLayout: handleDimensionsChange,
-        columnIndex: i,
-        sampleIndexes: sampleIndexes
+    }, sampleRowIndicesByColumn.map(function (rowIndices, columnIndex) {
+      var Cell = columns[columnIndex].renderCell;
+      return rowIndices.map(function (rowIndex) {
+        return /*#__PURE__*/React.createElement(ElementMeasurer, {
+          key: "measure-".concat(columnIndex, "-").concat(rowIndex),
+          onDimensionsChange: function onDimensionsChange(dimensions) {
+            return handleDimensionsChange(columnIndex, rowIndex, dimensions);
+          },
+          item: /*#__PURE__*/React.createElement(Cell, {
+            value: columns[columnIndex].mapDataToValue(rows[rowIndex].data),
+            isMeasured: true,
+            onSelect: isSelectable && columnIndex === 0 ? function () {} : undefined,
+            x: columnIndex,
+            y: rowIndex
+          })
+        });
+      });
+    }), columns.map(function (column, columnIndex) {
+      return /*#__PURE__*/React.createElement(ElementMeasurer, {
+        key: "measure-column-".concat(columnIndex),
+        onDimensionsChange: function onDimensionsChange(dimensions) {
+          return handleDimensionsChange(columnIndex, -1, dimensions);
+        },
+        item: /*#__PURE__*/React.createElement(_headerCell.default, {
+          index: columnIndex,
+          isHovered: true,
+          isMeasured: true,
+          isSelectable: isSelectable && columnIndex === 0,
+          isSelectedAll: false,
+          isSelectedIndeterminate: false,
+          onMouseEnter: function onMouseEnter() {},
+          onMouseLeave: function onMouseLeave() {},
+          onSelectAll: function onSelectAll() {},
+          onSelectNone: function onSelectNone() {},
+          onSort: function onSort(i) {},
+          sortable: column.sortable,
+          sortDirection: null,
+          title: column.title
+        })
       });
     }))
   );

package/data-table/measure-column-widths.js.flow

@@ -12,69 +12,46 @@ import {useStyletron} from '../styles/index.js';
 
 import HeaderCell from './header-cell.js';
 import type {ColumnT, RowT} from './types.js';
-import {useRef} from 'react';
 
-// Measures the column header + sampled data
-function MeasureColumn({
-  sampleIndexes,
-  column,
-  columnIndex,
-  rows,
-  isSelectable,
-  onLayout,
-}) {
-  const [css] = useStyletron();
+// https://github.com/Swizec/useDimensions
+function useDimensions() {
+  const [dimensions, setDimensions] = React.useState({});
+  const [node, setNode] = React.useState(null);
 
-  const ref = useRef();
+  const ref = React.useCallback(node => {
+    setNode(node);
+  }, []);
 
   React.useEffect(() => {
-    if (ref.current) {
-      onLayout(columnIndex, ref.current.getBoundingClientRect());
+    if (__BROWSER__) {
+      if (node) {
+        window.requestAnimationFrame(() => {
+          setDimensions(node.getBoundingClientRect());
+        });
+      }
     }
-  }, []);
+  }, [node]);
 
-  return (
-    <div
-      ref={ref}
-      className={css({
-        display: 'flex',
-        flexDirection: 'column',
-        width: 'fit-content',
-      })}
-    >
-      <HeaderCell
-        index={columnIndex}
-        isHovered
-        isMeasured
-        isSelectedAll={false}
-        isSelectedIndeterminate={false}
-        onMouseEnter={() => {}}
-        onMouseLeave={() => {}}
-        onSelectAll={() => {}}
-        onSelectNone={() => {}}
-        onSort={i => {}}
-        sortable={column.sortable}
-        sortDirection={null}
-        title={column.title}
-        isSelectable={isSelectable}
-      />
-      {sampleIndexes.map((rowIndex, i) => {
-        const Cell = column.renderCell;
-        return (
-          <Cell
-            key={`measure-${i}`}
-            value={column.mapDataToValue(rows[rowIndex].data)}
-            isSelectable={isSelectable}
-            isMeasured
-            sortable={column.sortable}
-            x={0}
-            y={rowIndex}
-          />
-        );
-      })}
-    </div>
-  );
+  return [ref, dimensions];
 }
+
+type ElementMeasurerPropsT = {
+  onDimensionsChange: (dimensions: {width: number}) => void,
+  // eslint-disable-next-line flowtype/no-weak-types
+  item: React.Element<any>,
+};
+
+function ElementMeasurer(props: ElementMeasurerPropsT) {
+  const {onDimensionsChange} = props;
+  const [ref, dimensions] = useDimensions();
+
+  React.useEffect(() => {
+    onDimensionsChange(dimensions);
+  }, [dimensions, onDimensionsChange]);
+
+  return React.cloneElement(props.item, {ref});
+}
+
 type MeasureColumnWidthsPropsT = {
   columns: ColumnT<>[],
   // if selectable, measure the first column with checkbox included
@@ -84,6 +61,7 @@ type MeasureColumnWidthsPropsT = {
   widths: number[],
 };
 
+// sample size could likely be generated based on row count, to have higher confidence
 const MAX_SAMPLE_SIZE = 50;
 
 function generateSampleIndices(inputMin, inputMax, maxSamples) {
@@ -118,41 +96,51 @@ export default function MeasureColumnWidths({
 }: MeasureColumnWidthsPropsT) {
   const [css] = useStyletron();
 
-  const widthMap = React.useMemo(() => {
-    return new Map();
-  }, []);
+  const measurementCount = React.useRef(0);
+  const dimensionsCache = React.useRef(widths);
 
   const sampleSize =
     rows.length < MAX_SAMPLE_SIZE ? rows.length : MAX_SAMPLE_SIZE;
   const finishedMeasurementCount = (sampleSize + 1) * columns.length;
 
-  const sampleIndexes = React.useMemo<number[]>(() => {
-    return generateSampleIndices(0, rows.length - 1, sampleSize);
+  const sampleRowIndicesByColumn = React.useMemo<number[][]>(() => {
+    measurementCount.current = 0;
+    dimensionsCache.current = widths;
+
+    const indices = generateSampleIndices(0, rows.length - 1, sampleSize);
+    return columns.map(() => indices);
   }, [columns, rows, widths, sampleSize]);
 
   const handleDimensionsChange = React.useCallback(
-    (columnIndex, dimensions) => {
+    (columnIndex, rowIndex, dimensions) => {
+      if (dimensions.width === undefined) return;
+
+      if (
+        columns[columnIndex] === undefined ||
+        dimensionsCache.current[columnIndex] === undefined
+      ) {
+        return;
+      }
+
+      measurementCount.current += 1;
+
       const nextWidth = Math.min(
         Math.max(
           columns[columnIndex].minWidth || 0,
-          widthMap.get(columnIndex) || 0,
+          dimensionsCache.current[columnIndex],
           dimensions.width + 1,
         ),
         columns[columnIndex].maxWidth || Infinity,
       );
 
-      if (nextWidth !== widthMap.get(columnIndex)) {
-        widthMap.set(columnIndex, nextWidth);
+      if (nextWidth !== dimensionsCache.current[columnIndex]) {
+        const nextWidths = [...dimensionsCache.current];
+        nextWidths[columnIndex] = nextWidth;
+        dimensionsCache.current = nextWidths;
       }
-      if (
-        // Refresh at 100% of done
-        widthMap.size === columns.length ||
-        // ...50%
-        widthMap.size === Math.floor(columns.length / 2) ||
-        // ...25%
-        widthMap.size === Math.floor(columns.length / 4)
-      ) {
-        onWidthsChange(Array.from(widthMap.values()));
+
+      if (measurementCount.current >= finishedMeasurementCount) {
+        onWidthsChange(dimensionsCache.current);
       }
     },
     [columns, finishedMeasurementCount, onWidthsChange],
@@ -164,27 +152,61 @@ export default function MeasureColumnWidths({
     height: 0,
   });
 
-  // Remove the measurement nodes after we are done updating our column width
-  if (widthMap.size === columns.length) {
+  if (measurementCount.current >= finishedMeasurementCount) {
     return null;
   }
 
   return (
     // eslint-disable-next-line jsx-a11y/role-supports-aria-props
     <div className={hiddenStyle} aria-hidden role="none">
-      {columns.map((column, i) => {
-        return (
-          <MeasureColumn
-            key={column.title + i}
-            column={column}
-            rows={rows}
-            isSelectable={isSelectable}
-            onLayout={handleDimensionsChange}
-            columnIndex={i}
-            sampleIndexes={sampleIndexes}
+      {sampleRowIndicesByColumn.map((rowIndices, columnIndex) => {
+        const Cell = columns[columnIndex].renderCell;
+        return rowIndices.map(rowIndex => (
+          <ElementMeasurer
+            key={`measure-${columnIndex}-${rowIndex}`}
+            onDimensionsChange={dimensions =>
+              handleDimensionsChange(columnIndex, rowIndex, dimensions)
+            }
+            item={
+              <Cell
+                value={columns[columnIndex].mapDataToValue(rows[rowIndex].data)}
+                isMeasured
+                onSelect={
+                  isSelectable && columnIndex === 0 ? () => {} : undefined
+                }
+                x={columnIndex}
+                y={rowIndex}
+              />
+            }
           />
-        );
+        ));
       })}
+      {columns.map((column, columnIndex) => (
+        <ElementMeasurer
+          key={`measure-column-${columnIndex}`}
+          onDimensionsChange={dimensions =>
+            handleDimensionsChange(columnIndex, -1, dimensions)
+          }
+          item={
+            <HeaderCell
+              index={columnIndex}
+              isHovered
+              isMeasured
+              isSelectable={isSelectable && columnIndex === 0}
+              isSelectedAll={false}
+              isSelectedIndeterminate={false}
+              onMouseEnter={() => {}}
+              onMouseLeave={() => {}}
+              onSelectAll={() => {}}
+              onSelectNone={() => {}}
+              onSort={i => {}}
+              sortable={column.sortable}
+              sortDirection={null}
+              title={column.title}
+            />
+          }
+        />
+      ))}
     </div>
   );
 }