@elliemae/ds-shuttle 2.2.0-alpha.4 → 3.0.0-next.2

package/esm/components/VirtualizedItem.js

@@ -1,22 +1,40 @@
-import * as React from "react";
-import { memo } from "react";
-import { areEqual } from "react-window";
-const VirtualizedItem = memo(({ data, index, style: virtualizedStyles, showSortHandler = false }) => {
-  const { items, itemRenderer, isItemMoving } = data;
-  const { item, props: animatedStyles, key } = items[index] || {};
-  if (!item)
-    return null;
+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 { memo } from 'react';
+import { areEqual } from 'react-window';
+
+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 VirtualizedItem = /*#__PURE__*/memo(_ref => {
+  let {
+    data,
+    index,
+    style: virtualizedStyles,
+    showSortHandler = false
+  } = _ref;
+  const {
+    items,
+    itemRenderer,
+    isItemMoving
+  } = data;
+  const {
+    item,
+    props: animatedStyles,
+    key
+  } = items[index] || {};
+  if (!item) return null;
   return itemRenderer({
     index,
     key,
     item,
     showSortHandler,
-    style: isItemMoving ? { ...animatedStyles, ...virtualizedStyles } : virtualizedStyles
+    style: isItemMoving ? _objectSpread(_objectSpread({}, animatedStyles), virtualizedStyles) : virtualizedStyles
   });
 }, areEqual);
-var VirtualizedItem_default = VirtualizedItem;
-export {
-  VirtualizedItem,
-  VirtualizedItem_default as default
-};
-//# sourceMappingURL=VirtualizedItem.js.map
+
+export { VirtualizedItem as default };

package/esm/components/VirtualizedList.js

@@ -1,59 +1,84 @@
-import * as React from "react";
-import React2, { useContext, useEffect, useRef } from "react";
-import { useTransition } from "react-spring/web";
-import { FixedSizeList as List } from "react-window";
-import InfiniteLoader from "react-window-infinite-loader";
-import AutoSizer from "react-virtualized-auto-sizer";
-import { animationConfig } from "../animation/animationConfig";
-import { AnimationState } from "../AnimationState";
-import { VirtualizedItem } from "./VirtualizedItem";
-function VirtualizedList({
-  items,
-  itemRenderer,
-  searching,
-  target = false,
-  innerRef,
-  children,
-  hasNextPage = true,
-  getMoreItems = () => {
-  }
-}) {
+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 { useRef, useContext, useEffect } from 'react';
+import { useTransition } from 'react-spring/web';
+import { FixedSizeList } from 'react-window';
+import InfiniteLoader from 'react-window-infinite-loader';
+import AutoSizer from 'react-virtualized-auto-sizer';
+import { animationConfig } from '../animation/animationConfig.js';
+import AnimationContext from '../AnimationState.js';
+import VirtualizedItem from './VirtualizedItem.js';
+import { jsx } from 'react/jsx-runtime';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function VirtualizedList(_ref) {
+  let {
+    items,
+    itemRenderer,
+    searching,
+    target = false,
+    innerRef,
+    children,
+    hasNextPage = true,
+    getMoreItems = () => {}
+  } = _ref;
   const hasMounted = useRef(false);
   const {
-    state: { isMoving, isMovingBack },
+    state: {
+      isMoving,
+      isMovingBack
+    },
     reset
-  } = useContext(AnimationState.Context);
+  } = useContext(AnimationContext.Context);
   useEffect(() => {
     hasMounted.current = true;
   }, []);
-  const transitions = useTransition(items, (item) => item.id, {
-    ...animationConfig.moveItem(target),
+  const transitions = useTransition(items, item => item.id, _objectSpread(_objectSpread({}, animationConfig.moveItem(target)), {}, {
     onDestroyed: () => reset()
-  });
+  }));
   const itemCount = hasNextPage ? items.length + 1 : items.length;
-  const isItemLoaded = (index) => !hasNextPage || index < items.length;
-  return /* @__PURE__ */ React2.createElement(AutoSizer, null, ({ height, width }) => /* @__PURE__ */ React2.createElement(InfiniteLoader, {
-    isItemLoaded,
-    itemCount,
-    loadMoreItems: getMoreItems
-  }, ({ onItemsRendered, ref }) => /* @__PURE__ */ React2.createElement(List, {
-    height: searching ? 300 : height,
-    width,
-    innerRef,
-    itemCount: transitions.length,
-    itemData: {
-      items: transitions,
-      itemRenderer,
-      isItemMoving: hasMounted.current && (isMoving || isMovingBack)
-    },
-    itemSize: 35,
-    onItemsRendered,
-    ref
-  }, children || VirtualizedItem)));
+
+  const isItemLoaded = index => !hasNextPage || index < items.length;
+
+  return /*#__PURE__*/_jsx(AutoSizer, {}, void 0, _ref2 => {
+    let {
+      height,
+      width
+    } = _ref2;
+    return /*#__PURE__*/_jsx(InfiniteLoader, {
+      isItemLoaded: isItemLoaded,
+      itemCount: itemCount,
+      loadMoreItems: getMoreItems
+    }, void 0, _ref3 => {
+      let {
+        onItemsRendered,
+        ref
+      } = _ref3;
+      return /*#__PURE__*/jsx(FixedSizeList, {
+        height: searching ? 300 : height,
+        width: width,
+        innerRef: innerRef,
+        itemCount: transitions.length,
+        itemData: {
+          items: transitions,
+          itemRenderer,
+          isItemMoving: hasMounted.current && (isMoving || isMovingBack)
+        },
+        itemSize: 35,
+        onItemsRendered: onItemsRendered,
+        ref: ref,
+        children: children || VirtualizedItem
+      });
+    });
+  });
 }
-var VirtualizedList_default = VirtualizedList;
-export {
-  VirtualizedList,
-  VirtualizedList_default as default
-};
-//# sourceMappingURL=VirtualizedList.js.map
+
+export { VirtualizedList as default };

package/esm/components/VirtualizedSortableList.js

@@ -1,19 +1,34 @@
-import * as React from "react";
-import React2 from "react";
-import { sortableElement, sortableContainer } from "react-sortable-hoc";
-import { VirtualizedList } from "./VirtualizedList";
-import { VirtualizedItem } from "./VirtualizedItem";
+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 'react';
+import { sortableContainer, sortableElement } from 'react-sortable-hoc';
+import VirtualizedList from './VirtualizedList.js';
+import VirtualizedItem from './VirtualizedItem.js';
+import { jsx } from 'react/jsx-runtime';
+
+const _excluded = ["items"];
+
+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 SortableList = sortableContainer(VirtualizedList);
-function VirtualizedSortableList({ items, ...otherProps }) {
-  return /* @__PURE__ */ React2.createElement(SortableList, {
-    ...otherProps,
-    items,
-    useDragHandle: true
-  }, sortableElement(VirtualizedItem));
+
+function VirtualizedSortableList(_ref) {
+  let {
+    items
+  } = _ref,
+      otherProps = _objectWithoutProperties(_ref, _excluded);
+
+  return /*#__PURE__*/jsx(SortableList, _objectSpread(_objectSpread({}, otherProps), {}, {
+    items: items,
+    useDragHandle: true,
+    children: sortableElement(VirtualizedItem)
+  }));
 }
-var VirtualizedSortableList_default = VirtualizedSortableList;
-export {
-  VirtualizedSortableList,
-  VirtualizedSortableList_default as default
-};
-//# sourceMappingURL=VirtualizedSortableList.js.map
+
+export { VirtualizedSortableList as default };

package/esm/helper.js

@@ -1,54 +1,78 @@
-import * as React from "react";
-import { omit, compose, hashArray } from "@elliemae/ds-utilities";
-import * as tree from "treetabular";
-const getHierarchyTypeName = (dest) => !dest ? "hierarchy" : "hierarchyDest";
-const checkHasChildren = (list, currentItem) => list.some((item) => currentItem.id === item.parent);
-const getActiveIdFromHierarchy = (hierarchy = []) => hierarchy[hierarchy.length - 1] || {};
-const filterItemsByHierarchy = (list, hierarchyId, parentField = "parent") => list.filter((item) => item[parentField] === hierarchyId);
-const getItemsById = (ids, list) => ids.reduce((acc, id) => acc.concat(list.find((item) => String(item.id) === String(id))), []).filter((item) => item);
-const toggleInObject = (obj, key, value) => obj[key] ? omit(obj, [key]) : { ...obj, [key]: value };
-const isMovable = (item) => !item.forceNotMovable && (item.hasChildren && item.isMoveableContainer || !item.hasChildren);
-const pipe = (actions) => (initState, props) => actions.reduce((prevState, action) => action(prevState, props), initState);
-const moveItems = ({ oldIndex, newIndex }) => (items) => {
-  const sourceItem = items[oldIndex];
-  items.splice(oldIndex, 1);
-  items.splice(newIndex, 0, sourceItem);
-  return items;
+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.some.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.some.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import { omit, compose, hashArray } from '@elliemae/ds-utilities';
+import * as tree from 'treetabular';
+
+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 getHierarchyTypeName = dest => !dest ? 'hierarchy' : 'hierarchyDest';
+const checkHasChildren = (list, currentItem) => list.some(item => currentItem.id === item.parent);
+const getActiveIdFromHierarchy = function () {
+  let hierarchy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return hierarchy[hierarchy.length - 1] || {};
 };
-const prepareItems = (items) => compose(tree.fixOrder(), (items2) => items2.map((item) => ({
-  ...item,
-  hasChildren: checkHasChildren(items2, item)
+const filterItemsByHierarchy = function (list, hierarchyId) {
+  let parentField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'parent';
+  return list.filter(item => item[parentField] === hierarchyId);
+};
+const getItemsById = (ids, list) => ids.reduce((acc, id) => acc.concat(list.find(item => String(item.id) === String(id))), []).filter(item => item);
+const toggleInObject = (obj, key, value) => obj[key] ? omit(obj, [key]) : _objectSpread(_objectSpread({}, obj), {}, {
+  [key]: value
+});
+const isMovable = item => !item.forceNotMovable && (item.hasChildren && item.isMoveableContainer || !item.hasChildren); // utility to execute all specified actions in sequence
+
+const pipe = actions => (initState, props) => actions.reduce((prevState, action) => action(prevState, props), initState);
+const moveItems = _ref => {
+  let {
+    oldIndex,
+    newIndex
+  } = _ref;
+  return items => {
+    const sourceItem = items[oldIndex];
+    items.splice(oldIndex, 1);
+    items.splice(newIndex, 0, sourceItem);
+    return items;
+  };
+};
+const prepareItems = items => compose(tree.fixOrder(), items => items.map(item => _objectSpread(_objectSpread({}, item), {}, {
+  hasChildren: checkHasChildren(items, item)
 })))(items);
 const defaultOptions = {
-  parentField: "parent",
-  idField: "id",
-  op: (hasMoved) => !hasMoved
+  parentField: 'parent',
+  idField: 'id',
+  op: hasMoved => !hasMoved
 };
 function getChildrenFromParent(parentId, options) {
-  const { parentField } = { ...defaultOptions, ...options };
-  return (items) => items.filter((item) => item[parentField] === parentId);
+  const {
+    parentField
+  } = _objectSpread(_objectSpread({}, defaultOptions), options);
+
+  return items => items.filter(item => item[parentField] === parentId);
 }
 function filterMovedItems(movedItems, options) {
-  const { idField, op: filterOp } = { ...defaultOptions, ...options };
+  const {
+    idField,
+    op: filterOp
+  } = _objectSpread(_objectSpread({}, defaultOptions), options);
+
   const movedItemsHash = hashArray(movedItems, idField);
-  return (items) => items.filter((item) => filterOp(!!movedItemsHash[item[idField]]));
+  return items => items.filter(item => filterOp(!!movedItemsHash[item[idField]]));
 }
 function filterBySearch(term, searching) {
-  return (items) => searching ? items.filter((item) => item.name.toLowerCase().indexOf(String(term).toLowerCase()) !== -1) : items;
+  return items => searching ? items.filter(item => item.name.toLowerCase().indexOf(String(term).toLowerCase()) !== -1) : items;
 }
-export {
-  checkHasChildren,
-  filterBySearch,
-  filterItemsByHierarchy,
-  filterMovedItems,
-  getActiveIdFromHierarchy,
-  getChildrenFromParent,
-  getHierarchyTypeName,
-  getItemsById,
-  isMovable,
-  moveItems,
-  pipe,
-  prepareItems,
-  toggleInObject
-};
-//# sourceMappingURL=helper.js.map
+
+export { checkHasChildren, filterBySearch, filterItemsByHierarchy, filterMovedItems, getActiveIdFromHierarchy, getChildrenFromParent, getHierarchyTypeName, getItemsById, isMovable, moveItems, pipe, prepareItems, toggleInObject };

package/esm/index.js

@@ -1,9 +1,2 @@
-import * as React from "react";
-import { default as default2, utils, DSShuttleWithSchema, DSShuttle } from "./DSShuttle";
-export {
-  DSShuttle,
-  DSShuttleWithSchema,
-  default2 as default,
-  utils
-};
-//# sourceMappingURL=index.js.map
+export { DSShuttleWithSchema, default } from './DSShuttle.js';
+export { default as utils } from './utils.js';

package/esm/updateShuttleStateFromProps.js

@@ -1,44 +1,66 @@
-import * as React from "react";
-import { compose, isEqual, hashArray } from "@elliemae/ds-utilities";
-import { getItemsById, pipe, prepareItems } from "./helper";
-import { addToTarget, resetMovedItems } from "./Shuttle.actions";
-const mergeToPrevState = (prevState, nextState) => ({
-  ...prevState,
-  ...nextState,
-  prevProps: {
-    ...prevState.prevProps,
-    ...nextState.prevProps
-  }
+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 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import { compose, isEqual, hashArray } from '@elliemae/ds-utilities';
+import { getItemsById, pipe, prepareItems } from './helper.js';
+import { addToTarget, resetMovedItems } from './Shuttle.actions.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+const mergeToPrevState = (prevState, nextState) => _objectSpread(_objectSpread(_objectSpread({}, prevState), nextState), {}, {
+  prevProps: _objectSpread(_objectSpread({}, prevState.prevProps), nextState.prevProps)
 });
+
 function compareSelectedItems(nextProps, prevProps) {
-  const { selectedItems, idField } = nextProps;
-  return (nextState) => {
-    if (isEqual(selectedItems, prevProps.selectedItems))
-      return nextState;
-    if (nextProps.nonSelectedItems)
-      return nextState;
-    const { preparedItems } = nextState;
+  const {
+    selectedItems,
+    idField
+  } = nextProps;
+  return nextState => {
+    if (isEqual(selectedItems, prevProps.selectedItems)) return nextState; // if we are using nonSelectedItems skip this legacy logic and paint just what's passed
+    // to nonSelectedItems (source) and selectedItems (target)
+    // TODO make controlledV2 the default behavior for controlled shuttle
+
+    if (nextProps.nonSelectedItems) return nextState;
+    const {
+      preparedItems
+    } = nextState;
     const prevSelectedItemsHash = hashArray(prevProps.selectedItems || []);
     const itemsToMove = getItemsById(selectedItems, preparedItems);
-    const actions = itemsToMove.map((item) => prevSelectedItemsHash[item[idField]] ? addToTarget(item, nextState.targetItems) : addToTarget(item));
-    return mergeToPrevState(nextState, {
-      ...pipe([resetMovedItems(), ...actions])(nextState, nextProps),
-      prevProps: {
-        ...nextState.prevProps,
+    const actions = itemsToMove.map(item => prevSelectedItemsHash[item[idField]] ? addToTarget(item, nextState.targetItems) : addToTarget(item));
+    return mergeToPrevState(nextState, _objectSpread(_objectSpread({}, pipe([resetMovedItems(), ...actions])(nextState, nextProps)), {}, {
+      prevProps: _objectSpread(_objectSpread({}, nextState.prevProps), {}, {
         selectedItems
-      }
-    });
+      })
+    }));
   };
 }
+
 function compareItems(nextProps, prevProps) {
-  const { items } = nextProps;
-  return (nextState) => {
+  const {
+    items
+  } = nextProps;
+  return nextState => {
     const preparedItems = prepareItems(items);
-    const isControlledV2 = nextProps.nonSelectedItems;
+    const isControlledV2 = nextProps.nonSelectedItems; // TODO make controlledV2 the default behavior for controlled shuttle
+
     if (isControlledV2) {
-      const targetItems = nextProps.selectedItems.map((id) => preparedItems.find((it) => it.id === id));
+      const targetItems = nextProps.selectedItems.map(id => preparedItems.find(it => it.id === id));
       return mergeToPrevState(nextState, {
         preparedItems,
+        // PUI-4462 on async load and items change, the shuttle loads
+        // all children from currently selected targetItems from items prop
+        // (items prop update)
         targetItems,
         movedItems: targetItems,
         prevProps: {
@@ -46,8 +68,8 @@ function compareItems(nextProps, prevProps) {
         }
       });
     }
-    if (isEqual(items, prevProps.items))
-      return nextState;
+
+    if (isEqual(items, prevProps.items)) return nextState;
     return mergeToPrevState(nextState, {
       preparedItems,
       prevProps: {
@@ -56,14 +78,11 @@ function compareItems(nextProps, prevProps) {
     });
   };
 }
-function updateShuttleStateFromProps(nextProps, prevState) {
-  const stateReducers = [compareSelectedItems, compareItems].map((fn) => fn(nextProps, prevState.prevProps));
+
+function updateShuttleStateFromProps (nextProps, prevState) {
+  const stateReducers = [compareSelectedItems, compareItems].map(fn => fn(nextProps, prevState.prevProps));
   const nextState = compose(...stateReducers)(prevState);
   return !isEqual(nextState, prevState) ? nextState : null;
 }
-var updateShuttleStateFromProps_default = updateShuttleStateFromProps;
-export {
-  updateShuttleStateFromProps_default as default,
-  updateShuttleStateFromProps
-};
-//# sourceMappingURL=updateShuttleStateFromProps.js.map
+
+export { updateShuttleStateFromProps as default };

package/esm/utils.js

@@ -1,12 +1,18 @@
-import * as React from "react";
-import * as tree from "treetabular";
-import { compose } from "@elliemae/ds-utilities";
-import { prepareItems } from "./helper";
-var utils_default = {
-  prepareItems: (items, options) => compose(tree.fixOrder(options), prepareItems)(items),
-  ...tree
-};
-export {
-  utils_default as default
-};
-//# sourceMappingURL=utils.js.map
+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 * as tree from 'treetabular';
+import { compose } from '@elliemae/ds-utilities';
+import { prepareItems } from './helper.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; }
+var utils = _objectSpread({
+  prepareItems: (items, options) => compose(tree.fixOrder(options), prepareItems)(items)
+}, tree);
+
+export { utils as default };

package/esm/withProviders.js

@@ -1,16 +1,22 @@
-import * as React from "react";
-import React2 from "react";
-import { AnimationState } from "./AnimationState";
-import { SearchState } from "./SearchState";
-import { ShuttleState } from "./ShuttleState";
+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 'react';
+import AnimationContext from './AnimationState.js';
+import SearchState from './SearchState.js';
+import useShuttleState from './ShuttleState.js';
+import { jsx } from 'react/jsx-runtime';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
 function withProviders(Component) {
-  return (props) => /* @__PURE__ */ React2.createElement(ShuttleState.Provider, null, /* @__PURE__ */ React2.createElement(AnimationState.Provider, null, /* @__PURE__ */ React2.createElement(SearchState.Provider, null, /* @__PURE__ */ React2.createElement(Component, {
-    ...props
-  }))));
+  return props => /*#__PURE__*/_jsx(useShuttleState.Provider, {}, void 0, /*#__PURE__*/_jsx(AnimationContext.Provider, {}, void 0, /*#__PURE__*/_jsx(SearchState.Provider, {}, void 0, /*#__PURE__*/jsx(Component, _objectSpread({}, props)))));
 }
-var withProviders_default = withProviders;
-export {
-  withProviders_default as default,
-  withProviders
-};
-//# sourceMappingURL=withProviders.js.map
+
+export { withProviders as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-shuttle",
-  "version": "2.2.0-alpha.4",
+  "version": "3.0.0-next.2",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Shuttle",
   "module": "./esm/index.js",
@@ -152,16 +152,16 @@
     "build": "node ../../scripts/build/build.js"
   },
   "dependencies": {
-    "@elliemae/ds-basic": "2.2.0-alpha.4",
-    "@elliemae/ds-button": "2.2.0-alpha.4",
-    "@elliemae/ds-circular-progress-indicator": "2.2.0-alpha.4",
-    "@elliemae/ds-classnames": "2.2.0-alpha.4",
-    "@elliemae/ds-form": "2.2.0-alpha.4",
-    "@elliemae/ds-icons": "2.2.0-alpha.4",
-    "@elliemae/ds-indeterminate-progress-indicator": "2.2.0-alpha.4",
-    "@elliemae/ds-system": "2.2.0-alpha.4",
-    "@elliemae/ds-truncated-tooltip-text": "2.2.0-alpha.4",
-    "@elliemae/ds-utilities": "2.2.0-alpha.4",
+    "@elliemae/ds-basic": "3.0.0-next.2",
+    "@elliemae/ds-button": "3.0.0-next.2",
+    "@elliemae/ds-circular-progress-indicator": "3.0.0-next.2",
+    "@elliemae/ds-classnames": "3.0.0-next.2",
+    "@elliemae/ds-form": "3.0.0-next.2",
+    "@elliemae/ds-icons": "3.0.0-next.2",
+    "@elliemae/ds-indeterminate-progress-indicator": "3.0.0-next.2",
+    "@elliemae/ds-system": "3.0.0-next.2",
+    "@elliemae/ds-truncated-tooltip-text": "3.0.0-next.2",
+    "@elliemae/ds-utilities": "3.0.0-next.2",
     "constate": "~1.3.2",
     "prop-types": "~15.7.2",
     "react-desc": "~4.1.3",

package/types/AnimationState.d.ts

@@ -1,4 +1,4 @@
-declare const AnimationState: import("constate/dist/ts/src/types").ContextHookReturn<unknown, {
+declare const _default: import("constate/dist/ts/src/types").ContextHookReturn<unknown, {
     state: {
         isMoving: boolean;
         isMovingBack: boolean;
@@ -23,5 +23,4 @@ declare const AnimationState: import("constate/dist/ts/src/types").ContextHookRe
     isMovingBack: boolean;
     isDrillingDown: boolean;
 }[]]>;
-export { AnimationState };
-export default AnimationState;
+export default _default;

package/types/DSShuttle.d.ts

@@ -337,5 +337,5 @@ declare const DSShuttleWithSchema: {
     propTypes: unknown;
     toTypescript: () => import("react-desc").TypescriptSchema;
 };
-export { utils, DSShuttleWithSchema, DSShuttle };
+export { utils, DSShuttleWithSchema };
 export default DSShuttle;