@elliemae/ds-data-table 2.0.0-alpha.1 → 2.0.0-alpha.13

package/esm/parts/Headers/HeaderResizer.js

@@ -1,38 +1,47 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/web.dom-collections.iterator.js';
+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 { useContext, useState, useMemo, useEffect, useRef, useCallback } from 'react';
 import { ColsLayoutStyle } from '../../configs/constants.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
 import 'react-virtual';
 import { columnsToGrid } from '../../helpers/columnsToGrid.js';
 import '../../configs/useRowFlattenization.js';
 import '@babel/runtime/helpers/esm/jsx';
-import '@elliemae/ds-icons/ArrowShortReturn';
-import 'styled-components';
 import '@elliemae/ds-icons';
+import 'styled-components';
 import { StyledResizer } from '../../styled.js';
 import { jsx } from 'react/jsx-runtime';
-import '@elliemae/ds-form/Checkbox';
-import '@elliemae/ds-form/Radio';
+import '@elliemae/ds-form';
 import '../TableContent.js';
 import '@elliemae/ds-grid';
 import '@elliemae/ds-circular-progress-indicator';
-import '@elliemae/ds-icons/WarningTriangle';
 import '@elliemae/ds-system';
 import '@elliemae/ds-button';
 import DataTableContext from '../../DataTableContext.js';
 import '../Row.js';
 import '../Footer.js';
-import '@elliemae/ds-icons/GripperVertical';
 import '../HoC/SortableItemContext.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; }
 
-const narrow = (value, min, max) => Math.min(Math.max(value, min ?? 30), max ?? Infinity);
+const narrow = (value, min, max) => Math.min(Math.max(value, min !== null && min !== void 0 ? min : 30), max !== null && max !== void 0 ? max : Infinity);
+
+const HeaderResizer = _ref => {
+  var _column$width;
 
-const HeaderResizer = ({
-  column
-}) => {
+  let {
+    column
+  } = _ref;
   const {
     layoutHelpers: {
       setGridLayout
@@ -43,7 +52,7 @@ const HeaderResizer = ({
     }
   } = useContext(DataTableContext);
   const [isResizing, setIsResizing] = useState(false);
-  const [nextWidth, setNextWidth] = useState(column.width ?? 150);
+  const [nextWidth, setNextWidth] = useState((_column$width = column.width) !== null && _column$width !== void 0 ? _column$width : 150);
   const visibleColumnsCopy = useMemo(() => visibleColumns.map(col => _objectSpread({}, col)), [visibleColumns]);
   useEffect(() => {
     const realColumnIndex = visibleColumnsCopy.findIndex(visibleColumn => visibleColumn.id === column.id);

package/esm/parts/Headers/index.js

@@ -1,9 +1,11 @@
 import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
 import { useContext, useMemo } from 'react';
 import { StyledHeadTr, StyledHeadWrapper } from '../../styled.js';
 import DataTableContext from '../../DataTableContext.js';
 import { withConditionalDnDColumnContext } from '../HoC/withConditionalDnDColumnContext.js';
-import { HeaderCellGroup } from './HeaderCellGroup.js';
+import HeaderCellGroupSortable from './HeaderCellGroup.js';
 import { SortableHeaderCell } from '../SortableHeaderCell.js';
 import { jsx } from 'react/jsx-runtime';
 
@@ -27,7 +29,7 @@ const HeadersComp = () => {
     cols: gridLayout,
     colsLayoutStyle: colsLayoutStyle,
     isExpandable: isExpandable
-  }, void 0, visibleColumns.map((h, index) => /*#__PURE__*/_jsx(HeaderCellGroup, {
+  }, void 0, visibleColumns.map((h, index) => /*#__PURE__*/_jsx(HeaderCellGroupSortable, {
     header: h,
     isLast: index === visibleColumns.length - 1
   }, h.id)))), [isExpandable, visibleColumns, gridLayout, colsLayoutStyle]);

package/esm/parts/Headers/useHeaderCellConfig.js

@@ -1,11 +1,16 @@
+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';
+
 /* eslint-disable complexity */
-const useHeaderCellConfig = ({
-  column,
-  dragAndDropColumns,
-  draggableProps,
-  reduxHeader,
-  isDragOverlay
-}) => {
+const useHeaderCellConfig = _ref => {
+  let {
+    column,
+    dragAndDropColumns,
+    draggableProps,
+    reduxHeader,
+    isDragOverlay
+  } = _ref;
   const hasFilter = !!(column.filter || column.Filter);
   const hasDnD = dragAndDropColumns && !column.disableDnD;
   const hasSortingCaret = column.canSort && typeof column.isSortedDesc === 'boolean';

package/esm/parts/Headers/useHeaderCellHandlers.js

@@ -1,3 +1,8 @@
+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 _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import { useCallback } from 'react';
 
@@ -5,30 +10,36 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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; }
 
-const buildNextHeader = (reduxHeader, value, hasFilter, hasDnD, withTabStops = false) => _objectSpread(_objectSpread({
-  hideFilterMenu: true
-}, reduxHeader), {}, {
-  hideFilterButton: !(hasFilter && value),
-  showDnDHandle: hasDnD && value,
-  withTabStops
-});
+const buildNextHeader = function (reduxHeader, value, hasFilter, hasDnD) {
+  let withTabStops = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  return _objectSpread(_objectSpread({
+    hideFilterMenu: true
+  }, reduxHeader), {}, {
+    hideFilterButton: !(hasFilter && value),
+    showDnDHandle: hasDnD && value,
+    withTabStops
+  });
+};
 
-const useHeaderCellHandlers = ({
-  hasFilter,
-  patchHeader,
-  column,
-  reduxHeader,
-  hasDnD,
-  onColumnSortChange,
-  dragHandleRef,
-  filterIconRef,
-  headerRef
-}) => {
+const useHeaderCellHandlers = _ref => {
+  let {
+    hasFilter,
+    patchHeader,
+    column,
+    reduxHeader,
+    hasDnD,
+    onColumnSortChange,
+    dragHandleRef,
+    filterIconRef,
+    headerRef
+  } = _ref;
   const onMouseEnter = useCallback(() => {
     patchHeader(column.id, buildNextHeader(reduxHeader, true, hasFilter, hasDnD));
   }, [column.id, hasDnD, hasFilter, patchHeader, reduxHeader]);
   const onMouseLeave = useCallback(() => {
-    if (!headerRef.current.contains(document.activeElement)) {
+    var _headerRef$current;
+
+    if (!(headerRef !== null && headerRef !== void 0 && (_headerRef$current = headerRef.current) !== null && _headerRef$current !== void 0 && _headerRef$current.contains(document.activeElement))) {
       patchHeader(column.id, buildNextHeader(reduxHeader, false, hasFilter, hasDnD));
     }
   }, [column.id, hasDnD, hasFilter, headerRef, patchHeader, reduxHeader]);
@@ -63,7 +74,7 @@ const useHeaderCellHandlers = ({
   }, [column.canSort, column.id, onColumnSortChange, patchHeader, reduxHeader, hasFilter, hasDnD, dragHandleRef, filterIconRef]);
   const onFocus = useCallback(e => {
     // Don't do anything if focus wasn't placed in the element (bubling issues)
-    if (e.target === headerRef.current) {
+    if (e.target === (headerRef === null || headerRef === void 0 ? void 0 : headerRef.current)) {
       patchHeader(column.id, buildNextHeader(reduxHeader, true, hasFilter, hasDnD));
     }
   }, [column.id, hasDnD, hasFilter, headerRef, patchHeader, reduxHeader]);

package/esm/parts/HoC/withConditionalDnDColumnContext.js

@@ -1,11 +1,20 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
 import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.find.js';
 import React, { useMemo, useCallback, createContext } from 'react';
 import { DndContext, DragOverlay } from '@dnd-kit/core';
+import { useHierarchyDndkitConfig } from '@elliemae/ds-drag-and-drop';
 import { arrayMove } from '@dnd-kit/sortable';
-import { DragOverlayContext } from './DragOverlayContext.js';
-import useHierarchyDndkitConfig from '../../helpers/dndkit/hierarchy/useHierarchyDndkitConfig.js';
 import DataTableContext from '../../DataTableContext.js';
+import { HeaderCellGroup } from '../Headers/HeaderCellGroup.js';
+import { DATA_TESTID } from '../../configs/constants.js';
 import { jsxs, 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; }
@@ -18,8 +27,11 @@ const DnDGroupContext = /*#__PURE__*/createContext({
 const flattenColumns = cols => {
   const flattened = [];
 
-  const flatten = (col, index, parentId = null) => {
-    const id = col.Header;
+  const flatten = function (col, index) {
+    let parentId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    const {
+      id
+    } = col;
     flattened.push([{
       id,
       parentId,
@@ -37,24 +49,25 @@ const withConditionalDnDColumnContext = Component => props => {
   const {
     tableProps: {
       dragAndDropColumns,
-      columns,
       onColumnsReorder
-    }
+    },
+    visibleColumns
   } = React.useContext(DataTableContext);
-  const [PureDraggedJSX, setPureDraggedJSX] = React.useState(null); // todo: check if this can be done via portal
-
-  const flattenedItems = useMemo(() => flattenColumns(columns), [columns]);
+  const flattenedItems = useMemo(() => flattenColumns(visibleColumns), [visibleColumns]);
   const onReorder = useCallback((movedItem, indexes) => {
     // Send from index to target index
     const newFlattenedData = arrayMove(flattenedItems, indexes.fromIndex, indexes.targetIndex); // Pull the cols's data into an object
 
     const nodes = {};
-    newFlattenedData.forEach(([dndData, colData]) => {
+    newFlattenedData.forEach(_ref => {
+      let [dndData, colData] = _ref;
       delete colData.columns;
       nodes[dndData.id] = colData;
     });
     const newData = [];
-    newFlattenedData.forEach(([dndData, colData]) => {
+    newFlattenedData.forEach(_ref2 => {
+      let [dndData, colData] = _ref2;
+
       // If row has parent, insert it to it's subrows
       // otherwise append it to the new user data
       if (dndData.parentId) {
@@ -64,25 +77,43 @@ const withConditionalDnDColumnContext = Component => props => {
     });
     onColumnsReorder(newData, indexes);
   }, [flattenedItems, onColumnsReorder]);
+  const onPreviewResetState = useCallback(() => {
+    const el = document.body.querySelector("[data-testid=\"".concat(DATA_TESTID.DATA_TABLE_SCROLLABLE_CONTAINER, "\"]"));
+    if (el) el.onscroll = () => null;
+  }, []);
+  const onPreviewDragStart = useCallback(() => {
+    const el = document.body.querySelector("[data-testid=\"".concat(DATA_TESTID.DATA_TABLE_SCROLLABLE_CONTAINER, "\"]"));
+
+    if (el) {
+      const y = el.scrollTop;
+
+      el.onscroll = () => el.scrollTo(0, y);
+    }
+  }, []);
   const {
     dndContextProps,
     activeId,
     activeIndex
   } = useHierarchyDndkitConfig({
     flattenedItems,
+    dragOverlayDataTestid: DATA_TESTID.DATA_TABLE_COLUMN_DRAG_OVERLAY,
     isHorizontalDnD: true,
-    onReorder
+    onReorder,
+    onPreviewResetState,
+    onPreviewDragStart
   });
   if (dragAndDropColumns) return /*#__PURE__*/jsxs(DndContext, _objectSpread(_objectSpread({}, dndContextProps), {}, {
-    children: [/*#__PURE__*/_jsx(DragOverlayContext.Provider, {
-      value: {
-        setPureDraggedJSX
-      }
-    }, void 0, /*#__PURE__*/_jsx(DnDGroupContext.Provider, {
+    children: [/*#__PURE__*/_jsx(DnDGroupContext.Provider, {
       value: {
         activeIndex
       }
-    }, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props)))), /*#__PURE__*/_jsx(DragOverlay, {}, void 0, activeId ? PureDraggedJSX : null)]
+    }, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props))), /*#__PURE__*/_jsx(DragOverlay, {}, void 0, activeId ? /*#__PURE__*/_jsx(HeaderCellGroup, {
+      header: flattenedItems.find(_ref3 => {
+        let [item] = _ref3;
+        return item.id === activeId;
+      })[1],
+      isDragOverlay: true
+    }) : null)]
   }));
   return /*#__PURE__*/jsx(Component, _objectSpread({}, props));
 };

package/esm/parts/HoC/withConditionalDnDRowContext.js

@@ -1,12 +1,20 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
 import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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.constructor.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 React, { createContext, useCallback } from 'react';
 import { DndContext, DragOverlay } from '@dnd-kit/core';
 import { SortableContext } from '@dnd-kit/sortable';
 import DataTableContext from '../../DataTableContext.js';
-import useTreeDndkitConfig from '../../helpers/dndkit/tree/useTreeDndkitConfig.js';
-import { DragOverlayContext } from './DragOverlayContext.js';
+import { useTreeDndkitConfig } from '@elliemae/ds-drag-and-drop';
 import { DropIndicatorPosition } from './SortableItemContext.js';
+import { Row } from '../Row.js';
 import { jsxs, 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; }
@@ -32,8 +40,6 @@ const withConditionalDnDRowContext = Component => props => {
     flattenedData,
     allDataFlattened
   } = React.useContext(DataTableContext);
-  const [PureDraggedJSX, setPureDraggedJSX] = React.useState(null); // todo: check if this can be done via portal
-
   const [lastActiveId, setLastActiveId] = React.useState(null);
   const onReorder = useCallback((newData, indexes, considerExpanding) => {
     // Pull the row's original data into an object
@@ -73,11 +79,7 @@ const withConditionalDnDRowContext = Component => props => {
   if (lastActiveId !== activeId && activeId) setLastActiveId(activeId);
   if (dragAndDropRows) return /*#__PURE__*/jsxs(DndContext, _objectSpread(_objectSpread({}, dndContextProps), {}, {
     children: [/*#__PURE__*/jsx(SortableContext, _objectSpread(_objectSpread({}, sortableContextProps), {}, {
-      children: /*#__PURE__*/_jsx(DragOverlayContext.Provider, {
-        value: {
-          setPureDraggedJSX
-        }
-      }, void 0, /*#__PURE__*/_jsx(DnDTreeContext.Provider, {
+      children: /*#__PURE__*/_jsx(DnDTreeContext.Provider, {
         value: {
           activeIndex,
           depth,
@@ -86,12 +88,15 @@ const withConditionalDnDRowContext = Component => props => {
           lastActiveId,
           setLastActiveId
         }
-      }, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props))))
+      }, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props)))
     })), /*#__PURE__*/_jsx(DragOverlay, {
       style: {
         width: 'auto'
       }
-    }, void 0, activeId ? PureDraggedJSX : null)]
+    }, void 0, activeId ? /*#__PURE__*/_jsx(Row, {
+      row: flattenedData.find(row => row.uid === activeId),
+      isDragOverlay: true
+    }) : null)]
   }));
   return /*#__PURE__*/jsx(Component, _objectSpread({}, props));
 };

package/esm/parts/HoC/withConditionalDnDSortableContext.js

@@ -1,5 +1,12 @@
 import _jsx from '@babel/runtime/helpers/esm/jsx';
 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 { SortableContext, horizontalListSortingStrategy } from '@dnd-kit/sortable';
 import { useContext } from 'react';
 import DataTableContext from '../../DataTableContext.js';
@@ -8,19 +15,22 @@ 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; }
-const withConditionalDnDSortableContext = (items, isDragOverlay = false) => Component => props => {
-  const {
-    tableProps: {
-      dragAndDropColumns
-    }
-  } = useContext(DataTableContext); // Only add the context if it's not a dragOverlay and dnd for cols was requested
-  // It's important that drag overlays DO NOT have any sortable functionality!
+const withConditionalDnDSortableContext = function (items) {
+  let isDragOverlay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  return Component => props => {
+    const {
+      tableProps: {
+        dragAndDropColumns
+      }
+    } = useContext(DataTableContext); // Only add the context if it's not a dragOverlay and dnd for cols was requested
+    // It's important that drag overlays DO NOT have any sortable functionality!
 
-  if (!isDragOverlay && dragAndDropColumns) return /*#__PURE__*/_jsx(SortableContext, {
-    items: items.map(item => item.Header),
-    strategy: horizontalListSortingStrategy
-  }, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props)));
-  return /*#__PURE__*/jsx(Component, _objectSpread({}, props));
+    if (!isDragOverlay && dragAndDropColumns) return /*#__PURE__*/_jsx(SortableContext, {
+      items: items.map(item => item.id),
+      strategy: horizontalListSortingStrategy
+    }, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props)));
+    return /*#__PURE__*/jsx(Component, _objectSpread({}, props));
+  };
 };
 
 export { withConditionalDnDSortableContext };

package/esm/parts/HoC/withDnDSortableColumnContext.js

@@ -1,9 +1,13 @@
+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 { useContext, useMemo, useEffect, cloneElement } from 'react';
+import { useContext, useMemo } from 'react';
 import { useSortable } from '@dnd-kit/sortable';
 import DataTableContext from '../../DataTableContext.js';
-import { DragOverlayContext } from './DragOverlayContext.js';
 import { DnDGroupContext } from './withConditionalDnDColumnContext.js';
 import { DropIndicatorPosition, SortableItemContext } from './SortableItemContext.js';
 import { jsx } from 'react/jsx-runtime';
@@ -17,18 +21,14 @@ const withDnDSortableColumnContext = Component => props => {
       dragAndDropColumns
     }
   } = useContext(DataTableContext);
-  const {
-    setPureDraggedJSX
-  } = useContext(DragOverlayContext);
   const {
     activeIndex
   } = useContext(DnDGroupContext); // onMount generate unique options, so everyting is only ran once
 
   const draggableOptions = useMemo(() => ({
-    id: props.header.Header
-  }), [props.header.Header]);
-  const useSortableHelpers = useSortable(draggableOptions);
-  const PureComponentJSX = useMemo(() => /*#__PURE__*/jsx(Component, _objectSpread({}, props)), [props]); // calculate all the "useSortable" values as per required
+    id: props.header.id
+  }), [props.header.id]);
+  const useSortableHelpers = useSortable(draggableOptions); // calculate all the "useSortable" values as per required
 
   const draggableProps = useMemo(() => {
     if (!dragAndDropColumns) return false;
@@ -40,16 +40,7 @@ const withDnDSortableColumnContext = Component => props => {
       shouldShowDropIndicatorPosition: overIndex === index && overIndex !== -1,
       dropIndicatorPosition: index > activeIndex ? DropIndicatorPosition.After : DropIndicatorPosition.Before
     });
-  }, [useSortableHelpers, dragAndDropColumns, activeIndex]);
-  useEffect(() => {
-    // We assume the structure of the inner element WON'T change during DnD
-    // This is a huge performance boost
-    if (useSortableHelpers.isDragging) {
-      setPureDraggedJSX( /*#__PURE__*/cloneElement(PureComponentJSX, {
-        isDragOverlay: true
-      }));
-    }
-  }, [useSortableHelpers.isDragging, setPureDraggedJSX]); // we use a context so we can easly access information wherever without bubbling down
+  }, [useSortableHelpers, dragAndDropColumns, activeIndex]); // we use a context so we can easly access information wherever without bubbling down
   // this context is all Memoized so as long as component is not re-mounted,
   // the context won't trigger un-required renders per-se...
 
@@ -59,7 +50,7 @@ const withDnDSortableColumnContext = Component => props => {
 
   return /*#__PURE__*/_jsx(SortableItemContext.Provider, {
     value: ctx
-  }, void 0, PureComponentJSX);
+  }, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props)));
 };
 
 export { withDnDSortableColumnContext };

package/esm/parts/HoC/withDnDSortableRowContext.js

@@ -1,10 +1,14 @@
+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 { useContext, useMemo, useEffect, cloneElement } from 'react';
+import { useContext, useMemo } from 'react';
 import { useSortable } from '@dnd-kit/sortable';
 import DataTableContext from '../../DataTableContext.js';
 import { DnDTreeContext } from './withConditionalDnDRowContext.js';
-import { DragOverlayContext } from './DragOverlayContext.js';
 import { SortableItemContext } from './SortableItemContext.js';
 import { jsx } from 'react/jsx-runtime';
 
@@ -17,9 +21,6 @@ const withDnDSortableRowContext = Component => props => {
       dragAndDropRows
     }
   } = useContext(DataTableContext);
-  const {
-    setPureDraggedJSX
-  } = useContext(DragOverlayContext);
   const {
     dropIndicatorPosition,
     lastActiveId,
@@ -29,8 +30,7 @@ const withDnDSortableRowContext = Component => props => {
   const draggableOptions = useMemo(() => ({
     id: props.row.uid
   }), [props.row]);
-  const useSortableHelpers = useSortable(draggableOptions);
-  const PureComponentJSX = useMemo(() => /*#__PURE__*/jsx(Component, _objectSpread({}, props)), [props]); // calculate all the "useSortable" values as per required
+  const useSortableHelpers = useSortable(draggableOptions); // calculate all the "useSortable" values as per required
 
   const draggableProps = useMemo(() => {
     if (!dragAndDropRows) return false;
@@ -44,16 +44,7 @@ const withDnDSortableRowContext = Component => props => {
       lastActiveId,
       setLastActiveId
     });
-  }, [dragAndDropRows, useSortableHelpers, dropIndicatorPosition, lastActiveId, setLastActiveId]);
-  useEffect(() => {
-    // We assume the structure of the inner element WON'T change during DnD
-    // This is a huge performance boost
-    if (useSortableHelpers.isDragging) {
-      setPureDraggedJSX( /*#__PURE__*/cloneElement(PureComponentJSX, {
-        isDragOverlay: true
-      }));
-    }
-  }, [useSortableHelpers.isDragging, setPureDraggedJSX]); // we use a context so we can easly access information wherever without bubbling down
+  }, [dragAndDropRows, useSortableHelpers, dropIndicatorPosition, lastActiveId, setLastActiveId]); // we use a context so we can easly access information wherever without bubbling down
   // this context is all Memoized so as long as component is not re-mounted,
   // the context won't trigger un-required renders per-se...
 
@@ -63,7 +54,7 @@ const withDnDSortableRowContext = Component => props => {
 
   return /*#__PURE__*/_jsx(SortableItemContext.Provider, {
     value: ctx
-  }, void 0, PureComponentJSX);
+  }, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props)));
 };
 
 export { withDnDSortableRowContext };

package/esm/parts/Row.js

@@ -1,26 +1,32 @@
 import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import { useContext } from 'react';
 import { connect } from 'react-redux';
 import DataTableContext from '../DataTableContext.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import '../configs/constants.js';
 import { setMultipleRefs } from '../helpers/refs-helpers.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
 import { SortableItemContext } from './HoC/SortableItemContext.js';
 import { withDnDSortableRowContext } from './HoC/withDnDSortableRowContext.js';
 import { RowVariantMapItem } from './RowVariants/index.js';
 import { jsx } from 'react/jsx-runtime';
 
 const setItemRefs = (measureRef, draggableRef, ref) => {
-  const refsToSet = [measureRef];
+  const refsToSet = [];
+  if (measureRef) refsToSet.push(measureRef);
   if (draggableRef) refsToSet.push(draggableRef);
   setMultipleRefs(...refsToSet)(ref);
 };
 
-const Row = props => {
+const RowComp = props => {
   const {
     row,
     measureRef,
     itemWrapperStyle,
-    itemIndex,
     isDragOverlay,
     focusedRowId,
     selectedRowId
@@ -35,7 +41,7 @@ const Row = props => {
     ref: ref => setItemRefs(measureRef, draggableRef, ref),
     children: /*#__PURE__*/_jsx(RowVariantMapItem, {
       row: row,
-      itemIndex: itemIndex,
+      itemIndex: row.realIndex,
       isDragOverlay: isDragOverlay,
       ctx: ctx,
       focusedRowId: focusedRowId,
@@ -44,15 +50,12 @@ const Row = props => {
   });
 };
 
-Row.defaultProps = {
-  itemWrapperStyle: {}
-};
-
 const mapStateToProps = state => ({
   focusedRowId: state.rows.focusedRowId,
   selectedRowId: state.rows.selectedRowId
 });
 
-var Row$1 = withDnDSortableRowContext(connect(mapStateToProps)(Row));
+const Row = connect(mapStateToProps)(RowComp);
+var Row$1 = withDnDSortableRowContext(Row);
 
-export { Row$1 as default };
+export { Row, Row$1 as default };

package/esm/parts/RowLoading.js

@@ -4,24 +4,30 @@ import DSIndeterminateProgressIndicator from '@elliemae/ds-indeterminate-progres
 import Grid from '@elliemae/ds-grid';
 import styled from 'styled-components';
 import { DATA_TESTID } from '../configs/constants.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/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
 import 'react-virtual';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import '../configs/useRowFlattenization.js';
 import '@babel/runtime/helpers/esm/defineProperty';
-import '@elliemae/ds-icons/ArrowShortReturn';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
 import '@elliemae/ds-icons';
 import '../styled.js';
 import 'react/jsx-runtime';
-import '@elliemae/ds-form/Checkbox';
-import '@elliemae/ds-form/Radio';
+import '@elliemae/ds-form';
 import './TableContent.js';
 import '@elliemae/ds-circular-progress-indicator';
-import '@elliemae/ds-icons/WarningTriangle';
 import '@elliemae/ds-system';
 import '@elliemae/ds-button';
 import '../DataTableContext.js';
 import './Row.js';
 import './Footer.js';
-import '@elliemae/ds-icons/GripperVertical';
 import './HoC/SortableItemContext.js';
 
 var _DSIndeterminateProgr;