@ohos-ports/sprucelabs-react-heartwood-components 9.1.0-beta.0

package/lib/components/RecordSelectionList/RecordSelectionList.js

@@ -0,0 +1,702 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _lodash = require("lodash");
+
+var _reactVirtualized = require("react-virtualized");
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _utilities = require("../../utilities");
+
+var _Forms = require("../Forms");
+
+var _FormPartials = require("../Forms/FormPartials");
+
+var _TextContainer = _interopRequireDefault(require("../TextContainer/TextContainer"));
+
+var _Text = _interopRequireDefault(require("../Text/Text"));
+
+var _Button = _interopRequireWildcard(require("../Button/Button"));
+
+var _ListItem = _interopRequireDefault(require("../List/components/ListItem/ListItem"));
+
+var _EmptyState = _interopRequireDefault(require("../EmptyState/EmptyState"));
+
+var RecordSelectionList =
+/*#__PURE__*/
+function (_Component) {
+  (0, _inherits2["default"])(RecordSelectionList, _Component);
+
+  function RecordSelectionList(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, RecordSelectionList);
+    _this = (0, _possibleConstructorReturn2["default"])(this, (0, _getPrototypeOf2["default"])(RecordSelectionList).call(this, props));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "cache", new _reactVirtualized.CellMeasurerCache({
+      fixedWidth: true
+    }));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "loadSearchResults", (0, _lodash.debounce)(
+    /*#__PURE__*/
+    function () {
+      var _ref2 = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee(_ref) {
+        var value, uniqueId, newRows;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                value = _ref.value, uniqueId = _ref.uniqueId;
+                _context.next = 3;
+                return _this.loadRecordsRequest({
+                  offset: 0,
+                  search: value
+                });
+
+              case 3:
+                newRows = _context.sent;
+
+                if (uniqueId === _this.state.loadingId) {
+                  _this.setState({
+                    isLoading: false,
+                    loadedRecords: newRows || []
+                  }, function () {
+                    _this.resetVirtualizedList();
+                  });
+                }
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function (_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }(), _this.props.searchDelayMs || 200));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getVisibleRecordHeight", function () {
+      var maxRowsVisible = _this.props.maxRowsVisible;
+      var visibleRecordHeight = 0;
+
+      if (typeof maxRowsVisible === 'number') {
+        for (var i = 0; i < Math.min(maxRowsVisible); i += 1) {
+          if (i < _this.cache._rowCount) {
+            visibleRecordHeight += _this.cache.rowHeight({
+              index: i
+            });
+          } else {
+            visibleRecordHeight += 1;
+          }
+        }
+      }
+
+      return visibleRecordHeight;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "updateSearchValue",
+    /*#__PURE__*/
+    function () {
+      var _ref3 = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee3(value) {
+        var onSearchChange, uniqueId;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                onSearchChange = _this.props.onSearchChange; // Search will rapid-fire, but we only want to use the last result.
+                // If this value doesn't change by the time the API responds, we'll use
+                // that data to update the list!
+
+                uniqueId = "".concat(Math.random());
+
+                _this.setState({
+                  search: value,
+                  isLoading: true,
+                  loadingId: uniqueId
+                },
+                /*#__PURE__*/
+                (0, _asyncToGenerator2["default"])(
+                /*#__PURE__*/
+                _regenerator["default"].mark(function _callee2() {
+                  return _regenerator["default"].wrap(function _callee2$(_context2) {
+                    while (1) {
+                      switch (_context2.prev = _context2.next) {
+                        case 0:
+                          if (onSearchChange) {
+                            onSearchChange(value);
+                          }
+
+                          _this.loadSearchResults({
+                            value: value,
+                            uniqueId: uniqueId
+                          });
+
+                        case 2:
+                        case "end":
+                          return _context2.stop();
+                      }
+                    }
+                  }, _callee2);
+                })));
+
+              case 3:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }));
+
+      return function (_x2) {
+        return _ref3.apply(this, arguments);
+      };
+    }());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "resetVirtualizedList", function () {
+      if (_this.virtualizedList && _this.cache && _this.infiniteLoader) {
+        _this.cache.clearAll();
+
+        _this.virtualizedList.recomputeRowHeights();
+
+        _this.virtualizedList.forceUpdateGrid();
+
+        _this.infiniteLoader.resetLoadMoreRowsCache(true);
+
+        setTimeout(function () {
+          _this.setState({
+            listHeight: _this.getVisibleRecordHeight()
+          });
+        }, 0);
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "loadRecordsRequest",
+    /*#__PURE__*/
+    function () {
+      var _ref5 = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee4(options) {
+        var _this$props, loadRecords, loadRecordListItems, recordsPerRequest, requestArgs;
+
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _this$props = _this.props, loadRecords = _this$props.loadRecords, loadRecordListItems = _this$props.loadRecordListItems, recordsPerRequest = _this$props.recordsPerRequest;
+                requestArgs = (0, _objectSpread2["default"])({
+                  limit: recordsPerRequest
+                }, options);
+
+                if (!loadRecords) {
+                  _context4.next = 8;
+                  break;
+                }
+
+                _context4.next = 5;
+                return loadRecords(requestArgs);
+
+              case 5:
+                return _context4.abrupt("return", _context4.sent);
+
+              case 8:
+                if (!loadRecordListItems) {
+                  _context4.next = 12;
+                  break;
+                }
+
+                _context4.next = 11;
+                return loadRecordListItems(requestArgs);
+
+              case 11:
+                return _context4.abrupt("return", _context4.sent);
+
+              case 12:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4);
+      }));
+
+      return function (_x3) {
+        return _ref5.apply(this, arguments);
+      };
+    }());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "renderRow", function (_ref6) {
+      var index = _ref6.index,
+          key = _ref6.key,
+          parent = _ref6.parent,
+          style = _ref6.style;
+      var loadedRecords = _this.state.loadedRecords;
+      var record = loadedRecords[index];
+      return record && _react["default"].createElement(_reactVirtualized.CellMeasurer, {
+        cache: _this.cache,
+        columnIndex: 0,
+        key: key,
+        parent: parent,
+        rowIndex: index
+      }, function () {
+        return _this.renderInnerRow({
+          record: record,
+          style: style
+        });
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "renderInnerRow", function (_ref7) {
+      var record = _ref7.record,
+          style = _ref7.style;
+      var loadedRecords = _this.state.loadedRecords;
+      var _this$props2 = _this.props,
+          selectedIds = _this$props2.selectedIds,
+          unselectableIds = _this$props2.unselectableIds,
+          getRecordId = _this$props2.getRecordId,
+          canSelect = _this$props2.canSelect,
+          canRemove = _this$props2.canRemove,
+          onSelect = _this$props2.onSelect,
+          onRemove = _this$props2.onRemove,
+          renderRecord = _this$props2.renderRecord,
+          loadRecords = _this$props2.loadRecords,
+          loadRecordListItems = _this$props2.loadRecordListItems;
+
+      if (loadRecordListItems && record.id) {
+        var recordId = record.id;
+        return _react["default"].createElement("div", {
+          className: "record-selection__record-wrapper",
+          key: recordId,
+          style: (0, _objectSpread2["default"])({}, style)
+        }, _react["default"].createElement(_ListItem["default"], (0, _extends2["default"])({}, record, {
+          key: recordId,
+          selectableId: onSelect && canSelect && recordId,
+          selectableProps: {
+            onChange: onSelect ? function () {
+              onSelect(recordId, record);
+            } : function () {
+              return null;
+            },
+            isChecked: selectedIds && selectedIds.indexOf(recordId) >= 0
+          },
+          selectableType: canSelect === 'one' ? 'radio' : 'checkbox',
+          isDisabled: unselectableIds && unselectableIds.indexOf(recordId) >= 0,
+          actions: onRemove && canRemove ? [{
+            kind: 'simple',
+            className: 'record-selection__record-remove-btn',
+            disabled: false,
+            isSmall: true,
+            icon: {
+              name: 'cancel_solid',
+              className: 'btn__line-icon'
+            },
+            onClick: function onClick() {
+              _this.setState({
+                loadedRecords: loadedRecords.filter(function (loadedRecord) {
+                  return loadedRecord.id !== recordId;
+                })
+              }, function () {
+                _this.setState({
+                  listHeight: _this.getVisibleRecordHeight()
+                });
+              });
+
+              onRemove(recordId, record);
+            }
+          }] : []
+        })));
+      } else if (loadRecords && renderRecord && getRecordId) {
+        // DEPRECATED RENDER METHOD
+        var SelectionComponent = canSelect === 'one' ? _Forms.Radio : _Forms.Checkbox;
+
+        var _recordId = getRecordId(record);
+
+        return _react["default"].createElement("div", {
+          className: "record-selection__record-wrapper",
+          key: _recordId,
+          style: (0, _objectSpread2["default"])({}, style)
+        }, onSelect && canSelect && _react["default"].createElement(SelectionComponent, {
+          id: _recordId,
+          name: _recordId,
+          className: "record-selection__record-select",
+          onChange: function onChange() {
+            onSelect(_recordId, record);
+          },
+          isDisabled: unselectableIds && unselectableIds.indexOf(_recordId) >= 0,
+          isChecked: selectedIds && selectedIds.indexOf(_recordId) >= 0 ? true : false
+        }), _react["default"].createElement("div", {
+          className: "record-selection__record-content",
+          key: _recordId
+        }, renderRecord(record)), onRemove && canRemove && _react["default"].createElement(_Button["default"], {
+          kind: _Button.ButtonKinds.Simple,
+          className: "record-selection__record-remove-btn",
+          isDisabled: false,
+          isSmall: true,
+          icon: {
+            name: 'cancel_solid',
+            className: 'btn__line-icon'
+          },
+          onClick: function onClick() {
+            _this.setState({
+              loadedRecords: loadedRecords.filter(function (loadedRecord) {
+                return getRecordId(loadedRecord) !== _recordId;
+              })
+            }, function () {
+              _this.setState({
+                listHeight: _this.getVisibleRecordHeight()
+              });
+            });
+
+            onRemove(_recordId, record);
+          }
+        }));
+      } else {
+        return null;
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleInfiniteLoad",
+    /*#__PURE__*/
+    (0, _asyncToGenerator2["default"])(
+    /*#__PURE__*/
+    _regenerator["default"].mark(function _callee5() {
+      var _this$state, loadedRecords, isLoading, search, newRows;
+
+      return _regenerator["default"].wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _this$state = _this.state, loadedRecords = _this$state.loadedRecords, isLoading = _this$state.isLoading, search = _this$state.search;
+
+              if (!isLoading) {
+                _context5.next = 3;
+                break;
+              }
+
+              return _context5.abrupt("return");
+
+            case 3:
+              _this.setState({
+                isLoading: true
+              });
+
+              _context5.next = 6;
+              return _this.loadRecordsRequest({
+                offset: loadedRecords.length,
+                search: search
+              });
+
+            case 6:
+              newRows = _context5.sent;
+
+              _this.setState({
+                isLoading: false
+              });
+
+              if (newRows && newRows.length > 0) {
+                _this.setState({
+                  loadedRecords: [].concat((0, _toConsumableArray2["default"])(loadedRecords), (0, _toConsumableArray2["default"])(newRows))
+                });
+              }
+
+              return _context5.abrupt("return", true);
+
+            case 10:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5);
+    })));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleRemoveSelection", function () {});
+
+    if (props.loadRecords && !props.getRecordId) {
+      throw new Error("RecordSelectionList: `getRecordId` must be provided to determine a record's unique identifier. (record => string)");
+    }
+
+    (0, _utilities.checkDeprecatedProps)({
+      componentName: 'RecordSelectionList',
+      props: props,
+      deprecatedProps: {
+        renderRecord: {
+          details: 'Use loadRecordListItems to manage loading and rendering of record list item.'
+        },
+        getRecordId: {
+          details: 'Use loadRecordListItems to manage loading and rendering of record list item.'
+        },
+        loadRecords: {
+          details: 'Use loadRecordListItems to manage loading and rendering of record list item.'
+        }
+      }
+    });
+    _this.state = {
+      loadedRecords: [],
+      isLoading: true,
+      search: props.searchValue,
+      listHeight: 1
+    };
+    return _this;
+  }
+
+  (0, _createClass2["default"])(RecordSelectionList, [{
+    key: "componentDidMount",
+    value: function () {
+      var _componentDidMount = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee6() {
+        var search, initialRecords, newListHeight;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                search = this.state.search;
+                _context6.next = 3;
+                return this.loadRecordsRequest({
+                  search: search,
+                  offset: 0
+                });
+
+              case 3:
+                initialRecords = _context6.sent;
+                _context6.next = 6;
+                return this.setState({
+                  loadedRecords: initialRecords || [],
+                  isLoading: false
+                });
+
+              case 6:
+                newListHeight = this.getVisibleRecordHeight();
+
+                if (this.state.listHeight !== newListHeight) {
+                  this.setState({
+                    listHeight: newListHeight
+                  });
+                }
+
+              case 8:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function componentDidMount() {
+        return _componentDidMount.apply(this, arguments);
+      }
+
+      return componentDidMount;
+    }()
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var _this$props3 = this.props,
+          canRemove = _this$props3.canRemove,
+          canSelect = _this$props3.canSelect,
+          searchValue = _this$props3.searchValue;
+
+      if (searchValue && searchValue !== prevProps.searchValue) {
+        this.updateSearchValue(searchValue);
+      } // We need to manually tell virtualized to update if these props
+      // change. This is mostly for storybook but it may be nice to support later in product.
+
+
+      if (prevProps.canRemove !== canRemove || prevProps.canSelect !== canSelect) {
+        this.resetVirtualizedList();
+      }
+    }
+  }, {
+    key: "reset",
+    value: function () {
+      var _reset = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee7() {
+        var _ref9,
+            _ref9$persistSearch,
+            persistSearch,
+            _args7 = arguments;
+
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                _ref9 = _args7.length > 0 && _args7[0] !== undefined ? _args7[0] : {}, _ref9$persistSearch = _ref9.persistSearch, persistSearch = _ref9$persistSearch === void 0 ? false : _ref9$persistSearch;
+                // TODO: This just "works" but ideally I'd be resetting more holistically.
+                // Come back to this and clean up the API a bit. Make sure that resetting
+                // doesn't cause infiniteLoad to fail.
+                this.updateSearchValue(persistSearch && this.state.search ? this.state.search : '');
+
+              case 2:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+
+      function reset() {
+        return _reset.apply(this, arguments);
+      }
+
+      return reset;
+    }()
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var _this$props4 = this.props,
+          canSearch = _this$props4.canSearch,
+          maxRowsVisible = _this$props4.maxRowsVisible,
+          hideDataEmptyState = _this$props4.hideDataEmptyState,
+          hideSearchResultsEmptyState = _this$props4.hideSearchResultsEmptyState,
+          noDataEmptyState = _this$props4.noDataEmptyState,
+          noSearchResultsEmptyState = _this$props4.noSearchResultsEmptyState,
+          searchLabel = _this$props4.searchLabel,
+          searchPlaceholder = _this$props4.searchPlaceholder,
+          _this$props4$selected = _this$props4.selectedIds,
+          selectedIds = _this$props4$selected === void 0 ? [] : _this$props4$selected,
+          showSelectedCount = _this$props4.showSelectedCount,
+          totalRecordCount = _this$props4.totalRecordCount;
+      var _this$state2 = this.state,
+          loadedRecords = _this$state2.loadedRecords,
+          search = _this$state2.search,
+          listHeight = _this$state2.listHeight,
+          isLoading = _this$state2.isLoading;
+      var totalSelected = selectedIds.length;
+
+      var isRowLoaded = function isRowLoaded(_ref10) {
+        var index = _ref10.index;
+        return !!loadedRecords[index];
+      };
+
+      var onResize = function onResize() {
+        _this2.resetVirtualizedList();
+      };
+
+      return _react["default"].createElement("div", {
+        className: (0, _classnames["default"])('record-selection__list', {
+          'record-selection__list--is-infinite': maxRowsVisible,
+          'record-selection__list--is-searchable': canSearch,
+          'record-selection__list--is-showing-selected-count': showSelectedCount
+        }),
+        ref: function ref(_ref15) {
+          return _this2.listContainer = _ref15;
+        }
+      }, showSelectedCount && _react["default"].createElement(_TextContainer["default"], null, _react["default"].createElement(_Text["default"], null, "".concat(totalSelected, " selected"))), canSearch && loadedRecords.length > 0 && _react["default"].createElement(_react.Fragment, null, searchLabel && _react["default"].createElement(_FormPartials.InputPre, {
+        label: searchLabel
+      }), _react["default"].createElement(_Forms.TextInput, {
+        id: 'record-selection-list-filter',
+        type: "text",
+        iconBefore: "search",
+        placeholder: searchPlaceholder || 'Search...',
+        value: search,
+        onChange: function onChange(e) {
+          _this2.updateSearchValue(e.target.value);
+        }
+      })), loadedRecords.length > 0 ? _react["default"].createElement(_react.Fragment, null, !maxRowsVisible ? loadedRecords.map(function (record) {
+        return _this2.renderInnerRow({
+          record: record,
+          style: {}
+        });
+      }) : _react["default"].createElement("div", (0, _extends2["default"])({
+        className: "record-selection__list-wrapper" // Only set listHeight if maxRowsVisible is not undefined or 'auto'
+
+      }, typeof maxRowsVisible === 'number' ? {
+        style: {
+          height: "".concat(listHeight, "px")
+        }
+      } : {}), _react["default"].createElement(_reactVirtualized.InfiniteLoader, {
+        ref: function ref(_ref14) {
+          return _this2.infiniteLoader = _ref14;
+        },
+        isRowLoaded: isRowLoaded,
+        loadMoreRows: function loadMoreRows() {
+          return _this2.handleInfiniteLoad();
+        },
+        rowCount: totalRecordCount || Infinity,
+        threshold: maxRowsVisible || 5
+      }, function (_ref11) {
+        var _onRowsRendered = _ref11.onRowsRendered,
+            registerChild = _ref11.registerChild;
+        return _react["default"].createElement(_reactVirtualized.AutoSizer, {
+          onResize: onResize
+        }, function (_ref12) {
+          var height = _ref12.height,
+              width = _ref12.width;
+          return _react["default"].createElement(_reactVirtualized.List, {
+            ref: function ref(_ref13) {
+              registerChild(_ref13);
+              _this2.virtualizedList = _ref13;
+            },
+            className: "record-selection__virtual-list",
+            deferredMeasurementCache: _this2.cache,
+            height: height,
+            width: width,
+            rowHeight: _this2.cache.rowHeight,
+            rowCount: loadedRecords.length,
+            rowRenderer: _this2.renderRow,
+            onRowsRendered: function onRowsRendered(args) {
+              _onRowsRendered(args);
+            },
+            selectedIds: JSON.stringify(selectedIds)
+          });
+        });
+      }))) : !isLoading && loadedRecords.length === 0 && _react["default"].createElement(_react.Fragment, null, search ? !hideSearchResultsEmptyState && _react["default"].createElement(_EmptyState["default"], (0, _extends2["default"])({
+        icon: "no_matches",
+        headline: "No search results"
+      }, noSearchResultsEmptyState, {
+        primaryAction: (0, _objectSpread2["default"])({
+          text: 'Show all',
+          type: 'submit',
+          onClick: function onClick() {
+            _this2.updateSearchValue('');
+          }
+        }, (0, _lodash.get)(noSearchResultsEmptyState, 'primaryAction', {}))
+      })) : !hideDataEmptyState && _react["default"].createElement(_EmptyState["default"], (0, _extends2["default"])({
+        headline: "No records"
+      }, noDataEmptyState))));
+    }
+  }]);
+  return RecordSelectionList;
+}(_react.Component);
+
+exports["default"] = RecordSelectionList;
+(0, _defineProperty2["default"])(RecordSelectionList, "defaultProps", {
+  showSelectedCount: false,
+  hideSearchResultsEmptyState: false,
+  hideDataEmptyState: false,
+  recordsPerRequest: 10
+});
+//# sourceMappingURL=RecordSelectionList.js.map