@elliemae/ds-datagrids 1.61.0 → 2.0.0-alpha.12

package/esm/plugins/sortable/checkIfSortable.js

@@ -1,9 +1,9 @@
 /* eslint-disable no-plusplus */
 
 /* eslint-disable no-loops/no-loops */
-var checkIfSortable = function checkIfSortable(column, rows) {
-  for (var index = 0; index < rows.length; index++) {
-    var element = rows[index][column];
+const checkIfSortable = (column, rows) => {
+  for (let index = 0; index < rows.length; index++) {
+    const element = rows[index][column];
 
     if (!(element === null || element === undefined)) {
       // PUI-6452
@@ -15,4 +15,3 @@ var checkIfSortable = function checkIfSortable(column, rows) {
 };
 
 export { checkIfSortable, checkIfSortable as default };
-//# sourceMappingURL=checkIfSortable.js.map

package/esm/plugins/sortable/index.js

@@ -1,18 +1 @@
 export { SortablePlugin } from './SortablePlugin.js';
-import 'sortabular';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-shared/useDataGrid/initColumnDefinition';
-import '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
-import './sortHeaderFormatter.js';
-import 'react';
-import '@elliemae/ds-classnames';
-import '@elliemae/ds-icons';
-import './useSortableState.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import 'sortabular/dist';
-import './checkIfSortable.js';
-import './sorter.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import 'moment';
-//# sourceMappingURL=index.js.map

package/esm/plugins/sortable/sortHeaderFormatter.js

@@ -1,49 +1,53 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
 import React from 'react';
 import { aggregatedClasses } from '@elliemae/ds-classnames';
 import { ArrowheadUp, ArrowheadDown } from '@elliemae/ds-icons';
 
-var blockName = 'data-grid-sort-header';
-var SortHeaderContainer = aggregatedClasses('div')(blockName);
-var iconColor = ['brand-primary', 800];
-var SortHeader = /*#__PURE__*/React.memo(function (_ref) {
-  var value = _ref.value,
-      onClick = _ref.onClick,
-      sortState = _ref.sortState;
-  var sortIndicator = sortState === 'asc' ? /*#__PURE__*/React.createElement(ArrowheadUp, {
+var _ArrowheadUp, _ArrowheadDown;
+const blockName = 'data-grid-sort-header';
+const SortHeaderContainer = aggregatedClasses('div')(blockName);
+const iconColor = ['brand-primary', 800];
+const SortHeader = /*#__PURE__*/React.memo(_ref => {
+  let {
+    value,
+    onClick,
+    sortState
+  } = _ref;
+  const sortIndicator = sortState === 'asc' ? _ArrowheadUp || (_ArrowheadUp = /*#__PURE__*/_jsx(ArrowheadUp, {
     color: iconColor
-  }) : /*#__PURE__*/React.createElement(ArrowheadDown, {
+  })) : _ArrowheadDown || (_ArrowheadDown = /*#__PURE__*/_jsx(ArrowheadDown, {
     color: iconColor
-  });
-  return /*#__PURE__*/React.createElement(SortHeaderContainer, {
+  }));
+  return /*#__PURE__*/_jsx(SortHeaderContainer, {
     onClick: onClick
-  }, /*#__PURE__*/React.createElement("span", {
+  }, void 0, /*#__PURE__*/_jsx("span", {
     className: "header-value"
-  }, value), sortState && sortIndicator);
+  }, void 0, value), sortState && sortIndicator);
 });
 
-var sortHeaderFormatter = function sortHeaderFormatter(sortable, grid) {
-  return function (value, _ref2) {
-    var columnIndex = _ref2.columnIndex,
-        property = _ref2.property;
-
-    var _grid$getInstance = grid.getInstance(),
-        sortingColumns = _grid$getInstance.state.sortingColumns;
-
-    var _sortable = sortable(value, {
-      columnIndex: columnIndex,
-      property: property
-    }),
-        onClick = _sortable.onClick,
-        className = _sortable.className;
-
-    return /*#__PURE__*/React.createElement(SortHeader, {
-      className: className,
-      onClick: onClick,
-      sortState: sortingColumns[property] && sortingColumns[property].direction,
-      value: value
-    });
-  };
+const sortHeaderFormatter = (sortable, grid) => (value, _ref2) => {
+  let {
+    columnIndex,
+    property
+  } = _ref2;
+  const {
+    state: {
+      sortingColumns
+    }
+  } = grid.getInstance();
+  const {
+    onClick,
+    className
+  } = sortable(value, {
+    columnIndex,
+    property
+  });
+  return /*#__PURE__*/_jsx(SortHeader, {
+    className: className,
+    onClick: onClick,
+    sortState: sortingColumns[property] && sortingColumns[property].direction,
+    value: value
+  });
 };
 
 export { sortHeaderFormatter as default };
-//# sourceMappingURL=sortHeaderFormatter.js.map

package/esm/plugins/sortable/sortTree.js

@@ -1,24 +1,26 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import * as sortabular from 'sortabular';
 
 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; }
 
-var deepSorting = function deepSorting(sortConfig) {
-  var rows = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-  return sortabular.sorter(sortConfig)(rows.map(function (row) {
-    return row.children && row.children.length ? _objectSpread(_objectSpread({}, row), {}, {
-      children: deepSorting(sortConfig, row.children)
-    }) : row;
-  }));
+const deepSorting = function (sortConfig) {
+  let rows = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return sortabular.sorter(sortConfig)(rows.map(row => row.children && row.children.length ? _objectSpread(_objectSpread({}, row), {}, {
+    children: deepSorting(sortConfig, row.children)
+  }) : row));
 };
 
 function sortTree(sortConfig) {
-  return function (rows) {
-    return deepSorting(sortConfig, rows);
-  };
+  return rows => deepSorting(sortConfig, rows);
 }
 
 export { sortTree as default };
-//# sourceMappingURL=sortTree.js.map

package/esm/plugins/sortable/sorter.js

@@ -1,19 +1,30 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.some.js';
+import 'core-js/modules/esnext.iterator.some.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
 import { get } from '@elliemae/ds-utilities';
 import moment from 'moment';
 
 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; }
-var sorter = function sorter() {
-  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-      columns = _ref.columns,
-      sortingColumns = _ref.sortingColumns,
-      sort = _ref.sort,
-      emptyLast = _ref.emptyLast;
-
-  return function (data) {
+const sorter = function () {
+  let {
+    columns,
+    sortingColumns,
+    sort,
+    emptyLast
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return data => {
     if (!columns) {
       throw new Error('sort.sorter - Missing "columns" argument!');
     }
@@ -26,40 +37,32 @@ var sorter = function sorter() {
       return data;
     }
 
-    var columnIndexList = new Array(sortingColumns.length);
-    var orderList = new Array(sortingColumns.length);
-    var actualSortFunction = sort;
+    const columnIndexList = new Array(sortingColumns.length);
+    const orderList = new Array(sortingColumns.length);
+    let actualSortFunction = sort;
 
     if (emptyLast) {
-      actualSortFunction = function actualSortFunction(innerData, innerColumnIndexList, innerOrderList) {
-        var sortedData = sort(innerData, innerColumnIndexList, innerOrderList);
-        var keys = Object.keys(sortingColumns);
-        var withData = sortedData.filter(function (r) {
-          return keys.some(function (key) {
-            return !!r[key];
-          });
-        });
-        var withoutData = sortedData.filter(function (r) {
-          return keys.some(function (key) {
-            return !r[key];
-          });
-        });
-        return [].concat(_toConsumableArray(withData), _toConsumableArray(withoutData));
+      actualSortFunction = (innerData, innerColumnIndexList, innerOrderList) => {
+        const sortedData = sort(innerData, innerColumnIndexList, innerOrderList);
+        const keys = Object.keys(sortingColumns);
+        const withData = sortedData.filter(r => keys.some(key => !!r[key]));
+        const withoutData = sortedData.filter(r => keys.some(key => !r[key]));
+        return [...withData, ...withoutData];
       };
     }
 
-    Object.keys(sortingColumns).forEach(function (sortingColumnKey) {
-      var realColumn = columns.find(function (column) {
-        return column.property === sortingColumnKey;
-      });
+    Object.keys(sortingColumns).forEach(sortingColumnKey => {
+      const realColumn = columns.find(column => column.property === sortingColumnKey);
       if (!realColumn) return;
 
-      var columnSorter = realColumn.sort || function resolveValue(row) {
-        var property = realColumn.property,
-            sortBy = realColumn.sortBy;
-        var value = row[sortBy || property]; // Pick resolved value by convention
+      const columnSorter = realColumn.sort || function resolveValue(row) {
+        const {
+          property,
+          sortBy
+        } = realColumn;
+        const value = row[sortBy || property]; // Pick resolved value by convention
 
-        var resolvedValue = get(row, "_".concat(property), value);
+        const resolvedValue = get(row, "_".concat(property), value);
 
         if (realColumn.type === 'DateTime') {
           return moment(resolvedValue);
@@ -68,21 +71,21 @@ var sorter = function sorter() {
         return typeof resolvedValue === 'string' ? resolvedValue.toLowerCase() : resolvedValue;
       };
 
-      var sortingColumn = sortingColumns[sortingColumnKey];
+      const sortingColumn = sortingColumns[sortingColumnKey];
       columnIndexList[sortingColumn.position] = columnSorter;
       orderList[sortingColumn.position] = sortingColumn.direction;
     });
     return actualSortFunction(data, columnIndexList, orderList);
   };
 };
-var sorterGroups = function sorterGroups() {
-  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-      columns = _ref2.columns,
-      sortingColumns = _ref2.sortingColumns,
-      sort = _ref2.sort,
-      emptyLast = _ref2.emptyLast;
-
-  return function (data, rowsData) {
+const sorterGroups = function () {
+  let {
+    columns,
+    sortingColumns,
+    sort,
+    emptyLast
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (data, rowsData) => {
     if (!columns) {
       throw new Error('sort.sorter - Missing "columns" argument!');
     }
@@ -95,40 +98,32 @@ var sorterGroups = function sorterGroups() {
       return data;
     }
 
-    var columnIndexList = new Array(sortingColumns.length);
-    var orderList = new Array(sortingColumns.length);
-    var actualSortFunction = sort;
+    const columnIndexList = new Array(sortingColumns.length);
+    const orderList = new Array(sortingColumns.length);
+    let actualSortFunction = sort;
 
     if (emptyLast) {
-      actualSortFunction = function actualSortFunction(innerData, innerColumnIndexList, innerOrderList) {
-        var sortedData = sort(innerData, innerColumnIndexList, innerOrderList);
-        var keys = Object.keys(sortingColumns);
-        var withData = sortedData.filter(function (r) {
-          return keys.some(function (key) {
-            return !!r[key];
-          });
-        });
-        var withoutData = sortedData.filter(function (r) {
-          return keys.some(function (key) {
-            return !r[key];
-          });
-        });
-        return [].concat(_toConsumableArray(withData), _toConsumableArray(withoutData));
+      actualSortFunction = (innerData, innerColumnIndexList, innerOrderList) => {
+        const sortedData = sort(innerData, innerColumnIndexList, innerOrderList);
+        const keys = Object.keys(sortingColumns);
+        const withData = sortedData.filter(r => keys.some(key => !!r[key]));
+        const withoutData = sortedData.filter(r => keys.some(key => !r[key]));
+        return [...withData, ...withoutData];
       };
     }
 
-    Object.keys(sortingColumns).forEach(function (sortingColumnKey) {
-      var realColumn = columns.find(function (column) {
-        return column.property === sortingColumnKey;
-      });
+    Object.keys(sortingColumns).forEach(sortingColumnKey => {
+      const realColumn = columns.find(column => column.property === sortingColumnKey);
       if (!realColumn) return;
 
-      var columnSorter = realColumn.sort || function resolveValue(row) {
-        var property = realColumn.property,
-            sortBy = realColumn.sortBy;
-        var value = row[sortBy || property]; // Pick resolved value by convention
+      const columnSorter = realColumn.sort || function resolveValue(row) {
+        const {
+          property,
+          sortBy
+        } = realColumn;
+        const value = row[sortBy || property]; // Pick resolved value by convention
 
-        var resolvedValue = get(row, "_".concat(property), value);
+        const resolvedValue = get(row, "_".concat(property), value);
 
         if (realColumn.type === 'DateTime') {
           return moment(resolvedValue);
@@ -137,36 +132,30 @@ var sorterGroups = function sorterGroups() {
         return typeof resolvedValue === 'string' ? resolvedValue.toLowerCase() : resolvedValue;
       };
 
-      var sortingColumn = sortingColumns[sortingColumnKey];
+      const sortingColumn = sortingColumns[sortingColumnKey];
       columnIndexList[sortingColumn.position] = columnSorter;
       orderList[sortingColumn.position] = sortingColumn.direction;
     });
-    var groups = {};
-    var preserveData = {};
-    data.forEach(function (c) {
+    const groups = {};
+    const preserveData = {};
+    data.forEach(c => {
       preserveData[c.id] = _objectSpread({}, c);
     });
-    rowsData.forEach(function (group) {
+    rowsData.forEach(group => {
       groups[group.id] = {
-        children: actualSortFunction(group.children.map(function (c) {
-          return _objectSpread({
-            parentNode: preserveData[c.id].parentNode,
-            data: c
-          }, c);
-        }), columnIndexList, orderList) // sort internally
+        children: actualSortFunction(group.children.map(c => _objectSpread({
+          parentNode: preserveData[c.id].parentNode,
+          data: c
+        }, c)), columnIndexList, orderList) // sort internally
 
       };
     });
-    var sorted = actualSortFunction(data.map(function (r) {
-      return _objectSpread(_objectSpread({}, r.data), r);
-    }), columnIndexList, orderList); // sort global
-
-    var ssortGlobal = [];
-    sorted.filter(function (s) {
-      return !s.isGroup;
-    }).forEach(function (sr) {
+    const sorted = actualSortFunction(data.map(r => _objectSpread(_objectSpread({}, r.data), r)), columnIndexList, orderList); // sort global
+
+    let ssortGlobal = [];
+    sorted.filter(s => !s.isGroup).forEach(sr => {
       if (groups[sr.parentNode.id]) {
-        ssortGlobal = [].concat(_toConsumableArray(ssortGlobal), [preserveData[sr.parentNode.id]], _toConsumableArray(groups[sr.parentNode.id].children));
+        ssortGlobal = [...ssortGlobal, preserveData[sr.parentNode.id], ...groups[sr.parentNode.id].children];
         delete groups[sr.parentNode.id];
       }
     });
@@ -175,4 +164,3 @@ var sorterGroups = function sorterGroups() {
 };
 
 export { sorter, sorterGroups };
-//# sourceMappingURL=sorter.js.map

package/esm/plugins/sortable/useSortableState.js

@@ -1,52 +1,54 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
-import * as sortabular from 'sortabular/dist';
-import { useDerivedStateFromProps } from '@elliemae/ds-utilities';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import * as sortabular from 'sortabular/dist/index.js';
+import useDerivedStateFromProps from '@elliemae/ds-utilities/hooks/useDerivedStateFromProps';
 import { checkIfSortable } from './checkIfSortable.js';
 
 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 useSortableState(grid) {
-  var _grid$props = grid.props,
-      onSort = _grid$props.onSort,
-      sortingColumnsProp = _grid$props.sortingColumns,
-      pagination = _grid$props.pagination;
+  const {
+    onSort,
+    sortingColumns: sortingColumnsProp,
+    pagination
+  } = grid.props;
+  const [sortingColumns, setSortingColumns] = useDerivedStateFromProps(sortingColumnsProp);
 
-  var _useDerivedStateFromP = useDerivedStateFromProps(sortingColumnsProp),
-      _useDerivedStateFromP2 = _slicedToArray(_useDerivedStateFromP, 2),
-      sortingColumns = _useDerivedStateFromP2[0],
-      setSortingColumns = _useDerivedStateFromP2[1];
-
-  var handleSort = function handleSort(selectedColumn) {
+  const handleSort = selectedColumn => {
     // support for pagination
-    var _grid$getInstance = grid.getInstance(),
-        _grid$getInstance$com = _grid$getInstance.composedRows,
-        composedRows = _grid$getInstance$com === void 0 ? {} : _grid$getInstance$com,
-        props = _grid$getInstance.props;
-
-    var allRows = composedRows.allRows,
-        rows = composedRows.rows;
-    var serverSidePagination = pagination && composedRows.amount !== (composedRows.rows && composedRows.rows.length);
+    const {
+      composedRows = {},
+      props
+    } = grid.getInstance();
+    const {
+      allRows,
+      rows
+    } = composedRows;
+    const serverSidePagination = pagination && composedRows.amount !== (composedRows.rows && composedRows.rows.length);
 
     if (props.serverSideData || serverSidePagination || checkIfSortable(selectedColumn, allRows || rows || composedRows)) {
-      setSortingColumns(function (prevSortingColumns) {
-        var nextSortingColumns = sortabular.byColumn({
+      setSortingColumns(prevSortingColumns => {
+        const nextSortingColumns = sortabular.byColumn({
           sortingColumns: prevSortingColumns,
           sortingOrder: {
             FIRST: 'asc',
             asc: 'desc',
             desc: 'asc'
           },
-          selectedColumn: selectedColumn
-        });
-
-        var _grid$getInstance2 = grid.getInstance(),
-            columns = _grid$getInstance2.columns;
-
-        var columnSorted = columns.find(function (col) {
-          return col.property === selectedColumn;
+          selectedColumn
         });
+        const {
+          columns
+        } = grid.getInstance();
+        let columnSorted = columns.find(col => col.property === selectedColumn);
         columnSorted = _objectSpread(_objectSpread({}, columnSorted), {}, {
           originalProperty: columnSorted.property
         });
@@ -58,7 +60,7 @@ function useSortableState(grid) {
 
   return {
     state: {
-      sortingColumns: sortingColumns
+      sortingColumns
     },
     actions: {
       sort: handleSort
@@ -67,4 +69,3 @@ function useSortableState(grid) {
 }
 
 export { useSortableState };
-//# sourceMappingURL=useSortableState.js.map

package/esm/plugins/toolbar/RowRenderer.js

@@ -1,52 +1,45 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
-import React, { useRef, useState, useEffect } from 'react';
-import PropTypes from 'prop-types';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useRef, useState, useEffect } from 'react';
 import { isEmpty } from 'lodash';
 import { omit } from '@elliemae/ds-utilities';
 import { ToolbarTrigger } from './ToolbarTrigger.js';
 import { RowSizes } from '../../rowSizes.js';
-import 'styled-components';
-import '@elliemae/ds-button';
-import '@elliemae/ds-icons';
+import { jsx } from 'react/jsx-runtime';
 
 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; }
-var RowRenderer = function RowRenderer(Row, grid) {
-  var Wrapped = function Wrapped(props) {
-    var ref = useRef();
-    var _props$rowData = props.rowData,
-        rowData = _props$rowData === void 0 ? {} : _props$rowData,
-        index = props.index,
-        rowIndex = props.rowIndex,
-        style = props.style;
-
-    var _grid$getInstance = grid.getInstance(),
-        wrapText = _grid$getInstance.props.wrapText;
-
-    var _useState = useState({}),
-        _useState2 = _slicedToArray(_useState, 2),
-        popStyle = _useState2[0],
-        setPopStyle = _useState2[1];
-
-    var _useState3 = useState(style),
-        _useState4 = _slicedToArray(_useState3, 2),
-        rowStyle = _useState4[0],
-        setRowStyle = _useState4[1];
-
-    var gridInstance = grid.getInstance();
-    var refs = gridInstance.refs,
-        isRowDragging = gridInstance.isRowDragging;
-
-    var _useState5 = useState(refs.body.current && refs.body.current.offsetWidth > refs.body.current.clientWidth),
-        _useState6 = _slicedToArray(_useState5, 2),
-        hasVerticalScrollBar = _useState6[0],
-        setHasVerticalScrollBar = _useState6[1];
-
-    useEffect(function () {
-      var shouldOmit = isRowDragging ? ['top'] : [];
+const RowRenderer = (Row, grid) => {
+  const Wrapped = props => {
+    const ref = useRef();
+    const {
+      rowData = {},
+      index,
+      rowIndex,
+      style
+    } = props;
+    const {
+      props: {
+        wrapText
+      }
+    } = grid.getInstance();
+    const [popStyle, setPopStyle] = useState({});
+    const [rowStyle, setRowStyle] = useState(style);
+    const gridInstance = grid.getInstance();
+    const {
+      refs,
+      isRowDragging
+    } = gridInstance;
+    const [hasVerticalScrollBar, setHasVerticalScrollBar] = useState(refs.body.current && refs.body.current.offsetWidth > refs.body.current.clientWidth);
+    useEffect(() => {
+      const shouldOmit = isRowDragging ? ['top'] : [];
       setPopStyle(_objectSpread(_objectSpread({}, popStyle), {
         top: style && !isRowDragging ? style.top : '0'
       }));
@@ -63,40 +56,33 @@ var RowRenderer = function RowRenderer(Row, grid) {
         position: 'relative'
       }, [shouldOmit]));
     }, [style, isRowDragging]);
-    return /*#__PURE__*/React.createElement("div", {
+    return /*#__PURE__*/_jsx("div", {
       className: "row-renderer-fixed-height",
       style: {
         height: !wrapText ? RowSizes[gridInstance.props.rowSize] : 'auto',
         position: style ? 'auto' : 'relative' // top: isDragging ? rowStyle.top - RowSizes[gridInstance.props.rowSize] : 'auto',
 
       }
-    }, /*#__PURE__*/React.createElement(Row, _extends({
+    }, void 0, /*#__PURE__*/jsx(Row, _objectSpread(_objectSpread({
       ref: ref
-    }, props, {
+    }, props), {}, {
       style: rowStyle
-    })), isEmpty(rowData) && !rowData.index && !rowData.rowIndex ? null : /*#__PURE__*/React.createElement("div", {
+    })), isEmpty(rowData) && !rowData.index && !rowData.rowIndex ? null : /*#__PURE__*/_jsx("div", {
       className: "toolbar-trigger-container ".concat(style ? 'move' : 'stay'),
       style: _objectSpread({}, popStyle)
-    }, /*#__PURE__*/React.createElement(ToolbarTrigger, {
+    }, void 0, /*#__PURE__*/_jsx(ToolbarTrigger, {
       grid: grid,
       rowData: {
-        rowData: rowData,
-        index: index,
-        rowIndex: rowIndex
+        rowData,
+        index,
+        rowIndex
       },
       hasScrollBar: hasVerticalScrollBar,
       rowRef: ref
     })));
   };
 
-  Wrapped.propTypes = {
-    rowData: PropTypes.any,
-    index: PropTypes.number,
-    rowIndex: PropTypes.number,
-    style: PropTypes.any
-  };
   return Wrapped;
 };
 
 export { RowRenderer };
-//# sourceMappingURL=RowRenderer.js.map