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

package/esm/plugins/body-header-scroll-sync/BodyHeaderScrollSyncPlugin.js

@@ -1,132 +1,132 @@
+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 _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
-import _extends from '@babel/runtime/helpers/esm/extends';
-import React, { useMemo, useRef, useEffect } from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { useMemo, useRef, useEffect } from 'react';
 import { mergeRefs } from '@elliemae/ds-utilities';
 import { ScrollSync, ScrollSyncPane } from '@elliemae/ds-shared/ScrollSync';
 import createInstancePlugin from '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
 import { getScrollbarWidth } from '../../utilities/getScrollbarSize.js';
+import { jsx } from 'react/jsx-runtime';
 
-var _excluded = ["children", "classProps", "columns", "getContainer", "helperClass", "innerBodyRef", "innerRef", "isPlaceholderActive", "listProps", "lockAxis", "noResultsPlaceholder", "numRowsVisible", "onSortEnd", "onSortOver", "onSortStart", "rowKey", "rowRenderer", "rows", "useDragHandle", "className", "listComponent"];
-getScrollbarWidth(2);
+const _excluded = ["children", "classProps", "columns", "getContainer", "helperClass", "innerBodyRef", "innerRef", "isPlaceholderActive", "listProps", "lockAxis", "noResultsPlaceholder", "numRowsVisible", "onSortEnd", "onSortOver", "onSortStart", "rowKey", "rowRenderer", "rows", "useDragHandle", "className", "listComponent"];
 
-var HeaderSyncHoc = function HeaderSyncHoc(Component) {
-  return function (props) {
-    return /*#__PURE__*/React.createElement(ScrollSyncPane, null, function (_ref) {
-      var registerPane = _ref.registerPane;
-      return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
-        innerRef: mergeRefs(props.innerRef, registerPane)
-      }));
-    });
-  };
-};
+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; }
 
-var BodySyncHoc = function BodySyncHoc(Component, notPaginated, grid) {
-  return function (_ref2) {
-    _ref2.children;
-        var classProps = _ref2.classProps,
-        columns = _ref2.columns,
-        getContainer = _ref2.getContainer,
-        helperClass = _ref2.helperClass,
-        innerBodyRef = _ref2.innerBodyRef,
-        innerRef = _ref2.innerRef,
-        isPlaceholderActive = _ref2.isPlaceholderActive,
-        listProps = _ref2.listProps,
-        lockAxis = _ref2.lockAxis,
-        noResultsPlaceholder = _ref2.noResultsPlaceholder,
-        numRowsVisible = _ref2.numRowsVisible,
-        onSortEnd = _ref2.onSortEnd,
-        onSortOver = _ref2.onSortOver,
-        onSortStart = _ref2.onSortStart,
-        rowKey = _ref2.rowKey,
-        rowRenderer = _ref2.rowRenderer,
-        rows = _ref2.rows,
-        useDragHandle = _ref2.useDragHandle,
-        className = _ref2.className,
-        listComponent = _ref2.listComponent,
-        rest = _objectWithoutProperties(_ref2, _excluded);
+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; }
+getScrollbarWidth(2);
 
-    var t = useRef();
+const HeaderSyncHoc = Component => props => /*#__PURE__*/_jsx(ScrollSyncPane, {}, void 0, _ref => {
+  let {
+    registerPane
+  } = _ref;
+  return /*#__PURE__*/jsx(Component, _objectSpread(_objectSpread({}, props), {}, {
+    innerRef: mergeRefs(props.innerRef, registerPane)
+  }));
+});
 
-    var repositionToolbarBasedOnBodyScrollPosition = function repositionToolbarBasedOnBodyScrollPosition(SCROLLBAR_WIDTH) {
-      return function () {
-        grid.refs.body.current.style.setProperty('--toolbar-scroll', "".concat(grid.refs.body.current.offsetWidth + grid.refs.body.current.scrollLeft - 15, "px"));
-        grid.refs.body.current.style.setProperty('--toolbar-scroll-paginated', "".concat(grid.refs.body.current.offsetWidth + grid.refs.body.current.scrollLeft - 19, "px"));
-      };
-    };
+const BodySyncHoc = (Component, notPaginated, grid) => _ref2 => {
+  let {
+    children,
+    classProps,
+    columns,
+    getContainer,
+    helperClass,
+    innerBodyRef,
+    innerRef,
+    isPlaceholderActive,
+    listProps,
+    lockAxis,
+    noResultsPlaceholder,
+    numRowsVisible,
+    onSortEnd,
+    onSortOver,
+    onSortStart,
+    rowKey,
+    rowRenderer,
+    rows,
+    useDragHandle,
+    className,
+    listComponent
+  } = _ref2,
+      rest = _objectWithoutProperties(_ref2, _excluded);
 
-    useEffect(function () {
-      setTimeout(repositionToolbarBasedOnBodyScrollPosition(), 300);
-    }, []);
-    useEffect(function () {
-      window.addEventListener('resize', repositionToolbarBasedOnBodyScrollPosition());
-      return function () {
-        window.removeEventListener('resize', repositionToolbarBasedOnBodyScrollPosition());
-      };
-    });
-    return /*#__PURE__*/React.createElement(ScrollSyncPane, {
-      notPaginated: notPaginated
-    }, function (_ref3) {
-      var registerPane = _ref3.registerPane;
-      return /*#__PURE__*/React.createElement(Component, _extends({
-        ref: t,
-        classProps: classProps,
-        className: className,
-        listComponent: listComponent,
-        columns: columns,
-        getContainer: getContainer,
-        helperClass: helperClass,
-        innerBodyRef: innerBodyRef // innerRef={innerRef}
-        ,
-        isPlaceholderActive: isPlaceholderActive,
-        listProps: listProps,
-        lockAxis: lockAxis,
-        noResultsPlaceholder: noResultsPlaceholder,
-        numRowsVisible: numRowsVisible,
-        onSortEnd: onSortEnd,
-        onSortOver: onSortOver,
-        onSortStart: onSortStart,
-        rowKey: rowKey,
-        rowRenderer: rowRenderer,
-        rows: rows,
-        useDragHandle: useDragHandle,
-        innerRef: mergeRefs(innerRef, registerPane, t)
-      }, rest));
-    });
-  };
-};
+  const t = useRef();
 
-var TableSyncHoc = function TableSyncHoc(Component) {
-  return function (props) {
-    return /*#__PURE__*/React.createElement(ScrollSync, {
-      proportional: false,
-      onScroll: function onScroll(e) {
-        e.target.style.setProperty('--toolbar-scroll', "".concat(e.target.offsetWidth + e.target.scrollLeft - 15, "px"));
-        e.target.style.setProperty('--toolbar-scroll-paginated', "".concat(e.target.offsetWidth + e.target.scrollLeft - 19, "px"));
-      }
-    }, /*#__PURE__*/React.createElement(Component, props));
+  const repositionToolbarBasedOnBodyScrollPosition = SCROLLBAR_WIDTH => () => {
+    grid.refs.body.current.style.setProperty('--toolbar-scroll', "".concat(grid.refs.body.current.offsetWidth + grid.refs.body.current.scrollLeft - 15, "px"));
+    grid.refs.body.current.style.setProperty('--toolbar-scroll-paginated', "".concat(grid.refs.body.current.offsetWidth + grid.refs.body.current.scrollLeft - 19, "px"));
   };
-};
 
-var decorateRenderers = function decorateRenderers(renderers, grid) {
-  var HeaderWrapper = renderers.header.wrapper;
-  var BodyWrapper = renderers.body.wrapper;
-  var Table = renderers.table;
-  var paginated = grid.props.paginated;
-  renderers.table = useMemo(function () {
-    return TableSyncHoc(Table);
-  }, []);
-  renderers.header.wrapper = useMemo(function () {
-    return HeaderSyncHoc(HeaderWrapper);
-  }, []);
-  renderers.body.wrapper = useMemo(function () {
-    return BodySyncHoc(BodyWrapper, !paginated, grid);
+  useEffect(() => {
+    setTimeout(repositionToolbarBasedOnBodyScrollPosition(), 300);
   }, []);
+  useEffect(() => {
+    window.addEventListener('resize', repositionToolbarBasedOnBodyScrollPosition());
+    return () => {
+      window.removeEventListener('resize', repositionToolbarBasedOnBodyScrollPosition());
+    };
+  });
+  return /*#__PURE__*/_jsx(ScrollSyncPane, {
+    notPaginated: notPaginated
+  }, void 0, _ref3 => {
+    let {
+      registerPane
+    } = _ref3;
+    return /*#__PURE__*/jsx(Component, _objectSpread({
+      ref: t,
+      classProps: classProps,
+      className: className,
+      listComponent: listComponent,
+      columns: columns,
+      getContainer: getContainer,
+      helperClass: helperClass,
+      innerBodyRef: innerBodyRef // innerRef={innerRef}
+      ,
+      isPlaceholderActive: isPlaceholderActive,
+      listProps: listProps,
+      lockAxis: lockAxis,
+      noResultsPlaceholder: noResultsPlaceholder,
+      numRowsVisible: numRowsVisible,
+      onSortEnd: onSortEnd,
+      onSortOver: onSortOver,
+      onSortStart: onSortStart,
+      rowKey: rowKey,
+      rowRenderer: rowRenderer,
+      rows: rows,
+      useDragHandle: useDragHandle,
+      innerRef: mergeRefs(innerRef, registerPane, t)
+    }, rest));
+  });
+};
+
+const TableSyncHoc = Component => props => /*#__PURE__*/_jsx(ScrollSync, {
+  proportional: false,
+  onScroll: e => {
+    e.target.style.setProperty('--toolbar-scroll', "".concat(e.target.offsetWidth + e.target.scrollLeft - 15, "px"));
+    e.target.style.setProperty('--toolbar-scroll-paginated', "".concat(e.target.offsetWidth + e.target.scrollLeft - 19, "px"));
+  }
+}, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props)));
+
+const decorateRenderers = (renderers, grid) => {
+  const HeaderWrapper = renderers.header.wrapper;
+  const BodyWrapper = renderers.body.wrapper;
+  const Table = renderers.table;
+  const {
+    paginated
+  } = grid.props;
+  renderers.table = useMemo(() => TableSyncHoc(Table), []);
+  renderers.header.wrapper = useMemo(() => HeaderSyncHoc(HeaderWrapper), []);
+  renderers.body.wrapper = useMemo(() => BodySyncHoc(BodyWrapper, !paginated, grid), []);
   return renderers;
 };
 
-var BodyHeaderScrollSyncPlugin = createInstancePlugin('body-header-scroll-sync', {
-  decorateRenderers: decorateRenderers
+const BodyHeaderScrollSyncPlugin = createInstancePlugin('body-header-scroll-sync', {
+  decorateRenderers
 });
 
 export { BodyHeaderScrollSyncPlugin };
-//# sourceMappingURL=BodyHeaderScrollSyncPlugin.js.map

package/esm/plugins/body-header-scroll-sync/index.js

@@ -1,9 +1 @@
 export { BodyHeaderScrollSyncPlugin } from './BodyHeaderScrollSyncPlugin.js';
-import '@babel/runtime/helpers/esm/objectWithoutProperties';
-import '@babel/runtime/helpers/esm/extends';
-import 'react';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-shared/ScrollSync';
-import '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
-import '../../utilities/getScrollbarSize.js';
-//# sourceMappingURL=index.js.map

package/esm/plugins/column-dnd/DndColumnsPlugin.js

@@ -1,47 +1,51 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import React, { useRef, useEffect, useMemo } from 'react';
+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.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import { useRef, useEffect, useMemo } from 'react';
 import { SortableContainer, SortableElement } from 'react-sortable-hoc';
 import { mergeRefs, omit, arrayMove } from '@elliemae/ds-utilities';
 import createInstancePlugin from '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
 import { addDragAndDropToColumn } from './decorateGridWithDndColumns.js';
-import '@elliemae/ds-icons';
-import '@elliemae/ds-shared/useDataGrid/initColumnDefinition';
+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 keysToOmit = ['axis', 'contentWindow', 'disableAutoscroll', 'distance', 'getContainer', 'getHelperDimensions', 'helperClass', 'helperContainer', 'hideSortableGhost', 'keyboardSortingTransitionDuration', 'lockAxis', 'lockOffset', 'lockToContainerEdges', 'onSortEnd', 'onSortMove', 'onSortOver', 'onSortStart', 'pressDelay', 'pressThreshold', 'shouldCancelStart', 'transitionDuration', 'updateBeforeSortStart', 'useDragHandle', 'useWindowAsScrollContainer'];
 
-var keysToOmit = ['axis', 'contentWindow', 'disableAutoscroll', 'distance', 'getContainer', 'getHelperDimensions', 'helperClass', 'helperContainer', 'hideSortableGhost', 'keyboardSortingTransitionDuration', 'lockAxis', 'lockOffset', 'lockToContainerEdges', 'onSortEnd', 'onSortMove', 'onSortOver', 'onSortStart', 'pressDelay', 'pressThreshold', 'shouldCancelStart', 'transitionDuration', 'updateBeforeSortStart', 'useDragHandle', 'useWindowAsScrollContainer'];
+const decorateColumn = (column, grid) => column.isUserColumn ? addDragAndDropToColumn(grid, column) : column;
 
-var decorateColumn = function decorateColumn(column, grid) {
-  return column.isUserColumn ? addDragAndDropToColumn(grid, column) : column;
-};
-
-var getHeaderRowProps = function getHeaderRowProps(props, grid) {
-  var _grid$props = grid.props,
-      onMoveColumnStart = _grid$props.onMoveColumnStart,
-      onMoveColumnEnd = _grid$props.onMoveColumnEnd,
-      onMoveColumnOver = _grid$props.onMoveColumnOver;
-  var headerRowRef = useRef();
-  var columnDraggingOffset = useRef(0);
-  var sortedColumns = useRef(grid.getInstance().decoratedColumns);
-  var nodeRef = useRef();
-  useEffect(function () {
+const getHeaderRowProps = (props, grid) => {
+  const {
+    onMoveColumnStart,
+    onMoveColumnEnd,
+    onMoveColumnOver
+  } = grid.props;
+  const headerRowRef = useRef();
+  const columnDraggingOffset = useRef(0);
+  const sortedColumns = useRef(grid.getInstance().decoratedColumns);
+  const nodeRef = useRef();
+  useEffect(() => {
     sortedColumns.current = grid.getInstance().decoratedColumns;
   });
 
-  var onSortOver = function onSortOver(params) {
-    var index = params.index,
-        newIndex = params.newIndex,
-        oldIndex = params.oldIndex;
-    var oldColumn = sortedColumns.current[oldIndex];
-    var newColumn = sortedColumns.current[newIndex];
+  const onSortOver = params => {
+    const {
+      index,
+      newIndex,
+      oldIndex
+    } = params;
+    const oldColumn = sortedColumns.current[oldIndex];
+    const newColumn = sortedColumns.current[newIndex];
     if (!newColumn.isUserColumn || !oldColumn.isUserColumn) return;
-    var columnWidth = nodeRef.current.offsetWidth;
-    var newColumnWidth = headerRowRef.current.childNodes.item(newColumn.index).offsetWidth;
-    var forward = newIndex > oldIndex; // eslint-disable-next-line no-nested-ternary
+    const columnWidth = nodeRef.current.offsetWidth;
+    const newColumnWidth = headerRowRef.current.childNodes.item(newColumn.index).offsetWidth;
+    const forward = newIndex > oldIndex; // eslint-disable-next-line no-nested-ternary
 
-    var columnTranslate = forward ? newIndex > index ? columnWidth * -1 : 0 : newIndex < index ? columnWidth : 0;
+    const columnTranslate = forward ? newIndex > index ? columnWidth * -1 : 0 : newIndex < index ? columnWidth : 0;
     columnDraggingOffset.current += forward ? newColumnWidth : newColumnWidth * -1;
     newColumn.updateStyle({
       transitionDuration: '300ms',
@@ -55,32 +59,32 @@ var getHeaderRowProps = function getHeaderRowProps(props, grid) {
     onMoveColumnOver(params);
   };
 
-  var onSortStart = function onSortStart(params) {
-    var node = params.node;
+  const onSortStart = params => {
+    const {
+      node
+    } = params;
     grid.disableEvents();
     nodeRef.current = node;
     onMoveColumnStart(params);
   };
 
-  var onSortEnd = function onSortEnd(params) {
-    var oldIndex = params.oldIndex,
-        newIndex = params.newIndex;
+  const onSortEnd = params => {
+    const {
+      oldIndex,
+      newIndex
+    } = params;
     grid.enableEvents();
     columnDraggingOffset.current = 0;
     sortedColumns.current = grid.decoratedColumns;
-    grid.decoratedColumns.forEach(function (column) {
+    grid.decoratedColumns.forEach(column => {
       if (!column.updateStyle) return;
       column.updateStyle({
         transitionDuration: null,
         transform: null
       });
     });
-    var originalOldColumnIndex = grid.columns.findIndex(function (column) {
-      return column.property === grid.decoratedColumns[oldIndex].property;
-    });
-    var originalNewColumnIndex = grid.columns.findIndex(function (column) {
-      return column.property === grid.decoratedColumns[newIndex].property;
-    });
+    const originalOldColumnIndex = grid.columns.findIndex(column => column.property === grid.decoratedColumns[oldIndex].property);
+    const originalNewColumnIndex = grid.columns.findIndex(column => column.property === grid.decoratedColumns[newIndex].property);
     onMoveColumnEnd({
       newIndex: originalNewColumnIndex,
       oldIndex: originalOldColumnIndex
@@ -92,24 +96,18 @@ var getHeaderRowProps = function getHeaderRowProps(props, grid) {
     helperClass: 'header-dnd-column',
     innerRef: mergeRefs(props.innerRef, headerRowRef),
     lockAxis: 'x',
-    onSortEnd: onSortEnd,
-    onSortOver: onSortOver,
-    onSortStart: onSortStart,
+    onSortEnd,
+    onSortOver,
+    onSortStart,
     useDragHandle: true
   };
 };
 
-var decorateRenderers = function decorateRenderers(renderers) {
-  var RowComponent = renderers.header.row;
-  var CellComponent = renderers.header.cell;
-  var Row = useMemo(function () {
-    return SortableContainer(function (props) {
-      return /*#__PURE__*/React.createElement(RowComponent, omit(props, keysToOmit));
-    });
-  }, []);
-  var Cell = useMemo(function () {
-    return SortableElement(CellComponent);
-  }, []);
+const decorateRenderers = renderers => {
+  const RowComponent = renderers.header.row;
+  const CellComponent = renderers.header.cell;
+  const Row = useMemo(() => SortableContainer(props => /*#__PURE__*/jsx(RowComponent, _objectSpread({}, omit(props, keysToOmit)))), []);
+  const Cell = useMemo(() => SortableElement(CellComponent), []);
   return _objectSpread(_objectSpread({}, renderers), {}, {
     header: _objectSpread(_objectSpread({}, renderers.header), {}, {
       row: Row,
@@ -118,11 +116,10 @@ var decorateRenderers = function decorateRenderers(renderers) {
   });
 };
 
-var DndColumnsPlugin = createInstancePlugin('dnd-columns', {
-  getHeaderRowProps: getHeaderRowProps,
-  decorateColumn: decorateColumn,
-  decorateRenderers: decorateRenderers
+const DndColumnsPlugin = createInstancePlugin('dnd-columns', {
+  getHeaderRowProps,
+  decorateColumn,
+  decorateRenderers
 });
 
 export { DndColumnsPlugin };
-//# sourceMappingURL=DndColumnsPlugin.js.map

package/esm/plugins/column-dnd/decorateGridWithDndColumns.js

@@ -1,22 +1,22 @@
-import React from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
 import { SortableHandle } from 'react-sortable-hoc';
 import { GripperVertical } from '@elliemae/ds-icons';
 import { appendHeaderFormatter, mergeClassNameToColumnHeader } from '@elliemae/ds-shared/useDataGrid/initColumnDefinition';
+import { jsxs, Fragment } from 'react/jsx-runtime';
 
-var DragHandle = SortableHandle(function () {
-  return /*#__PURE__*/React.createElement(GripperVertical, {
-    className: "drag-handle"
-  });
-});
+var _GripperVertical, _DragHandle;
+const DragHandle = SortableHandle(() => _GripperVertical || (_GripperVertical = /*#__PURE__*/_jsx(GripperVertical, {
+  className: "drag-handle"
+})));
 
-var DndHeaderFormatter = function DndHeaderFormatter(value) {
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DragHandle, null), value);
-};
+const DndHeaderFormatter = value => /*#__PURE__*/jsxs(Fragment, {
+  children: [_DragHandle || (_DragHandle = /*#__PURE__*/_jsx(DragHandle, {})), value]
+});
 
-var addDragAndDropToColumn = function addDragAndDropToColumn(grid, column) {
+const addDragAndDropToColumn = (grid, column) => {
   column = appendHeaderFormatter(DndHeaderFormatter, column);
   return mergeClassNameToColumnHeader('with-dnd-column', column);
 };
 
 export { addDragAndDropToColumn };
-//# sourceMappingURL=decorateGridWithDndColumns.js.map

package/esm/plugins/column-dnd/index.js

@@ -1,10 +1 @@
 export { DndColumnsPlugin } from './DndColumnsPlugin.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import 'react';
-import 'react-sortable-hoc';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
-import './decorateGridWithDndColumns.js';
-import '@elliemae/ds-icons';
-import '@elliemae/ds-shared/useDataGrid/initColumnDefinition';
-//# sourceMappingURL=index.js.map

package/esm/plugins/column-sizing/ColumnSizingPlugin.js

@@ -5,49 +5,43 @@ import { useStylesheetHelpers } from './useStylesheetHelpers.js';
 import useColumnSizeService from './useColumnSizeService.js';
 import { getTableProps } from './ext-points/getTableProps.js';
 import { decorateColumn } from './ext-points/decorateColumn.js';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import 'stylesheet-helpers';
-import './getColumnNameFromProperty.js';
-import '../../utilities/getScrollbarSize.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import './utils.js';
-import './columnMeasurerTransformer.js';
 
 /* eslint-disable no-param-reassign */
 
-var getHeaderRowProps = function getHeaderRowProps(rowProps, _ref) {
-  var rowsStylesheet = _ref.rowsStylesheet;
+const getHeaderRowProps = (rowProps, _ref) => {
+  let {
+    rowsStylesheet
+  } = _ref;
   rowProps.className = "".concat(rowsStylesheet.getRowClassName(), "-header");
   return rowProps;
 };
 
-var getRowProps = function getRowProps(rowProps, _ref2) {
-  var rowsStylesheet = _ref2.rowsStylesheet;
+const getRowProps = (rowProps, _ref2) => {
+  let {
+    rowsStylesheet
+  } = _ref2;
   rowProps.className = cx(rowProps.className, rowsStylesheet.getRowClassName());
   return rowProps;
 };
 
-var decorateColumns = function decorateColumns(columns, grid) {
-  return grid.columnsStylesheet.decorateColumns(columns, grid);
-};
-
-var decorateGrid = function decorateGrid(grid) {
-  var isDragging = useRef(false);
-  var tableRef = useRef();
-  var resizedColumns = useRef({});
-  var scrollbarWidth = useRef();
-  var bodyWidth = useRef();
-  var allColumnsHaveBeenFixed = useRef(false);
-  var columnSizeService = useColumnSizeService(grid);
-
-  var _useStylesheetHelpers = useStylesheetHelpers(grid),
-      columnsStylesheet = _useStylesheetHelpers.columnsStylesheet,
-      rowsStylesheet = _useStylesheetHelpers.rowsStylesheet; // row size side-effect
+const decorateColumns = (columns, grid) => grid.columnsStylesheet.decorateColumns(columns, grid);
 
+const decorateGrid = grid => {
+  const isDragging = useRef(false);
+  const tableRef = useRef();
+  const resizedColumns = useRef({});
+  const scrollbarWidth = useRef();
+  const bodyWidth = useRef();
+  const allColumnsHaveBeenFixed = useRef(false);
+  const columnSizeService = useColumnSizeService(grid);
+  const {
+    columnsStylesheet,
+    rowsStylesheet
+  } = useStylesheetHelpers(grid); // row size side-effect
 
-  var updateRowWidth = function updateRowWidth(width) {
-    var gridWidth = width || tableRef.current.offsetWidth;
-    var columnsTotalSize = columnSizeService.computeColumnsTotalSize();
+  const updateRowWidth = width => {
+    const gridWidth = width || tableRef.current.offsetWidth;
+    const columnsTotalSize = columnSizeService.computeColumnsTotalSize();
 
     if (columnsTotalSize > gridWidth + 5) {
       if (!allColumnsHaveBeenFixed.current && isDragging.current) {
@@ -62,26 +56,25 @@ var decorateGrid = function decorateGrid(grid) {
   };
 
   return {
-    isDragging: isDragging,
-    tableRef: tableRef,
-    bodyWidth: bodyWidth,
-    scrollbarWidth: scrollbarWidth,
-    columnSizeService: columnSizeService,
-    rowsStylesheet: rowsStylesheet,
-    columnsStylesheet: columnsStylesheet,
-    resizedColumns: resizedColumns,
-    updateRowWidth: updateRowWidth
+    isDragging,
+    tableRef,
+    bodyWidth,
+    scrollbarWidth,
+    columnSizeService,
+    rowsStylesheet,
+    columnsStylesheet,
+    resizedColumns,
+    updateRowWidth
   };
 };
 
-var ColumnSizingPlugin = createInstancePlugin('column-sizing', {
-  decorateGrid: decorateGrid,
-  decorateColumn: decorateColumn,
-  getRowProps: getRowProps,
-  getHeaderRowProps: getHeaderRowProps,
-  getTableProps: getTableProps,
-  decorateColumns: decorateColumns
+const ColumnSizingPlugin = createInstancePlugin('column-sizing', {
+  decorateGrid,
+  decorateColumn,
+  getRowProps,
+  getHeaderRowProps,
+  getTableProps,
+  decorateColumns
 });
 
 export { ColumnSizingPlugin };
-//# sourceMappingURL=ColumnSizingPlugin.js.map