@elliemae/ds-datagrids 2.3.0-alpha.9 → 2.3.0-next.3

package/esm/plugins/virtualization/VirtualizationPlugin.js

@@ -0,0 +1,97 @@
+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 { useMemo, useRef } from 'react';
+import { get } from 'lodash';
+import FocusGridManager from '@elliemae/ds-shared/FocusGroup/FocusGrid';
+import { mergeRefs, runAll } from '@elliemae/ds-utilities';
+import createInstancePlugin from '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
+import VirtualizedBody from './VirtualizedBody.js';
+import { jsx } from 'react/jsx-runtime';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+const VirtualizationPlugin = createInstancePlugin('virtualization', {
+  decorateRenderers(renderers, grid) {
+    const BodyWrapper = renderers.body.wrapper; // eslint-disable-next-line react/display-name
+
+    renderers.body.wrapper = useMemo(() => props => {
+      const {
+        listProps = {},
+        rows
+      } = props;
+      const {
+        hotKeys,
+        props: {
+          autoHeight,
+          autoScrollToId,
+          expandable,
+          overscanCount,
+          rowSize
+        },
+        refs: {
+          innerBody
+        },
+        setHasScroll,
+        state: {
+          filters
+        }
+      } = grid.getInstance();
+      const listRef = useRef();
+
+      const nextListProps = _objectSpread(_objectSpread({}, listProps), {}, {
+        ref: mergeRefs(listRef, listProps.ref)
+      });
+
+      return /*#__PURE__*/_jsx(FocusGridManager, {
+        hotKeys: hotKeys,
+        keyBindings: _ref => {
+          let {
+            defaultBindings
+          } = _ref;
+          return _objectSpread(_objectSpread({}, defaultBindings), {}, {
+            // todo: this is kind of hacky, since it's virtualized and there's
+            //  the possibility that the firsts or lasts rows aren't rendered
+            Home: runAll(e => {
+              if (e.ctrlKey) {
+                listRef.current.scrollToItem(0);
+                setTimeout(() => defaultBindings.Home(e), 10);
+              } else {
+                defaultBindings.Home(e);
+              }
+            }),
+            End: runAll(e => {
+              if (e.ctrlKey) {
+                listRef.current.scrollToItem(rows.length - 1);
+                setTimeout(() => defaultBindings.End(e), 10);
+              } else {
+                defaultBindings.End(e);
+              }
+            })
+          });
+        },
+        shouldRefocus: false
+      }, void 0, /*#__PURE__*/jsx(VirtualizedBody, _objectSpread(_objectSpread({}, props), {}, {
+        autoScrollToId: autoScrollToId,
+        autoHeight: autoHeight,
+        component: BodyWrapper,
+        expandable: expandable,
+        innerBody: innerBody,
+        listProps: nextListProps,
+        overscanCount: overscanCount,
+        rowSize: rowSize,
+        setHasScroll: setHasScroll,
+        filters: filters
+      })));
+    }, [get(grid.getInstance(), 'rows.length')]);
+    return renderers;
+  }
+
+});
+
+export { VirtualizationPlugin };

package/esm/plugins/virtualization/VirtualizedBody.js

@@ -0,0 +1,268 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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 { jsx } from 'react/jsx-runtime';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+const wrapperSafari = {};
+const wrapperGeneric = {
+  overflowY: 'auto',
+  overflowX: 'visible'
+};
+
+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((_, idx) => idx).map(idx => itemSize(idx)).reduce((acc, curr) => acc + curr, 0);
+    }
+
+    return (end - start) * rowHeight;
+  };
+
+  const generateRowPositionMap = () => rows.map((row, idx) => getCalculatedHeightBetweenIndexes(0, idx));
+
+  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);
+    }
+
+    if (lastPosition < val) {
+      val = lastPosition;
+    }
+
+    if (virtualizedBodyRef) {
+      if (idx > -1) {
+        setScrollTop(val);
+        virtualizedBodyRef.scrollTop = val;
+      }
+    }
+  }, [rows, virtualizedBodyRef]);
+  useEffect(() => {
+    autoScrollTo(visibleHeight);
+  }, [autoScrollToId, visibleHeight]);
+  const handler = useCallback(debounce(_ref => {
+    let {
+      target
+    } = _ref;
+    // Update coordinates
+    setScrollTop(target.scrollTop || 0);
+  }, 100), [setScrollTop]);
+  useEffect(() => {
+    setScrollTop(0);
+  }, [filters]);
+  useEffect(() => {
+    handlerRef.current = handler;
+  }, [handler]);
+  useLayoutEffect(() => {
+    let top = Math.ceil(scrollTop / rowHeight);
+    let bot = Math.ceil((scrollTop + visibleHeight) / rowHeight);
+
+    if (expandable) {
+      // updateMapperFirst
+      rowPositionMap.current = generateRowPositionMap();
+      top = rowPositionMap.current.findIndex(item => item > scrollTop);
+      bot = rowPositionMap.current.findIndex(item => item > scrollTop + visibleHeight);
+      if (bot === -1) bot = rowPositionMap.current.length;
+    }
+
+    let upperBound = top - 1 - overscanCount;
+    let lowerBound = bot - 1 + overscanCount;
+
+    if (upperBound < 0) {
+      upperBound = 0;
+    }
+
+    if (lowerBound - upperBound < overscanCount) {
+      lowerBound = upperBound + overscanCount;
+    }
+
+    if (lowerBound > rows.length) {
+      lowerBound = rows.length;
+    }
+
+    setHasScrollBar(visibleHeight < getHeight());
+    setHasScroll(visibleHeight < getHeight());
+    setRenderedIndexes([upperBound, lowerBound]);
+  }, [visibleHeight, scrollTop, rows]);
+  useLayoutEffect(() => {
+    if (virtualizedBodyRef) {
+      const parsedVisibleHeight = parseFloat(window.getComputedStyle(virtualizedBodyRef, null).getPropertyValue('height')); // eslint-disable-next-line no-restricted-globals
+
+      if (!isNaN(parsedVisibleHeight)) {
+        setVisibleHeight(parsedVisibleHeight);
+        autoScrollTo(parsedVisibleHeight);
+      }
+    }
+  }, [rows, virtualizedBodyRef]);
+  useEffect(() => {
+    if (virtualizedBodyRef) {
+      const eventListener = event => handlerRef.current(event);
+
+      virtualizedBodyRef.addEventListener('scroll', eventListener);
+      return () => {
+        virtualizedBodyRef.removeEventListener('scroll', eventListener);
+      };
+    }
+
+    return () => null;
+  }, [virtualizedBodyRef]);
+
+  const getHeight = () => {
+    let returnHeight = 0;
+
+    if (expandable) {
+      returnHeight = getCalculatedHeightBetweenIndexes(0, rows.length) + 8;
+    } else {
+      returnHeight = rows.length * rowHeight + 8;
+    } // if (visibleHeight > returnHeight) {
+    //   return visibleHeight;
+    // }
+
+
+    if (virtualizedBodyRef && virtualizedBodyRef.scrollHeight > virtualizedBodyRef.clientHeight) {
+      return returnHeight + 10;
+    }
+
+    return returnHeight;
+  };
+
+  const getRowStyle = (row, index, specificRowHeight) => {
+    const {
+      itemSize
+    } = listProps;
+
+    if (!expandable && rowStyleCache.current[index]) {
+      return rowStyleCache.current[index];
+    }
+
+    rowStyleCache.current[index] = {
+      height: itemSize ? itemSize(index) : specificRowHeight,
+      left: 0,
+      right: 0,
+      top: getCalculatedHeightBetweenIndexes(0, index),
+      position: 'absolute'
+    };
+    return rowStyleCache.current[index];
+  };
+
+  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]));
+
+  const wrapperStyle = _objectSpread({
+    height: '100%'
+  }, isSafari ? wrapperSafari : wrapperGeneric);
+
+  const bodyStyle = {
+    height: getHeight(),
+    willChange: 'transform',
+    backfaceVisibility: 'hidden'
+  };
+  return /*#__PURE__*/jsx(Component, _objectSpread(_objectSpread({}, props), {}, {
+    innerRef: innerRef,
+    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
+};
+
+export { VirtualizedBody as default };

package/esm/plugins/virtualization/VirtualizedBodyRow.js

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

package/esm/plugins/virtualization/helper.js

@@ -0,0 +1,3 @@
+const isSafari = navigator.vendor && navigator.vendor.indexOf('Apple') > -1 && navigator.userAgent && navigator.userAgent.indexOf('CriOS') === -1 && navigator.userAgent.indexOf('FxiOS') === -1;
+
+export { isSafari };

package/esm/plugins/virtualization/index.js

@@ -0,0 +1 @@
+export { VirtualizationPlugin } from './VirtualizationPlugin.js';

package/esm/renders/CellWithAddons.js

@@ -0,0 +1,53 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
+import { get } from 'lodash';
+import Grid from '@elliemae/ds-grid';
+import DSTruncatedTooltipText from '@elliemae/ds-truncated-tooltip-text';
+import { CellWrapper, ValueWrapper } from './styled.js';
+
+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__*/_jsx(CellWrapper, {
+    noPadding: hasLeftAddon || badgeAddon || highLight || hasRightAddon,
+    hasLeftAddon: hasLeftAddon,
+    hasRightAddon: hasRightAddon,
+    badgeAddon: badgeAddon,
+    highLight: highLight
+  }, void 0, /*#__PURE__*/_jsx(Grid, {
+    height: "100%",
+    cols: cols
+  }, void 0, hasLeftAddon && /*#__PURE__*/_jsx(Grid, {
+    alignItems: "center",
+    pl: "xxs",
+    pr: "xxs",
+    width: keepLeftPadding ? '32px' : undefined
+  }, void 0, hasLeftAddon && leftAddon), /*#__PURE__*/_jsx(Grid, {
+    alignItems: "center"
+  }, void 0, /*#__PURE__*/_jsx(ValueWrapper, {
+    grayText: shouldBeGray
+  }, void 0, isEdit ? editComponent : /*#__PURE__*/_jsx(DSTruncatedTooltipText, {
+    value: value
+  }))), hasRightAddon && /*#__PURE__*/_jsx(Grid, {
+    alignItems: "center",
+    pl: "xxs"
+  }, void 0, rightAddon)));
+};
+
+export { CellWithAddons };

package/esm/renders/index.js

@@ -0,0 +1,2 @@
+export { CellWithAddons } from './CellWithAddons.js';
+export { CellContainer } from './styled.js';

package/esm/renders/styled.js

@@ -0,0 +1,16 @@
+import styled from 'styled-components';
+import Grid from '@elliemae/ds-grid';
+
+const m = '0.61538rem';
+const m2 = '1.23076rem';
+const CellWrapper = /*#__PURE__*/styled.div.withConfig({
+  componentId: "sc-1n8exyf-0"
+})(["max-height:36px;height:100%;width:", ";margin-left:", ";margin-right:", ";padding-left:", ";padding-right:", ";", ";", ""], props => props.noPadding ? "calc(100% + ".concat(m2, ")") : '100%', props => props.noPadding ? "-".concat(m) : '0', props => props.noPadding ? "-".concat(m) : '0', props => !props.hasLeftAddon && (props.badgeAddon || props.highLight || props.hasRightAddon) ? m : '0', props => !props.hasRightAddon && (props.badgeAddon || props.highLight || props.hasLeftAddon) ? m : '0', props => props.highLight ? "background: ".concat(props.theme.colors.brand['200']) : '', props => props.badgeAddon ? "\n  position: relative;  \n  &::before {\n    display: block;\n    content: '';\n    position: absolute;\n    top: 0;\n    left:0;\n    border-style: solid;\n    border-width:  ".concat(props.theme.space.xxs, " ").concat(props.theme.space.xxs, "  ").concat(props.theme.space.xxs, " 0;\n    border-color: ").concat(props.theme.colors.brand['600'], " transparent  transparent ").concat(props.theme.colors.brand['600'], ";\n  }\n  ") : '');
+const ValueWrapper = /*#__PURE__*/styled.div.withConfig({
+  componentId: "sc-1n8exyf-1"
+})(["display:flex;align-items:center;overflow:hidden;& > span{display:inline-flex;align-items:center;}", ""], props => props.grayText ? "color: ".concat(props.theme.colors.neutral['500'], ";") : '');
+const CellContainer = /*#__PURE__*/styled(Grid).withConfig({
+  componentId: "sc-1n8exyf-2"
+})(["padding-left:", ";padding-right:", ";position:relative;"], m, m);
+
+export { CellContainer, CellWrapper, ValueWrapper };

package/esm/rowSizes.js

@@ -0,0 +1,13 @@
+const RowSizes = {
+  compact: 28,
+  normal: 36,
+  extend: 56
+};
+const RowSizesOptions = {
+  compact: 'compact',
+  normal: 'normal',
+  extend: 'extend'
+};
+const RowSizesOptionsArr = [RowSizesOptions.compact, RowSizesOptions.normal, RowSizesOptions.extend];
+
+export { RowSizes, RowSizesOptions, RowSizesOptionsArr };

package/esm/utilities/getPluginsFromProps.js

@@ -0,0 +1,42 @@
+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 { DndRowsPlugin } from '../plugins/row-dnd/DndRowsPlugin.js';
+import { DndColumnsPlugin } from '../plugins/column-dnd/DndColumnsPlugin.js';
+import { InfiniteScrollPlugin } from '../plugins/infinite-scrolling/InfiniteScrollPlugin.js';
+import { EditablePlugin } from '../plugins/editable/EditablePlugin.js';
+import { SortablePlugin } from '../plugins/sortable/SortablePlugin.js';
+import { SelectablePlugin } from '../plugins/selectable/SelectablePlugin.js';
+import { FilterablePlugin } from '../plugins/filterable/FilterablePlugin.js';
+import { ToolbarPlugin } from '../plugins/toolbar/ToolbarPlugin.js';
+import { PaginationPlugin } from '../plugins/pagination/PaginationPlugin.js';
+import { VirtualizationPlugin } from '../plugins/virtualization/VirtualizationPlugin.js';
+import { ExpandablePlugin } from '../plugins/expandable-grid/ExpandablePlugin.js';
+import { GroupingPlugin } from '../plugins/grouping-grid/GroupingPlugin.js';
+import { GroupingByPlugin } from '../plugins/grouping-by/GroupingByPlugin.js';
+
+const mapPropToPlugin = {
+  dragAndDropColumns: DndColumnsPlugin,
+  editable: EditablePlugin,
+  selectable: SelectablePlugin,
+  sortable: SortablePlugin,
+  searchFilters: FilterablePlugin,
+  renderToolbar: ToolbarPlugin,
+  infiniteScrolling: InfiniteScrollPlugin,
+  paginated: PaginationPlugin,
+  virtualized: VirtualizationPlugin,
+  expandable: ExpandablePlugin,
+  groupedBy: GroupingByPlugin,
+  groupedRows: GroupingPlugin,
+  dragAndDropRows: DndRowsPlugin
+};
+function getPluginsFromProps(props) {
+  let omit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const plugins = [];
+  Object.keys(mapPropToPlugin).forEach(key => {
+    if (props[key] && !omit[key]) plugins.push(mapPropToPlugin[key]);
+  });
+  return plugins;
+}
+
+export { getPluginsFromProps as default };

package/esm/utilities/getScrollbarSize.js

@@ -0,0 +1,23 @@
+function getScrollbarWidth() {
+  let compensatePixels = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  // Creating invisible container
+  const outer = document.createElement('div');
+  outer.style.visibility = 'hidden';
+  outer.style.overflow = 'scroll'; // forcing scrollbar to appear
+
+  outer.style.msOverflowStyle = 'scrollbar'; // needed for WinJS apps
+
+  document.body.appendChild(outer); // Creating inner element and placing it in the container
+
+  const inner = document.createElement('div');
+  outer.appendChild(inner); // Calculating difference between container's full width and the child width
+
+  const scrollbarWidth = outer.offsetWidth - inner.offsetWidth; // Removing temporary elements from the DOM
+
+  outer.parentNode.removeChild(outer); // compensatePixels to check for MacOS's show
+  // scrollbar only when moving it
+
+  return scrollbarWidth + compensatePixels;
+}
+
+export { getScrollbarWidth };

package/esm/utilities/normalizeData.js

@@ -0,0 +1,29 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+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.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/es.string.replace.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+const normalizeRows = rows => rows.map(row => {
+  Object.keys(row).forEach(key => row[normalizeText(key)] = row[key]);
+  return row;
+});
+const normalizeColumns = columns => columns.map(column => {
+  const {
+    property
+  } = column;
+  return _objectSpread(_objectSpread({}, column), {}, {
+    originalProperty: column.property,
+    property: normalizeText(property)
+  });
+});
+const normalizeText = text => text.replace(/\s+/g, '');
+
+export { normalizeColumns, normalizeRows, normalizeText };