baseui 10.9.2 → 10.11.1

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

@@ -19,14 +19,6 @@ 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."); }
@@ -39,50 +31,63 @@ function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-// 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];
+// 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;
 
-  var _React$useState3 = React.useState(null),
-      _React$useState4 = _slicedToArray(_React$useState3, 2),
-      node = _React$useState4[0],
-      setNode = _React$useState4[1];
+  var _useStyletron = (0, _index.useStyletron)(),
+      _useStyletron2 = _slicedToArray(_useStyletron, 1),
+      css = _useStyletron2[0];
 
-  var ref = React.useCallback(function (node) {
-    setNode(node);
-  }, []);
+  var ref = (0, React.useRef)();
   React.useEffect(function () {
     if (typeof document !== 'undefined') {
-      if (node) {
-        window.requestAnimationFrame(function () {
-          setDimensions(node.getBoundingClientRect());
-        });
+      if (ref.current) {
+        onLayout(columnIndex, ref.current.getBoundingClientRect());
       }
     }
-  }, [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
-  });
+  }, []);
+  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
+    });
+  }));
 }
 
-// sample size could likely be generated based on row count, to have higher confidence
 var MAX_SAMPLE_SIZE = 50;
 
 function generateSampleIndices(inputMin, inputMax, maxSamples) {
@@ -114,57 +119,46 @@ function generateSampleIndices(inputMin, inputMax, maxSamples) {
   return indices;
 }
 
-function MeasureColumnWidths(_ref) {
-  var columns = _ref.columns,
-      rows = _ref.rows,
-      widths = _ref.widths,
-      isSelectable = _ref.isSelectable,
-      onWidthsChange = _ref.onWidthsChange;
+function MeasureColumnWidths(_ref2) {
+  var columns = _ref2.columns,
+      rows = _ref2.rows,
+      widths = _ref2.widths,
+      isSelectable = _ref2.isSelectable,
+      onWidthsChange = _ref2.onWidthsChange;
 
-  var _useStyletron = (0, _index.useStyletron)(),
-      _useStyletron2 = _slicedToArray(_useStyletron, 1),
-      css = _useStyletron2[0];
+  var _useStyletron3 = (0, _index.useStyletron)(),
+      _useStyletron4 = _slicedToArray(_useStyletron3, 1),
+      css = _useStyletron4[0];
 
-  var measurementCount = React.useRef(0);
-  var dimensionsCache = React.useRef(widths);
+  var widthMap = React.useMemo(function () {
+    return new Map();
+  }, []);
   var sampleSize = rows.length < MAX_SAMPLE_SIZE ? rows.length : MAX_SAMPLE_SIZE;
   var finishedMeasurementCount = (sampleSize + 1) * columns.length;
-  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;
-    });
+  var sampleIndexes = React.useMemo(function () {
+    return generateSampleIndices(0, rows.length - 1, sampleSize);
   }, [columns, rows, widths, sampleSize]);
-  var handleDimensionsChange = React.useCallback(function (columnIndex, rowIndex, dimensions) {
-    if (dimensions.width === undefined) return;
+  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);
 
-    if (columns[columnIndex] === undefined || dimensionsCache.current[columnIndex] === undefined) {
-      return;
+    if (nextWidth !== widthMap.get(columnIndex)) {
+      widthMap.set(columnIndex, nextWidth);
     }
 
-    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);
+    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()));
     }
   }, [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 (measurementCount.current >= finishedMeasurementCount) {
+  if (widthMap.size === columns.length) {
     return null;
   }
 
@@ -175,45 +169,15 @@ function MeasureColumnWidths(_ref) {
       className: hiddenStyle,
       "aria-hidden": true,
       role: "none"
-    }, 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
-        })
+    }, 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
       });
     }))
   );

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

@@ -8,50 +8,68 @@ LICENSE file in the root directory of this source tree.
 
 import * as React from 'react';
 
-import {useStyletron} from '../styles/index.js';
+import { useStyletron } from '../styles/index.js';
 
 import HeaderCell from './header-cell.js';
-import type {ColumnT, RowT} from './types.js';
+import type { ColumnT, RowT } from './types.js';
+import { useRef } from 'react';
 
-// https://github.com/Swizec/useDimensions
-function useDimensions() {
-  const [dimensions, setDimensions] = React.useState({});
-  const [node, setNode] = React.useState(null);
+// Measures the column header + sampled data
+function MeasureColumn({ sampleIndexes, column, columnIndex, rows, isSelectable, onLayout }) {
+  const [css] = useStyletron();
 
-  const ref = React.useCallback(node => {
-    setNode(node);
-  }, []);
+  const ref = useRef();
 
   React.useEffect(() => {
     if (__BROWSER__) {
-      if (node) {
-        window.requestAnimationFrame(() => {
-          setDimensions(node.getBoundingClientRect());
-        });
+      if (ref.current) {
+        onLayout(columnIndex, ref.current.getBoundingClientRect());
       }
     }
-  }, [node]);
-
-  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});
+  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>
+  );
 }
-
 type MeasureColumnWidthsPropsT = {
   columns: ColumnT<>[],
   // if selectable, measure the first column with checkbox included
@@ -61,7 +79,6 @@ 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) {
@@ -96,54 +113,43 @@ export default function MeasureColumnWidths({
 }: MeasureColumnWidthsPropsT) {
   const [css] = useStyletron();
 
-  const measurementCount = React.useRef(0);
-  const dimensionsCache = React.useRef(widths);
+  const widthMap = React.useMemo(() => {
+    return new Map();
+  }, []);
 
-  const sampleSize =
-    rows.length < MAX_SAMPLE_SIZE ? rows.length : MAX_SAMPLE_SIZE;
+  const sampleSize = rows.length < MAX_SAMPLE_SIZE ? rows.length : MAX_SAMPLE_SIZE;
   const finishedMeasurementCount = (sampleSize + 1) * columns.length;
 
-  const sampleRowIndicesByColumn = React.useMemo<number[][]>(() => {
-    measurementCount.current = 0;
-    dimensionsCache.current = widths;
-
-    const indices = generateSampleIndices(0, rows.length - 1, sampleSize);
-    return columns.map(() => indices);
+  const sampleIndexes = React.useMemo<number[]>(() => {
+    return generateSampleIndices(0, rows.length - 1, sampleSize);
   }, [columns, rows, widths, sampleSize]);
 
   const handleDimensionsChange = React.useCallback(
-    (columnIndex, rowIndex, dimensions) => {
-      if (dimensions.width === undefined) return;
-
-      if (
-        columns[columnIndex] === undefined ||
-        dimensionsCache.current[columnIndex] === undefined
-      ) {
-        return;
-      }
-
-      measurementCount.current += 1;
-
+    (columnIndex, dimensions) => {
       const nextWidth = Math.min(
         Math.max(
           columns[columnIndex].minWidth || 0,
-          dimensionsCache.current[columnIndex],
-          dimensions.width + 1,
+          widthMap.get(columnIndex) || 0,
+          dimensions.width + 1
         ),
-        columns[columnIndex].maxWidth || Infinity,
+        columns[columnIndex].maxWidth || Infinity
       );
 
-      if (nextWidth !== dimensionsCache.current[columnIndex]) {
-        const nextWidths = [...dimensionsCache.current];
-        nextWidths[columnIndex] = nextWidth;
-        dimensionsCache.current = nextWidths;
+      if (nextWidth !== widthMap.get(columnIndex)) {
+        widthMap.set(columnIndex, nextWidth);
       }
-
-      if (measurementCount.current >= finishedMeasurementCount) {
-        onWidthsChange(dimensionsCache.current);
+      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()));
       }
     },
-    [columns, finishedMeasurementCount, onWidthsChange],
+    [columns, finishedMeasurementCount, onWidthsChange]
   );
 
   const hiddenStyle = css({
@@ -152,61 +158,27 @@ export default function MeasureColumnWidths({
     height: 0,
   });
 
-  if (measurementCount.current >= finishedMeasurementCount) {
+  // Remove the measurement nodes after we are done updating our column width
+  if (widthMap.size === columns.length) {
     return null;
   }
 
   return (
     // eslint-disable-next-line jsx-a11y/role-supports-aria-props
     <div className={hiddenStyle} aria-hidden role="none">
-      {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, i) => {
+        return (
+          <MeasureColumn
+            key={column.title + i}
+            column={column}
+            rows={rows}
+            isSelectable={isSelectable}
+            onLayout={handleDimensionsChange}
+            columnIndex={i}
+            sampleIndexes={sampleIndexes}
           />
-        ));
+        );
       })}
-      {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>
   );
 }

package/data-table/stateful-container.js.flow

@@ -8,19 +8,16 @@ LICENSE file in the root directory of this source tree.
 
 import * as React from 'react';
 
-import {SORT_DIRECTIONS} from './constants.js';
-import type {ColumnT, StatefulContainerPropsT} from './types.js';
+import { SORT_DIRECTIONS } from './constants.js';
+import type { ColumnT, StatefulContainerPropsT } from './types.js';
 
 function useDuplicateColumnTitleWarning(columns: ColumnT<>[]) {
   React.useEffect(() => {
     if (__DEV__) {
-      const titles = columns.reduce(
-        (set, column) => set.add(column.title),
-        new Set(),
-      );
+      const titles = columns.reduce((set, column) => set.add(column.title), new Set());
       if (titles.size < columns.length) {
         console.warn(
-          'BaseWeb DataTable: Column titles must be unique else will result in non-deterministic filtering.',
+          'BaseWeb DataTable: Column titles must be unique else will result in non-deterministic filtering.'
         );
       }
     }
@@ -29,9 +26,7 @@ function useDuplicateColumnTitleWarning(columns: ColumnT<>[]) {
 
 function useSortParameters(initialSortIndex = -1, initialSortDirection = null) {
   const [sortIndex, setSortIndex] = React.useState(initialSortIndex);
-  const [sortDirection, setSortDirection] = React.useState(
-    initialSortDirection,
-  );
+  const [sortDirection, setSortDirection] = React.useState(initialSortDirection);
 
   function handleSort(columnIndex) {
     if (columnIndex === sortIndex) {
@@ -54,11 +49,9 @@ export function StatefulContainer(props: StatefulContainerPropsT) {
   useDuplicateColumnTitleWarning(props.columns);
   const [sortIndex, sortDirection, handleSort] = useSortParameters(
     props.initialSortIndex,
-    props.initialSortDirection,
-  );
-  const [filters, setFilters] = React.useState(
-    props.initialFilters || new Map(),
+    props.initialSortDirection
   );
+  const [filters, setFilters] = React.useState(props.initialFilters || new Map());
   const [textQuery, setTextQuery] = React.useState('');
 
   function handleFilterAdd(title, filterParams) {
@@ -77,21 +70,19 @@ export function StatefulContainer(props: StatefulContainerPropsT) {
   }
 
   const [selectedRowIds, setSelectedRowIds] = React.useState(
-    props.initialSelectedRowIds || new Set(),
+    props.initialSelectedRowIds || new Set()
   );
   function handleSelectChange(next) {
     setSelectedRowIds(next);
 
     const selectionCallback = props.onSelectionChange;
     if (selectionCallback) {
-      selectionCallback(props.rows.filter(r => next.has(r.id)));
+      selectionCallback(props.rows.filter((r) => next.has(r.id)));
     }
   }
   function handleSelectMany(incomingRows) {
     // only adds rows that are visible in the table
-    handleSelectChange(
-      new Set([...selectedRowIds, ...incomingRows.map(r => r.id)]),
-    );
+    handleSelectChange(new Set([...selectedRowIds, ...incomingRows.map((r) => r.id)]));
   }
   function handleSelectNone() {
     handleSelectChange(new Set());
@@ -106,12 +97,12 @@ export function StatefulContainer(props: StatefulContainerPropsT) {
   }
 
   const handleIncludedRowsChange = React.useCallback(
-    rows => {
+    (rows) => {
       if (props.onIncludedRowsChange) {
         props.onIncludedRowsChange(rows);
       }
     },
-    [props.onIncludedRowsChange],
+    [props.onIncludedRowsChange]
   );
 
   const handleRowHighlightChange = React.useCallback(
@@ -120,7 +111,7 @@ export function StatefulContainer(props: StatefulContainerPropsT) {
         props.onRowHighlightChange(rowIndex, row);
       }
     },
-    [props.rowHighlightIndex],
+    [props.rowHighlightIndex]
   );
 
   return props.children({