@elliemae/ds-datagrids 2.3.0-alpha.8 → 2.3.0-next.2

package/cjs/plugins/virtualization/VirtualizedBody.js

@@ -0,0 +1,275 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var React = require('react');
+var dsUtilities = require('@elliemae/ds-utilities');
+var NoResults = require('../../components/NoResults.js');
+var VirtualizedBodyRow = require('./VirtualizedBodyRow.js');
+var rowSizes = require('../../rowSizes.js');
+var helper = require('./helper.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+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__default["default"](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.RowSizes[rowSize];
+  const [scrollTop, setScrollTop] = React.useState(0);
+  const [visibleHeight, setVisibleHeight] = React.useState(0);
+  const [hasScrollBar, setHasScrollBar] = React.useState(false);
+  const rowStyleCache = React.useRef({});
+  const [renderedIndexes, setRenderedIndexes] = React.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 = React.useRef(generateRowPositionMap());
+  const [virtualizedBodyRef, setVirtualizedBodyRef] = React.useState(null);
+  const handlerRef = React.useRef();
+  const autoScrollTo = React.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]);
+  React.useEffect(() => {
+    autoScrollTo(visibleHeight);
+  }, [autoScrollToId, visibleHeight]);
+  const handler = React.useCallback(dsUtilities.debounce(_ref => {
+    let {
+      target
+    } = _ref;
+    // Update coordinates
+    setScrollTop(target.scrollTop || 0);
+  }, 100), [setScrollTop]);
+  React.useEffect(() => {
+    setScrollTop(0);
+  }, [filters]);
+  React.useEffect(() => {
+    handlerRef.current = handler;
+  }, [handler]);
+  React.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]);
+  React.useLayoutEffect(() => {
+    if (virtualizedBodyRef) {
+      const parsedVisibleHeight = parseFloat(window.getComputedStyle(virtualizedBodyRef, null).getPropertyValue('height')); // eslint-disable-next-line no-restricted-globals
+
+      if (!dsUtilities.isNaN(parsedVisibleHeight)) {
+        setVisibleHeight(parsedVisibleHeight);
+        autoScrollTo(parsedVisibleHeight);
+      }
+    }
+  }, [rows, virtualizedBodyRef]);
+  React.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__default["default"](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%'
+  }, helper.isSafari ? wrapperSafari : wrapperGeneric);
+
+  const bodyStyle = {
+    height: getHeight(),
+    willChange: 'transform',
+    backfaceVisibility: 'hidden'
+  };
+  return /*#__PURE__*/jsxRuntime.jsx(Component, _objectSpread(_objectSpread({}, props), {}, {
+    innerRef: innerRef,
+    children: !isPlaceholderActive ? /*#__PURE__*/jsxRuntime.jsx("div", {
+      className: "virtualized-body-wrapper",
+      style: wrapperStyle,
+      ref: elem => {
+        if (elem) {
+          if (helper.isSafari) {
+            setVirtualizedBodyRef(elem.parentElement); // eslint-disable-next-line no-param-reassign
+
+            elem.parentElement.scrollTop = scrollTop;
+            dsUtilities.mergeRefs(listProps.outerRef)(elem.parentElement);
+          } else {
+            setVirtualizedBodyRef(elem);
+            dsUtilities.mergeRefs(listProps.outerRef)(elem);
+          }
+        }
+      },
+      children: /*#__PURE__*/jsxRuntime.jsx("div", {
+        "data-testid": "virtualized-body",
+        className: "virtualized-body".concat(hasScrollBar ? ' with-scrollbar' : ''),
+        style: bodyStyle,
+        ref: r => {
+          dsUtilities.mergeRefs(innerBody)(r);
+        },
+        children: generateRenderedRows()
+      })
+    }) : /*#__PURE__*/_jsx__default["default"](NoResults, {
+      innerRef: innerRef,
+      rowRenderer: rowRenderer
+    }, void 0, noResultsPlaceholder)
+  }));
+};
+
+VirtualizedBody.defaultProps = {
+  rows: [],
+  overscanCount: 10
+};
+
+module.exports = VirtualizedBody;

package/cjs/plugins/virtualization/VirtualizedBodyRow.js

@@ -0,0 +1,30 @@
+'use strict';
+
+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
+  });
+}
+
+module.exports = VirtualizedBodyRow;

package/cjs/plugins/virtualization/helper.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isSafari = navigator.vendor && navigator.vendor.indexOf('Apple') > -1 && navigator.userAgent && navigator.userAgent.indexOf('CriOS') === -1 && navigator.userAgent.indexOf('FxiOS') === -1;
+
+exports.isSafari = isSafari;

package/cjs/plugins/virtualization/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var VirtualizationPlugin = require('./VirtualizationPlugin.js');
+
+
+
+exports.VirtualizationPlugin = VirtualizationPlugin.VirtualizationPlugin;

package/cjs/renders/CellWithAddons.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('react');
+var lodash = require('lodash');
+var Grid = require('@elliemae/ds-grid');
+var DSTruncatedTooltipText = require('@elliemae/ds-truncated-tooltip-text');
+var styled = require('./styled.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var Grid__default = /*#__PURE__*/_interopDefaultLegacy(Grid);
+var DSTruncatedTooltipText__default = /*#__PURE__*/_interopDefaultLegacy(DSTruncatedTooltipText);
+
+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 || lodash.get(metaData, 'rowData.customRowProps.neutralText');
+  if (hasLeftAddon) cols.unshift('auto');
+  if (hasRightAddon) cols.push('auto');
+  return /*#__PURE__*/_jsx__default["default"](styled.CellWrapper, {
+    noPadding: hasLeftAddon || badgeAddon || highLight || hasRightAddon,
+    hasLeftAddon: hasLeftAddon,
+    hasRightAddon: hasRightAddon,
+    badgeAddon: badgeAddon,
+    highLight: highLight
+  }, void 0, /*#__PURE__*/_jsx__default["default"](Grid__default["default"], {
+    height: "100%",
+    cols: cols
+  }, void 0, hasLeftAddon && /*#__PURE__*/_jsx__default["default"](Grid__default["default"], {
+    alignItems: "center",
+    pl: "xxs",
+    pr: "xxs",
+    width: keepLeftPadding ? '32px' : undefined
+  }, void 0, hasLeftAddon && leftAddon), /*#__PURE__*/_jsx__default["default"](Grid__default["default"], {
+    alignItems: "center"
+  }, void 0, /*#__PURE__*/_jsx__default["default"](styled.ValueWrapper, {
+    grayText: shouldBeGray
+  }, void 0, isEdit ? editComponent : /*#__PURE__*/_jsx__default["default"](DSTruncatedTooltipText__default["default"], {
+    value: value
+  }))), hasRightAddon && /*#__PURE__*/_jsx__default["default"](Grid__default["default"], {
+    alignItems: "center",
+    pl: "xxs"
+  }, void 0, rightAddon)));
+};
+
+exports.CellWithAddons = CellWithAddons;

package/cjs/renders/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var CellWithAddons = require('./CellWithAddons.js');
+var styled = require('./styled.js');
+
+
+
+exports.CellWithAddons = CellWithAddons.CellWithAddons;
+exports.CellContainer = styled.CellContainer;

package/cjs/renders/styled.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var styled = require('styled-components');
+var Grid = require('@elliemae/ds-grid');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var styled__default = /*#__PURE__*/_interopDefaultLegacy(styled);
+var Grid__default = /*#__PURE__*/_interopDefaultLegacy(Grid);
+
+const m = '0.61538rem';
+const m2 = '1.23076rem';
+const CellWrapper = /*#__PURE__*/styled__default["default"].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__default["default"].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__default["default"](Grid__default["default"]).withConfig({
+  componentId: "sc-1n8exyf-2"
+})(["padding-left:", ";padding-right:", ";position:relative;"], m, m);
+
+exports.CellContainer = CellContainer;
+exports.CellWrapper = CellWrapper;
+exports.ValueWrapper = ValueWrapper;

package/cjs/rowSizes.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const RowSizes = {
+  compact: 28,
+  normal: 36,
+  extend: 56
+};
+const RowSizesOptions = {
+  compact: 'compact',
+  normal: 'normal',
+  extend: 'extend'
+};
+const RowSizesOptionsArr = [RowSizesOptions.compact, RowSizesOptions.normal, RowSizesOptions.extend];
+
+exports.RowSizes = RowSizes;
+exports.RowSizesOptions = RowSizesOptions;
+exports.RowSizesOptionsArr = RowSizesOptionsArr;

package/cjs/utilities/getPluginsFromProps.js

@@ -0,0 +1,44 @@
+'use strict';
+
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var DndRowsPlugin = require('../plugins/row-dnd/DndRowsPlugin.js');
+var DndColumnsPlugin = require('../plugins/column-dnd/DndColumnsPlugin.js');
+var InfiniteScrollPlugin = require('../plugins/infinite-scrolling/InfiniteScrollPlugin.js');
+var EditablePlugin = require('../plugins/editable/EditablePlugin.js');
+var SortablePlugin = require('../plugins/sortable/SortablePlugin.js');
+var SelectablePlugin = require('../plugins/selectable/SelectablePlugin.js');
+var FilterablePlugin = require('../plugins/filterable/FilterablePlugin.js');
+var ToolbarPlugin = require('../plugins/toolbar/ToolbarPlugin.js');
+var PaginationPlugin = require('../plugins/pagination/PaginationPlugin.js');
+var VirtualizationPlugin = require('../plugins/virtualization/VirtualizationPlugin.js');
+var ExpandablePlugin = require('../plugins/expandable-grid/ExpandablePlugin.js');
+var GroupingPlugin = require('../plugins/grouping-grid/GroupingPlugin.js');
+var GroupingByPlugin = require('../plugins/grouping-by/GroupingByPlugin.js');
+
+const mapPropToPlugin = {
+  dragAndDropColumns: DndColumnsPlugin.DndColumnsPlugin,
+  editable: EditablePlugin.EditablePlugin,
+  selectable: SelectablePlugin.SelectablePlugin,
+  sortable: SortablePlugin.SortablePlugin,
+  searchFilters: FilterablePlugin.FilterablePlugin,
+  renderToolbar: ToolbarPlugin.ToolbarPlugin,
+  infiniteScrolling: InfiniteScrollPlugin.InfiniteScrollPlugin,
+  paginated: PaginationPlugin.PaginationPlugin,
+  virtualized: VirtualizationPlugin.VirtualizationPlugin,
+  expandable: ExpandablePlugin.ExpandablePlugin,
+  groupedBy: GroupingByPlugin.GroupingByPlugin,
+  groupedRows: GroupingPlugin.GroupingPlugin,
+  dragAndDropRows: DndRowsPlugin.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;
+}
+
+module.exports = getPluginsFromProps;

package/cjs/utilities/getScrollbarSize.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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;
+}
+
+exports.getScrollbarWidth = getScrollbarWidth;

package/cjs/utilities/normalizeData.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/es.string.replace.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+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__default["default"](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, '');
+
+exports.normalizeColumns = normalizeColumns;
+exports.normalizeRows = normalizeRows;
+exports.normalizeText = normalizeText;