@elliemae/ds-shared 2.3.0-alpha.7 → 2.3.0-next.1

package/esm/useDataGrid/useDataGrid.js

@@ -0,0 +1,194 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import 'core-js/modules/web.dom-collections.iterator.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.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import { useDerivedStateFromProps, compose, cloneDeep, usePrevious, isObject, isEqual, setRef } from '@elliemae/ds-utilities';
+import { useRef, useState, useMemo } from 'react';
+import { v4 } from 'uuid';
+import * as resolve from 'table-resolver';
+import initColumnDefinition from './initColumnDefinition.js';
+import { applyDecorators, decorateColumns, reducePropsGetter } from '../createDataInstance/utils.js';
+import VolatileRowsListener from './VolatileRowsListener.js';
+import { isInternetExplorer } from '../utils.js';
+
+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(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 = 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(_ref, _excluded);
+
+  const plugins = pluginsFromProps;
+  const instance = useRef();
+  const tableRef = useRef();
+  const headerRef = useRef();
+  const bodyRef = useRef();
+  const bodyInnerRef = useRef();
+  const [uuid] = useState(uuidProp || (() => v4()));
+  const [hasScroll, setHasScroll] = useState(false);
+  const [isRowDragging, setIsRowDragging] = useState(false);
+  const isScrolling = useRef();
+  const shouldRefocus = useRef(); // todo: we probably need a plugin for focus related stuff
+
+  const [RowsObserver] = useState(() => new VolatileRowsListener()); // todo move this with rows composition
+
+  const [originalRows, updateRows] = useDerivedStateFromProps(rows, {
+    onUpdate: resolve.resolve({
+      columns,
+      method: extra => compose(resolve.byFunction('valueTransformation')(extra), resolve.nested(extra))
+    }),
+    updateOnStateChange: true
+  });
+  instance.current = {
+    decoratedRenderers: cloneDeep(renderers),
+    decoratedColumns: columns,
+    columns,
+    rows,
+    composedRows: originalRows,
+    getRowProps: [],
+    getHeaderRowProps: [],
+    getBodyProps: [],
+    getTableProps: [],
+    effects: [],
+    uuid,
+    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({
+      useTextTruncation: col.useTextTruncation,
+      wrapText: props.wrapText,
+      normalize: props.normalizeDataKeys
+    })(col))],
+    decorateRenderers: [],
+    getRowProps: [],
+    getHeaderRowProps: [],
+    getBodyProps: [],
+    getTableProps: [],
+    getHeaderProps: [],
+    composeRows: []
+  };
+  const decorators = 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 = applyDecorators(instance.current.decoratedRenderers, decorators.decorateRenderers, instance.current);
+  instance.current.decoratedColumns = useMemo(() => {
+    const visibleColumns = cloneDeep(columns).filter(column => typeof column.visible === 'undefined' || column.visible);
+    return visibleColumns.length ? decorateColumns(visibleColumns, decorators, instance.current) : [];
+  }, [columns]);
+  instance.current.getBodyProps = reducePropsGetter(decorators.getBodyProps, instance.current);
+  instance.current.getHeaderProps = reducePropsGetter(decorators.getHeaderProps, instance.current);
+  instance.current.getRowProps = reducePropsGetter(decorators.getRowProps, instance.current);
+  instance.current.getHeaderRowProps = reducePropsGetter(decorators.getHeaderRowProps, instance.current);
+  instance.current.getTableProps = 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 = usePrevious(instance.current.state);
+
+  if (isObject(currentShouldRefocus) && currentShouldRefocus.forced) {
+    instance.current.shouldRefocus.current = currentShouldRefocus.value;
+  } else {
+    instance.current.shouldRefocus.current = !isEqual(prevState, instance.current.state);
+  }
+
+  if (props.instanceRef) setRef(props.instanceRef, instance.current);
+  return _objectSpread(_objectSpread({}, instance.current), {}, {
+    decorators
+  });
+}
+
+export { useDataGrid as default };

package/esm/useDataList/index.js

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

package/esm/useDataList/recordIterator.js

@@ -0,0 +1,27 @@
+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;
+}
+
+export { recordIterator };

package/esm/useDataList/useDataList.js

@@ -0,0 +1,90 @@
+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 _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+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 { useRef, useMemo } from 'react';
+import { setRef } from '@elliemae/ds-utilities';
+import get from 'lodash/get';
+import { reducePropsGetter, composeFormatters } from '../createDataInstance/utils.js';
+import { recordIterator } from './recordIterator.js';
+import createDataInstanceRef from '../createDataInstance/createInstanceRef.js';
+
+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(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(record, ['data', nameKey]);
+};
+const getItemChildren = function (record) {
+  let childrenKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'children';
+  return get(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(_ref, _excluded);
+
+  const listRef = useRef();
+  const {
+    instance,
+    decorators
+  } = createDataInstanceRef(_objectSpread({
+    data,
+    renderers,
+    plugins,
+    customDecorators: _objectSpread(_objectSpread({}, customDecorators), {}, {
+      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 = reducePropsGetter(decorators.getListProps, instance.current);
+  instance.current.getItemProps = reducePropsGetter(decorators.getItemProps, instance.current);
+  instance.current.itemRenderer = composeFormatters(instance.current.decorators.itemRenderer, instance.current);
+  instance.current.records = useMemo(() => {
+    // record iterator TREE / Simple
+    let nextRecords = 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) setRef(props.instanceRef, instance.current);
+  return instance.current;
+}
+
+export { useDataList as default, getItemChildren, getItemLabel };

package/esm/utils.js

@@ -0,0 +1,95 @@
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.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.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.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; }
+
+/* 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;
+};
+
+export { closest, getAllNonEmptyNodesIds, getOffsetRect, getTotalScroll, getTransformProps, isArray, isDefined, isFunction, isInternetExplorer, isNumber, isString, isUndefined, listWithChildren, objectType };

package/esm/virtualization/AutoHeightList.js

@@ -0,0 +1,52 @@
+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 _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import { forwardRef, useRef } from 'react';
+import { FixedSizeList } from 'react-window';
+import { useWindowScrollerList, mergeRefs, cx } from '@elliemae/ds-utilities';
+import { jsx } from 'react/jsx-runtime';
+
+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(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__*/forwardRef((_ref, ref) => {
+  let {
+    itemCount,
+    className,
+    innerRef,
+    itemData,
+    itemKey,
+    itemSize,
+    outerRef,
+    component: ListComponent = FixedSizeList
+  } = _ref,
+      otherProps = _objectWithoutProperties(_ref, _excluded);
+
+  const listRef = useRef();
+  const outerListRef = useRef();
+  useWindowScrollerList({
+    listInstance: listRef,
+    outerListRef
+  });
+  return /*#__PURE__*/jsx(ListComponent, _objectSpread(_objectSpread({}, otherProps), {}, {
+    ref: mergeRefs(ref, listRef),
+    className: cx(className, 'window-scroller-override'),
+    height: window.innerHeight,
+    innerRef: innerRef,
+    itemCount: itemCount,
+    itemData: itemData,
+    itemKey: itemKey,
+    itemSize: itemSize,
+    outerRef: mergeRefs(outerListRef, outerRef),
+    overscanCount: 10,
+    useIsScrolling: true
+  }));
+});
+
+export { AutoHeightList };

package/esm/virtualization/FluidHeightList.js

@@ -0,0 +1,38 @@
+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 _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import { forwardRef } from 'react';
+import AutoSizer from 'react-virtualized-auto-sizer';
+import { jsx } from 'react/jsx-runtime';
+
+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(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__*/forwardRef((_ref, ref) => {
+  let {
+    component: Component
+  } = _ref,
+      props = _objectWithoutProperties(_ref, _excluded);
+
+  return /*#__PURE__*/_jsx(AutoSizer, {
+    disableWidth: true
+  }, void 0, _ref2 => {
+    let {
+      height: fluidHeight
+    } = _ref2;
+    return /*#__PURE__*/jsx(Component, _objectSpread(_objectSpread({}, props), {}, {
+      ref: ref,
+      height: fluidHeight - 32 // taking in count the margins of the list
+
+    }));
+  });
+});
+
+export { FluidHeightList };

package/esm/virtualization/index.js

@@ -0,0 +1,18 @@
+import { FluidHeightList } from './FluidHeightList.js';
+export { FluidHeightList } from './FluidHeightList.js';
+import { AutoHeightList } from './AutoHeightList.js';
+export { AutoHeightList } from './AutoHeightList.js';
+
+function getVirtualListComponent(_ref) {
+  let {
+    component: Component,
+    fluid,
+    height,
+    autoHeight
+  } = _ref;
+  if (autoHeight) return AutoHeightList;
+  if (fluid) return FluidHeightList;
+  return Component;
+}
+
+export { getVirtualListComponent };