td-stylekit 24.8.0 → 25.2.0

package/dist/es/DataGrid/components/InputCell.js

@@ -1,22 +1,52 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
-import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { jsx as ___EmotionJSX } from "@emotion/core";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _elements = require("../elements");
+
+var _reactClickOutside = _interopRequireDefault(require("react-click-outside"));
+
+var _Select = _interopRequireDefault(require("../../Select"));
+
+var _RightTruncatedText = _interopRequireDefault(require("../../RightTruncatedText"));
+
+var _TooltipPopover = _interopRequireDefault(require("../../TooltipPopover"));
+
+var _react2 = require("@emotion/react");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 if (typeof window !== "undefined" && !window.gs) window.gs = function () {};
 if (typeof window !== "undefined" && !window.gsC) window.gsC = function () {};
-
-/* eslint-disable td/instrumentation */
-// this level of fine grained instrumentation is not needed
-import React from 'react';
-import { Cell, CellBody, SelectWrapper, SymbolDropdownIcon, InlineInput } from '../elements';
-import enhanceWithClickOutside from 'react-click-outside';
-import Select from '../../Select';
-import RightTruncatedText from '../../RightTruncatedText';
-import TooltipPopover from '../../TooltipPopover';
 var TYPES = {
   NUMBER: 'number',
   SELECT: 'select',
@@ -26,14 +56,16 @@ var TYPES = {
 var InputCell = /*#__PURE__*/function (_React$Component) {
   _inherits(InputCell, _React$Component);
 
+  var _super = _createSuper(InputCell);
+
   function InputCell(props) {
     var _this;
 
     _classCallCheck(this, InputCell);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(InputCell).call(this, props));
+    _this = _super.call(this, props);
 
-    _defineProperty(_assertThisInitialized(_this), "cellRef", React.createRef());
+    _defineProperty(_assertThisInitialized(_this), "cellRef", /*#__PURE__*/_react["default"].createRef());
 
     _defineProperty(_assertThisInitialized(_this), "handleClickOutside", function (e) {
       // This hack prevents handleClickOutside from being called before onSelect
@@ -140,7 +172,7 @@ var InputCell = /*#__PURE__*/function (_React$Component) {
       switch (type) {
         case TYPES.NUMBER:
         case TYPES.TEXT:
-          input = ___EmotionJSX(InlineInput, {
+          input = (0, _react2.jsx)(_elements.InlineInput, {
             "data-gs-c": gsC(name, internalValue),
             "data-gs": gs("src", "datagrid", "components", "inline-input"),
             autoFocus: true,
@@ -156,9 +188,9 @@ var InputCell = /*#__PURE__*/function (_React$Component) {
           break;
 
         case TYPES.SELECT:
-          input = ___EmotionJSX(SelectWrapper, {
+          input = (0, _react2.jsx)(_elements.SelectWrapper, {
             "data-gs": gs("src", "datagrid", "components", "select-wrapper")
-          }, ___EmotionJSX(Select, {
+          }, (0, _react2.jsx)(_Select["default"], {
             "data-gs-c": gsC(name, value),
             "data-gs": gs("src", "datagrid", "components", "select-wrapper", "select"),
             autoFocus: true,
@@ -174,20 +206,19 @@ var InputCell = /*#__PURE__*/function (_React$Component) {
           }));
       }
 
-      var cellBody = renderInput ? input : ___EmotionJSX(CellBody, {
+      var cellBody = renderInput ? input : (0, _react2.jsx)(_elements.CellBody, {
         "data-gs": gs("src", "datagrid", "components", "cell-body"),
         rightAlign: typeof value === 'number',
         type: type
-      }, ___EmotionJSX(RightTruncatedText, {
+      }, (0, _react2.jsx)(_RightTruncatedText["default"], {
         "data-gs-c": gsC(title),
         "data-gs": gs("src", "datagrid", "components", "cell-body", "right-truncated-text"),
         text: children,
         title: title
-      }), displaySelectArrow && ___EmotionJSX(SymbolDropdownIcon, {
+      }), displaySelectArrow && (0, _react2.jsx)(_elements.SymbolDropdownIcon, {
         "data-gs": gs("src", "datagrid", "components", "cell-body", "symbol-dropdown-icon")
       }));
-
-      var cell = ___EmotionJSX(Cell, {
+      var cell = (0, _react2.jsx)(_elements.Cell, {
         "data-gs-c": gsC(cellBody),
         "data-gs": gs("src", "datagrid", "components", "cell"),
         editable: true,
@@ -203,8 +234,7 @@ var InputCell = /*#__PURE__*/function (_React$Component) {
         },
         ref: this.cellRef
       }, cellBody);
-
-      return overlay && !renderInput ? ___EmotionJSX(React.Fragment, null, ___EmotionJSX(TooltipPopover, {
+      return overlay && !renderInput ? (0, _react2.jsx)(_react["default"].Fragment, null, (0, _react2.jsx)(_TooltipPopover["default"], {
         "data-gs-c": gsC(overlay),
         "data-gs": gs("src", "datagrid", "components", "tooltip-popover"),
         interactive: false,
@@ -215,10 +245,12 @@ var InputCell = /*#__PURE__*/function (_React$Component) {
   }]);
 
   return InputCell;
-}(React.Component);
+}(_react["default"].Component);
 
 _defineProperty(InputCell, "defaultProps", {
   options: []
 });
 
-export default enhanceWithClickOutside(InputCell);
+var _default = (0, _reactClickOutside["default"])(InputCell);
+
+exports["default"] = _default;

package/dist/es/DataGrid/components/ScrollableTable.d.ts

@@ -1,6 +1,6 @@
 import React, { PureComponent } from 'react';
-import { Grid } from 'react-virtualized';
 import type { TableProps } from 'react-virtualized';
+import { ColumnProps, Grid } from 'react-virtualized';
 export declare type ScrollableTableState = {
     scrollbarWidth: number;
 };
@@ -46,12 +46,12 @@ declare class ScrollableTable extends PureComponent<TableProps, ScrollableTableS
     };
     render(): JSX.Element;
     createColumn: ({ column, columnIndex, isScrolling, parent, rowData, rowIndex }: {
-        column: any;
-        columnIndex: any;
-        isScrolling: any;
-        parent: any;
-        rowData: any;
-        rowIndex: any;
+        column: React.ReactElement<ColumnProps>;
+        columnIndex: number;
+        isScrolling: boolean;
+        parent: React.ReactElement<unknown>;
+        rowData: unknown;
+        rowIndex: number;
     }) => JSX.Element;
     createHeader: ({ column, index }: {
         column: any;

package/dist/es/DataGrid/components/ScrollableTable.js

@@ -1,27 +1,59 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
-import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { jsx as ___EmotionJSX } from "@emotion/core";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactDom = require("react-dom");
+
+var _reactVirtualized = require("react-virtualized");
+
+var _react2 = require("@emotion/react");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
 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) { _defineProperty(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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 if (typeof window !== "undefined" && !window.gs) window.gs = function () {};
 if (typeof window !== "undefined" && !window.gsC) window.gsC = function () {};
 
-/* eslint-disable td/instrumentation */
-// this level of fine grained instrumentation is not needed
-import React, { PureComponent } from 'react';
-import { Grid, ScrollSync, SortDirection, accessibilityOverscanIndicesGetter } from 'react-virtualized';
-import cx from 'classnames';
-import { findDOMNode } from 'react-dom';
-
 /**
  * This mirrors react-virtualized Table component to enable horizontal
  * scrolling. The render function is mostly copy/pasted with the only changes
@@ -42,12 +74,14 @@ import { findDOMNode } from 'react-dom';
 var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
   _inherits(ScrollableTable, _PureComponent);
 
+  var _super = _createSuper(ScrollableTable);
+
   function ScrollableTable(props) {
     var _this;
 
     _classCallCheck(this, ScrollableTable);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(ScrollableTable).call(this, props));
+    _this = _super.call(this, props);
 
     _defineProperty(_assertThisInitialized(_this), "createColumn", function (_ref) {
       var column = _ref.column,
@@ -64,12 +98,12 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
           columnData = _column$props.columnData,
           dataKey = _column$props.dataKey,
           id = _column$props.id;
-      var cellData = cellDataGetter({
+      var cellData = cellDataGetter === null || cellDataGetter === void 0 ? void 0 : cellDataGetter({
         columnData: columnData,
         dataKey: dataKey,
         rowData: rowData
       });
-      var renderedCell = cellRenderer({
+      var renderedCell = cellRenderer === null || cellRenderer === void 0 ? void 0 : cellRenderer({
         cellData: cellData,
         columnData: columnData,
         columnIndex: columnIndex,
@@ -93,13 +127,13 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
       // Since it results in an extra method call to 'babel-runtime/helpers/extends'
       // See PR https://github.com/bvaughn/react-virtualized/pull/942
 
-      return ___EmotionJSX("div", {
+      return (0, _react2.jsx)("div", {
         "data-gs-c": gsC(renderedCell, title),
         "data-gs": gs("src", "datagrid", "components", "scrollable-table", "div"),
         "aria-colindex": columnIndex + 1,
         "aria-describedby": id,
-        className: cx('ReactVirtualized__Table__rowColumn', className),
-        key: 'Row' + rowIndex + '-' + 'Col' + columnIndex,
+        className: (0, _classnames["default"])('ReactVirtualized__Table__rowColumn', className),
+        key: "Row ".concat(rowIndex, "-Col").concat(columnIndex),
         onClick: onClick,
         role: "gridcell",
         style: style,
@@ -127,11 +161,11 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
           id = _column$props2.id,
           label = _column$props2.label;
       var sortEnabled = !disableSort && sort;
-      var classNames = cx('ReactVirtualized__Table__headerColumn', headerClassName, column.props.headerClassName, {
+      var classNames = (0, _classnames["default"])('ReactVirtualized__Table__headerColumn', headerClassName, column.props.headerClassName, {
         ReactVirtualized__Table__sortableHeaderColumn: sortEnabled
       });
 
-      var style = _this.getFlexStyleForColumn(column, _objectSpread({}, headerStyle, {}, column.props.headerStyle));
+      var style = _this.getFlexStyleForColumn(column, _objectSpread(_objectSpread({}, headerStyle), column.props.headerStyle));
 
       var renderedHeader = headerRenderer({
         columnData: columnData,
@@ -148,7 +182,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
         var isFirstTimeSort = sortBy !== dataKey; // If this is the firstTime sort of this column, use the column default sort order.
         // Otherwise, invert the direction of the sort.
 
-        var newSortDirection = isFirstTimeSort ? defaultSortDirection : sortDirection === SortDirection.DESC ? SortDirection.ASC : SortDirection.DESC;
+        var newSortDirection = isFirstTimeSort ? defaultSortDirection : sortDirection === _reactVirtualized.SortDirection.DESC ? _reactVirtualized.SortDirection.ASC : _reactVirtualized.SortDirection.DESC;
 
         var onClick = function onClick(event) {
           sortEnabled && sort && sort({
@@ -176,20 +210,20 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
       }
 
       if (sortBy === dataKey) {
-        headerAriaSort = sortDirection === SortDirection.ASC ? 'ascending' : 'descending';
+        headerAriaSort = sortDirection === _reactVirtualized.SortDirection.ASC ? 'ascending' : 'descending';
       } // Avoid using object-spread syntax with multiple objects here,
       // Since it results in an extra method call to 'babel-runtime/helpers/extends'
       // See PR https://github.com/bvaughn/react-virtualized/pull/942
 
 
-      return ___EmotionJSX("div", {
+      return (0, _react2.jsx)("div", {
         "data-gs-c": gsC(renderedHeader),
         "data-gs": gs("src", "datagrid", "components", "scrollable-table", "div"),
         "aria-label": headerAriaLabel,
         "aria-sort": headerAriaSort,
         className: classNames,
         id: id,
-        key: 'Header-Col' + index,
+        key: "Header-Col".concat(index),
         onClick: headerOnClick,
         onKeyDown: headerOnKeyDown,
         role: "columnheader",
@@ -225,7 +259,8 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
       var rowData = rowGetter && rowGetter({
         index: index
       });
-      var columns = React.Children.toArray(children).map(function (column, columnIndex) {
+
+      var columns = _react["default"].Children.toArray(children).map(function (column, columnIndex) {
         return _this.createColumn({
           column: column,
           columnIndex: columnIndex,
@@ -235,9 +270,10 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
           rowIndex: index
         });
       });
-      var className = cx('ReactVirtualized__Table__row', rowClass);
 
-      var flattenedStyle = _objectSpread({}, style, {
+      var className = (0, _classnames["default"])('ReactVirtualized__Table__row', rowClass);
+
+      var flattenedStyle = _objectSpread(_objectSpread({}, style), {}, {
         height: _this.getRowHeight(index),
         overflow: 'hidden',
         paddingRight: scrollbarWidth
@@ -263,7 +299,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
       var customStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var flexValue = "".concat(column.props.flexGrow, " ").concat(column.props.flexShrink, " ").concat(column.props.width, "px");
 
-      var style = _objectSpread({}, customStyle, {
+      var style = _objectSpread(_objectSpread({}, customStyle), {}, {
         flex: flexValue,
         msFlex: flexValue,
         WebkitFlex: flexValue,
@@ -286,7 +322,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
       var _this$props3 = _this.props,
           children = _this$props3.children,
           disableHeader = _this$props3.disableHeader;
-      var items = disableHeader ? [] : React.Children.toArray(children);
+      var items = disableHeader ? [] : _react["default"].Children.toArray(children);
       return items.map(function (column, index) {
         return _this.createHeader({
           column: column,
@@ -388,36 +424,38 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
       }) : rowStyle; // Precompute and cache column styles before rendering rows and columns to speed things up
 
       this._cachedColumnStyles = [];
-      React.Children.toArray(children).forEach(function (column, index) {
-        var columnProps = React.isValidElement(column) && column.props;
+
+      _react["default"].Children.toArray(children).forEach(function (column, index) {
+        var columnProps = /*#__PURE__*/_react["default"].isValidElement(column) && column.props;
 
         var flexStyles = _this2.getFlexStyleForColumn(column, columnProps.style);
 
-        _this2._cachedColumnStyles[index] = _objectSpread({}, flexStyles, {
+        _this2._cachedColumnStyles[index] = _objectSpread(_objectSpread({}, flexStyles), {}, {
           overflow: 'hidden'
         });
       });
+
       var innerWidth = scrollWidth && scrollWidth > width ? scrollWidth : width; // Note that we specify :rowCount, :scrollbarWidth, :sortBy, and :sortDirection as properties on Grid even though these have nothing to do with Grid.
       // This is done because Grid is a pure component and won't update unless its properties or state has changed.
       // Any property that should trigger a re-render of Grid then is specified here to avoid a stale display.
 
-      return ___EmotionJSX("div", {
+      return (0, _react2.jsx)("div", {
         "data-gs": gs("src", "datagrid", "components", "div"),
         "aria-label": this.props['aria-label'],
         "aria-labelledby": this.props['aria-labelledby'],
-        "aria-colcount": React.Children.toArray(children).length,
+        "aria-colcount": _react["default"].Children.toArray(children).length,
         "aria-rowcount": this.props.rowCount,
-        className: cx('ReactVirtualized__Table', className),
+        className: (0, _classnames["default"])('ReactVirtualized__Table', className),
         id: id,
         role: "grid",
         style: style
-      }, ___EmotionJSX(ScrollSync, {
+      }, (0, _react2.jsx)(_reactVirtualized.ScrollSync, {
         "data-gs-c": gsC(function (_ref6) {
           var _onScroll = _ref6.onScroll,
               scrollLeft = _ref6.scrollLeft;
-          return ___EmotionJSX(React.Fragment, null, ___EmotionJSX("div", {
+          return (0, _react2.jsx)(_react["default"].Fragment, null, (0, _react2.jsx)("div", {
             "data-gs-c": gsC(!disableHeader && headerRowRenderer && headerRowRenderer({
-              className: cx('ReactVirtualized__Table__headerRow', rowClass),
+              className: (0, _classnames["default"])('ReactVirtualized__Table__headerRow', rowClass),
               columns: _this2.getHeaderColumns(),
               style: _objectSpread({
                 height: headerHeight,
@@ -434,7 +472,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
               overflow: 'hidden'
             }
           }, !disableHeader && headerRowRenderer && headerRowRenderer({
-            className: cx('ReactVirtualized__Table__headerRow', rowClass),
+            className: (0, _classnames["default"])('ReactVirtualized__Table__headerRow', rowClass),
             columns: _this2.getHeaderColumns(),
             style: _objectSpread({
               height: headerHeight,
@@ -444,10 +482,10 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
               left: -scrollLeft,
               position: 'relative'
             }, rowStyleObject)
-          })), ___EmotionJSX(Grid, _extends({
+          })), (0, _react2.jsx)(_reactVirtualized.Grid, _extends({
             "data-gs": gs("src", "datagrid", "components", "div", "scroll-sync", "grid")
           }, _this2.props, {
-            className: cx('ReactVirtualized__Table__Grid', gridClassName),
+            className: (0, _classnames["default"])('ReactVirtualized__Table__Grid', gridClassName),
             cellRenderer: _this2.createRow,
             columnWidth: innerWidth,
             columnCount: 1,
@@ -464,7 +502,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
             role: "rowgroup",
             scrollbarWidth: scrollbarWidth,
             scrollToRow: scrollToIndex,
-            style: _objectSpread({}, gridStyle, {
+            style: _objectSpread(_objectSpread({}, gridStyle), {}, {
               overflow: 'auto'
             })
           })));
@@ -473,9 +511,9 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
       }, function (_ref6) {
         var _onScroll = _ref6.onScroll,
             scrollLeft = _ref6.scrollLeft;
-        return ___EmotionJSX(React.Fragment, null, ___EmotionJSX("div", {
+        return (0, _react2.jsx)(_react["default"].Fragment, null, (0, _react2.jsx)("div", {
           "data-gs-c": gsC(!disableHeader && headerRowRenderer && headerRowRenderer({
-            className: cx('ReactVirtualized__Table__headerRow', rowClass),
+            className: (0, _classnames["default"])('ReactVirtualized__Table__headerRow', rowClass),
             columns: _this2.getHeaderColumns(),
             style: _objectSpread({
               height: headerHeight,
@@ -492,7 +530,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
             overflow: 'hidden'
           }
         }, !disableHeader && headerRowRenderer && headerRowRenderer({
-          className: cx('ReactVirtualized__Table__headerRow', rowClass),
+          className: (0, _classnames["default"])('ReactVirtualized__Table__headerRow', rowClass),
           columns: _this2.getHeaderColumns(),
           style: _objectSpread({
             height: headerHeight,
@@ -502,10 +540,10 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
             left: -scrollLeft,
             position: 'relative'
           }, rowStyleObject)
-        })), ___EmotionJSX(Grid, _extends({
+        })), (0, _react2.jsx)(_reactVirtualized.Grid, _extends({
           "data-gs": gs("src", "datagrid", "components", "div", "scroll-sync", "grid")
         }, _this2.props, {
-          className: cx('ReactVirtualized__Table__Grid', gridClassName),
+          className: (0, _classnames["default"])('ReactVirtualized__Table__Grid', gridClassName),
           cellRenderer: _this2.createRow,
           columnWidth: innerWidth,
           columnCount: 1,
@@ -522,7 +560,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
           role: "rowgroup",
           scrollbarWidth: scrollbarWidth,
           scrollToRow: scrollToIndex,
-          style: _objectSpread({}, gridStyle, {
+          style: _objectSpread(_objectSpread({}, gridStyle), {}, {
             overflow: 'auto'
           })
         })));
@@ -533,7 +571,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
     value: function getScrollbarWidth() {
       if (this.Grid) {
         // eslint-disable-next-line react/no-find-dom-node
-        var _Grid = findDOMNode(this.Grid);
+        var _Grid = (0, _reactDom.findDOMNode)(this.Grid);
 
         var clientWidth = _Grid && _Grid.clientWidth || 0;
         var offsetWidth = _Grid && _Grid.offsetWidth || 0;
@@ -545,7 +583,7 @@ var ScrollableTable = /*#__PURE__*/function (_PureComponent) {
   }]);
 
   return ScrollableTable;
-}(PureComponent);
+}(_react.PureComponent);
 
 _defineProperty(ScrollableTable, "defaultProps", {
   disableHeader: false,
@@ -561,7 +599,7 @@ _defineProperty(ScrollableTable, "defaultProps", {
   onScroll: function onScroll() {
     return null;
   },
-  overscanIndicesGetter: accessibilityOverscanIndicesGetter,
+  overscanIndicesGetter: _reactVirtualized.accessibilityOverscanIndicesGetter,
   overscanRowCount: 10,
   rowStyle: {},
   scrollToAlignment: 'auto',
@@ -569,4 +607,5 @@ _defineProperty(ScrollableTable, "defaultProps", {
   style: {}
 });
 
-export default ScrollableTable;
+var _default = ScrollableTable;
+exports["default"] = _default;

package/dist/es/DataGrid/components/index.js

@@ -1,10 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BasicColumn", {
+  enumerable: true,
+  get: function get() {
+    return _BasicColumn["default"];
+  }
+});
+Object.defineProperty(exports, "CategoryFilter", {
+  enumerable: true,
+  get: function get() {
+    return _CategoryFilter["default"];
+  }
+});
+Object.defineProperty(exports, "CollapsibleCell", {
+  enumerable: true,
+  get: function get() {
+    return _CollapsibleCell["default"];
+  }
+});
+Object.defineProperty(exports, "ColumnHeader", {
+  enumerable: true,
+  get: function get() {
+    return _ColumnHeader["default"];
+  }
+});
+Object.defineProperty(exports, "ColumnHeaderActions", {
+  enumerable: true,
+  get: function get() {
+    return _ColumnHeaderActions["default"];
+  }
+});
+Object.defineProperty(exports, "FocusableRow", {
+  enumerable: true,
+  get: function get() {
+    return _FocusableRow["default"];
+  }
+});
+Object.defineProperty(exports, "InputCell", {
+  enumerable: true,
+  get: function get() {
+    return _InputCell["default"];
+  }
+});
+Object.defineProperty(exports, "ScrollableTable", {
+  enumerable: true,
+  get: function get() {
+    return _ScrollableTable["default"];
+  }
+});
+
+var _BasicColumn = _interopRequireDefault(require("./BasicColumn"));
+
+var _ColumnHeader = _interopRequireDefault(require("./ColumnHeader"));
+
+var _FocusableRow = _interopRequireDefault(require("./FocusableRow"));
+
+var _ColumnHeaderActions = _interopRequireDefault(require("./ColumnHeaderActions"));
+
+var _InputCell = _interopRequireDefault(require("./InputCell"));
+
+var _CollapsibleCell = _interopRequireDefault(require("./CollapsibleCell"));
+
+var _CategoryFilter = _interopRequireDefault(require("./CategoryFilter"));
+
+var _ScrollableTable = _interopRequireDefault(require("./ScrollableTable"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
 if (typeof window !== "undefined" && !window.gs) window.gs = function () {};
-if (typeof window !== "undefined" && !window.gsC) window.gsC = function () {};
-export { default as BasicColumn } from './BasicColumn';
-export { default as ColumnHeader } from './ColumnHeader';
-export { default as FocusableRow } from './FocusableRow';
-export { default as ColumnHeaderActions } from './ColumnHeaderActions';
-export { default as InputCell } from './InputCell';
-export { default as CollapsibleCell } from './CollapsibleCell';
-export { default as CategoryFilter } from './CategoryFilter';
-export { default as ScrollableTable } from './ScrollableTable';
+if (typeof window !== "undefined" && !window.gsC) window.gsC = function () {};