@kepler.gl/components 3.1.0-alpha.0 → 3.1.0-alpha.2

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

@@ -0,0 +1,183 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.adjustCellsToContainer = adjustCellsToContainer;
+exports.renderedSize = renderedSize;
+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(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var MIN_GHOST_CELL_SIZE = 200;
+var MIN_CELL_SIZE = 45;
+// first column have padding on the left
+var EDGE_COLUMN_PADDING = 10;
+
+// in case cell content is small, column name is big, we allow max empty space to
+// be added to min cell width in order to show column name
+var MAX_EMPTY_COLUMN_SPACE = 60;
+/**
+ * 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 ? 44 : _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) {
+    var value = (0, _utils.parseFieldValue)(dataContainer.valueAt(rowIdx, colIdx), type);
+    // measuring large text cause slow performance
+    if (value.length > maxCellSize) {
+      return maxCellSize;
+    }
+    var textWidth = context.measureText(value).width;
+    return Math.ceil(textWidth) + cellPadding;
+  })));
+  // header cell only has left padding
+  var headerWidth = Math.ceil(context.measureText(column).width) + cellPadding / 2 + optionsButton;
+
+  // min row width is measured by cell content
+  var minRowWidth = minCellSize + cellPadding;
+  // min header width is measured by cell
+  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));
+}
+
+// If total min cell size is bigger than containerWidth adjust column
+function getMinCellSize(cellSizeCache) {
+  return Object.keys(cellSizeCache).reduce(function (accu, col) {
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, col, cellSizeCache[col].row > cellSizeCache[col].header ? cellSizeCache[col].row :
+    // if row is smaller than header, use the smaller of MAX_EMPTY_COLUMN_SPACE + row width and header
+    Math.min(cellSizeCache[col].header, cellSizeCache[col].row + MAX_EMPTY_COLUMN_SPACE)));
+  }, {});
+}
+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
+  };
+}
+function addPaddingToFirstColumn(cellSizeCache) {
+  var columnOrder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var firstCol = columnOrder[0];
+  if (firstCol && cellSizeCache[firstCol]) {
+    return _objectSpread(_objectSpread({}, cellSizeCache), {}, (0, _defineProperty2["default"])({}, firstCol, {
+      header: cellSizeCache[firstCol].header + EDGE_COLUMN_PADDING,
+      row: cellSizeCache[firstCol].row + EDGE_COLUMN_PADDING
+    }));
+  }
+  return cellSizeCache;
+}
+
+/**
+ * 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 columnOrder = getColumnOrder(pinnedColumns, unpinnedColumns);
+  var paddedCellSize = addPaddingToFirstColumn(cellSizeCache, columnOrder);
+  var minRowSum = getSizeSum(paddedCellSize, 'row');
+  if (minRowSum >= containerWidth) {
+    // we apply the min Width to all cells
+    return {
+      cellSizeCache: getMinCellSize(paddedCellSize)
+    };
+  }
+  // if we have some room to expand
+  return expandCellSize(paddedCellSize, columnOrder, containerWidth, containerWidth - minRowSum);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_document","_interopRequireDefault","require","_utils","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","MIN_GHOST_CELL_SIZE","MIN_CELL_SIZE","EDGE_COLUMN_PADDING","MAX_EMPTY_COLUMN_SPACE","renderedSize","_ref","_ref$text","text","dataContainer","column","_ref$type","type","colIdx","_ref$numRowsToCalcula","numRowsToCalculate","_ref$fontSize","fontSize","_ref$font","font","_ref$cellPadding","cellPadding","_ref$maxCellSize","maxCellSize","_ref$maxHeaderSize","maxHeaderSize","_ref$minCellSize","minCellSize","_ref$optionsButton","optionsButton","document","row","header","textCanvas","createElement","body","appendChild","context","getContext","join","rowsToSample","_toConsumableArray2","Array","map","Math","floor","random","numRows","from","rowWidth","max","rowIdx","value","parseFieldValue","valueAt","textWidth","measureText","width","ceil","headerWidth","minRowWidth","minHeaderWidth","clampedRowWidth","clamp","clampedHeaderWidth","parentElement","removeChild","min","getColumnOrder","pinnedColumns","undefined","unpinnedColumns","concat","getMinCellSize","cellSizeCache","reduce","accu","col","getSizeSum","sizeCache","key","acc","val","expandCellSize","columnOrder","containerWidth","roomToFill","remaining","expandedCellSize","size","ghost","lastCell","addPaddingToFirstColumn","firstCol","adjustCellsToContainer","paddedCellSize","minRowSum"],"sources":["../../../src/common/data-table/cell-size.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport document from 'global/document';\nimport {DataContainerInterface, parseFieldValue} from '@kepler.gl/utils';\n\nconst MIN_GHOST_CELL_SIZE = 200;\nconst MIN_CELL_SIZE = 45;\n// first column have padding on the left\nconst EDGE_COLUMN_PADDING = 10;\n\n// in case cell content is small, column name is big, we allow max empty space to\n// be added to min cell width in order to show column name\nconst MAX_EMPTY_COLUMN_SPACE = 60;\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 = 44\n}: RenderSizeParam): {row: number; header: number} {\n  if (!document) {\n    return {\n      row: 0,\n      header: 0\n    };\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(rowIdx => {\n      const value = parseFieldValue(dataContainer.valueAt(rowIdx, colIdx), type);\n      // measuring large text cause slow performance\n      if (value.length > maxCellSize) {\n        return maxCellSize;\n      }\n      const textWidth = context.measureText(value).width;\n      return Math.ceil(textWidth) + 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  // min row width is measured by cell content\n  const minRowWidth = minCellSize + cellPadding;\n  // min header width is measured by cell\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\n// If total min cell size is bigger than containerWidth adjust column\nfunction getMinCellSize(cellSizeCache: CellSizeCache) {\n  return Object.keys(cellSizeCache).reduce(\n    (accu, col) => ({\n      ...accu,\n      // if row is larger than header, use row\n      [col]:\n        cellSizeCache[col].row > cellSizeCache[col].header\n          ? cellSizeCache[col].row\n          : // if row is smaller than header, use the smaller of MAX_EMPTY_COLUMN_SPACE + row width and header\n            Math.min(cellSizeCache[col].header, cellSizeCache[col].row + MAX_EMPTY_COLUMN_SPACE)\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\nfunction addPaddingToFirstColumn(\n  cellSizeCache: CellSizeCache,\n  columnOrder: string[] = []\n): CellSizeCache {\n  const firstCol = columnOrder[0];\n\n  if (firstCol && cellSizeCache[firstCol]) {\n    return {\n      ...cellSizeCache,\n      [firstCol]: {\n        header: cellSizeCache[firstCol].header + EDGE_COLUMN_PADDING,\n        row: cellSizeCache[firstCol].row + EDGE_COLUMN_PADDING\n      }\n    };\n  }\n  return cellSizeCache;\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 columnOrder = getColumnOrder(pinnedColumns, unpinnedColumns);\n  const paddedCellSize = addPaddingToFirstColumn(cellSizeCache, columnOrder);\n  const minRowSum = getSizeSum(paddedCellSize, 'row');\n\n  if (minRowSum >= containerWidth) {\n    // we apply the min Width to all cells\n    return {cellSizeCache: getMinCellSize(paddedCellSize)};\n  }\n  // if we have some room to expand\n  return expandCellSize(paddedCellSize, columnOrder, containerWidth, containerWidth - minRowSum);\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/common/data-table/display-format.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { TooltipFormat } from '@kepler.gl/constants';
+import { ColMeta } from '@kepler.gl/types';
+export declare type DataTableConfigProps = {
+    title: string;
+    id: string;
+    defaultFormat: string;
+    options: TooltipFormat[];
+    columns: {
+        name: string;
+    }[];
+    colMeta: ColMeta;
+    setColumnDisplayFormat: (formats: {
+        [key: string]: string;
+    }) => void;
+    onClose: () => void;
+};
+export declare const NumberFormatConfig: React.FC<DataTableConfigProps>;
+declare function DataTableConfigFactory(): ({ columns, colMeta, setColumnDisplayFormat, onClose }: {
+    columns: any;
+    colMeta: any;
+    setColumnDisplayFormat: any;
+    onClose: any;
+}) => React.JSX.Element;
+export default DataTableConfigFactory;

package/dist/common/data-table/display-format.js

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.NumberFormatConfig = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _utils = require("@kepler.gl/utils");
+var _constants = require("@kepler.gl/constants");
+var _styledComponents2 = require("../../common/styled-components");
+var _optionDropdown = require("./option-dropdown");
+var _templateObject, _templateObject2, _templateObject3; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+var StyledConfigPanel = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  background-color: ", ";\n  box-shadow: 0 10px 18px 0 rgb(0 0 0 / 36%);\n  flex-grow: 1;\n"])), function (props) {
+  return props.theme.headerCellBackground;
+});
+var StyledConfigPanelContent = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  padding: 20px;\n  min-width: 230px;\n  max-height: 400px;\n  overflow: overlay;\n"])));
+var StyledTableConfigGroup = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  margin-bottom: 10px;\n  display: flex;\n  align-items: center;\n\n  input {\n    cursor: pointer !important;\n    width: 184px;\n    height: 22px;\n  }\n"])));
+var NumberFormatConfig = exports.NumberFormatConfig = function NumberFormatConfig(_ref) {
+  var title = _ref.title,
+    id = _ref.id,
+    defaultFormat = _ref.defaultFormat,
+    options = _ref.options,
+    columns = _ref.columns,
+    setColumnDisplayFormat = _ref.setColumnDisplayFormat,
+    onClose = _ref.onClose;
+  var _useState = (0, _react.useState)(false),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    showFormatter = _useState2[0],
+    setShowFormatter = _useState2[1];
+  var _useState3 = (0, _react.useState)(defaultFormat),
+    _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+    format = _useState4[0],
+    setFormat = _useState4[1];
+  var onSetDisplayFormat = (0, _react.useCallback)(function (option) {
+    setFormat(option.label);
+    var formats = columns.reduce(function (prev, col) {
+      prev[col.name] = option.format;
+      return prev;
+    }, {});
+    setColumnDisplayFormat(formats);
+    onClose();
+  }, [columns, setColumnDisplayFormat, onClose]);
+  return /*#__PURE__*/_react["default"].createElement(StyledTableConfigGroup, null, /*#__PURE__*/_react["default"].createElement(_styledComponents2.InputLight, {
+    id: id,
+    type: "text",
+    value: title,
+    "data-tip": format,
+    readOnly: true,
+    onClick: function onClick() {
+      return setShowFormatter(true);
+    }
+  }), /*#__PURE__*/_react["default"].createElement(_optionDropdown.FormatterDropdown, {
+    left: -185,
+    top: 10,
+    isOpened: showFormatter,
+    displayFormat: format,
+    setDisplayFormat: onSetDisplayFormat,
+    onClose: function onClose() {
+      return setShowFormatter(false);
+    },
+    formatLabels: options
+  }));
+};
+function DataTableConfigFactory() {
+  var getColumnsByFieldType = function getColumnsByFieldType(columns, colMeta, fieldType) {
+    var result = [];
+    columns.forEach(function (colName) {
+      var _colMeta$colName;
+      if (((_colMeta$colName = colMeta[colName]) === null || _colMeta$colName === void 0 ? void 0 : _colMeta$colName.type) === fieldType) {
+        result.push(colMeta[colName]);
+      }
+    });
+    return result;
+  };
+  var DataTableConfig = function DataTableConfig(_ref2) {
+    var columns = _ref2.columns,
+      colMeta = _ref2.colMeta,
+      setColumnDisplayFormat = _ref2.setColumnDisplayFormat,
+      onClose = _ref2.onClose;
+    var formatConfigs = [{
+      title: '# Set Integer Number Format',
+      id: 'input-iteger-format',
+      displayType: _constants.ALL_FIELD_TYPES.integer
+    }, {
+      title: '# Set Float Number Format',
+      id: 'input-float-format',
+      displayType: _constants.ALL_FIELD_TYPES.real
+    }, {
+      title: '# Set Timestamp Format',
+      id: 'input-datetime-format',
+      displayType: _constants.ALL_FIELD_TYPES.timestamp
+    }, {
+      title: '# Set Date Format',
+      id: 'input-date-format',
+      displayType: _constants.ALL_FIELD_TYPES.date
+    }, {
+      title: '# Set Boolean Format',
+      id: 'input-bool-format',
+      displayType: _constants.ALL_FIELD_TYPES["boolean"]
+    }];
+    return /*#__PURE__*/_react["default"].createElement(StyledConfigPanel, null, /*#__PURE__*/_react["default"].createElement(StyledConfigPanelContent, null, formatConfigs.map(function (config, index) {
+      return /*#__PURE__*/_react["default"].createElement(NumberFormatConfig, {
+        title: "".concat(config.title),
+        key: index,
+        id: config.id,
+        defaultFormat: 'None',
+        colMeta: colMeta,
+        options: (0, _utils.getFieldFormatLabels)("".concat(config.displayType)),
+        columns: getColumnsByFieldType(columns, colMeta, "".concat(config.displayType)),
+        setColumnDisplayFormat: setColumnDisplayFormat,
+        onClose: onClose
+      });
+    })));
+  };
+  return DataTableConfig;
+}
+var _default = exports["default"] = DataTableConfigFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_styledComponents","_interopRequireDefault","_utils","_constants","_styledComponents2","_optionDropdown","_templateObject","_templateObject2","_templateObject3","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","StyledConfigPanel","styled","div","_taggedTemplateLiteral2","props","theme","headerCellBackground","StyledConfigPanelContent","StyledTableConfigGroup","NumberFormatConfig","exports","_ref","title","id","defaultFormat","options","columns","setColumnDisplayFormat","onClose","_useState","useState","_useState2","_slicedToArray2","showFormatter","setShowFormatter","_useState3","_useState4","format","setFormat","onSetDisplayFormat","useCallback","option","label","formats","reduce","prev","col","name","createElement","InputLight","type","value","readOnly","onClick","FormatterDropdown","left","top","isOpened","displayFormat","setDisplayFormat","formatLabels","DataTableConfigFactory","getColumnsByFieldType","colMeta","fieldType","result","forEach","colName","_colMeta$colName","push","DataTableConfig","_ref2","formatConfigs","displayType","ALL_FIELD_TYPES","integer","real","timestamp","date","map","config","index","concat","key","getFieldFormatLabels","_default"],"sources":["../../../src/common/data-table/display-format.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useState} from 'react';\nimport styled from 'styled-components';\n\nimport {getFieldFormatLabels} from '@kepler.gl/utils';\nimport {ALL_FIELD_TYPES, TooltipFormat} from '@kepler.gl/constants';\nimport {ColMeta, ColMetaProps} from '@kepler.gl/types';\n\nimport {InputLight} from '../../common/styled-components';\nimport {FormatterDropdown} from './option-dropdown';\n\nconst StyledConfigPanel = styled.div`\n  background-color: ${props => props.theme.headerCellBackground};\n  box-shadow: 0 10px 18px 0 rgb(0 0 0 / 36%);\n  flex-grow: 1;\n`;\nconst StyledConfigPanelContent = styled.div`\n  padding: 20px;\n  min-width: 230px;\n  max-height: 400px;\n  overflow: overlay;\n`;\n\nconst StyledTableConfigGroup = styled.div`\n  margin-bottom: 10px;\n  display: flex;\n  align-items: center;\n\n  input {\n    cursor: pointer !important;\n    width: 184px;\n    height: 22px;\n  }\n`;\n\nexport type DataTableConfigProps = {\n  title: string;\n  id: string;\n  defaultFormat: string;\n  options: TooltipFormat[];\n  columns: {name: string}[];\n  colMeta: ColMeta;\n  setColumnDisplayFormat: (formats: {[key: string]: string}) => void;\n  onClose: () => void;\n};\n\nexport const NumberFormatConfig: React.FC<DataTableConfigProps> = ({\n  title,\n  id,\n  defaultFormat,\n  options,\n  columns,\n  setColumnDisplayFormat,\n  onClose\n}: DataTableConfigProps) => {\n  const [showFormatter, setShowFormatter] = useState(false);\n  const [format, setFormat] = useState(defaultFormat);\n\n  const onSetDisplayFormat = useCallback(\n    (option: TooltipFormat) => {\n      setFormat(option.label);\n      const formats: {[key: string]: string} = columns.reduce((prev, col) => {\n        prev[col.name] = option.format;\n        return prev;\n      }, {});\n      setColumnDisplayFormat(formats);\n      onClose();\n    },\n    [columns, setColumnDisplayFormat, onClose]\n  );\n\n  return (\n    <StyledTableConfigGroup>\n      <InputLight\n        id={id}\n        type=\"text\"\n        value={title}\n        data-tip={format}\n        readOnly\n        onClick={() => setShowFormatter(true)}\n      />\n      <FormatterDropdown\n        left={-185}\n        top={10}\n        isOpened={showFormatter}\n        displayFormat={format}\n        setDisplayFormat={onSetDisplayFormat}\n        onClose={() => setShowFormatter(false)}\n        formatLabels={options}\n      />\n    </StyledTableConfigGroup>\n  );\n};\n\nfunction DataTableConfigFactory() {\n  const getColumnsByFieldType = (columns: string[], colMeta: ColMeta, fieldType: string) => {\n    const result: ColMetaProps[] = [];\n    columns.forEach(colName => {\n      if (colMeta[colName]?.type === fieldType) {\n        result.push(colMeta[colName]);\n      }\n    });\n    return result;\n  };\n\n  const DataTableConfig = ({columns, colMeta, setColumnDisplayFormat, onClose}) => {\n    const formatConfigs = [\n      {\n        title: '# Set Integer Number Format',\n        id: 'input-iteger-format',\n        displayType: ALL_FIELD_TYPES.integer\n      },\n      {\n        title: '# Set Float Number Format',\n        id: 'input-float-format',\n        displayType: ALL_FIELD_TYPES.real\n      },\n      {\n        title: '# Set Timestamp Format',\n        id: 'input-datetime-format',\n        displayType: ALL_FIELD_TYPES.timestamp\n      },\n      {\n        title: '# Set Date Format',\n        id: 'input-date-format',\n        displayType: ALL_FIELD_TYPES.date\n      },\n      {\n        title: '# Set Boolean Format',\n        id: 'input-bool-format',\n        displayType: ALL_FIELD_TYPES.boolean\n      }\n    ];\n\n    return (\n      <StyledConfigPanel>\n        <StyledConfigPanelContent>\n          {formatConfigs.map((config, index) => (\n            <NumberFormatConfig\n              title={`${config.title}`}\n              key={index}\n              id={config.id}\n              defaultFormat={'None'}\n              colMeta={colMeta}\n              options={getFieldFormatLabels(`${config.displayType}`)}\n              columns={getColumnsByFieldType(columns, colMeta, `${config.displayType}`)}\n              setColumnDisplayFormat={setColumnDisplayFormat}\n              onClose={onClose}\n            />\n          ))}\n        </StyledConfigPanelContent>\n      </StyledConfigPanel>\n    );\n  };\n  return DataTableConfig;\n}\n\nexport default DataTableConfigFactory;\n"],"mappings":";;;;;;;;;;AAGA,IAAAA,MAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAJ,OAAA;AAGA,IAAAK,kBAAA,GAAAL,OAAA;AACA,IAAAM,eAAA,GAAAN,OAAA;AAAoD,IAAAO,eAAA,EAAAC,gBAAA,EAAAC,gBAAA,EAXpD;AACA;AAAA,SAAAC,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,yBAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAZ,wBAAAY,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAI,UAAA,SAAAJ,CAAA,eAAAA,CAAA,gBAAAK,OAAA,CAAAL,CAAA,0BAAAA,CAAA,sBAAAA,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAG,GAAA,CAAAN,CAAA,UAAAG,CAAA,CAAAI,GAAA,CAAAP,CAAA,OAAAQ,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,CAAA,IAAAd,CAAA,oBAAAc,CAAA,OAAAC,cAAA,CAAAC,IAAA,CAAAhB,CAAA,EAAAc,CAAA,SAAAG,CAAA,GAAAP,CAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAb,CAAA,EAAAc,CAAA,UAAAG,CAAA,KAAAA,CAAA,CAAAV,GAAA,IAAAU,CAAA,CAAAC,GAAA,IAAAP,MAAA,CAAAC,cAAA,CAAAJ,CAAA,EAAAM,CAAA,EAAAG,CAAA,IAAAT,CAAA,CAAAM,CAAA,IAAAd,CAAA,CAAAc,CAAA,YAAAN,CAAA,cAAAR,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAe,GAAA,CAAAlB,CAAA,EAAAQ,CAAA,GAAAA,CAAA;AAYA,IAAMW,iBAAiB,GAAGC,4BAAM,CAACC,GAAG,CAAAzB,eAAA,KAAAA,eAAA,OAAA0B,uBAAA,kHACd,UAAAC,KAAK;EAAA,OAAIA,KAAK,CAACC,KAAK,CAACC,oBAAoB;AAAA,EAG9D;AACD,IAAMC,wBAAwB,GAAGN,4BAAM,CAACC,GAAG,CAAAxB,gBAAA,KAAAA,gBAAA,OAAAyB,uBAAA,yGAK1C;AAED,IAAMK,sBAAsB,GAAGP,4BAAM,CAACC,GAAG,CAAAvB,gBAAA,KAAAA,gBAAA,OAAAwB,uBAAA,iLAUxC;AAaM,IAAMM,kBAAkD,GAAAC,OAAA,CAAAD,kBAAA,GAAG,SAArDA,kBAAkDA,CAAAE,IAAA,EAQnC;EAAA,IAP1BC,KAAK,GAAAD,IAAA,CAALC,KAAK;IACLC,EAAE,GAAAF,IAAA,CAAFE,EAAE;IACFC,aAAa,GAAAH,IAAA,CAAbG,aAAa;IACbC,OAAO,GAAAJ,IAAA,CAAPI,OAAO;IACPC,OAAO,GAAAL,IAAA,CAAPK,OAAO;IACPC,sBAAsB,GAAAN,IAAA,CAAtBM,sBAAsB;IACtBC,OAAO,GAAAP,IAAA,CAAPO,OAAO;EAEP,IAAAC,SAAA,GAA0C,IAAAC,eAAQ,EAAC,KAAK,CAAC;IAAAC,UAAA,OAAAC,eAAA,aAAAH,SAAA;IAAlDI,aAAa,GAAAF,UAAA;IAAEG,gBAAgB,GAAAH,UAAA;EACtC,IAAAI,UAAA,GAA4B,IAAAL,eAAQ,EAACN,aAAa,CAAC;IAAAY,UAAA,OAAAJ,eAAA,aAAAG,UAAA;IAA5CE,MAAM,GAAAD,UAAA;IAAEE,SAAS,GAAAF,UAAA;EAExB,IAAMG,kBAAkB,GAAG,IAAAC,kBAAW,EACpC,UAACC,MAAqB,EAAK;IACzBH,SAAS,CAACG,MAAM,CAACC,KAAK,CAAC;IACvB,IAAMC,OAAgC,GAAGjB,OAAO,CAACkB,MAAM,CAAC,UAACC,IAAI,EAAEC,GAAG,EAAK;MACrED,IAAI,CAACC,GAAG,CAACC,IAAI,CAAC,GAAGN,MAAM,CAACJ,MAAM;MAC9B,OAAOQ,IAAI;IACb,CAAC,EAAE,CAAC,CAAC,CAAC;IACNlB,sBAAsB,CAACgB,OAAO,CAAC;IAC/Bf,OAAO,CAAC,CAAC;EACX,CAAC,EACD,CAACF,OAAO,EAAEC,sBAAsB,EAAEC,OAAO,CAC3C,CAAC;EAED,oBACElD,MAAA,YAAAsE,aAAA,CAAC9B,sBAAsB,qBACrBxC,MAAA,YAAAsE,aAAA,CAAC/D,kBAAA,CAAAgE,UAAU;IACT1B,EAAE,EAAEA,EAAG;IACP2B,IAAI,EAAC,MAAM;IACXC,KAAK,EAAE7B,KAAM;IACb,YAAUe,MAAO;IACjBe,QAAQ;IACRC,OAAO,EAAE,SAATA,OAAOA,CAAA;MAAA,OAAQnB,gBAAgB,CAAC,IAAI,CAAC;IAAA;EAAC,CACvC,CAAC,eACFxD,MAAA,YAAAsE,aAAA,CAAC9D,eAAA,CAAAoE,iBAAiB;IAChBC,IAAI,EAAE,CAAC,GAAI;IACXC,GAAG,EAAE,EAAG;IACRC,QAAQ,EAAExB,aAAc;IACxByB,aAAa,EAAErB,MAAO;IACtBsB,gBAAgB,EAAEpB,kBAAmB;IACrCX,OAAO,EAAE,SAATA,OAAOA,CAAA;MAAA,OAAQM,gBAAgB,CAAC,KAAK,CAAC;IAAA,CAAC;IACvC0B,YAAY,EAAEnC;EAAQ,CACvB,CACqB,CAAC;AAE7B,CAAC;AAED,SAASoC,sBAAsBA,CAAA,EAAG;EAChC,IAAMC,qBAAqB,GAAG,SAAxBA,qBAAqBA,CAAIpC,OAAiB,EAAEqC,OAAgB,EAAEC,SAAiB,EAAK;IACxF,IAAMC,MAAsB,GAAG,EAAE;IACjCvC,OAAO,CAACwC,OAAO,CAAC,UAAAC,OAAO,EAAI;MAAA,IAAAC,gBAAA;MACzB,IAAI,EAAAA,gBAAA,GAAAL,OAAO,CAACI,OAAO,CAAC,cAAAC,gBAAA,uBAAhBA,gBAAA,CAAkBlB,IAAI,MAAKc,SAAS,EAAE;QACxCC,MAAM,CAACI,IAAI,CAACN,OAAO,CAACI,OAAO,CAAC,CAAC;MAC/B;IACF,CAAC,CAAC;IACF,OAAOF,MAAM;EACf,CAAC;EAED,IAAMK,eAAe,GAAG,SAAlBA,eAAeA,CAAAC,KAAA,EAA4D;IAAA,IAAvD7C,OAAO,GAAA6C,KAAA,CAAP7C,OAAO;MAAEqC,OAAO,GAAAQ,KAAA,CAAPR,OAAO;MAAEpC,sBAAsB,GAAA4C,KAAA,CAAtB5C,sBAAsB;MAAEC,OAAO,GAAA2C,KAAA,CAAP3C,OAAO;IACzE,IAAM4C,aAAa,GAAG,CACpB;MACElD,KAAK,EAAE,6BAA6B;MACpCC,EAAE,EAAE,qBAAqB;MACzBkD,WAAW,EAAEC,0BAAe,CAACC;IAC/B,CAAC,EACD;MACErD,KAAK,EAAE,2BAA2B;MAClCC,EAAE,EAAE,oBAAoB;MACxBkD,WAAW,EAAEC,0BAAe,CAACE;IAC/B,CAAC,EACD;MACEtD,KAAK,EAAE,wBAAwB;MAC/BC,EAAE,EAAE,uBAAuB;MAC3BkD,WAAW,EAAEC,0BAAe,CAACG;IAC/B,CAAC,EACD;MACEvD,KAAK,EAAE,mBAAmB;MAC1BC,EAAE,EAAE,mBAAmB;MACvBkD,WAAW,EAAEC,0BAAe,CAACI;IAC/B,CAAC,EACD;MACExD,KAAK,EAAE,sBAAsB;MAC7BC,EAAE,EAAE,mBAAmB;MACvBkD,WAAW,EAAEC,0BAAe;IAC9B,CAAC,CACF;IAED,oBACEhG,MAAA,YAAAsE,aAAA,CAACtC,iBAAiB,qBAChBhC,MAAA,YAAAsE,aAAA,CAAC/B,wBAAwB,QACtBuD,aAAa,CAACO,GAAG,CAAC,UAACC,MAAM,EAAEC,KAAK;MAAA,oBAC/BvG,MAAA,YAAAsE,aAAA,CAAC7B,kBAAkB;QACjBG,KAAK,KAAA4D,MAAA,CAAKF,MAAM,CAAC1D,KAAK,CAAG;QACzB6D,GAAG,EAAEF,KAAM;QACX1D,EAAE,EAAEyD,MAAM,CAACzD,EAAG;QACdC,aAAa,EAAE,MAAO;QACtBuC,OAAO,EAAEA,OAAQ;QACjBtC,OAAO,EAAE,IAAA2D,2BAAoB,KAAAF,MAAA,CAAIF,MAAM,CAACP,WAAW,CAAE,CAAE;QACvD/C,OAAO,EAAEoC,qBAAqB,CAACpC,OAAO,EAAEqC,OAAO,KAAAmB,MAAA,CAAKF,MAAM,CAACP,WAAW,CAAE,CAAE;QAC1E9C,sBAAsB,EAAEA,sBAAuB;QAC/CC,OAAO,EAAEA;MAAQ,CAClB,CAAC;IAAA,CACH,CACuB,CACT,CAAC;EAExB,CAAC;EACD,OAAO0C,eAAe;AACxB;AAAC,IAAAe,QAAA,GAAAjE,OAAA,cAEcyC,sBAAsB","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+import React, { PureComponent } from 'react';
+import { Grid, GridProps } from 'react-virtualized';
+export default class GridHack extends PureComponent<GridProps> {
+    grid: Grid | null;
+    componentDidUpdate(preProps: any): void;
+    componentWillUnmount(): void;
+    _preventScrollBack: (e: any) => false | undefined;
+    _updateRef: (x: any) => void;
+    render(): React.JSX.Element;
+}

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

@@ -0,0 +1,107 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+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 _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+var _reactVirtualized = require("react-virtualized");
+var _lodash = _interopRequireDefault(require("lodash.isequal"));
+var _excluded = ["setGridRef"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var GridHack = exports["default"] = /*#__PURE__*/function (_PureComponent) {
+  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 = _callSuper(this, GridHack, [].concat(args));
+    (0, _defineProperty2["default"])(_this, "grid", null);
+    (0, _defineProperty2["default"])(_this, "_preventScrollBack", function (e) {
+      var scrollLeft = _this.props.scrollLeft;
+      if (scrollLeft !== undefined && scrollLeft <= 0 && e.deltaX < 0) {
+        // Prevent Scroll On Scrollable Elements, avoid browser backward navigation
+        // https://alvarotrigo.com/blog/prevent-scroll-on-scrollable-element-js/
+        e.preventDefault();
+        e.stopPropagation();
+        return false;
+      }
+      return;
+    });
+    (0, _defineProperty2["default"])(_this, "_updateRef", function (x) {
+      if (!_this.grid && x) {
+        var _this$grid;
+        _this.grid = x;
+        /*
+         * This hack exists because we need to add wheel event listener to the div rendered by Grid
+         *
+         */
+        // @ts-expect-error _scrollingContainer not typed in Grid
+        (_this$grid = _this.grid) === null || _this$grid === void 0 || (_this$grid = _this$grid._scrollingContainer) === null || _this$grid === void 0 || _this$grid.addEventListener('wheel', _this._preventScrollBack, {
+          passive: false
+        });
+      }
+    });
+    return _this;
+  }
+  (0, _inherits2["default"])(GridHack, _PureComponent);
+  return (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$grid2;
+        (_this$grid2 = this.grid) === null || _this$grid2 === void 0 || _this$grid2.recomputeGridSize();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      var _this$grid3;
+      // @ts-expect-error _scrollingContainer not typed in Grid
+      (_this$grid3 = this.grid) === null || _this$grid3 === void 0 || (_this$grid3 = _this$grid3._scrollingContainer) === null || _this$grid3 === void 0 || _this$grid3.removeEventListener('wheel', this._preventScrollBack, {
+        passive: false
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props = this.props,
+        setGridRef = _this$props.setGridRef,
+        rest = (0, _objectWithoutProperties2["default"])(_this$props, _excluded);
+      return /*#__PURE__*/_react["default"].createElement(_reactVirtualized.Grid, (0, _extends2["default"])({
+        ref: function ref(x) {
+          if (setGridRef) setGridRef(x);
+          _this2._updateRef(x);
+        },
+        key: "grid-hack"
+      }, rest));
+    }
+  }]);
+}(_react.PureComponent);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_reactVirtualized","_lodash","_interopRequireDefault","_excluded","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","_callSuper","o","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","apply","Boolean","prototype","valueOf","GridHack","exports","_PureComponent","_this","_classCallCheck2","_len","arguments","length","args","Array","_key","concat","_defineProperty2","scrollLeft","props","undefined","deltaX","preventDefault","stopPropagation","x","grid","_this$grid","_scrollingContainer","addEventListener","_preventScrollBack","passive","_inherits2","_createClass2","key","value","componentDidUpdate","preProps","isEqual","cellSizeCache","_this$grid2","recomputeGridSize","componentWillUnmount","_this$grid3","removeEventListener","render","_this2","_this$props","setGridRef","rest","_objectWithoutProperties2","createElement","Grid","_extends2","ref","_updateRef","PureComponent"],"sources":["../../../src/common/data-table/grid.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {PureComponent} from 'react';\nimport {Grid, GridProps} from 'react-virtualized';\nimport isEqual from 'lodash.isequal';\n\nexport default class GridHack extends PureComponent<GridProps> {\n  grid: Grid | null = null;\n\n  componentDidUpdate(preProps) {\n    /*\n     * This hack exists because in react-virtualized the\n     * _columnWidthGetter is only called in the constructor\n     * even though it is reassigned with new props resulting in\n     * a new width for cells not being calculated so we must\n     * force trigger a resize.\n     *\n     * https://github.com/bvaughn/react-virtualized/blob/master/source/Grid/Grid.js#L322\n     *\n     */\n    if (!isEqual(preProps.cellSizeCache, this.props.cellSizeCache)) {\n      this.grid?.recomputeGridSize();\n    }\n  }\n\n  componentWillUnmount() {\n    // @ts-expect-error _scrollingContainer not typed in Grid\n    this.grid?._scrollingContainer?.removeEventListener('wheel', this._preventScrollBack, {\n      passive: false\n    });\n  }\n\n  _preventScrollBack = e => {\n    const {scrollLeft} = this.props;\n    if (scrollLeft !== undefined && scrollLeft <= 0 && e.deltaX < 0) {\n      // Prevent Scroll On Scrollable Elements, avoid browser backward navigation\n      // https://alvarotrigo.com/blog/prevent-scroll-on-scrollable-element-js/\n      e.preventDefault();\n      e.stopPropagation();\n      return false;\n    }\n    return;\n  };\n\n  _updateRef = x => {\n    if (!this.grid && x) {\n      this.grid = x;\n      /*\n       * This hack exists because we need to add wheel event listener to the div rendered by Grid\n       *\n       */\n      // @ts-expect-error _scrollingContainer not typed in Grid\n      this.grid?._scrollingContainer?.addEventListener('wheel', this._preventScrollBack, {\n        passive: false\n      });\n    }\n  };\n\n  render() {\n    const {setGridRef, ...rest} = this.props;\n    return (\n      <Grid\n        ref={x => {\n          if (setGridRef) setGridRef(x);\n          this._updateRef(x);\n        }}\n        key=\"grid-hack\"\n        {...rest}\n      />\n    );\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,28 @@
+import React, { CSSProperties } from 'react';
+import { ColMeta } from '@kepler.gl/types';
+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'];
+    colMeta?: ColMeta;
+    isPinned?: boolean;
+    showStats?: boolean;
+    props: DataTableProps;
+    toggleMoreOptions: (moreOptionsColumn: string) => void;
+    moreOptionsColumn: null | string;
+};
+declare const HeaderCellFactory: {
+    (FieldToken: React.FC<FieldTokenProps>): ({ cellInfo, columns, isPinned, props, toggleMoreOptions, moreOptionsColumn }: HeaderCellProps) => React.JSX.Element;
+    deps: (typeof FieldTokenFactory)[];
+};
+export default HeaderCellFactory;