@kepler.gl/components 3.0.0-alpha.0

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

@@ -0,0 +1,108 @@
+import React from 'react';
+import { OnScrollParams, GridProps, Index } from 'react-virtualized';
+import { CellSizeCache } from './cell-size';
+import HeaderCellFactory from './header-cell';
+import { DataContainerInterface } from '@kepler.gl/utils';
+export declare const Container: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare type ColMeta = {
+    [key: string]: {
+        colIdx: number;
+        name: string;
+        displayName: string;
+        type: string;
+        format?: string;
+        columnStats?: any;
+    };
+};
+export declare type SortColumn = {
+    column?: string;
+    mode?: string;
+};
+interface TableSectionProps {
+    classList?: {
+        header: string;
+        rows: string;
+    };
+    isPinned?: boolean;
+    columns: (string & {
+        ghost?: boolean;
+    })[];
+    headerGridProps?: any;
+    fixedWidth?: number;
+    fixedHeight?: number;
+    onScroll?: (params: OnScrollParams) => void;
+    scrollTop?: number;
+    dataGridProps: {
+        rowHeight: number | ((params: Index) => number);
+        rowCount: number;
+    } & Partial<GridProps>;
+    columnWidth?: any;
+    setGridRef?: Function;
+    headerCellRender?: any;
+    dataCellRender?: any;
+    scrollLeft?: number;
+}
+export declare const TableSection: ({ classList, isPinned, columns, headerGridProps, fixedWidth, fixedHeight, onScroll, scrollTop, dataGridProps, columnWidth, setGridRef, headerCellRender, dataCellRender, scrollLeft }: TableSectionProps) => JSX.Element;
+export interface DataTableProps {
+    dataId?: string;
+    showStats?: boolean;
+    cellSizeCache?: CellSizeCache;
+    pinnedColumns?: string[];
+    columns: (string & {
+        ghost?: boolean;
+    })[];
+    fixedWidth?: number;
+    theme?: any;
+    dataContainer: DataContainerInterface;
+    fixedHeight?: number;
+    colMeta: ColMeta;
+    sortColumn?: SortColumn;
+    sortTableColumn: (column: string, mode?: string) => void;
+    pinTableColumn: (column: string) => void;
+    copyTableColumn: (column: string) => void;
+    sortOrder?: number[] | null;
+}
+declare function DataTableFactory(HeaderCell: ReturnType<typeof HeaderCellFactory>): React.ForwardRefExoticComponent<{
+    columns: (string & {
+        ghost?: boolean | undefined;
+    })[];
+    dataId?: string | undefined;
+    showStats?: boolean | undefined;
+    cellSizeCache?: CellSizeCache | undefined;
+    pinnedColumns?: string[] | undefined;
+    fixedWidth?: number | undefined;
+    dataContainer?: DataContainerInterface | undefined;
+    fixedHeight?: number | undefined;
+    colMeta?: ColMeta | undefined;
+    sortColumn?: SortColumn | undefined;
+    sortTableColumn: (column: string, mode?: string | undefined) => void;
+    pinTableColumn: (column: string) => void;
+    copyTableColumn: (column: string) => void;
+    sortOrder?: number[] | null | undefined;
+} & {
+    theme?: any;
+}>;
+declare namespace DataTableFactory {
+    var deps: {
+        (FieldToken: React.FC<import("../field-token").FieldTokenProps>): ({ cellInfo, columns, isPinned, props, toggleMoreOptions, moreOptionsColumn }: {
+            cellInfo: {
+                columnIndex: number;
+                isScrolling: boolean;
+                isVisible: boolean;
+                key: string;
+                parent: any;
+                rowIndex: number;
+                style: React.CSSProperties;
+            };
+            columns: (string & {
+                ghost?: boolean | undefined;
+            })[];
+            isPinned?: boolean | undefined;
+            props: DataTableProps;
+            toggleMoreOptions: (moreOptionsColumn: string) => void;
+            moreOptionsColumn: string | null;
+        }) => JSX.Element;
+        deps: typeof import("../field-token").default[];
+    }[];
+}
+export default DataTableFactory;

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

@@ -0,0 +1,457 @@
+// 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");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.TableSection = exports.Container = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+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 _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactVirtualized = require("react-virtualized");
+
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+
+var _classnames2 = _interopRequireDefault(require("classnames"));
+
+var _reselect = require("reselect");
+
+var _lodash = _interopRequireDefault(require("lodash.get"));
+
+var _lodash2 = _interopRequireDefault(require("lodash.debounce"));
+
+var _grid = _interopRequireDefault(require("./grid"));
+
+var _headerCell = _interopRequireDefault(require("./header-cell"));
+
+var _utils = require("@kepler.gl/utils");
+
+var _cellSize = require("./cell-size");
+
+var _constants = require("@kepler.gl/constants");
+
+var _fieldToAlignRight, _templateObject;
+
+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; }
+
+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 defaultHeaderRowHeight = 55;
+var defaultRowHeight = 32;
+var overscanColumnCount = 10;
+var overscanRowCount = 10;
+var fieldToAlignRight = (_fieldToAlignRight = {}, (0, _defineProperty2["default"])(_fieldToAlignRight, _constants.ALL_FIELD_TYPES.integer, true), (0, _defineProperty2["default"])(_fieldToAlignRight, _constants.ALL_FIELD_TYPES.real, true), _fieldToAlignRight);
+
+var Container = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  font-size: 11px;\n  flex-grow: 1;\n  color: ", ";\n  width: 100%;\n\n  .ReactVirtualized__Grid:focus,\n  .ReactVirtualized__Grid:active {\n    outline: 0;\n  }\n\n  .cell {\n    &::-webkit-scrollbar {\n      display: none;\n    }\n  }\n\n  *:focus {\n    outline: 0;\n  }\n\n  .results-table-wrapper {\n    position: relative;\n    min-height: 100%;\n    max-height: 100%;\n    display: flex;\n    flex-direction: row;\n    flex-grow: 1;\n    overflow: hidden;\n    border-top: none;\n\n    .scroll-in-ui-thread::after {\n      content: '';\n      height: 100%;\n      left: 0;\n      position: absolute;\n      pointer-events: none;\n      top: 0;\n      width: 100%;\n    }\n\n    .grid-row {\n      position: relative;\n      display: flex;\n      flex-direction: row;\n    }\n    .grid-column {\n      display: flex;\n      flex-direction: column;\n      flex: 1 1 auto;\n    }\n    .pinned-grid-container {\n      flex: 0 0 75px;\n      z-index: 10;\n      position: absolute;\n      left: 0;\n      top: 0;\n      border-right: 2px solid ", ";\n    }\n\n    .header-grid {\n      overflow: hidden !important;\n    }\n\n    .even-row {\n      background-color: ", ";\n    }\n    .odd-row {\n      background-color: ", ";\n    }\n    .cell,\n    .header-cell {\n      width: 100%;\n      height: 100%;\n      display: flex;\n      flex-direction: column;\n      justify-content: center;\n      align-items: flex-start;\n      text-align: center;\n      overflow: hidden;\n\n      .n-sort-idx {\n        font-size: 9px;\n      }\n    }\n    .cell {\n      border-bottom: 1px solid ", ";\n      border-right: 1px solid ", ";\n      white-space: nowrap;\n      overflow: auto;\n      padding: 0 ", "px;\n      font-size: ", "px;\n\n      .result-link {\n        text-decoration: none;\n      }\n    }\n    .cell.end-cell,\n    .header-cell.end-cell {\n      border-right: none;\n      padding-right: ", "px;\n    }\n    .cell.first-cell,\n    .header-cell.first-cell {\n      padding-left: ", "px;\n    }\n    .cell.bottom-cell {\n      border-bottom: none;\n    }\n    .cell.align-right {\n      align-items: flex-end;\n    }\n  }\n\n  :focus {\n    outline: none;\n  }\n"])), function (props) {
+  return props.theme.dataTableTextColor;
+}, function (props) {
+  return props.theme.pinnedGridBorderColor;
+}, function (props) {
+  return props.theme.evenRowBackground;
+}, function (props) {
+  return props.theme.oddRowBackground;
+}, function (props) {
+  return props.theme.cellBorderColor;
+}, function (props) {
+  return props.theme.cellBorderColor;
+}, function (props) {
+  return props.theme.cellPaddingSide;
+}, function (props) {
+  return props.theme.cellFontSize;
+}, function (props) {
+  return props.theme.cellPaddingSide + props.theme.edgeCellPaddingSide;
+}, function (props) {
+  return props.theme.cellPaddingSide + props.theme.edgeCellPaddingSide;
+});
+
+exports.Container = Container;
+var defaultColumnWidth = 200;
+
+var columnWidthFunction = function columnWidthFunction(columns, cellSizeCache, ghost) {
+  return function (_ref) {
+    var index = _ref.index;
+    return (columns[index] || {}).ghost ? ghost : cellSizeCache[columns[index]] || defaultColumnWidth;
+  };
+};
+
+/*
+ * This is an accessor method used to generalize getting a cell from a data row
+ */
+var getRowCell = function getRowCell(_ref2) {
+  var dataContainer = _ref2.dataContainer,
+      columns = _ref2.columns,
+      column = _ref2.column,
+      colMeta = _ref2.colMeta,
+      rowIndex = _ref2.rowIndex,
+      sortOrder = _ref2.sortOrder;
+  var rowIdx = sortOrder && sortOrder.length ? (0, _lodash["default"])(sortOrder, rowIndex) : rowIndex;
+  var type = colMeta[column].type;
+  var value = dataContainer.valueAt(rowIdx, columns.indexOf(column));
+  if (value === undefined) value = 'Err';
+  return (0, _utils.parseFieldValue)(value, type);
+};
+
+var TableSection = function TableSection(_ref3) {
+  var classList = _ref3.classList,
+      isPinned = _ref3.isPinned,
+      columns = _ref3.columns,
+      headerGridProps = _ref3.headerGridProps,
+      fixedWidth = _ref3.fixedWidth,
+      _ref3$fixedHeight = _ref3.fixedHeight,
+      fixedHeight = _ref3$fixedHeight === void 0 ? undefined : _ref3$fixedHeight,
+      onScroll = _ref3.onScroll,
+      scrollTop = _ref3.scrollTop,
+      dataGridProps = _ref3.dataGridProps,
+      columnWidth = _ref3.columnWidth,
+      _ref3$setGridRef = _ref3.setGridRef,
+      setGridRef = _ref3$setGridRef === void 0 ? undefined : _ref3$setGridRef,
+      headerCellRender = _ref3.headerCellRender,
+      dataCellRender = _ref3.dataCellRender,
+      _ref3$scrollLeft = _ref3.scrollLeft,
+      scrollLeft = _ref3$scrollLeft === void 0 ? 0 : _ref3$scrollLeft;
+  return /*#__PURE__*/_react["default"].createElement(_reactVirtualized.AutoSizer, null, function (_ref4) {
+    var width = _ref4.width,
+        height = _ref4.height;
+    var gridDimension = {
+      columnCount: columns.length,
+      columnWidth: columnWidth,
+      width: fixedWidth || width
+    };
+    var dataGridHeight = fixedHeight || height;
+    return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement("div", {
+      className: (0, _classnames2["default"])('scroll-in-ui-thread', classList === null || classList === void 0 ? void 0 : classList.header)
+    }, /*#__PURE__*/_react["default"].createElement(_grid["default"], (0, _extends2["default"])({
+      cellRenderer: headerCellRender
+    }, headerGridProps, gridDimension, {
+      scrollLeft: scrollLeft,
+      onScroll: onScroll
+    }))), /*#__PURE__*/_react["default"].createElement("div", {
+      className: (0, _classnames2["default"])('scroll-in-ui-thread', classList === null || classList === void 0 ? void 0 : classList.rows),
+      style: {
+        top: headerGridProps.height
+      }
+    }, /*#__PURE__*/_react["default"].createElement(_grid["default"], (0, _extends2["default"])({
+      cellRenderer: dataCellRender
+    }, dataGridProps, gridDimension, {
+      className: isPinned ? 'pinned-grid' : 'body-grid',
+      height: dataGridHeight - headerGridProps.height,
+      onScroll: onScroll,
+      scrollTop: scrollTop,
+      setGridRef: setGridRef
+    }))));
+  });
+};
+
+exports.TableSection = TableSection;
+DataTableFactory.deps = [_headerCell["default"]];
+
+function DataTableFactory(HeaderCell) {
+  var DataTable = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(DataTable, _Component);
+
+    var _super = _createSuper(DataTable);
+
+    function DataTable() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, DataTable);
+
+      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), "state", {
+        cellSizeCache: {},
+        moreOptionsColumn: null
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "root", /*#__PURE__*/(0, _react.createRef)());
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "columns", function (props) {
+        return props.columns;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "pinnedColumns", function (props) {
+        return props.pinnedColumns;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "unpinnedColumns", (0, _reselect.createSelector)(_this.columns, _this.pinnedColumns, function (columns, pinnedColumns) {
+        return !Array.isArray(pinnedColumns) ? columns : columns.filter(function (c) {
+          return !pinnedColumns.includes(c);
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "toggleMoreOptions", function (moreOptionsColumn) {
+        return _this.setState({
+          moreOptionsColumn: _this.state.moreOptionsColumn === moreOptionsColumn ? null : moreOptionsColumn
+        });
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getCellSizeCache", function () {
+        var _this$props = _this.props,
+            _this$props$cellSizeC = _this$props.cellSizeCache,
+            propsCache = _this$props$cellSizeC === void 0 ? {} : _this$props$cellSizeC,
+            fixedWidth = _this$props.fixedWidth,
+            _this$props$pinnedCol = _this$props.pinnedColumns,
+            pinnedColumns = _this$props$pinnedCol === void 0 ? [] : _this$props$pinnedCol;
+
+        var unpinnedColumns = _this.unpinnedColumns(_this.props);
+
+        var width = fixedWidth ? fixedWidth : _this.root.current ? _this.root.current.clientWidth : 0; // pin column border is 2 pixel vs 1 pixel
+
+        var adjustWidth = pinnedColumns.length ? width - 1 : width;
+
+        var _ref5 = (0, _cellSize.adjustCellsToContainer)(adjustWidth, propsCache, pinnedColumns, unpinnedColumns),
+            cellSizeCache = _ref5.cellSizeCache,
+            ghost = _ref5.ghost;
+
+        return {
+          cellSizeCache: cellSizeCache,
+          ghost: ghost
+        };
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "doScaleCellsToWidth", function () {
+        _this.setState(_this.getCellSizeCache());
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "scaleCellsToWidth", (0, _lodash2["default"])(_this.doScaleCellsToWidth, 300));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "renderDataCell", function (columns, isPinned, props) {
+        return function (cellInfo) {
+          var _classnames;
+
+          var columnIndex = cellInfo.columnIndex,
+              key = cellInfo.key,
+              style = cellInfo.style,
+              rowIndex = cellInfo.rowIndex;
+          var dataContainer = props.dataContainer,
+              colMeta = props.colMeta;
+          var column = columns[columnIndex];
+          var isGhost = column.ghost;
+          var rowCell = isGhost ? '' : getRowCell(_objectSpread(_objectSpread({}, props), {}, {
+            column: column,
+            rowIndex: rowIndex
+          }));
+          var type = isGhost ? null : colMeta[column].type;
+          var lastRowIndex = dataContainer ? dataContainer.numRows() - 1 : 0;
+          var endCell = columnIndex === columns.length - 1;
+          var firstCell = columnIndex === 0;
+          var bottomCell = rowIndex === lastRowIndex;
+          var alignRight = fieldToAlignRight[Number(type)];
+
+          var cell = /*#__PURE__*/_react["default"].createElement("div", {
+            className: (0, _classnames2["default"])('cell', (_classnames = {}, (0, _defineProperty2["default"])(_classnames, rowIndex % 2 === 0 ? 'even-row' : 'odd-row', true), (0, _defineProperty2["default"])(_classnames, "row-".concat(rowIndex), true), (0, _defineProperty2["default"])(_classnames, 'pinned-cell', isPinned), (0, _defineProperty2["default"])(_classnames, 'first-cell', firstCell), (0, _defineProperty2["default"])(_classnames, 'end-cell', endCell), (0, _defineProperty2["default"])(_classnames, 'bottom-cell', bottomCell), (0, _defineProperty2["default"])(_classnames, 'align-right', alignRight), _classnames)),
+            key: key,
+            style: style,
+            title: isGhost ? undefined : rowCell
+          }, "".concat(rowCell).concat(endCell ? '\n' : '\t'));
+
+          return cell;
+        };
+      });
+      return _this;
+    }
+
+    (0, _createClass2["default"])(DataTable, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        window.addEventListener('resize', this.scaleCellsToWidth);
+        this.scaleCellsToWidth();
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        if (this.props.cellSizeCache !== prevProps.cellSizeCache || this.props.pinnedColumns !== prevProps.pinnedColumns) {
+          this.scaleCellsToWidth();
+        }
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        window.removeEventListener('resize', this.scaleCellsToWidth); // fix Warning: Can't perform a React state update on an unmounted component
+
+        this.setState = function () {
+          return;
+        };
+      }
+    }, {
+      key: "renderHeaderCell",
+      value: function renderHeaderCell(columns, isPinned, props, toggleMoreOptions, moreOptionsColumn) {
+        return function (cellInfo) {
+          return /*#__PURE__*/_react["default"].createElement(HeaderCell, {
+            cellInfo: cellInfo,
+            key: cellInfo.columnIndex,
+            columns: columns,
+            isPinned: isPinned,
+            props: props,
+            toggleMoreOptions: toggleMoreOptions,
+            moreOptionsColumn: moreOptionsColumn
+          });
+        };
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+
+        var _this$props2 = this.props,
+            dataContainer = _this$props2.dataContainer,
+            _this$props2$pinnedCo = _this$props2.pinnedColumns,
+            pinnedColumns = _this$props2$pinnedCo === void 0 ? [] : _this$props2$pinnedCo,
+            _this$props2$theme = _this$props2.theme,
+            theme = _this$props2$theme === void 0 ? {} : _this$props2$theme,
+            fixedWidth = _this$props2.fixedWidth,
+            _this$props2$fixedHei = _this$props2.fixedHeight,
+            fixedHeight = _this$props2$fixedHei === void 0 ? 0 : _this$props2$fixedHei,
+            showStats = _this$props2.showStats;
+        var unpinnedColumns = this.unpinnedColumns(this.props);
+        var _this$state = this.state,
+            _this$state$cellSizeC = _this$state.cellSizeCache,
+            cellSizeCache = _this$state$cellSizeC === void 0 ? {} : _this$state$cellSizeC,
+            moreOptionsColumn = _this$state.moreOptionsColumn,
+            ghost = _this$state.ghost;
+        var unpinnedColumnsGhost = ghost ? [].concat((0, _toConsumableArray2["default"])(unpinnedColumns), [{
+          ghost: true
+        }]) : unpinnedColumns;
+        var pinnedColumnsWidth = pinnedColumns.reduce(function (acc, val) {
+          return acc + (0, _lodash["default"])(cellSizeCache, val, 0);
+        }, 0);
+        var hasPinnedColumns = Boolean(pinnedColumns.length);
+        var _theme$headerRowHeigh = theme.headerRowHeight,
+            headerRowHeight = _theme$headerRowHeigh === void 0 ? defaultHeaderRowHeight : _theme$headerRowHeigh,
+            _theme$headerRowWStat = theme.headerRowWStatsHeight,
+            headerRowWStatsHeight = _theme$headerRowWStat === void 0 ? defaultHeaderRowHeight : _theme$headerRowWStat,
+            _theme$rowHeight = theme.rowHeight,
+            rowHeight = _theme$rowHeight === void 0 ? defaultRowHeight : _theme$rowHeight;
+        var headerGridProps = {
+          cellSizeCache: cellSizeCache,
+          className: 'header-grid',
+          height: showStats ? headerRowWStatsHeight : headerRowHeight,
+          rowCount: 1,
+          rowHeight: showStats ? headerRowWStatsHeight : headerRowHeight
+        };
+        var dataGridProps = {
+          cellSizeCache: cellSizeCache,
+          overscanColumnCount: overscanColumnCount,
+          overscanRowCount: overscanRowCount,
+          rowCount: dataContainer ? dataContainer.numRows() : 0,
+          rowHeight: rowHeight
+        };
+        return /*#__PURE__*/_react["default"].createElement(Container, {
+          className: "data-table-container",
+          ref: this.root
+        }, Object.keys(cellSizeCache).length ? /*#__PURE__*/_react["default"].createElement(_reactVirtualized.ScrollSync, null, function (_ref6) {
+          var _onScroll = _ref6.onScroll,
+              scrollLeft = _ref6.scrollLeft,
+              scrollTop = _ref6.scrollTop;
+          return /*#__PURE__*/_react["default"].createElement("div", {
+            className: "results-table-wrapper"
+          }, hasPinnedColumns && /*#__PURE__*/_react["default"].createElement("div", {
+            key: "pinned-columns",
+            className: "pinned-columns grid-row"
+          }, /*#__PURE__*/_react["default"].createElement(TableSection, {
+            classList: {
+              header: 'pinned-columns--header pinned-grid-container',
+              rows: 'pinned-columns--rows pinned-grid-container'
+            },
+            isPinned: true,
+            columns: pinnedColumns,
+            headerGridProps: headerGridProps,
+            fixedWidth: pinnedColumnsWidth,
+            onScroll: function onScroll(args) {
+              return _onScroll(_objectSpread(_objectSpread({}, args), {}, {
+                scrollLeft: scrollLeft
+              }));
+            },
+            scrollTop: scrollTop,
+            dataGridProps: dataGridProps,
+            columnWidth: columnWidthFunction(pinnedColumns, cellSizeCache),
+            headerCellRender: _this2.renderHeaderCell(pinnedColumns, true, _this2.props, _this2.toggleMoreOptions, moreOptionsColumn),
+            dataCellRender: _this2.renderDataCell(pinnedColumns, true, _this2.props)
+          })), /*#__PURE__*/_react["default"].createElement("div", {
+            key: "unpinned-columns",
+            style: {
+              marginLeft: "".concat(hasPinnedColumns ? "".concat(pinnedColumnsWidth, "px") : '0')
+            },
+            className: "unpinned-columns grid-column"
+          }, /*#__PURE__*/_react["default"].createElement(TableSection, {
+            classList: {
+              header: 'unpinned-columns--header unpinned-grid-container',
+              rows: 'unpinned-columns--rows unpinned-grid-container'
+            },
+            isPinned: false,
+            columns: unpinnedColumnsGhost,
+            headerGridProps: headerGridProps,
+            fixedWidth: fixedWidth,
+            fixedHeight: fixedHeight,
+            onScroll: _onScroll,
+            scrollTop: scrollTop,
+            scrollLeft: scrollLeft,
+            dataGridProps: dataGridProps,
+            columnWidth: columnWidthFunction(unpinnedColumnsGhost, cellSizeCache, ghost),
+            headerCellRender: _this2.renderHeaderCell(unpinnedColumnsGhost, false, _this2.props, _this2.toggleMoreOptions, moreOptionsColumn),
+            dataCellRender: _this2.renderDataCell(unpinnedColumnsGhost, false, _this2.props)
+          })));
+        }) : null);
+      }
+    }]);
+    return DataTable;
+  }(_react.Component);
+
+  (0, _defineProperty2["default"])(DataTable, "defaultProps", {
+    dataContainer: null,
+    pinnedColumns: [],
+    colMeta: {},
+    cellSizeCache: {},
+    sortColumn: {},
+    fixedWidth: null,
+    fixedHeight: null,
+    theme: {},
+    showStats: false
+  });
+  return (0, _styledComponents.withTheme)(DataTable);
+}
+
+var _default = DataTableFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/common/data-table/index.tsx"],"names":["defaultHeaderRowHeight","defaultRowHeight","overscanColumnCount","overscanRowCount","fieldToAlignRight","ALL_FIELD_TYPES","integer","real","Container","styled","div","props","theme","dataTableTextColor","pinnedGridBorderColor","evenRowBackground","oddRowBackground","cellBorderColor","cellPaddingSide","cellFontSize","edgeCellPaddingSide","defaultColumnWidth","columnWidthFunction","columns","cellSizeCache","ghost","index","getRowCell","dataContainer","column","colMeta","rowIndex","sortOrder","rowIdx","length","type","value","valueAt","indexOf","undefined","TableSection","classList","isPinned","headerGridProps","fixedWidth","fixedHeight","onScroll","scrollTop","dataGridProps","columnWidth","setGridRef","headerCellRender","dataCellRender","scrollLeft","width","height","gridDimension","columnCount","dataGridHeight","header","rows","top","DataTableFactory","deps","HeaderCellFactory","HeaderCell","DataTable","moreOptionsColumn","pinnedColumns","Array","isArray","filter","c","includes","setState","state","propsCache","unpinnedColumns","root","current","clientWidth","adjustWidth","getCellSizeCache","doScaleCellsToWidth","cellInfo","columnIndex","key","style","isGhost","rowCell","lastRowIndex","numRows","endCell","firstCell","bottomCell","alignRight","Number","cell","window","addEventListener","scaleCellsToWidth","prevProps","removeEventListener","toggleMoreOptions","showStats","unpinnedColumnsGhost","pinnedColumnsWidth","reduce","acc","val","hasPinnedColumns","Boolean","headerRowHeight","headerRowWStatsHeight","rowHeight","className","rowCount","Object","keys","args","renderHeaderCell","renderDataCell","marginLeft","Component","sortColumn"],"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 React, {Component, createRef} from 'react';\nimport {ScrollSync, AutoSizer, OnScrollParams, GridProps, Index} from 'react-virtualized';\nimport styled, {withTheme} from 'styled-components';\nimport classnames from 'classnames';\nimport {createSelector} from 'reselect';\nimport get from 'lodash.get';\nimport debounce from 'lodash.debounce';\n\nimport {CellSizeCache} from './cell-size';\n\nimport Grid from './grid';\nimport HeaderCellFactory from './header-cell';\n\nimport {parseFieldValue, DataContainerInterface} from '@kepler.gl/utils';\nimport {adjustCellsToContainer} from './cell-size';\n\nimport {ALL_FIELD_TYPES} from '@kepler.gl/constants';\n\nconst defaultHeaderRowHeight = 55;\nconst defaultRowHeight = 32;\nconst overscanColumnCount = 10;\nconst overscanRowCount = 10;\nconst fieldToAlignRight = {\n  [ALL_FIELD_TYPES.integer]: true,\n  [ALL_FIELD_TYPES.real]: true\n};\n\nexport const Container = styled.div`\n  display: flex;\n  font-size: 11px;\n  flex-grow: 1;\n  color: ${props => props.theme.dataTableTextColor};\n  width: 100%;\n\n  .ReactVirtualized__Grid:focus,\n  .ReactVirtualized__Grid:active {\n    outline: 0;\n  }\n\n  .cell {\n    &::-webkit-scrollbar {\n      display: none;\n    }\n  }\n\n  *:focus {\n    outline: 0;\n  }\n\n  .results-table-wrapper {\n    position: relative;\n    min-height: 100%;\n    max-height: 100%;\n    display: flex;\n    flex-direction: row;\n    flex-grow: 1;\n    overflow: hidden;\n    border-top: none;\n\n    .scroll-in-ui-thread::after {\n      content: '';\n      height: 100%;\n      left: 0;\n      position: absolute;\n      pointer-events: none;\n      top: 0;\n      width: 100%;\n    }\n\n    .grid-row {\n      position: relative;\n      display: flex;\n      flex-direction: row;\n    }\n    .grid-column {\n      display: flex;\n      flex-direction: column;\n      flex: 1 1 auto;\n    }\n    .pinned-grid-container {\n      flex: 0 0 75px;\n      z-index: 10;\n      position: absolute;\n      left: 0;\n      top: 0;\n      border-right: 2px solid ${props => props.theme.pinnedGridBorderColor};\n    }\n\n    .header-grid {\n      overflow: hidden !important;\n    }\n\n    .even-row {\n      background-color: ${props => props.theme.evenRowBackground};\n    }\n    .odd-row {\n      background-color: ${props => props.theme.oddRowBackground};\n    }\n    .cell,\n    .header-cell {\n      width: 100%;\n      height: 100%;\n      display: flex;\n      flex-direction: column;\n      justify-content: center;\n      align-items: flex-start;\n      text-align: center;\n      overflow: hidden;\n\n      .n-sort-idx {\n        font-size: 9px;\n      }\n    }\n    .cell {\n      border-bottom: 1px solid ${props => props.theme.cellBorderColor};\n      border-right: 1px solid ${props => props.theme.cellBorderColor};\n      white-space: nowrap;\n      overflow: auto;\n      padding: 0 ${props => props.theme.cellPaddingSide}px;\n      font-size: ${props => props.theme.cellFontSize}px;\n\n      .result-link {\n        text-decoration: none;\n      }\n    }\n    .cell.end-cell,\n    .header-cell.end-cell {\n      border-right: none;\n      padding-right: ${props => props.theme.cellPaddingSide + props.theme.edgeCellPaddingSide}px;\n    }\n    .cell.first-cell,\n    .header-cell.first-cell {\n      padding-left: ${props => props.theme.cellPaddingSide + props.theme.edgeCellPaddingSide}px;\n    }\n    .cell.bottom-cell {\n      border-bottom: none;\n    }\n    .cell.align-right {\n      align-items: flex-end;\n    }\n  }\n\n  :focus {\n    outline: none;\n  }\n`;\n\nconst defaultColumnWidth = 200;\n\nexport type ColMeta = {\n  [key: string]: {\n    colIdx: number;\n    name: string;\n    displayName: string;\n    type: string;\n    format?: string;\n    columnStats?: any;\n  };\n};\n\nexport type SortColumn = {\n  column?: string;\n  mode?: string;\n};\n\nconst columnWidthFunction = (columns, cellSizeCache, ghost?) => ({index}) => {\n  return (columns[index] || {}).ghost ? ghost : cellSizeCache[columns[index]] || defaultColumnWidth;\n};\n\ninterface GetRowCellProps {\n  dataContainer: DataContainerInterface;\n  columns: (string & {ghost?: boolean})[];\n  column: string;\n  colMeta;\n  rowIndex: number;\n  sortOrder?: number[] | null;\n}\n\n/*\n * This is an accessor method used to generalize getting a cell from a data row\n */\nconst getRowCell = ({\n  dataContainer,\n  columns,\n  column,\n  colMeta,\n  rowIndex,\n  sortOrder\n}: GetRowCellProps) => {\n  const rowIdx = sortOrder && sortOrder.length ? get(sortOrder, rowIndex) : rowIndex;\n  const {type} = colMeta[column];\n\n  let value = dataContainer.valueAt(rowIdx, columns.indexOf(column));\n  if (value === undefined) value = 'Err';\n  return parseFieldValue(value, type);\n};\n\ninterface TableSectionProps {\n  classList?: {\n    header: string;\n    rows: string;\n  };\n  isPinned?: boolean;\n  columns: (string & {ghost?: boolean})[];\n  headerGridProps?;\n  fixedWidth?: number;\n  fixedHeight?: number;\n  onScroll?: (params: OnScrollParams) => void;\n  scrollTop?: number;\n  dataGridProps: {\n    rowHeight: number | ((params: Index) => number);\n    rowCount: number;\n  } & Partial<GridProps>;\n  columnWidth?;\n  setGridRef?: Function;\n  headerCellRender?;\n  dataCellRender?;\n  scrollLeft?: number;\n}\n\nexport const TableSection = ({\n  classList,\n  isPinned,\n  columns,\n  headerGridProps,\n  fixedWidth,\n  fixedHeight = undefined,\n  onScroll,\n  scrollTop,\n  dataGridProps,\n  columnWidth,\n  setGridRef = undefined,\n  headerCellRender,\n  dataCellRender,\n  scrollLeft = 0\n}: TableSectionProps) => (\n  <AutoSizer>\n    {({width, height}) => {\n      const gridDimension = {\n        columnCount: columns.length,\n        columnWidth,\n        width: fixedWidth || width\n      };\n      const dataGridHeight = fixedHeight || height;\n      return (\n        <>\n          <div className={classnames('scroll-in-ui-thread', classList?.header)}>\n            <Grid\n              cellRenderer={headerCellRender}\n              {...headerGridProps}\n              {...gridDimension}\n              scrollLeft={scrollLeft}\n              onScroll={onScroll}\n            />\n          </div>\n          <div\n            className={classnames('scroll-in-ui-thread', classList?.rows)}\n            style={{\n              top: headerGridProps.height\n            }}\n          >\n            <Grid\n              cellRenderer={dataCellRender}\n              {...dataGridProps}\n              {...gridDimension}\n              className={isPinned ? 'pinned-grid' : 'body-grid'}\n              height={dataGridHeight - headerGridProps.height}\n              onScroll={onScroll}\n              scrollTop={scrollTop}\n              setGridRef={setGridRef}\n            />\n          </div>\n        </>\n      );\n    }}\n  </AutoSizer>\n);\n\nexport interface DataTableProps {\n  dataId?: string;\n  showStats?: boolean;\n  cellSizeCache?: CellSizeCache;\n  pinnedColumns?: string[];\n  columns: (string & {ghost?: boolean})[];\n  fixedWidth?: number;\n  theme?: any;\n  dataContainer: DataContainerInterface;\n  fixedHeight?: number;\n  colMeta: ColMeta;\n  sortColumn?: SortColumn;\n  sortTableColumn: (column: string, mode?: string) => void;\n  pinTableColumn: (column: string) => void;\n  copyTableColumn: (column: string) => void;\n  sortOrder?: number[] | null;\n}\n\ninterface DataTableState {\n  cellSizeCache?: CellSizeCache;\n  moreOptionsColumn?;\n  ghost?;\n}\n\nDataTableFactory.deps = [HeaderCellFactory];\nfunction DataTableFactory(HeaderCell: ReturnType<typeof HeaderCellFactory>) {\n  class DataTable extends Component<DataTableProps, DataTableState> {\n    static defaultProps = {\n      dataContainer: null,\n      pinnedColumns: [],\n      colMeta: {},\n      cellSizeCache: {},\n      sortColumn: {},\n      fixedWidth: null,\n      fixedHeight: null,\n      theme: {},\n      showStats: false\n    };\n\n    state: DataTableState = {\n      cellSizeCache: {},\n      moreOptionsColumn: null\n    };\n\n    componentDidMount() {\n      window.addEventListener('resize', this.scaleCellsToWidth);\n      this.scaleCellsToWidth();\n    }\n\n    componentDidUpdate(prevProps) {\n      if (\n        this.props.cellSizeCache !== prevProps.cellSizeCache ||\n        this.props.pinnedColumns !== prevProps.pinnedColumns\n      ) {\n        this.scaleCellsToWidth();\n      }\n    }\n\n    componentWillUnmount() {\n      window.removeEventListener('resize', this.scaleCellsToWidth);\n      // fix Warning: Can't perform a React state update on an unmounted component\n      this.setState = () => {\n        return;\n      };\n    }\n\n    root = createRef<HTMLDivElement>();\n    columns = (props: DataTableProps) => props.columns;\n    pinnedColumns = (props: DataTableProps) => props.pinnedColumns;\n    unpinnedColumns = createSelector(this.columns, this.pinnedColumns, (columns, pinnedColumns) =>\n      !Array.isArray(pinnedColumns) ? columns : columns.filter(c => !pinnedColumns.includes(c))\n    );\n\n    toggleMoreOptions = moreOptionsColumn =>\n      this.setState({\n        moreOptionsColumn:\n          this.state.moreOptionsColumn === moreOptionsColumn ? null : moreOptionsColumn\n      });\n\n    getCellSizeCache = () => {\n      const {cellSizeCache: propsCache = {}, fixedWidth, pinnedColumns = []} = this.props;\n      const unpinnedColumns = this.unpinnedColumns(this.props);\n\n      const width = fixedWidth ? fixedWidth : this.root.current ? this.root.current.clientWidth : 0;\n\n      // pin column border is 2 pixel vs 1 pixel\n      const adjustWidth = pinnedColumns.length ? width - 1 : width;\n      const {cellSizeCache, ghost} = adjustCellsToContainer(\n        adjustWidth,\n        propsCache,\n        pinnedColumns,\n        unpinnedColumns\n      ) as {cellSizeCache: {}; ghost: number | null | undefined};\n\n      return {\n        cellSizeCache,\n        ghost\n      };\n    };\n\n    doScaleCellsToWidth = () => {\n      this.setState(this.getCellSizeCache());\n    };\n\n    scaleCellsToWidth = debounce(this.doScaleCellsToWidth, 300);\n\n    renderDataCell = (columns, isPinned, props: DataTableProps) => {\n      return cellInfo => {\n        const {columnIndex, key, style, rowIndex} = cellInfo;\n        const {dataContainer, colMeta} = props;\n        const column = columns[columnIndex];\n        const isGhost = column.ghost;\n\n        const rowCell = isGhost ? '' : getRowCell({...props, column, rowIndex});\n        const type = isGhost ? null : colMeta[column].type;\n\n        const lastRowIndex = dataContainer ? dataContainer.numRows() - 1 : 0;\n\n        const endCell = columnIndex === columns.length - 1;\n        const firstCell = columnIndex === 0;\n        const bottomCell = rowIndex === lastRowIndex;\n        const alignRight = fieldToAlignRight[Number(type)];\n\n        const cell = (\n          <div\n            className={classnames('cell', {\n              [rowIndex % 2 === 0 ? 'even-row' : 'odd-row']: true,\n              [`row-${rowIndex}`]: true,\n              'pinned-cell': isPinned,\n              'first-cell': firstCell,\n              'end-cell': endCell,\n              'bottom-cell': bottomCell,\n              'align-right': alignRight\n            })}\n            key={key}\n            style={style}\n            title={isGhost ? undefined : rowCell}\n          >\n            {`${rowCell}${endCell ? '\\n' : '\\t'}`}\n          </div>\n        );\n\n        return cell;\n      };\n    };\n\n    renderHeaderCell(columns, isPinned, props, toggleMoreOptions, moreOptionsColumn) {\n      return cellInfo => (\n        <HeaderCell\n          cellInfo={cellInfo}\n          key={cellInfo.columnIndex}\n          columns={columns}\n          isPinned={isPinned}\n          props={props}\n          toggleMoreOptions={toggleMoreOptions}\n          moreOptionsColumn={moreOptionsColumn}\n        />\n      );\n    }\n    render() {\n      const {\n        dataContainer,\n        pinnedColumns = [],\n        theme = {},\n        fixedWidth,\n        fixedHeight = 0,\n        showStats\n      } = this.props;\n      const unpinnedColumns = this.unpinnedColumns(this.props);\n\n      const {cellSizeCache = {}, moreOptionsColumn, ghost} = this.state;\n      const unpinnedColumnsGhost = ghost\n        ? [...unpinnedColumns, {ghost: true} as string & {ghost: boolean}]\n        : unpinnedColumns;\n      const pinnedColumnsWidth = pinnedColumns.reduce(\n        (acc, val) => acc + (get(cellSizeCache, val, 0) as number),\n        0\n      );\n\n      const hasPinnedColumns = Boolean(pinnedColumns.length);\n      const {\n        headerRowHeight = defaultHeaderRowHeight,\n        headerRowWStatsHeight = defaultHeaderRowHeight,\n        rowHeight = defaultRowHeight\n      } = theme;\n\n      const headerGridProps = {\n        cellSizeCache,\n        className: 'header-grid',\n        height: showStats ? headerRowWStatsHeight : headerRowHeight,\n        rowCount: 1,\n        rowHeight: showStats ? headerRowWStatsHeight : headerRowHeight\n      };\n\n      const dataGridProps = {\n        cellSizeCache,\n        overscanColumnCount,\n        overscanRowCount,\n        rowCount: dataContainer ? dataContainer.numRows() : 0,\n        rowHeight\n      };\n\n      return (\n        <Container className=\"data-table-container\" ref={this.root}>\n          {Object.keys(cellSizeCache).length ? (\n            <ScrollSync>\n              {({onScroll, scrollLeft, scrollTop}) => {\n                return (\n                  <div className=\"results-table-wrapper\">\n                    {hasPinnedColumns && (\n                      <div key=\"pinned-columns\" className=\"pinned-columns grid-row\">\n                        <TableSection\n                          classList={{\n                            header: 'pinned-columns--header pinned-grid-container',\n                            rows: 'pinned-columns--rows pinned-grid-container'\n                          }}\n                          isPinned\n                          columns={pinnedColumns}\n                          headerGridProps={headerGridProps}\n                          fixedWidth={pinnedColumnsWidth}\n                          onScroll={args => onScroll({...args, scrollLeft})}\n                          scrollTop={scrollTop}\n                          dataGridProps={dataGridProps}\n                          columnWidth={columnWidthFunction(pinnedColumns, cellSizeCache)}\n                          headerCellRender={this.renderHeaderCell(\n                            pinnedColumns,\n                            true,\n                            this.props,\n                            this.toggleMoreOptions,\n                            moreOptionsColumn\n                          )}\n                          dataCellRender={this.renderDataCell(pinnedColumns, true, this.props)}\n                        />\n                      </div>\n                    )}\n                    <div\n                      key=\"unpinned-columns\"\n                      style={{\n                        marginLeft: `${hasPinnedColumns ? `${pinnedColumnsWidth}px` : '0'}`\n                      }}\n                      className=\"unpinned-columns grid-column\"\n                    >\n                      <TableSection\n                        classList={{\n                          header: 'unpinned-columns--header unpinned-grid-container',\n                          rows: 'unpinned-columns--rows unpinned-grid-container'\n                        }}\n                        isPinned={false}\n                        columns={unpinnedColumnsGhost}\n                        headerGridProps={headerGridProps}\n                        fixedWidth={fixedWidth}\n                        fixedHeight={fixedHeight}\n                        onScroll={onScroll}\n                        scrollTop={scrollTop}\n                        scrollLeft={scrollLeft}\n                        dataGridProps={dataGridProps}\n                        columnWidth={columnWidthFunction(\n                          unpinnedColumnsGhost,\n                          cellSizeCache,\n                          ghost\n                        )}\n                        headerCellRender={this.renderHeaderCell(\n                          unpinnedColumnsGhost,\n                          false,\n                          this.props,\n                          this.toggleMoreOptions,\n                          moreOptionsColumn\n                        )}\n                        dataCellRender={this.renderDataCell(\n                          unpinnedColumnsGhost,\n                          false,\n                          this.props\n                        )}\n                      />\n                    </div>\n                  </div>\n                );\n              }}\n            </ScrollSync>\n          ) : null}\n        </Container>\n      );\n    }\n  }\n\n  return withTheme(DataTable);\n}\n\nexport default DataTableFactory;\n"]}