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

package/cjs/useDataGrid/useDataGrid.js

@@ -0,0 +1,220 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+require('core-js/modules/web.dom-collections.iterator.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.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+var dsUtilities = require('@elliemae/ds-utilities');
+var React = require('react');
+var uuid = require('uuid');
+var resolve = require('table-resolver');
+var initColumnDefinition = require('./initColumnDefinition.js');
+var utils$1 = require('../createDataInstance/utils.js');
+var VolatileRowsListener = require('./VolatileRowsListener.js');
+var utils = require('../utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
+var resolve__namespace = /*#__PURE__*/_interopNamespace(resolve);
+
+const _excluded = ["uuid", "plugins", "rows", "columns", "renderers"];
+
+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 IS_INTERNET_EXPLORER = utils.isInternetExplorer(); // TODO: Reuse createDataInstance for the grid the same
+//  way as the list does ex: packages/ds-shared/src/useDataList/useDataList.js
+// eslint-disable-next-line max-statements
+
+function useDataGrid(_ref) {
+  let {
+    uuid: uuidProp,
+    plugins: pluginsFromProps,
+    rows,
+    columns,
+    renderers = {}
+  } = _ref,
+      props = _objectWithoutProperties__default["default"](_ref, _excluded);
+
+  const plugins = pluginsFromProps;
+  const instance = React.useRef();
+  const tableRef = React.useRef();
+  const headerRef = React.useRef();
+  const bodyRef = React.useRef();
+  const bodyInnerRef = React.useRef();
+  const [uuid$1] = React.useState(uuidProp || (() => uuid.v4()));
+  const [hasScroll, setHasScroll] = React.useState(false);
+  const [isRowDragging, setIsRowDragging] = React.useState(false);
+  const isScrolling = React.useRef();
+  const shouldRefocus = React.useRef(); // todo: we probably need a plugin for focus related stuff
+
+  const [RowsObserver] = React.useState(() => new VolatileRowsListener()); // todo move this with rows composition
+
+  const [originalRows, updateRows] = dsUtilities.useDerivedStateFromProps(rows, {
+    onUpdate: resolve__namespace.resolve({
+      columns,
+      method: extra => dsUtilities.compose(resolve__namespace.byFunction('valueTransformation')(extra), resolve__namespace.nested(extra))
+    }),
+    updateOnStateChange: true
+  });
+  instance.current = {
+    decoratedRenderers: dsUtilities.cloneDeep(renderers),
+    decoratedColumns: columns,
+    columns,
+    rows,
+    composedRows: originalRows,
+    getRowProps: [],
+    getHeaderRowProps: [],
+    getBodyProps: [],
+    getTableProps: [],
+    effects: [],
+    uuid: uuid$1,
+    props,
+    refs: {
+      table: tableRef,
+      body: bodyRef,
+      header: headerRef,
+      innerBody: bodyInnerRef
+    },
+    state: {
+      hasScroll
+    },
+    actions: {
+      updateRows
+    },
+    updateRows,
+    // eslint-disable-next-line no-return-assign
+    enableEvents: () => document.body.style.pointerEvents = IS_INTERNET_EXPLORER ? '' : null,
+    // eslint-disable-next-line no-return-assign
+    disableEvents: () => document.body.style.pointerEvents = 'none',
+    observeRows: observer => RowsObserver.observe(observer),
+    hotKeys: {},
+    shouldRefocus,
+    isScrolling,
+    setHasScroll,
+    setIsRowDragging,
+    isRowDragging,
+    plugins
+  };
+
+  instance.current.getState = () => instance.current.state;
+
+  instance.current.getInstance = () => instance.current;
+
+  const defaultDecorators = {
+    decorateGrid: [],
+    registerStateHook: [],
+    registerHotKeys: [],
+    decorateColumn: [],
+    decorateColumns: [cols => cols.map(col => initColumnDefinition["default"]({
+      useTextTruncation: col.useTextTruncation,
+      wrapText: props.wrapText,
+      normalize: props.normalizeDataKeys
+    })(col))],
+    decorateRenderers: [],
+    getRowProps: [],
+    getHeaderRowProps: [],
+    getBodyProps: [],
+    getTableProps: [],
+    getHeaderProps: [],
+    composeRows: []
+  };
+  const decorators = React.useMemo(() => {
+    let nextDecorators = defaultDecorators; // eslint-disable-next-line no-return-assign
+
+    plugins.forEach(plugin => nextDecorators = plugin(nextDecorators));
+    return nextDecorators;
+  }, [plugins]);
+  instance.current = decorators.decorateGrid.reduce((nextInstance, decorator) => _objectSpread(_objectSpread({}, nextInstance), decorator(instance.current)), instance.current);
+  instance.current = decorators.registerStateHook.reduce((nextInstance, decorator) => {
+    const {
+      state,
+      actions
+    } = decorator(instance.current);
+    return _objectSpread(_objectSpread({}, nextInstance), {}, {
+      state: _objectSpread(_objectSpread({}, nextInstance.state), state),
+      actions: _objectSpread(_objectSpread({}, nextInstance.actions), actions)
+    });
+  }, instance.current);
+
+  const reduceHotKey = (nextInstance, _ref2) => {
+    let {
+      key,
+      handler,
+      options
+    } = _ref2;
+    return _objectSpread(_objectSpread({}, nextInstance), {}, {
+      hotKeys: _objectSpread(_objectSpread({}, nextInstance.hotKeys), {}, {
+        [key]: {
+          handler,
+          options
+        }
+      })
+    });
+  };
+
+  instance.current = decorators.registerHotKeys.reduce((nextInstance, decorator) => {
+    const hotKeys = decorator(nextInstance);
+
+    if (Array.isArray(hotKeys)) {
+      return hotKeys.reduce(reduceHotKey, nextInstance);
+    }
+
+    return reduceHotKey(nextInstance, hotKeys);
+  }, instance.current);
+  instance.current.decoratedRenderers = utils$1.applyDecorators(instance.current.decoratedRenderers, decorators.decorateRenderers, instance.current);
+  instance.current.decoratedColumns = React.useMemo(() => {
+    const visibleColumns = dsUtilities.cloneDeep(columns).filter(column => typeof column.visible === 'undefined' || column.visible);
+    return visibleColumns.length ? utils$1.decorateColumns(visibleColumns, decorators, instance.current) : [];
+  }, [columns]);
+  instance.current.getBodyProps = utils$1.reducePropsGetter(decorators.getBodyProps, instance.current);
+  instance.current.getHeaderProps = utils$1.reducePropsGetter(decorators.getHeaderProps, instance.current);
+  instance.current.getRowProps = utils$1.reducePropsGetter(decorators.getRowProps, instance.current);
+  instance.current.getHeaderRowProps = utils$1.reducePropsGetter(decorators.getHeaderRowProps, instance.current);
+  instance.current.getTableProps = utils$1.reducePropsGetter(decorators.getTableProps, instance.current);
+  instance.current.composedRows = decorators.composeRows.reduce((nextRows, getter) => getter(nextRows, instance.current), instance.current.composedRows);
+  RowsObserver.notify(instance.current.composedRows);
+  const currentShouldRefocus = instance.current.shouldRefocus.current;
+  const prevState = dsUtilities.usePrevious(instance.current.state);
+
+  if (dsUtilities.isObject(currentShouldRefocus) && currentShouldRefocus.forced) {
+    instance.current.shouldRefocus.current = currentShouldRefocus.value;
+  } else {
+    instance.current.shouldRefocus.current = !dsUtilities.isEqual(prevState, instance.current.state);
+  }
+
+  if (props.instanceRef) dsUtilities.setRef(props.instanceRef, instance.current);
+  return _objectSpread(_objectSpread({}, instance.current), {}, {
+    decorators
+  });
+}
+
+module.exports = useDataGrid;

package/cjs/useDataList/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var useDataList = require('./useDataList.js');
+
+
+
+module.exports = useDataList["default"];

package/cjs/useDataList/recordIterator.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const defaultStrategy = () => {
+  throw Error('Implement an iterator strategy for record iterator');
+};
+
+function recordIterator(records) {
+  let strategy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultStrategy;
+  let decorators = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  let instance = arguments.length > 3 ? arguments[3] : undefined;
+  const nextRows = [];
+  strategy({
+    data: records,
+    cb: row => {
+      let nextRow = row; // eslint-disable-next-line no-loops/no-loops,no-plusplus
+
+      for (let i = 0; i < decorators.length; i++) {
+        nextRow = decorators[i](nextRow, instance);
+        if (!nextRow) break;
+      }
+
+      if (nextRow) nextRows.push(nextRow);
+    },
+    instance
+  });
+  return nextRows;
+}
+
+exports.recordIterator = recordIterator;

package/cjs/useDataList/useDataList.js

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+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.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 get = require('lodash/get');
+var utils = require('../createDataInstance/utils.js');
+var recordIterator = require('./recordIterator.js');
+var createInstanceRef = require('../createDataInstance/createInstanceRef.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
+var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
+
+const _excluded = ["data", "plugins", "renderers", "itemRenderer", "customDecorators"];
+
+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 getItemLabel = function (record) {
+  let nameKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'name';
+  return get__default["default"](record, ['data', nameKey]);
+};
+const getItemChildren = function (record) {
+  let childrenKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'children';
+  return get__default["default"](record, ['data', childrenKey]);
+};
+const listRenderers = {
+  list: 'ul',
+  item: 'li'
+}; // todo: check if a plugin is a LIST plugin rather than GRID
+
+function useDataList(_ref) {
+  let {
+    data = [],
+    plugins = [],
+    renderers = listRenderers,
+    itemRenderer = [],
+    customDecorators
+  } = _ref,
+      props = _objectWithoutProperties__default["default"](_ref, _excluded);
+
+  const listRef = React.useRef();
+  const {
+    instance,
+    decorators
+  } = createInstanceRef(_objectSpread({
+    data,
+    renderers,
+    plugins,
+    customDecorators: _objectSpread(_objectSpread({}, customDecorators), {}, {
+      recordIterator: recordIterator.recordIterator,
+      getListProps: [],
+      getItemProps: [],
+      itemRenderer: [...itemRenderer],
+      // components reduce to compose item content
+      record: [],
+      records: []
+    })
+  }, props));
+
+  instance.current.getListRef = () => listRef;
+
+  instance.current.setListRef = ref => {
+    listRef.current = ref;
+  };
+
+  instance.current.getItemLabel = record => getItemLabel(record, props.nameKey);
+
+  instance.current.getItemChildren = record => getItemChildren(record, props.childrenKey);
+
+  instance.current.decorators = decorators;
+  instance.current.getListProps = utils.reducePropsGetter(decorators.getListProps, instance.current);
+  instance.current.getItemProps = utils.reducePropsGetter(decorators.getItemProps, instance.current);
+  instance.current.itemRenderer = utils.composeFormatters(instance.current.decorators.itemRenderer, instance.current);
+  instance.current.records = React.useMemo(() => {
+    // record iterator TREE / Simple
+    let nextRecords = recordIterator.recordIterator(data, instance.current.decorators.recordIterator, decorators.record, instance.current); // compose all records
+
+    nextRecords = decorators.records.reduce((nextRows, getter) => getter(nextRows, instance.current), nextRecords);
+    return nextRecords;
+  });
+  if (props.instanceRef) dsUtilities.setRef(props.instanceRef, instance.current);
+  return instance.current;
+}
+
+exports["default"] = useDataList;
+exports.getItemChildren = getItemChildren;
+exports.getItemLabel = getItemLabel;

package/cjs/utils.js

@@ -0,0 +1,116 @@
+'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.filter.js');
+require('core-js/modules/esnext.iterator.constructor.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');
+
+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; }
+
+/* eslint-disable no-cond-assign */
+const objectType = obj => Object.prototype.toString.call(obj).slice(8, -1);
+const isDefined = param => typeof param !== 'undefined';
+const isUndefined = param => typeof param === 'undefined';
+const isFunction = param => typeof param === 'function';
+const isNumber = param => typeof param === 'number' && !isNaN(param); // eslint-disable-line
+
+const isString = str => objectType(str) === 'String';
+const isArray = arr => objectType(arr) === 'Array';
+const closest = (target, selector) => {
+  // closest(e.target, '.field')
+  while (target) {
+    // eslint-disable-line
+    if (target.matches && target.matches(selector)) return target;
+    if (target.msMatchesSelector && target.msMatchesSelector(selector)) return target; // eslint-disable-next-line no-param-reassign
+
+    target = target.parentNode;
+  }
+
+  return null;
+};
+const getOffsetRect = elem => {
+  // (1)
+  const box = elem.getBoundingClientRect();
+  const {
+    body,
+    documentElement
+  } = document; // (2)
+
+  const scrollTop = window.pageYOffset || documentElement.scrollTop || body.scrollTop;
+  const scrollLeft = window.pageXOffset || documentElement.scrollLeft || body.scrollLeft; // (3)
+
+  const clientTop = documentElement.clientTop || body.clientTop || 0;
+  const clientLeft = documentElement.clientLeft || body.clientLeft || 0; // (4)
+
+  const top = box.top + scrollTop - clientTop;
+  const left = box.left + scrollLeft - clientLeft;
+  return {
+    top: Math.round(top),
+    left: Math.round(left)
+  };
+};
+const getTotalScroll = elem => {
+  let top = 0;
+  let left = 0; // eslint-disable-next-line no-param-reassign
+
+  while (elem = elem.parentNode) {
+    top += elem.scrollTop || 0;
+    left += elem.scrollLeft || 0;
+  }
+
+  return {
+    top,
+    left
+  };
+};
+const getTransformProps = (x, y) => ({
+  transform: "translate(".concat(x, "px, ").concat(y, "px)")
+});
+const listWithChildren = (list, childrenProp) => list.map(item => _objectSpread(_objectSpread({}, item), {}, {
+  [childrenProp]: item[childrenProp] ? listWithChildren(item[childrenProp], childrenProp) : []
+}));
+const getAllNonEmptyNodesIds = (items, childrenProp) => {
+  let childrenIds = [];
+  const ids = items.filter(item => item[childrenProp].length).map(item => {
+    childrenIds = childrenIds.concat(getAllNonEmptyNodesIds(item[childrenProp], childrenProp));
+    return item.id;
+  });
+  return ids.concat(childrenIds);
+};
+const isInternetExplorer = () => {
+  const ua = window.navigator.userAgent;
+  const msie = ua.indexOf('MSIE '); // If Internet Explorer, return version number
+
+  if (msie > 0 || !!navigator.userAgent.match(/Trident.*rv:11\./)) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.closest = closest;
+exports.getAllNonEmptyNodesIds = getAllNonEmptyNodesIds;
+exports.getOffsetRect = getOffsetRect;
+exports.getTotalScroll = getTotalScroll;
+exports.getTransformProps = getTransformProps;
+exports.isArray = isArray;
+exports.isDefined = isDefined;
+exports.isFunction = isFunction;
+exports.isInternetExplorer = isInternetExplorer;
+exports.isNumber = isNumber;
+exports.isString = isString;
+exports.isUndefined = isUndefined;
+exports.listWithChildren = listWithChildren;
+exports.objectType = objectType;

package/cjs/virtualization/AutoHeightList.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.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 _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var React = require('react');
+var reactWindow = require('react-window');
+var dsUtilities = require('@elliemae/ds-utilities');
+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 _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
+
+const _excluded = ["itemCount", "className", "innerRef", "itemData", "itemKey", "itemSize", "outerRef", "component"];
+
+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 AutoHeightList = /*#__PURE__*/React.forwardRef((_ref, ref) => {
+  let {
+    itemCount,
+    className,
+    innerRef,
+    itemData,
+    itemKey,
+    itemSize,
+    outerRef,
+    component: ListComponent = reactWindow.FixedSizeList
+  } = _ref,
+      otherProps = _objectWithoutProperties__default["default"](_ref, _excluded);
+
+  const listRef = React.useRef();
+  const outerListRef = React.useRef();
+  dsUtilities.useWindowScrollerList({
+    listInstance: listRef,
+    outerListRef
+  });
+  return /*#__PURE__*/jsxRuntime.jsx(ListComponent, _objectSpread(_objectSpread({}, otherProps), {}, {
+    ref: dsUtilities.mergeRefs(ref, listRef),
+    className: dsUtilities.cx(className, 'window-scroller-override'),
+    height: window.innerHeight,
+    innerRef: innerRef,
+    itemCount: itemCount,
+    itemData: itemData,
+    itemKey: itemKey,
+    itemSize: itemSize,
+    outerRef: dsUtilities.mergeRefs(outerListRef, outerRef),
+    overscanCount: 10,
+    useIsScrolling: true
+  }));
+});
+
+exports.AutoHeightList = AutoHeightList;

package/cjs/virtualization/FluidHeightList.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.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 _jsx = require('@babel/runtime/helpers/jsx');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var React = require('react');
+var AutoSizer = require('react-virtualized-auto-sizer');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
+var AutoSizer__default = /*#__PURE__*/_interopDefaultLegacy(AutoSizer);
+
+const _excluded = ["component"];
+
+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 FluidHeightList = /*#__PURE__*/React.forwardRef((_ref, ref) => {
+  let {
+    component: Component
+  } = _ref,
+      props = _objectWithoutProperties__default["default"](_ref, _excluded);
+
+  return /*#__PURE__*/_jsx__default["default"](AutoSizer__default["default"], {
+    disableWidth: true
+  }, void 0, _ref2 => {
+    let {
+      height: fluidHeight
+    } = _ref2;
+    return /*#__PURE__*/jsxRuntime.jsx(Component, _objectSpread(_objectSpread({}, props), {}, {
+      ref: ref,
+      height: fluidHeight - 32 // taking in count the margins of the list
+
+    }));
+  });
+});
+
+exports.FluidHeightList = FluidHeightList;

package/cjs/virtualization/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var FluidHeightList = require('./FluidHeightList.js');
+var AutoHeightList = require('./AutoHeightList.js');
+
+function getVirtualListComponent(_ref) {
+  let {
+    component: Component,
+    fluid,
+    height,
+    autoHeight
+  } = _ref;
+  if (autoHeight) return AutoHeightList.AutoHeightList;
+  if (fluid) return FluidHeightList.FluidHeightList;
+  return Component;
+}
+
+exports.FluidHeightList = FluidHeightList.FluidHeightList;
+exports.AutoHeightList = AutoHeightList.AutoHeightList;
+exports.getVirtualListComponent = getVirtualListComponent;

package/esm/Animations/BaseAnimation.js

@@ -0,0 +1,30 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'react';
+import { Transition } from 'react-spring/renderprops';
+
+const BaseAnimation = _ref => {
+  let {
+    keys = undefined,
+    items = [],
+    duration = 100,
+    enter = {},
+    from = {},
+    leave = {},
+    onRest = () => null,
+    children
+  } = _ref;
+  return /*#__PURE__*/_jsx(Transition, {
+    config: {
+      duration
+    },
+    enter: enter,
+    from: from,
+    items: items,
+    keys: keys,
+    leave: leave,
+    onRest: onRest
+  }, void 0, children);
+};
+
+export { BaseAnimation as default };