baseui 0.0.0-next-a3efedf → 0.0.0-next-cefa45f

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

@@ -12,46 +12,69 @@ import {useStyletron} from '../styles/index.js';
 
 import HeaderCell from './header-cell.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 +84,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,51 +118,41 @@ 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 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],
+          widthMap.get(columnIndex) || 0,
           dimensions.width + 1,
         ),
         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],
@@ -152,61 +164,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/es/data-table/data-table.js

@@ -17,6 +17,8 @@ import { LocaleContext } from '../locale/index.js'; // consider pulling this out
 
 const HEADER_ROW_HEIGHT = 48;
 
+const sum = ns => ns.reduce((s, n) => s + n, 0);
+
 function CellPlacement({
   columnIndex,
   rowIndex,
@@ -255,7 +257,7 @@ function Header(props) {
   }))));
 }
 
-function Headers(props) {
+function Headers() {
   const [css, theme] = useStyletron();
   const locale = React.useContext(LocaleContext);
   const ctx = React.useContext(HeaderContext);
@@ -265,7 +267,7 @@ function Headers(props) {
       position: 'sticky',
       top: 0,
       left: 0,
-      width: `${ctx.widths.reduce((sum, w) => sum + w, 0)}px`,
+      width: `${sum(ctx.widths)}px`,
       height: `${HEADER_ROW_HEIGHT}px`,
       display: 'flex',
       // this feels bad.. the absolutely positioned children elements
@@ -467,8 +469,10 @@ export function DataTable({
     }
 
     return rowHeight;
-  }, [rowHeight]);
-  const gridRef = React.useRef(null);
+  }, [rowHeight]); // We use state for our ref, to allow hooks to  update when the ref changes.
+  // eslint-disable-next-line flowtype/no-weak-types
+
+  const [gridRef, setGridRef] = React.useState(null);
   const [measuredWidths, setMeasuredWidths] = React.useState(columns.map(() => 0));
   const [resizeDeltas, setResizeDeltas] = React.useState(columns.map(() => 0));
   React.useEffect(() => {
@@ -480,11 +484,11 @@ export function DataTable({
     });
   }, [columns]);
   const resetAfterColumnIndex = React.useCallback(columnIndex => {
-    if (gridRef.current) {
+    if (gridRef) {
       // $FlowFixMe trigger react-window to layout the elements again
-      gridRef.current.resetAfterColumnIndex(columnIndex, true);
+      gridRef.resetAfterColumnIndex(columnIndex, true);
     }
-  }, [gridRef.current]);
+  }, [gridRef]);
   const handleWidthsChange = React.useCallback(nextWidths => {
     setMeasuredWidths(nextWidths);
     resetAfterColumnIndex(0);
@@ -594,13 +598,10 @@ export function DataTable({
   }, [sortedIndices, filteredIndices, onIncludedRowsChange, allRows]);
   const [browserScrollbarWidth, setBrowserScrollbarWidth] = React.useState(0);
   const normalizedWidths = React.useMemo(() => {
-    const sum = ns => ns.reduce((s, n) => s + n, 0);
-
     const resizedWidths = measuredWidths.map((w, i) => Math.floor(w) + Math.floor(resizeDeltas[i]));
 
-    if (gridRef.current) {
-      // $FlowFixMe
-      const gridProps = gridRef.current.props;
+    if (gridRef) {
+      const gridProps = gridRef.props;
       let isContentTallerThanContainer = false;
       let visibleRowHeight = 0;
 
@@ -635,7 +636,7 @@ export function DataTable({
     }
 
     return resizedWidths;
-  }, [measuredWidths, resizeDeltas, browserScrollbarWidth, rows.length, columns]);
+  }, [gridRef, measuredWidths, resizeDeltas, browserScrollbarWidth, rows.length, columns]);
   const isSelectable = batchActions ? !!batchActions.length : false;
   const isSelectedAll = React.useMemo(() => {
     if (!selectedRowIds) {
@@ -684,10 +685,10 @@ export function DataTable({
   function handleRowHighlightIndexChange(nextIndex) {
     setRowHighlightIndex(nextIndex);
 
-    if (gridRef.current) {
+    if (gridRef) {
       if (nextIndex >= 0) {
         // $FlowFixMe - unable to get react-window types
-        gridRef.current.scrollToItem({
+        gridRef.scrollToItem({
           rowIndex: nextIndex
         });
       }
@@ -776,8 +777,9 @@ export function DataTable({
     }
   }, /*#__PURE__*/React.createElement(VariableSizeGrid // eslint-disable-next-line flowtype/no-weak-types
   , {
-    ref: gridRef,
+    ref: setGridRef,
     overscanRowCount: 10,
+    overscanColumnCount: 5,
     innerElementType: InnerTableElement,
     columnCount: columns.length,
     columnWidth: columnIndex => normalizedWidths[columnIndex],

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

@@ -7,40 +7,59 @@ LICENSE file in the root directory of this source tree.
 import * as React from 'react';
 import { useStyletron } from '../styles/index.js';
 import HeaderCell from './header-cell.js';
+import { useRef } from 'react'; // Measures the column header + sampled data
 
-// https://github.com/Swizec/useDimensions
-function useDimensions() {
-  const [dimensions, setDimensions] = React.useState({});
-  const [node, setNode] = React.useState(null);
-  const ref = React.useCallback(node => {
-    setNode(node);
-  }, []);
+function MeasureColumn({
+  sampleIndexes,
+  column,
+  columnIndex,
+  rows,
+  isSelectable,
+  onLayout
+}) {
+  const [css] = useStyletron();
+  const ref = useRef();
   React.useEffect(() => {
-    if (typeof document !== 'undefined') {
-      if (node) {
-        window.requestAnimationFrame(() => {
-          setDimensions(node.getBoundingClientRect());
-        });
-      }
+    if (ref.current) {
+      onLayout(columnIndex, ref.current.getBoundingClientRect());
     }
-  }, [node]);
-  return [ref, dimensions];
-}
-
-function ElementMeasurer(props) {
-  const {
-    onDimensionsChange
-  } = props;
-  const [ref, dimensions] = useDimensions();
-  React.useEffect(() => {
-    onDimensionsChange(dimensions);
-  }, [dimensions, onDimensionsChange]);
-  return /*#__PURE__*/React.cloneElement(props.item, {
-    ref
-  });
+  }, []);
+  return /*#__PURE__*/React.createElement("div", {
+    ref: ref,
+    className: css({
+      display: 'flex',
+      flexDirection: 'column',
+      width: 'fit-content'
+    })
+  }, /*#__PURE__*/React.createElement(HeaderCell, {
+    index: columnIndex,
+    isHovered: true,
+    isMeasured: true,
+    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 /*#__PURE__*/React.createElement(Cell, {
+      key: `measure-${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
 const MAX_SAMPLE_SIZE = 50;
 
 function generateSampleIndices(inputMin, inputMax, maxSamples) {
@@ -77,43 +96,35 @@ export default function MeasureColumnWidths({
   onWidthsChange
 }) {
   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 finishedMeasurementCount = (sampleSize + 1) * columns.length;
-  const sampleRowIndicesByColumn = React.useMemo(() => {
-    measurementCount.current = 0;
-    dimensionsCache.current = widths;
-    const indices = generateSampleIndices(0, rows.length - 1, sampleSize);
-    return columns.map(() => indices);
+  const sampleIndexes = React.useMemo(() => {
+    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;
-    const nextWidth = Math.min(Math.max(columns[columnIndex].minWidth || 0, dimensionsCache.current[columnIndex], dimensions.width + 1), columns[columnIndex].maxWidth || Infinity);
+  const handleDimensionsChange = React.useCallback((columnIndex, dimensions) => {
+    const nextWidth = Math.min(Math.max(columns[columnIndex].minWidth || 0, widthMap.get(columnIndex) || 0, dimensions.width + 1), 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]);
   const 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;
   }
 
@@ -124,38 +135,16 @@ export default function MeasureColumnWidths({
       className: hiddenStyle,
       "aria-hidden": true,
       role: "none"
-    }, sampleRowIndicesByColumn.map((rowIndices, columnIndex) => {
-      const Cell = columns[columnIndex].renderCell;
-      return rowIndices.map(rowIndex => /*#__PURE__*/React.createElement(ElementMeasurer, {
-        key: `measure-${columnIndex}-${rowIndex}`,
-        onDimensionsChange: dimensions => handleDimensionsChange(columnIndex, rowIndex, dimensions),
-        item: /*#__PURE__*/React.createElement(Cell, {
-          value: columns[columnIndex].mapDataToValue(rows[rowIndex].data),
-          isMeasured: true,
-          onSelect: isSelectable && columnIndex === 0 ? () => {} : undefined,
-          x: columnIndex,
-          y: rowIndex
-        })
-      }));
-    }), columns.map((column, columnIndex) => /*#__PURE__*/React.createElement(ElementMeasurer, {
-      key: `measure-column-${columnIndex}`,
-      onDimensionsChange: dimensions => handleDimensionsChange(columnIndex, -1, dimensions),
-      item: /*#__PURE__*/React.createElement(HeaderCell, {
-        index: columnIndex,
-        isHovered: true,
-        isMeasured: true,
-        isSelectable: isSelectable && columnIndex === 0,
-        isSelectedAll: false,
-        isSelectedIndeterminate: false,
-        onMouseEnter: () => {},
-        onMouseLeave: () => {},
-        onSelectAll: () => {},
-        onSelectNone: () => {},
-        onSort: i => {},
-        sortable: column.sortable,
-        sortDirection: null,
-        title: column.title
-      })
-    })))
+    }, columns.map((column, i) => {
+      return /*#__PURE__*/React.createElement(MeasureColumn, {
+        key: column.title + i,
+        column: column,
+        rows: rows,
+        isSelectable: isSelectable,
+        onLayout: handleDimensionsChange,
+        columnIndex: i,
+        sampleIndexes: sampleIndexes
+      });
+    }))
   );
 }

package/es/utils/lcg.js

@@ -0,0 +1,14 @@
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+// https://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use
+const mul = 0x19660d;
+const inc = 0x3c6ef35f;
+const eps = 1 / 0x100000000;
+export default function lcg(seed) {
+  let state = (0 <= seed && seed < 1 ? seed / eps : Math.abs(seed)) | 0;
+  return () => (state = mul * state + inc | 0, eps * (state >>> 0));
+}