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

package/esm/plugins/virtualization/VirtualizedBody.js

@@ -1,112 +1,85 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
-import React, { useState, useRef, useCallback, useEffect, useLayoutEffect } from 'react';
-import PropTypes from 'prop-types';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.reduce.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.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import { useState, useRef, useCallback, useEffect, useLayoutEffect } from 'react';
 import { debounce, isNaN, mergeRefs } from '@elliemae/ds-utilities';
 import NoResults from '../../components/NoResults.js';
 import VirtualizedBodyRow from './VirtualizedBodyRow.js';
 import { RowSizes } from '../../rowSizes.js';
 import { isSafari } from './helper.js';
-import '@babel/runtime/helpers/esm/objectWithoutProperties';
-import 'styled-components';
-import '@elliemae/ds-system';
+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 wrapperSafari = {};
-var wrapperGeneric = {
+const wrapperSafari = {};
+const wrapperGeneric = {
   overflowY: 'auto',
   overflowX: 'visible'
 };
 
-var VirtualizedBody = function VirtualizedBody(props) {
-  var autoScrollToId = props.autoScrollToId,
-      columns = props.columns,
-      Component = props.component,
-      expandable = props.expandable,
-      innerRef = props.innerRef,
-      innerBody = props.innerBody,
-      isPlaceholderActive = props.isPlaceholderActive,
-      listProps = props.listProps,
-      noResultsPlaceholder = props.noResultsPlaceholder,
-      overscanCount = props.overscanCount,
-      rows = props.rows,
-      defaultRowHeight = props.rowHeight,
-      rowKey = props.rowKey,
-      rowRenderer = props.rowRenderer,
-      rowSize = props.rowSize,
-      setHasScroll = props.setHasScroll,
-      filters = props.filters;
-  var rowHeight = defaultRowHeight || RowSizes[rowSize];
-
-  var _useState = useState(0),
-      _useState2 = _slicedToArray(_useState, 2),
-      scrollTop = _useState2[0],
-      setScrollTop = _useState2[1];
-
-  var _useState3 = useState(0),
-      _useState4 = _slicedToArray(_useState3, 2),
-      visibleHeight = _useState4[0],
-      setVisibleHeight = _useState4[1];
-
-  var _useState5 = useState(false),
-      _useState6 = _slicedToArray(_useState5, 2),
-      hasScrollBar = _useState6[0],
-      setHasScrollBar = _useState6[1];
-
-  var rowStyleCache = useRef({});
-
-  var _useState7 = useState([0, 30]),
-      _useState8 = _slicedToArray(_useState7, 2),
-      renderedIndexes = _useState8[0],
-      setRenderedIndexes = _useState8[1];
-
-  var getCalculatedHeightBetweenIndexes = function getCalculatedHeightBetweenIndexes(start, end) {
-    var _listProps$itemSize = listProps.itemSize,
-        itemSize = _listProps$itemSize === void 0 ? function () {
-      return rowHeight;
-    } : _listProps$itemSize;
+const VirtualizedBody = props => {
+  const {
+    autoScrollToId,
+    columns,
+    component: Component,
+    expandable,
+    innerRef,
+    innerBody,
+    isPlaceholderActive,
+    listProps,
+    noResultsPlaceholder,
+    overscanCount,
+    rows,
+    rowHeight: defaultRowHeight,
+    rowKey,
+    rowRenderer,
+    rowSize,
+    setHasScroll,
+    filters // hack to reset the scrollTop to 0 if filters change
+
+  } = props;
+  const rowHeight = defaultRowHeight || RowSizes[rowSize];
+  const [scrollTop, setScrollTop] = useState(0);
+  const [visibleHeight, setVisibleHeight] = useState(0);
+  const [hasScrollBar, setHasScrollBar] = useState(false);
+  const rowStyleCache = useRef({});
+  const [renderedIndexes, setRenderedIndexes] = useState([0, 30]);
+
+  const getCalculatedHeightBetweenIndexes = (start, end) => {
+    const {
+      itemSize = () => rowHeight
+    } = listProps;
 
     if (expandable) {
-      return rows.slice(start, end).map(function (_, idx) {
-        return idx;
-      }).map(function (idx) {
-        return itemSize(idx);
-      }).reduce(function (acc, curr) {
-        return acc + curr;
-      }, 0);
+      return rows.slice(start, end).map((_, idx) => idx).map(idx => itemSize(idx)).reduce((acc, curr) => acc + curr, 0);
     }
 
     return (end - start) * rowHeight;
   };
 
-  var generateRowPositionMap = function generateRowPositionMap() {
-    return rows.map(function (row, idx) {
-      return getCalculatedHeightBetweenIndexes(0, idx);
-    });
-  };
+  const generateRowPositionMap = () => rows.map((row, idx) => getCalculatedHeightBetweenIndexes(0, idx));
 
-  var rowPositionMap = useRef(generateRowPositionMap());
-
-  var _useState9 = useState(null),
-      _useState10 = _slicedToArray(_useState9, 2),
-      virtualizedBodyRef = _useState10[0],
-      setVirtualizedBodyRef = _useState10[1];
-
-  var handlerRef = useRef();
-  var autoScrollTo = useCallback(function (scrollHeight) {
-    var _listProps$itemSize2 = listProps.itemSize,
-        itemSize = _listProps$itemSize2 === void 0 ? function () {
-      return rowHeight;
-    } : _listProps$itemSize2;
-    var idx = rows.findIndex(function (item) {
-      return item[rowKey] === autoScrollToId;
-    });
-    var val = rowPositionMap.current[idx] || 0;
-    var lastPositionIdx = rowPositionMap.current.length - 1;
-    var lastPosition = 0;
+  const rowPositionMap = useRef(generateRowPositionMap());
+  const [virtualizedBodyRef, setVirtualizedBodyRef] = useState(null);
+  const handlerRef = useRef();
+  const autoScrollTo = useCallback(scrollHeight => {
+    const {
+      itemSize = () => rowHeight
+    } = listProps;
+    const idx = rows.findIndex(item => item[rowKey] === autoScrollToId);
+    let val = rowPositionMap.current[idx] || 0;
+    const lastPositionIdx = rowPositionMap.current.length - 1;
+    let lastPosition = 0;
 
     if (lastPositionIdx > -1) {
       lastPosition = rowPositionMap.current[lastPositionIdx] - scrollHeight + itemSize(lastPositionIdx);
@@ -123,38 +96,36 @@ var VirtualizedBody = function VirtualizedBody(props) {
       }
     }
   }, [rows, virtualizedBodyRef]);
-  useEffect(function () {
+  useEffect(() => {
     autoScrollTo(visibleHeight);
   }, [autoScrollToId, visibleHeight]);
-  var handler = useCallback(debounce(function (_ref) {
-    var target = _ref.target;
+  const handler = useCallback(debounce(_ref => {
+    let {
+      target
+    } = _ref;
     // Update coordinates
     setScrollTop(target.scrollTop || 0);
   }, 100), [setScrollTop]);
-  useEffect(function () {
+  useEffect(() => {
     setScrollTop(0);
   }, [filters]);
-  useEffect(function () {
+  useEffect(() => {
     handlerRef.current = handler;
   }, [handler]);
-  useLayoutEffect(function () {
-    var top = Math.ceil(scrollTop / rowHeight);
-    var bot = Math.ceil((scrollTop + visibleHeight) / rowHeight);
+  useLayoutEffect(() => {
+    let top = Math.ceil(scrollTop / rowHeight);
+    let bot = Math.ceil((scrollTop + visibleHeight) / rowHeight);
 
     if (expandable) {
       // updateMapperFirst
       rowPositionMap.current = generateRowPositionMap();
-      top = rowPositionMap.current.findIndex(function (item) {
-        return item > scrollTop;
-      });
-      bot = rowPositionMap.current.findIndex(function (item) {
-        return item > scrollTop + visibleHeight;
-      });
+      top = rowPositionMap.current.findIndex(item => item > scrollTop);
+      bot = rowPositionMap.current.findIndex(item => item > scrollTop + visibleHeight);
       if (bot === -1) bot = rowPositionMap.current.length;
     }
 
-    var upperBound = top - 1 - overscanCount;
-    var lowerBound = bot - 1 + overscanCount;
+    let upperBound = top - 1 - overscanCount;
+    let lowerBound = bot - 1 + overscanCount;
 
     if (upperBound < 0) {
       upperBound = 0;
@@ -172,9 +143,9 @@ var VirtualizedBody = function VirtualizedBody(props) {
     setHasScroll(visibleHeight < getHeight());
     setRenderedIndexes([upperBound, lowerBound]);
   }, [visibleHeight, scrollTop, rows]);
-  useLayoutEffect(function () {
+  useLayoutEffect(() => {
     if (virtualizedBodyRef) {
-      var parsedVisibleHeight = parseFloat(window.getComputedStyle(virtualizedBodyRef, null).getPropertyValue('height')); // eslint-disable-next-line no-restricted-globals
+      const parsedVisibleHeight = parseFloat(window.getComputedStyle(virtualizedBodyRef, null).getPropertyValue('height')); // eslint-disable-next-line no-restricted-globals
 
       if (!isNaN(parsedVisibleHeight)) {
         setVisibleHeight(parsedVisibleHeight);
@@ -182,25 +153,21 @@ var VirtualizedBody = function VirtualizedBody(props) {
       }
     }
   }, [rows, virtualizedBodyRef]);
-  useEffect(function () {
+  useEffect(() => {
     if (virtualizedBodyRef) {
-      var eventListener = function eventListener(event) {
-        return handlerRef.current(event);
-      };
+      const eventListener = event => handlerRef.current(event);
 
       virtualizedBodyRef.addEventListener('scroll', eventListener);
-      return function () {
+      return () => {
         virtualizedBodyRef.removeEventListener('scroll', eventListener);
       };
     }
 
-    return function () {
-      return null;
-    };
+    return () => null;
   }, [virtualizedBodyRef]);
 
-  var getHeight = function getHeight() {
-    var returnHeight = 0;
+  const getHeight = () => {
+    let returnHeight = 0;
 
     if (expandable) {
       returnHeight = getCalculatedHeightBetweenIndexes(0, rows.length) + 8;
@@ -218,8 +185,10 @@ var VirtualizedBody = function VirtualizedBody(props) {
     return returnHeight;
   };
 
-  var getRowStyle = function getRowStyle(row, index, specificRowHeight) {
-    var itemSize = listProps.itemSize;
+  const getRowStyle = (row, index, specificRowHeight) => {
+    const {
+      itemSize
+    } = listProps;
 
     if (!expandable && rowStyleCache.current[index]) {
       return rowStyleCache.current[index];
@@ -235,90 +204,65 @@ var VirtualizedBody = function VirtualizedBody(props) {
     return rowStyleCache.current[index];
   };
 
-  var generateRenderedRows = function generateRenderedRows() {
-    return rows.slice(renderedIndexes[0], renderedIndexes[1] + 1).map(function (_, index) {
-      return /*#__PURE__*/React.createElement(VirtualizedBodyRow, {
-        data: {
-          rows: rows,
-          columns: columns,
-          rowKey: rowKey,
-          renderer: {
-            rowRenderer: rowRenderer
-          }
-        },
-        index: renderedIndexes[0] + index,
-        key: rows[renderedIndexes[0] + index][rowKey],
-        style: getRowStyle(rows[renderedIndexes[0] + index], renderedIndexes[0] + index, rowHeight)
-      });
-    });
-  };
+  const generateRenderedRows = () => rows.slice(renderedIndexes[0], renderedIndexes[1] + 1).map((_, index) => /*#__PURE__*/_jsx(VirtualizedBodyRow, {
+    data: {
+      rows,
+      columns,
+      rowKey,
+      renderer: {
+        rowRenderer
+      }
+    },
+    index: renderedIndexes[0] + index,
+    style: getRowStyle(rows[renderedIndexes[0] + index], renderedIndexes[0] + index, rowHeight)
+  }, rows[renderedIndexes[0] + index][rowKey]));
 
-  var wrapperStyle = _objectSpread({
+  const wrapperStyle = _objectSpread({
     height: '100%'
   }, isSafari ? wrapperSafari : wrapperGeneric);
 
-  var bodyStyle = {
+  const bodyStyle = {
     height: getHeight(),
     willChange: 'transform',
     backfaceVisibility: 'hidden'
   };
-  return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
-    innerRef: innerRef
-  }), !isPlaceholderActive ? /*#__PURE__*/React.createElement("div", {
-    className: "virtualized-body-wrapper",
-    style: wrapperStyle,
-    ref: function ref(elem) {
-      if (elem) {
-        if (isSafari) {
-          setVirtualizedBodyRef(elem.parentElement); // eslint-disable-next-line no-param-reassign
-
-          elem.parentElement.scrollTop = scrollTop;
-          mergeRefs(listProps.outerRef)(elem.parentElement);
-        } else {
-          setVirtualizedBodyRef(elem);
-          mergeRefs(listProps.outerRef)(elem);
-        }
-      }
-    }
-  }, /*#__PURE__*/React.createElement("div", {
-    "data-testid": "virtualized-body",
-    className: "virtualized-body".concat(hasScrollBar ? ' with-scrollbar' : ''),
-    style: bodyStyle,
-    ref: function ref(r) {
-      mergeRefs(innerBody)(r);
-    }
-  }, generateRenderedRows())) : /*#__PURE__*/React.createElement(NoResults, {
+  return /*#__PURE__*/jsx(Component, _objectSpread(_objectSpread({}, props), {}, {
     innerRef: innerRef,
-    rowRenderer: rowRenderer
-  }, noResultsPlaceholder));
+    children: !isPlaceholderActive ? /*#__PURE__*/jsx("div", {
+      className: "virtualized-body-wrapper",
+      style: wrapperStyle,
+      ref: elem => {
+        if (elem) {
+          if (isSafari) {
+            setVirtualizedBodyRef(elem.parentElement); // eslint-disable-next-line no-param-reassign
+
+            elem.parentElement.scrollTop = scrollTop;
+            mergeRefs(listProps.outerRef)(elem.parentElement);
+          } else {
+            setVirtualizedBodyRef(elem);
+            mergeRefs(listProps.outerRef)(elem);
+          }
+        }
+      },
+      children: /*#__PURE__*/jsx("div", {
+        "data-testid": "virtualized-body",
+        className: "virtualized-body".concat(hasScrollBar ? ' with-scrollbar' : ''),
+        style: bodyStyle,
+        ref: r => {
+          mergeRefs(innerBody)(r);
+        },
+        children: generateRenderedRows()
+      })
+    }) : /*#__PURE__*/_jsx(NoResults, {
+      innerRef: innerRef,
+      rowRenderer: rowRenderer
+    }, void 0, noResultsPlaceholder)
+  }));
 };
 
 VirtualizedBody.defaultProps = {
   rows: [],
   overscanCount: 10
 };
-VirtualizedBody.propTypes = {
-  autoScrollToId: PropTypes.number,
-  columns: PropTypes.arrayOf(PropTypes.shape({})),
-  component: PropTypes.element,
-  expandable: PropTypes.bool,
-  filters: PropTypes.any,
-  innerRef: PropTypes.any,
-  innerBody: PropTypes.any,
-  isPlaceholderActive: PropTypes.bool,
-  listProps: PropTypes.shape({
-    itemSize: PropTypes.func,
-    outerRef: PropTypes.any
-  }),
-  noResultsPlaceholder: PropTypes.oneOf([PropTypes.string, PropTypes.element]),
-  overscanCount: PropTypes.number,
-  rows: PropTypes.arrayOf(PropTypes.shape({})),
-  rowHeight: PropTypes.number,
-  rowKey: PropTypes.string,
-  rowRenderer: PropTypes.element,
-  rowSize: PropTypes.any,
-  setHasScroll: PropTypes.func
-};
 
 export { VirtualizedBody as default };
-//# sourceMappingURL=VirtualizedBody.js.map

package/esm/plugins/virtualization/VirtualizedBodyRow.js

@@ -1,23 +1,28 @@
 function VirtualizedBodyRow(_ref) {
-  var data = _ref.data,
-      index = _ref.index,
-      style = _ref.style,
-      key = _ref.key,
-      isScrolling = _ref.isScrolling;
-  var rows = data.rows,
-      rowRenderer = data.renderer.rowRenderer;
-  var rowData = rows[index];
+  let {
+    data,
+    index,
+    style,
+    key,
+    isScrolling
+  } = _ref;
+  const {
+    rows,
+    renderer: {
+      rowRenderer
+    }
+  } = data;
+  const rowData = rows[index];
   return rowRenderer(rowData, {
-    style: style,
-    index: index,
+    style,
+    index,
     rowIndex: index,
-    key: key
+    key
   }, {
     // eslint-disable-next-line no-underscore-dangle
     rowIndex: index,
-    isScrolling: isScrolling
+    isScrolling
   });
 }
 
 export { VirtualizedBodyRow as default };
-//# sourceMappingURL=VirtualizedBodyRow.js.map

package/esm/plugins/virtualization/helper.js

@@ -1,4 +1,3 @@
-var isSafari = navigator.vendor && navigator.vendor.indexOf('Apple') > -1 && navigator.userAgent && navigator.userAgent.indexOf('CriOS') === -1 && navigator.userAgent.indexOf('FxiOS') === -1;
+const isSafari = navigator.vendor && navigator.vendor.indexOf('Apple') > -1 && navigator.userAgent && navigator.userAgent.indexOf('CriOS') === -1 && navigator.userAgent.indexOf('FxiOS') === -1;
 
 export { isSafari };
-//# sourceMappingURL=helper.js.map

package/esm/plugins/virtualization/index.js

@@ -1,19 +1 @@
 export { VirtualizationPlugin } from './VirtualizationPlugin.js';
-import '@babel/runtime/helpers/esm/extends';
-import '@babel/runtime/helpers/esm/defineProperty';
-import 'react';
-import 'lodash';
-import '@elliemae/ds-shared/FocusGroup/FocusGrid';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
-import './VirtualizedBody.js';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import 'prop-types';
-import '../../components/NoResults.js';
-import '@babel/runtime/helpers/esm/objectWithoutProperties';
-import 'styled-components';
-import '@elliemae/ds-system';
-import './VirtualizedBodyRow.js';
-import '../../rowSizes.js';
-import './helper.js';
-//# sourceMappingURL=index.js.map

package/esm/renders/CellWithAddons.js

@@ -1,98 +1,53 @@
-import React from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
 import { get } from 'lodash';
-import PropTypes from 'prop-types';
 import Grid from '@elliemae/ds-grid';
 import DSTruncatedTooltipText from '@elliemae/ds-truncated-tooltip-text';
 import { CellWrapper, ValueWrapper } from './styled.js';
-import 'styled-components';
 
-var CellWithAddons = function CellWithAddons(_ref) {
-  var leftAddon = _ref.leftAddon,
-      keepLeftPadding = _ref.keepLeftPadding,
-      rightAddon = _ref.rightAddon,
-      badgeAddon = _ref.badgeAddon,
-      highLight = _ref.highLight,
-      isEdit = _ref.isEdit,
-      editComponent = _ref.editComponent,
-      value = _ref.value,
-      neutralText = _ref.neutralText,
-      metaData = _ref.metaData;
-  var hasLeftAddon = !!leftAddon || keepLeftPadding;
-  var hasRightAddon = !!rightAddon && !isEdit;
-  var cols = [1];
-  var shouldBeGray = neutralText || get(metaData, 'rowData.customRowProps.neutralText');
+const CellWithAddons = _ref => {
+  let {
+    leftAddon,
+    keepLeftPadding,
+    rightAddon,
+    badgeAddon,
+    highLight,
+    isEdit,
+    editComponent,
+    value,
+    neutralText,
+    metaData
+  } = _ref;
+  const hasLeftAddon = !!leftAddon || keepLeftPadding;
+  const hasRightAddon = !!rightAddon && !isEdit;
+  const cols = [1];
+  const shouldBeGray = neutralText || get(metaData, 'rowData.customRowProps.neutralText');
   if (hasLeftAddon) cols.unshift('auto');
   if (hasRightAddon) cols.push('auto');
-  return /*#__PURE__*/React.createElement(CellWrapper, {
+  return /*#__PURE__*/_jsx(CellWrapper, {
     noPadding: hasLeftAddon || badgeAddon || highLight || hasRightAddon,
     hasLeftAddon: hasLeftAddon,
     hasRightAddon: hasRightAddon,
     badgeAddon: badgeAddon,
     highLight: highLight
-  }, /*#__PURE__*/React.createElement(Grid, {
+  }, void 0, /*#__PURE__*/_jsx(Grid, {
     height: "100%",
     cols: cols
-  }, hasLeftAddon && /*#__PURE__*/React.createElement(Grid, {
+  }, void 0, hasLeftAddon && /*#__PURE__*/_jsx(Grid, {
     alignItems: "center",
     pl: "xxs",
     pr: "xxs",
     width: keepLeftPadding ? '32px' : undefined
-  }, hasLeftAddon && leftAddon), /*#__PURE__*/React.createElement(Grid, {
+  }, void 0, hasLeftAddon && leftAddon), /*#__PURE__*/_jsx(Grid, {
     alignItems: "center"
-  }, /*#__PURE__*/React.createElement(ValueWrapper, {
+  }, void 0, /*#__PURE__*/_jsx(ValueWrapper, {
     grayText: shouldBeGray
-  }, isEdit ? editComponent : /*#__PURE__*/React.createElement(DSTruncatedTooltipText, {
+  }, void 0, isEdit ? editComponent : /*#__PURE__*/_jsx(DSTruncatedTooltipText, {
     value: value
-  }))), hasRightAddon && /*#__PURE__*/React.createElement(Grid, {
+  }))), hasRightAddon && /*#__PURE__*/_jsx(Grid, {
     alignItems: "center",
     pl: "xxs"
-  }, rightAddon)));
-};
-CellWithAddons.propTypes = {
-  /** Text to render inside the cell */
-  value: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
-
-  /** Left Icon */
-  leftAddon: PropTypes.element,
-
-  /** keep the left spacing even if no left addons is addded */
-  keepLeftPadding: PropTypes.bool,
-
-  /** Right Icon Button or Dropdown */
-  rightAddon: PropTypes.element,
-
-  /** TextBox/InputMask/ComboBox */
-  editComponent: PropTypes.element,
-
-  /** if is true it will show editComponent */
-  isEdit: PropTypes.bool,
-
-  /** Shows a blue mark in the top left corner */
-  badgeAddon: PropTypes.bool,
-
-  /** change background color to light blue */
-  highLight: PropTypes.bool,
-
-  /** change text color to light gray */
-  neutralText: PropTypes.bool,
-
-  /** data grid meta-information */
-  metaData: PropTypes.shape({
-    className: PropTypes.string,
-    column: PropTypes.object,
-    columnIndex: PropTypes.number,
-    index: PropTypes.number,
-    isScrolling: PropTypes.bool,
-    key: PropTypes.string,
-    parentRowData: PropTypes.any,
-    property: PropTypes.string,
-    registerFocus: PropTypes.func,
-    rowData: PropTypes.object,
-    rowIndex: PropTypes.number,
-    rowKey: PropTypes.string,
-    style: PropTypes.object
-  })
+  }, void 0, rightAddon)));
 };
 
 export { CellWithAddons };
-//# sourceMappingURL=CellWithAddons.js.map

package/esm/renders/index.js

@@ -1,9 +1,2 @@
 export { CellWithAddons } from './CellWithAddons.js';
 export { CellContainer } from './styled.js';
-import 'react';
-import 'lodash';
-import 'prop-types';
-import '@elliemae/ds-grid';
-import '@elliemae/ds-truncated-tooltip-text';
-import 'styled-components';
-//# sourceMappingURL=index.js.map