@kepler.gl/components 3.0.0-alpha.0

package/dist/common/data-table/cell-size.d.ts

@@ -0,0 +1,43 @@
+import { DataContainerInterface } from '@kepler.gl/utils';
+declare type RenderSizeParam = {
+    text: {
+        dataContainer: DataContainerInterface;
+        column: string;
+    };
+    type?: string;
+    colIdx: number;
+    numRowsToCalculate?: number;
+    fontSize?: number;
+    font?: string;
+    cellPadding?: number;
+    maxCellSize?: number;
+    maxHeaderSize?: number;
+    minCellSize?: number;
+    optionsButton?: number;
+};
+export declare type CellSizeCache = {
+    [key: string]: {
+        row: number;
+        header: number;
+    };
+};
+/**
+ * Measure rows and column content to determine min width for each column
+ * @param {RenderSizeParam} param0
+ */
+export declare function renderedSize({ text: { dataContainer, column }, type, colIdx, numRowsToCalculate, fontSize, font, cellPadding, maxCellSize, maxHeaderSize, minCellSize, optionsButton }: RenderSizeParam): {
+    row: number;
+    header: number;
+};
+/**
+ * Adjust cell size based on container width
+ * @param {number} containerWidth
+ * @param {CellSizeCache} cellSizeCache
+ * @param {string[]} pinnedColumns
+ * @param {string[]} unpinnedColumns
+ */
+export declare function adjustCellsToContainer(containerWidth: number, cellSizeCache: CellSizeCache, pinnedColumns: string[], unpinnedColumns: string[]): {
+    cellSizeCache: CellSizeCache;
+    ghost?: number | null;
+};
+export {};

package/dist/common/data-table/cell-size.js

@@ -0,0 +1,195 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// 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.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderedSize = renderedSize;
+exports.adjustCellsToContainer = adjustCellsToContainer;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _document = _interopRequireDefault(require("global/document"));
+
+var _utils = require("@kepler.gl/utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var MIN_GHOST_CELL_SIZE = 200;
+var MIN_CELL_SIZE = 45;
+
+/**
+ * Measure rows and column content to determine min width for each column
+ * @param {RenderSizeParam} param0
+ */
+function renderedSize(_ref) {
+  var _ref$text = _ref.text,
+      dataContainer = _ref$text.dataContainer,
+      column = _ref$text.column,
+      _ref$type = _ref.type,
+      type = _ref$type === void 0 ? 'string' : _ref$type,
+      colIdx = _ref.colIdx,
+      _ref$numRowsToCalcula = _ref.numRowsToCalculate,
+      numRowsToCalculate = _ref$numRowsToCalcula === void 0 ? 10 : _ref$numRowsToCalcula,
+      _ref$fontSize = _ref.fontSize,
+      fontSize = _ref$fontSize === void 0 ? 12 : _ref$fontSize,
+      _ref$font = _ref.font,
+      font = _ref$font === void 0 ? 'Lato' : _ref$font,
+      _ref$cellPadding = _ref.cellPadding,
+      cellPadding = _ref$cellPadding === void 0 ? 40 : _ref$cellPadding,
+      _ref$maxCellSize = _ref.maxCellSize,
+      maxCellSize = _ref$maxCellSize === void 0 ? 500 : _ref$maxCellSize,
+      _ref$maxHeaderSize = _ref.maxHeaderSize,
+      maxHeaderSize = _ref$maxHeaderSize === void 0 ? 500 : _ref$maxHeaderSize,
+      _ref$minCellSize = _ref.minCellSize,
+      minCellSize = _ref$minCellSize === void 0 ? MIN_CELL_SIZE : _ref$minCellSize,
+      _ref$optionsButton = _ref.optionsButton,
+      optionsButton = _ref$optionsButton === void 0 ? 30 : _ref$optionsButton;
+
+  if (!_document["default"]) {
+    return {
+      row: 0,
+      header: 0
+    };
+  }
+
+  var textCanvas = _document["default"].createElement('canvas');
+
+  _document["default"].body.appendChild(textCanvas);
+
+  var context = textCanvas.getContext('2d');
+  context.font = [fontSize, font].join('px ');
+  var rowsToSample = (0, _toConsumableArray2["default"])(Array(numRowsToCalculate)).map(function () {
+    return Math.floor(Math.random() * (dataContainer.numRows() - 1));
+  }); // If we have less than 10 rows, lets measure all of them
+
+  if (dataContainer.numRows() <= numRowsToCalculate) {
+    rowsToSample = Array.from(Array(dataContainer.numRows()).keys());
+  }
+
+  var rowWidth = Math.max.apply(Math, (0, _toConsumableArray2["default"])(rowsToSample.map(function (rowIdx) {
+    return Math.ceil(context.measureText((0, _utils.parseFieldValue)(dataContainer.valueAt(rowIdx, colIdx), type)).width) + cellPadding;
+  }))); // header cell only has left padding
+
+  var headerWidth = Math.ceil(context.measureText(column).width) + cellPadding / 2 + optionsButton;
+  var minRowWidth = minCellSize + cellPadding;
+  var minHeaderWidth = minCellSize + cellPadding / 2 + optionsButton;
+  var clampedRowWidth = clamp(minRowWidth, maxCellSize, rowWidth);
+  var clampedHeaderWidth = clamp(minHeaderWidth, maxHeaderSize, headerWidth); // cleanup
+
+  textCanvas.parentElement.removeChild(textCanvas);
+  return {
+    row: clampedRowWidth,
+    header: clampedHeaderWidth
+  };
+}
+
+function clamp(min, max, value) {
+  return Math.max(Math.min(max, value), min);
+}
+
+function getColumnOrder() {
+  var pinnedColumns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var unpinnedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return [].concat((0, _toConsumableArray2["default"])(pinnedColumns), (0, _toConsumableArray2["default"])(unpinnedColumns));
+}
+
+function getMinCellSize(cellSizeCache) {
+  return Object.keys(cellSizeCache).reduce(function (accu, col) {
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, col, cellSizeCache[col].row));
+  }, {});
+}
+
+function getSizeSum(sizeCache, key) {
+  return Object.keys(sizeCache).reduce(function (acc, val) {
+    return acc + (key ? sizeCache[val][key] : sizeCache[val]);
+  }, 0);
+}
+/**
+ * Expand cell to fit both row and header, if there is still room left,
+ * expand last cell to fit the entire width of the container
+ * @param {CellSizeCache} cellSizeCache
+ * @param {string[]} columnOrder
+ * @param {number} containerWidth
+ * @param {number} roomToFill
+ */
+
+
+function expandCellSize(cellSizeCache, columnOrder, containerWidth, roomToFill) {
+  var remaining = roomToFill;
+  var expandedCellSize = columnOrder.reduce(function (accu, col) {
+    var size = cellSizeCache[col].row;
+
+    if (cellSizeCache[col].row < cellSizeCache[col].header && remaining > 0) {
+      // if we are cutting off the header, expand to fit it
+      size = cellSizeCache[col].header - cellSizeCache[col].row < remaining ? cellSizeCache[col].header : cellSizeCache[col].row + remaining;
+      remaining -= size - cellSizeCache[col].row;
+    }
+
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, col, size));
+  }, {});
+  var ghost = null;
+
+  if (remaining > 0 && remaining < MIN_GHOST_CELL_SIZE) {
+    // expand last cell
+    var lastCell = columnOrder[columnOrder.length - 1];
+    expandedCellSize[lastCell] += remaining;
+  } else if (remaining >= MIN_GHOST_CELL_SIZE) {
+    // if too much left add a ghost cell
+    ghost = remaining;
+  }
+
+  return {
+    cellSizeCache: expandedCellSize,
+    ghost: ghost
+  };
+}
+/**
+ * Adjust cell size based on container width
+ * @param {number} containerWidth
+ * @param {CellSizeCache} cellSizeCache
+ * @param {string[]} pinnedColumns
+ * @param {string[]} unpinnedColumns
+ */
+
+
+function adjustCellsToContainer(containerWidth, cellSizeCache, pinnedColumns, unpinnedColumns) {
+  var minRowSum = getSizeSum(cellSizeCache, 'row');
+
+  if (minRowSum >= containerWidth) {
+    // we apply the min Width to all cells
+    return {
+      cellSizeCache: getMinCellSize(cellSizeCache)
+    };
+  } // if we have some room to expand
+
+
+  var columnOrder = getColumnOrder(pinnedColumns, unpinnedColumns);
+  return expandCellSize(cellSizeCache, columnOrder, containerWidth, containerWidth - minRowSum);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/common/data-table/cell-size.ts"],"names":["MIN_GHOST_CELL_SIZE","MIN_CELL_SIZE","renderedSize","text","dataContainer","column","type","colIdx","numRowsToCalculate","fontSize","font","cellPadding","maxCellSize","maxHeaderSize","minCellSize","optionsButton","document","row","header","textCanvas","createElement","body","appendChild","context","getContext","join","rowsToSample","Array","map","Math","floor","random","numRows","from","keys","rowWidth","max","rowIdx","ceil","measureText","valueAt","width","headerWidth","minRowWidth","minHeaderWidth","clampedRowWidth","clamp","clampedHeaderWidth","parentElement","removeChild","min","value","getColumnOrder","pinnedColumns","unpinnedColumns","getMinCellSize","cellSizeCache","Object","reduce","accu","col","getSizeSum","sizeCache","key","acc","val","expandCellSize","columnOrder","containerWidth","roomToFill","remaining","expandedCellSize","size","ghost","lastCell","length","adjustCellsToContainer","minRowSum"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport document from 'global/document';\nimport {DataContainerInterface, parseFieldValue} from '@kepler.gl/utils';\n\nconst MIN_GHOST_CELL_SIZE: number = 200;\nconst MIN_CELL_SIZE = 45;\n\ntype RenderSizeParam = {\n  text: {dataContainer: DataContainerInterface; column: string};\n  type?: string;\n  colIdx: number;\n  numRowsToCalculate?: number;\n  fontSize?: number;\n  font?: string;\n  cellPadding?: number;\n  maxCellSize?: number;\n  maxHeaderSize?: number;\n  minCellSize?: number;\n  optionsButton?: number;\n};\n\nexport type CellSizeCache = {\n  [key: string]: {\n    row: number;\n    header: number;\n  };\n};\n\n/**\n * Measure rows and column content to determine min width for each column\n * @param {RenderSizeParam} param0\n */\nexport function renderedSize({\n  text: {dataContainer, column},\n  type = 'string',\n  colIdx,\n  numRowsToCalculate = 10,\n  fontSize = 12,\n  font = 'Lato',\n  cellPadding = 40,\n  maxCellSize = 500,\n  maxHeaderSize = 500,\n  minCellSize = MIN_CELL_SIZE,\n  optionsButton = 30\n}: RenderSizeParam): {row: number; header: number} {\n  if (!document) {\n    return {\n      row: 0,\n      header: 0\n    };\n  }\n  const textCanvas = document.createElement('canvas');\n  document.body.appendChild(textCanvas);\n  const context = textCanvas.getContext('2d');\n  context.font = [fontSize, font].join('px ');\n\n  let rowsToSample = [...Array(numRowsToCalculate)].map(() =>\n    Math.floor(Math.random() * (dataContainer.numRows() - 1))\n  );\n\n  // If we have less than 10 rows, lets measure all of them\n  if (dataContainer.numRows() <= numRowsToCalculate) {\n    rowsToSample = Array.from(Array(dataContainer.numRows()).keys());\n  }\n  const rowWidth = Math.max(\n    ...rowsToSample.map(\n      rowIdx =>\n        Math.ceil(\n          context.measureText(parseFieldValue(dataContainer.valueAt(rowIdx, colIdx), type)).width\n        ) + cellPadding\n    )\n  );\n  // header cell only has left padding\n  const headerWidth =\n    Math.ceil(context.measureText(column).width) + cellPadding / 2 + optionsButton;\n\n  const minRowWidth = minCellSize + cellPadding;\n  const minHeaderWidth = minCellSize + cellPadding / 2 + optionsButton;\n\n  const clampedRowWidth = clamp(minRowWidth, maxCellSize, rowWidth);\n  const clampedHeaderWidth = clamp(minHeaderWidth, maxHeaderSize, headerWidth);\n\n  // cleanup\n  textCanvas.parentElement.removeChild(textCanvas);\n\n  return {\n    row: clampedRowWidth,\n    header: clampedHeaderWidth\n  };\n}\n\nfunction clamp(min, max, value) {\n  return Math.max(Math.min(max, value), min);\n}\n\nfunction getColumnOrder(pinnedColumns: string[] = [], unpinnedColumns: string[] = []) {\n  return [...pinnedColumns, ...unpinnedColumns];\n}\n\nfunction getMinCellSize(cellSizeCache: CellSizeCache) {\n  return Object.keys(cellSizeCache).reduce(\n    (accu, col) => ({\n      ...accu,\n      [col]: cellSizeCache[col].row\n    }),\n    {}\n  );\n}\n\nfunction getSizeSum(sizeCache, key) {\n  return Object.keys(sizeCache).reduce(\n    (acc, val) => acc + (key ? sizeCache[val][key] : sizeCache[val]),\n    0\n  );\n}\n\n/**\n * Expand cell to fit both row and header, if there is still room left,\n * expand last cell to fit the entire width of the container\n * @param {CellSizeCache} cellSizeCache\n * @param {string[]} columnOrder\n * @param {number} containerWidth\n * @param {number} roomToFill\n */\nfunction expandCellSize(\n  cellSizeCache: CellSizeCache,\n  columnOrder: string[],\n  containerWidth: number,\n  roomToFill: number\n): {\n  cellSizeCache: CellSizeCache;\n  ghost: number | null;\n} {\n  let remaining = roomToFill;\n\n  const expandedCellSize = columnOrder.reduce((accu, col) => {\n    let size = cellSizeCache[col].row;\n    if (cellSizeCache[col].row < cellSizeCache[col].header && remaining > 0) {\n      // if we are cutting off the header, expand to fit it\n      size =\n        cellSizeCache[col].header - cellSizeCache[col].row < remaining\n          ? cellSizeCache[col].header\n          : cellSizeCache[col].row + remaining;\n      remaining -= size - cellSizeCache[col].row;\n    }\n\n    return {\n      ...accu,\n      [col]: size\n    };\n  }, {});\n\n  let ghost: number | null = null;\n  if (remaining > 0 && remaining < MIN_GHOST_CELL_SIZE) {\n    // expand last cell\n    const lastCell = columnOrder[columnOrder.length - 1];\n    expandedCellSize[lastCell] += remaining;\n  } else if (remaining >= MIN_GHOST_CELL_SIZE) {\n    // if too much left add a ghost cell\n    ghost = remaining;\n  }\n\n  return {\n    cellSizeCache: expandedCellSize,\n    ghost\n  };\n}\n\n/**\n * Adjust cell size based on container width\n * @param {number} containerWidth\n * @param {CellSizeCache} cellSizeCache\n * @param {string[]} pinnedColumns\n * @param {string[]} unpinnedColumns\n */\nexport function adjustCellsToContainer(\n  containerWidth: number,\n  cellSizeCache: CellSizeCache,\n  pinnedColumns: string[],\n  unpinnedColumns: string[]\n): {\n  cellSizeCache: CellSizeCache;\n  ghost?: number | null;\n} {\n  const minRowSum = getSizeSum(cellSizeCache, 'row');\n  if (minRowSum >= containerWidth) {\n    // we apply the min Width to all cells\n    return {cellSizeCache: getMinCellSize(cellSizeCache)};\n  }\n\n  // if we have some room to expand\n  const columnOrder = getColumnOrder(pinnedColumns, unpinnedColumns);\n  return expandCellSize(cellSizeCache, columnOrder, containerWidth, containerWidth - minRowSum);\n}\n"]}

package/dist/common/data-table/grid.d.ts

@@ -0,0 +1,7 @@
+import { PureComponent } from 'react';
+import { Grid, GridProps } from 'react-virtualized';
+export default class GridHack extends PureComponent<GridProps> {
+    grid: Grid | null;
+    componentDidUpdate(preProps: any): void;
+    render(): JSX.Element;
+}

package/dist/common/data-table/grid.js

@@ -0,0 +1,119 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// 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.
+
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactVirtualized = require("react-virtualized");
+
+var _lodash = _interopRequireDefault(require("lodash.isequal"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var GridHack = /*#__PURE__*/function (_PureComponent) {
+  (0, _inherits2["default"])(GridHack, _PureComponent);
+
+  var _super = _createSuper(GridHack);
+
+  function GridHack() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, GridHack);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "grid", null);
+    return _this;
+  }
+
+  (0, _createClass2["default"])(GridHack, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(preProps) {
+      /*
+       * This hack exists because in react-virtualized the
+       * _columnWidthGetter is only called in the constructor
+       * even though it is reassigned with new props resulting in
+       * a new width for cells not being calculated so we must
+       * force trigger a resize.
+       *
+       * https://github.com/bvaughn/react-virtualized/blob/master/source/Grid/Grid.js#L322
+       *
+       */
+      if (!(0, _lodash["default"])(preProps.cellSizeCache, this.props.cellSizeCache)) {
+        var _this$grid;
+
+        (_this$grid = this.grid) === null || _this$grid === void 0 ? void 0 : _this$grid.recomputeGridSize();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var _this$props = this.props,
+          setGridRef = _this$props.setGridRef,
+          rest = (0, _objectWithoutProperties2["default"])(_this$props, ["setGridRef"]);
+      return /*#__PURE__*/_react["default"].createElement(_reactVirtualized.Grid, (0, _extends2["default"])({
+        ref: function ref(x) {
+          if (setGridRef) setGridRef(x);
+          _this2.grid = x;
+        },
+        key: "grid-hack"
+      }, rest));
+    }
+  }]);
+  return GridHack;
+}(_react.PureComponent);
+
+exports["default"] = GridHack;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/common/data-table/header-cell.d.ts

@@ -0,0 +1,25 @@
+import React, { CSSProperties } from 'react';
+import FieldTokenFactory, { FieldTokenProps } from '../../common/field-token';
+import { DataTableProps } from './index';
+declare type CellInfo = {
+    columnIndex: number;
+    isScrolling: boolean;
+    isVisible: boolean;
+    key: string;
+    parent: any;
+    rowIndex: number;
+    style: CSSProperties;
+};
+declare type HeaderCellProps = {
+    cellInfo: CellInfo;
+    columns: DataTableProps['columns'];
+    isPinned?: boolean;
+    props: DataTableProps;
+    toggleMoreOptions: (moreOptionsColumn: string) => void;
+    moreOptionsColumn: null | string;
+};
+declare const HeaderCellFactory: {
+    (FieldToken: React.FC<FieldTokenProps>): ({ cellInfo, columns, isPinned, props, toggleMoreOptions, moreOptionsColumn }: HeaderCellProps) => JSX.Element;
+    deps: (typeof FieldTokenFactory)[];
+};
+export default HeaderCellFactory;

package/dist/common/data-table/header-cell.js

@@ -0,0 +1,152 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// 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.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _classnames2 = _interopRequireDefault(require("classnames"));
+
+var _button = _interopRequireDefault(require("./button"));
+
+var _icons = require("../../common/icons");
+
+var _optionDropdown = _interopRequireDefault(require("./option-dropdown"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _fieldToken = _interopRequireDefault(require("../../common/field-token"));
+
+var _templateObject;
+
+var StyledHeaderCell = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  border-bottom: 1px solid ", ";\n  border-top: 1px solid ", ";\n  padding-top: ", "px;\n  padding-right: 0;\n  padding-bottom: ", "px;\n  padding-left: ", "px;\n  align-items: center;\n  justify-content: space-between;\n  display: flex;\n  flex-direction: row;\n  background-color: ", ";\n\n  &:hover {\n    .more {\n      color: ", ";\n    }\n  }\n  .n-sort-idx {\n    font-size: 9px;\n  }\n  .details {\n    font-weight: 500;\n    display: flex;\n    flex-direction: column;\n    justify-content: flex-start;\n    height: 100%;\n    overflow: hidden;\n    flex-grow: 1;\n\n    .col-name {\n      display: flex;\n      align-items: center;\n      justify-content: space-between;\n      cursor: pointer;\n\n      .col-name__left {\n        display: flex;\n        align-items: center;\n        overflow: hidden;\n        svg {\n          margin-left: 6px;\n        }\n      }\n      .col-name__name {\n        overflow: hidden;\n        white-space: nowrap;\n      }\n    }\n  }\n\n  .more {\n    color: transparent;\n    margin-left: 5px;\n  }\n"])), function (props) {
+  return props.theme.headerCellBorderColor;
+}, function (props) {
+  return props.theme.headerCellBorderColor;
+}, function (props) {
+  return props.theme.headerPaddingTop;
+}, function (props) {
+  return props.theme.headerPaddingBottom;
+}, function (props) {
+  return props.theme.cellPaddingSide;
+}, function (props) {
+  return props.theme.headerCellBackground;
+}, function (props) {
+  return props.theme.headerCellIconColor;
+});
+
+var HeaderCellFactory = function HeaderCellFactory(FieldToken) {
+  var HeaderCell = function HeaderCell(_ref) {
+    var _classnames;
+
+    var cellInfo = _ref.cellInfo,
+        columns = _ref.columns,
+        isPinned = _ref.isPinned,
+        props = _ref.props,
+        toggleMoreOptions = _ref.toggleMoreOptions,
+        moreOptionsColumn = _ref.moreOptionsColumn;
+    var columnIndex = cellInfo.columnIndex,
+        key = cellInfo.key,
+        style = cellInfo.style;
+    var colMeta = props.colMeta,
+        _props$sortColumn = props.sortColumn,
+        sortColumn = _props$sortColumn === void 0 ? {} : _props$sortColumn,
+        _sortTableColumn = props.sortTableColumn,
+        _pinTableColumn = props.pinTableColumn,
+        _copyTableColumn = props.copyTableColumn;
+    var column = columns[columnIndex];
+    var isGhost = column.ghost;
+    var isSorted = sortColumn[column];
+    var firstCell = columnIndex === 0;
+    return /*#__PURE__*/_react["default"].createElement(StyledHeaderCell, {
+      className: (0, _classnames2["default"])('header-cell', (_classnames = {}, (0, _defineProperty2["default"])(_classnames, "column-".concat(columnIndex), true), (0, _defineProperty2["default"])(_classnames, 'pinned-header-cell', isPinned), (0, _defineProperty2["default"])(_classnames, 'first-cell', firstCell), _classnames)),
+      key: key,
+      style: style,
+      onClick: function onClick(e) {
+        e.shiftKey ? _sortTableColumn(column) : null;
+      },
+      onDoubleClick: function onDoubleClick() {
+        return _sortTableColumn(column);
+      },
+      title: column
+    }, isGhost ? /*#__PURE__*/_react["default"].createElement("div", null) : /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement("section", {
+      className: "details"
+    }, /*#__PURE__*/_react["default"].createElement("div", {
+      className: "col-name"
+    }, /*#__PURE__*/_react["default"].createElement("div", {
+      className: "col-name__left"
+    }, /*#__PURE__*/_react["default"].createElement("div", {
+      className: "col-name__name"
+    }, colMeta[column].name), /*#__PURE__*/_react["default"].createElement(_button["default"], {
+      className: "col-name__sort",
+      onClick: function onClick() {
+        return _sortTableColumn(column);
+      }
+    }, isSorted ? isSorted === _constants.SORT_ORDER.ASCENDING ? /*#__PURE__*/_react["default"].createElement(_icons.ArrowUp, {
+      height: "14px"
+    }) : /*#__PURE__*/_react["default"].createElement(_icons.ArrowDown, {
+      height: "14px"
+    }) : null)), /*#__PURE__*/_react["default"].createElement(_button["default"], {
+      className: "more",
+      onClick: function onClick() {
+        return toggleMoreOptions(column);
+      }
+    }, /*#__PURE__*/_react["default"].createElement(_icons.VertThreeDots, {
+      height: "14px"
+    }))), /*#__PURE__*/_react["default"].createElement(FieldToken, {
+      type: colMeta[column].type
+    })), /*#__PURE__*/_react["default"].createElement("section", {
+      className: "options"
+    }, /*#__PURE__*/_react["default"].createElement(_optionDropdown["default"], {
+      isOpened: moreOptionsColumn === column,
+      column: column,
+      toggleMoreOptions: toggleMoreOptions,
+      sortTableColumn: function sortTableColumn(mode) {
+        return _sortTableColumn(column, mode);
+      },
+      pinTableColumn: function pinTableColumn() {
+        return _pinTableColumn(column);
+      },
+      copyTableColumn: function copyTableColumn() {
+        return _copyTableColumn(column);
+      }
+    }))));
+  };
+
+  return HeaderCell;
+};
+
+HeaderCellFactory.deps = [_fieldToken["default"]];
+var _default = HeaderCellFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/common/data-table/header-cell.tsx"],"names":["StyledHeaderCell","styled","div","props","theme","headerCellBorderColor","headerPaddingTop","headerPaddingBottom","cellPaddingSide","headerCellBackground","headerCellIconColor","HeaderCellFactory","FieldToken","HeaderCell","cellInfo","columns","isPinned","toggleMoreOptions","moreOptionsColumn","columnIndex","key","style","colMeta","sortColumn","sortTableColumn","pinTableColumn","copyTableColumn","column","isGhost","ghost","isSorted","firstCell","e","shiftKey","name","SORT_ORDER","ASCENDING","type","mode","deps","FieldTokenFactory"],"mappings":"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","sourcesContent":["import React, {CSSProperties} from 'react';\nimport styled from 'styled-components';\nimport classnames from 'classnames';\nimport Button from './button';\nimport {ArrowUp, ArrowDown, VertThreeDots} from '../../common/icons';\nimport OptionDropdown from './option-dropdown';\nimport {SORT_ORDER} from '@kepler.gl/constants';\nimport FieldTokenFactory, {FieldTokenProps} from '../../common/field-token';\nimport {DataTableProps} from './index';\n\nconst StyledHeaderCell = styled.div`\n  border-bottom: 1px solid ${props => props.theme.headerCellBorderColor};\n  border-top: 1px solid ${props => props.theme.headerCellBorderColor};\n  padding-top: ${props => props.theme.headerPaddingTop}px;\n  padding-right: 0;\n  padding-bottom: ${props => props.theme.headerPaddingBottom}px;\n  padding-left: ${props => props.theme.cellPaddingSide}px;\n  align-items: center;\n  justify-content: space-between;\n  display: flex;\n  flex-direction: row;\n  background-color: ${props => props.theme.headerCellBackground};\n\n  &:hover {\n    .more {\n      color: ${props => props.theme.headerCellIconColor};\n    }\n  }\n  .n-sort-idx {\n    font-size: 9px;\n  }\n  .details {\n    font-weight: 500;\n    display: flex;\n    flex-direction: column;\n    justify-content: flex-start;\n    height: 100%;\n    overflow: hidden;\n    flex-grow: 1;\n\n    .col-name {\n      display: flex;\n      align-items: center;\n      justify-content: space-between;\n      cursor: pointer;\n\n      .col-name__left {\n        display: flex;\n        align-items: center;\n        overflow: hidden;\n        svg {\n          margin-left: 6px;\n        }\n      }\n      .col-name__name {\n        overflow: hidden;\n        white-space: nowrap;\n      }\n    }\n  }\n\n  .more {\n    color: transparent;\n    margin-left: 5px;\n  }\n`;\n\ntype CellInfo = {\n  columnIndex: number;\n  isScrolling: boolean;\n  isVisible: boolean;\n  key: string;\n  parent: any;\n  rowIndex: number;\n  style: CSSProperties;\n};\n\ntype HeaderCellProps = {\n  // passed down from react virtualized Grid\n  cellInfo: CellInfo;\n  columns: DataTableProps['columns'];\n  isPinned?: boolean;\n  props: DataTableProps;\n  toggleMoreOptions: (moreOptionsColumn: string) => void;\n  moreOptionsColumn: null | string;\n};\n\nconst HeaderCellFactory = (FieldToken: React.FC<FieldTokenProps>) => {\n  const HeaderCell = ({\n    cellInfo,\n    columns,\n    isPinned,\n    props,\n    toggleMoreOptions,\n    moreOptionsColumn\n  }: HeaderCellProps) => {\n    const {columnIndex, key, style} = cellInfo;\n    const {colMeta, sortColumn = {}, sortTableColumn, pinTableColumn, copyTableColumn} = props;\n    const column = columns[columnIndex];\n\n    const isGhost = column.ghost;\n    const isSorted = sortColumn[column];\n    const firstCell = columnIndex === 0;\n    return (\n      <StyledHeaderCell\n        className={classnames('header-cell', {\n          [`column-${columnIndex}`]: true,\n          'pinned-header-cell': isPinned,\n          'first-cell': firstCell\n        })}\n        key={key}\n        style={style}\n        onClick={e => {\n          e.shiftKey ? sortTableColumn(column) : null;\n        }}\n        onDoubleClick={() => sortTableColumn(column)}\n        title={column}\n      >\n        {isGhost ? (\n          <div />\n        ) : (\n          <>\n            <section className=\"details\">\n              <div className=\"col-name\">\n                <div className=\"col-name__left\">\n                  <div className=\"col-name__name\">{colMeta[column].name}</div>\n                  <Button className=\"col-name__sort\" onClick={() => sortTableColumn(column)}>\n                    {isSorted ? (\n                      isSorted === SORT_ORDER.ASCENDING ? (\n                        <ArrowUp height=\"14px\" />\n                      ) : (\n                        <ArrowDown height=\"14px\" />\n                      )\n                    ) : null}\n                  </Button>\n                </div>\n                <Button className=\"more\" onClick={() => toggleMoreOptions(column)}>\n                  <VertThreeDots height=\"14px\" />\n                </Button>\n              </div>\n              <FieldToken type={colMeta[column].type} />\n            </section>\n\n            <section className=\"options\">\n              <OptionDropdown\n                isOpened={moreOptionsColumn === column}\n                column={column}\n                toggleMoreOptions={toggleMoreOptions}\n                sortTableColumn={mode => sortTableColumn(column, mode)}\n                pinTableColumn={() => pinTableColumn(column)}\n                copyTableColumn={() => copyTableColumn(column)}\n              />\n            </section>\n          </>\n        )}\n      </StyledHeaderCell>\n    );\n  };\n  return HeaderCell;\n};\nHeaderCellFactory.deps = [FieldTokenFactory];\nexport default HeaderCellFactory;\n"]}