@elliemae/ds-shuttle 2.3.0-alpha.9 → 2.3.0-next.3

package/esm/components/OverflowList.js

@@ -0,0 +1,46 @@
+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 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import { useContext } from 'react';
+import { useTransition, animated } from 'react-spring/web';
+import { animationConfig } from '../animation/animationConfig.js';
+import AnimationContext from '../AnimationState.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; }
+
+function OverflowList(_ref) {
+  let {
+    className = '',
+    activeHierarchy = '',
+    children
+  } = _ref;
+  const {
+    state: {
+      isDrillingDown = false
+    },
+    setIsDrillingDown
+  } = useContext(AnimationContext.Context);
+  const overflowTransition = useTransition(activeHierarchy, null, _objectSpread(_objectSpread({}, animationConfig.moveList(isDrillingDown)), {}, {
+    onDestroyed: () => setIsDrillingDown(false)
+  }));
+  return overflowTransition.map(_ref2 => {
+    let {
+      props,
+      key
+    } = _ref2;
+    return /*#__PURE__*/_jsx(animated.div, {
+      className: className,
+      style: props
+    }, key, children);
+  });
+}
+
+export { OverflowList as default };

package/esm/components/ShuttleBreadcrumb.js

@@ -0,0 +1,35 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'react';
+import { useTransition, animated } from 'react-spring/web';
+import DSBreadcrumb from '@elliemae/ds-basic/Breadcrumb';
+import { animationConfig } from '../animation/animationConfig.js';
+
+function ShuttleBreadcrumb(_ref) {
+  let {
+    className = '',
+    hierarchy = [],
+    onNavigateTo = () => null
+  } = _ref;
+  const animatedCrumbs = useTransition(hierarchy, item => item.id, animationConfig.breadcrumb());
+  return /*#__PURE__*/_jsx("div", {
+    className: className
+  }, void 0, /*#__PURE__*/_jsx(DSBreadcrumb, {
+    isTitle: true
+  }, void 0, animatedCrumbs.map(_ref2 => {
+    let {
+      item,
+      props,
+      key
+    } = _ref2;
+    return /*#__PURE__*/_jsx(DSBreadcrumb.Item, {
+      containerComponent: animated.li,
+      label: item.name,
+      onClick: () => onNavigateTo(item, 'up'),
+      style: props
+    }, key);
+  })));
+}
+
+export { ShuttleBreadcrumb as default };

package/esm/components/ShuttleInfiniteScrollIndicator.js

@@ -0,0 +1,32 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
+import { aggregatedClasses } from '@elliemae/ds-classnames';
+import DSIndeterminateProgressIndicator from '@elliemae/ds-indeterminate-progress-indicator';
+
+var _DSIndeterminateProgr;
+const blockName = 'shuttle-infinite-scroll-indicator';
+const InfiniteScrollBarContainer = aggregatedClasses('div')(blockName, null, _ref => {
+  let {
+    isOpen
+  } = _ref;
+  return {
+    opened: isOpen
+  };
+});
+
+const ShuttleInfiniteScrollIndicator = _ref2 => {
+  let {
+    isOpen
+  } = _ref2;
+  return /*#__PURE__*/_jsx(InfiniteScrollBarContainer, {
+    classProps: {
+      isOpen
+    },
+    "data-testid": blockName
+  }, void 0, _DSIndeterminateProgr || (_DSIndeterminateProgr = /*#__PURE__*/_jsx(DSIndeterminateProgressIndicator, {
+    processing: true,
+    title: "Loading"
+  })));
+};
+
+export { ShuttleInfiniteScrollIndicator as default };

package/esm/components/ShuttleListItem/ActionButtons.js

@@ -0,0 +1,43 @@
+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 _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
+import { aggregatedClasses } from '@elliemae/ds-classnames';
+import DSButton from '@elliemae/ds-button';
+import { ArrowShortRight, ArrowShortReturn, CloseCircle } from '@elliemae/ds-icons';
+import { jsx } from 'react/jsx-runtime';
+
+var _CloseCircle, _ArrowShortRight, _ArrowShortReturn;
+
+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 ActionButton = aggregatedClasses(DSButton)('shuttle-list-item', 'action-button');
+const DeleteButton = props => /*#__PURE__*/jsx(ActionButton, _objectSpread({
+  buttonType: "text",
+  icon: _CloseCircle || (_CloseCircle = /*#__PURE__*/_jsx(CloseCircle, {}))
+}, props));
+const MoveButton = props => /*#__PURE__*/jsx(ActionButton, _objectSpread(_objectSpread({
+  buttonType: "text",
+  icon: _ArrowShortRight || (_ArrowShortRight = /*#__PURE__*/_jsx(ArrowShortRight, {}))
+}, props), {}, {
+  containerProps: {
+    'data-testid': 'ds-shuttle__move-button'
+  }
+}));
+const DrillDownButton = props => /*#__PURE__*/jsx(ActionButton, _objectSpread(_objectSpread({
+  buttonType: "text",
+  icon: _ArrowShortReturn || (_ArrowShortReturn = /*#__PURE__*/_jsx(ArrowShortReturn, {
+    "data-testid": "shuttle__drill-btn-icon"
+  }))
+}, props), {}, {
+  containerProps: {
+    'data-testid': 'shuttle__drill-btn'
+  }
+}));
+
+export { DeleteButton, DrillDownButton, MoveButton };

package/esm/components/ShuttleListItem/ShuttleListItem.js

@@ -0,0 +1,76 @@
+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 _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
+import { aggregatedClasses } from '@elliemae/ds-classnames';
+import { animated } from 'react-spring/web';
+import TruncatedTooltipText from '@elliemae/ds-basic/TruncatedTooltipText';
+import { sortableHandle } from 'react-sortable-hoc';
+import { GripperVertical } from '@elliemae/ds-icons';
+import { isMovable } from '../../helper.js';
+import { jsxs } from 'react/jsx-runtime';
+
+const _excluded = ["item", "showIcons", "showIcon", "onSelect", "isChecked", "style", "showActions", "actions", "showSortHandler"];
+
+var _GripperVertical, _SortHandler;
+
+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 blockName = 'shuttle-list-item';
+const Wrapper = aggregatedClasses(animated.li)(blockName);
+const ActionsGroup = aggregatedClasses('div')(blockName, 'actions');
+const IconWrapper = aggregatedClasses('div')(blockName, 'icon-wrapper');
+const Content = aggregatedClasses('label')(blockName, 'content', _ref => {
+  let {
+    isChecked,
+    canMove,
+    isReadonly
+  } = _ref;
+  return {
+    checked: isChecked,
+    'can-hover': canMove,
+    'read-only': isReadonly
+  };
+});
+const SortHandler = sortableHandle(() => _GripperVertical || (_GripperVertical = /*#__PURE__*/_jsx(GripperVertical, {
+  className: "gripper"
+})));
+
+function ShuttleListItem(_ref2) {
+  let {
+    item = {},
+    showIcons = undefined,
+    showIcon = true,
+    onSelect = () => null,
+    isChecked = false,
+    style = undefined,
+    showActions = true,
+    actions = [],
+    showSortHandler = false
+  } = _ref2,
+      rest = _objectWithoutProperties(_ref2, _excluded);
+
+  return /*#__PURE__*/jsxs(Wrapper, _objectSpread(_objectSpread({}, rest), {}, {
+    role: "listitem",
+    style: style,
+    children: [/*#__PURE__*/_jsx(Content, {
+      classProps: {
+        canMove: isMovable(item),
+        isChecked,
+        isReadonly: item.readyOnly
+      },
+      onClick: onSelect
+    }, void 0, showSortHandler && (_SortHandler || (_SortHandler = /*#__PURE__*/_jsx(SortHandler, {}))), (showIcon || showIcons) && /*#__PURE__*/_jsx(IconWrapper, {}, void 0, item.icon), /*#__PURE__*/_jsx(TruncatedTooltipText, {
+      className: "shuttle-tooltip-text",
+      value: item.name
+    })), showActions && /*#__PURE__*/_jsx(ActionsGroup, {}, void 0, actions)]
+  }));
+}
+
+export { ShuttleListItem as default };

package/esm/components/ShuttleListItem/ShuttleSourceListItem.js

@@ -0,0 +1,68 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import 'core-js/modules/web.dom-collections.iterator.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';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import { useState, useCallback, useEffect } from 'react';
+import { isMovable } from '../../helper.js';
+import { DrillDownButton, MoveButton } from './ActionButtons.js';
+import ShuttleListItem from './ShuttleListItem.js';
+import { jsx } from 'react/jsx-runtime';
+
+const _excluded = ["item", "onItemCheck", "onMoveToTarget", "onNavigateOnSourceTo", "isChecked", "showMoveButton", "showDrillDownButton", "index"];
+
+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 ShuttleSourceListItem(_ref) {
+  let {
+    item = {},
+    onItemCheck = () => null,
+    onMoveToTarget = () => null,
+    onNavigateOnSourceTo = () => null,
+    isChecked = false,
+    showMoveButton = true,
+    showDrillDownButton = true,
+    index
+  } = _ref,
+      rest = _objectWithoutProperties(_ref, _excluded);
+
+  const [clicked, setClicked] = useState(false);
+  const moveToTarget = useCallback(() => onMoveToTarget(item), [item]);
+  useEffect(() => {
+    if (clicked) {
+      moveToTarget();
+    }
+  }, [clicked]);
+  const navigateOnSourceTo = useCallback(() => onNavigateOnSourceTo(item), [item]);
+  const checkItem = useCallback(() => {
+    if (!clicked) onItemCheck(item);
+  }, [item, clicked]);
+
+  const handleOnClick = () => {
+    if (!clicked) {
+      setClicked(true);
+    }
+  };
+
+  return /*#__PURE__*/jsx(ShuttleListItem, _objectSpread(_objectSpread({}, rest), {}, {
+    actions: [showDrillDownButton && /*#__PURE__*/_jsx(DrillDownButton, {
+      disabled: !item.hasChildren && !item.asyncLoad || item.readOnly || item.disableDrillDown,
+      onClick: navigateOnSourceTo
+    }, "drill-down"), showMoveButton && /*#__PURE__*/_jsx(MoveButton, {
+      "data-testid": "ds-shuttle__move-button",
+      disabled: !isMovable(item) || item.readOnly,
+      onClick: handleOnClick
+    }, "move")],
+    isChecked: isChecked,
+    item: item,
+    onSelect: checkItem
+  }));
+}
+
+export { ShuttleSourceListItem as default };

package/esm/components/ShuttleListItem/ShuttleTargetListItem.js

@@ -0,0 +1,49 @@
+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 _jsx from '@babel/runtime/helpers/esm/jsx';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import { useCallback } from 'react';
+import { DrillDownButton, DeleteButton } from './ActionButtons.js';
+import ShuttleListItem from './ShuttleListItem.js';
+import { jsx } from 'react/jsx-runtime';
+
+const _excluded = ["item", "onMoveToSource", "onNavigateOnTargetTo", "isRoot", "showDeleteButton", "showDrillDownButton", "showActions", "index"];
+
+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 ShuttleTargetListItem(_ref) {
+  let {
+    item = {},
+    onMoveToSource = () => null,
+    onNavigateOnTargetTo = () => null,
+    isRoot = false,
+    showDeleteButton = true,
+    showDrillDownButton = true,
+    showActions = true,
+    index
+  } = _ref,
+      rest = _objectWithoutProperties(_ref, _excluded);
+
+  const moveToSource = useCallback(() => onMoveToSource(item), [item]);
+  const navigateOnTargetTo = useCallback(() => onNavigateOnTargetTo(item), [item]);
+  return /*#__PURE__*/jsx(ShuttleListItem, _objectSpread(_objectSpread({}, rest), {}, {
+    actions: [showDrillDownButton && /*#__PURE__*/_jsx(DrillDownButton, {
+      disabled: !item.hasChildren && !item.asyncLoad || item.readOnly || item.disableDrillDown,
+      onClick: navigateOnTargetTo
+    }, "drill-down"), showDeleteButton && isRoot && /*#__PURE__*/_jsx(DeleteButton, {
+      disabled: item.readOnly,
+      onClick: moveToSource,
+      "data-testid": "ds-shuttle__close-button"
+    }, "delete")],
+    item: item,
+    showActions: showActions
+  }));
+}
+
+export { ShuttleTargetListItem as default };

package/esm/components/ShuttleListPanel.js

@@ -0,0 +1,24 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
+import DSButton from '@elliemae/ds-button';
+import { ShuttleListPanel as ShuttleListPanel$1 } from '../classedComponents.js';
+
+function ShuttleListPanel(_ref) {
+  let {
+    onClick = () => null,
+    open = false,
+    children
+  } = _ref;
+  return /*#__PURE__*/_jsx(ShuttleListPanel$1, {
+    classProps: {
+      open
+    }
+  }, void 0, /*#__PURE__*/_jsx(DSButton, {
+    buttonType: "text",
+    icon: children,
+    onClick: onClick,
+    "data-testid": "list-panel-btn"
+  }));
+}
+
+export { ShuttleListPanel as default };

package/esm/components/ShuttleSearchBox.js

@@ -0,0 +1,104 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { Component } from 'react';
+import { aggregatedClasses } from '@elliemae/ds-classnames';
+import { debounce } from '@elliemae/ds-utilities';
+import { DSTextBox } from '@elliemae/ds-form';
+
+const blockName = 'shuttle-search-box';
+const SearchBoxContainer = aggregatedClasses('div')(blockName, null, _ref => {
+  let {
+    isOpen
+  } = _ref;
+  return {
+    opened: isOpen
+  };
+});
+const filterList = debounce((term, onFilterCallback) => {
+  onFilterCallback(term);
+}, 200);
+class ShuttleSearchBox extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      value: props.value,
+      prevProps: {}
+    };
+    this.handleChange = this.handleChange.bind(this);
+    this.handleKeyPress = this.handleKeyPress.bind(this);
+  }
+
+  static getDerivedStateFromProps(nextProps, _ref2) {
+    let {
+      prevProps
+    } = _ref2;
+    const {
+      value
+    } = nextProps;
+
+    if (value !== prevProps.value) {
+      return {
+        value,
+        prevProps: {
+          value
+        }
+      };
+    }
+
+    return null;
+  }
+
+  handleChange(e) {
+    const {
+      onChange,
+      filterOnKeyStroke,
+      onFilter
+    } = this.props;
+    const {
+      value
+    } = e.target;
+    onChange(value);
+    if (filterOnKeyStroke) filterList(value, onFilter);
+    this.setState({
+      value
+    });
+  }
+
+  handleKeyPress(e) {
+    const {
+      onFilter
+    } = this.props;
+    if (e.keyCode === 13) onFilter(e.target.value);
+  }
+
+  render() {
+    const {
+      value
+    } = this.state;
+    const {
+      isOpen,
+      onClose,
+      placeholder
+    } = this.props;
+    return /*#__PURE__*/_jsx(SearchBoxContainer, {
+      classProps: {
+        isOpen
+      }
+    }, void 0, /*#__PURE__*/_jsx(DSTextBox, {
+      autoFocus: true,
+      clearable: true,
+      onChange: this.handleChange,
+      onClear: onClose,
+      onKeyDown: this.handleKeyPress,
+      placeholder: placeholder,
+      value: value
+    }));
+  }
+
+}
+ShuttleSearchBox.defaultProps = {
+  filterOnKeyStroke: false,
+  onChange: () => null,
+  onFilter: () => null
+};
+
+export { ShuttleSearchBox as default };

package/esm/components/ShuttleSource.js

@@ -0,0 +1,179 @@
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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 '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 { useContext, useMemo, useCallback } from 'react';
+import { Search, ArrowShortRight } from '@elliemae/ds-icons';
+import DSButton from '@elliemae/ds-button';
+import { runAll } from '@elliemae/ds-utilities';
+import ShuttleSearchBox from './ShuttleSearchBox.js';
+import ShuttleInfiniteScrollIndicator from './ShuttleInfiniteScrollIndicator.js';
+import ShuttleSourceListItem from './ShuttleListItem/ShuttleSourceListItem.js';
+import { ShuttleWrapper, ShuttleHeader, ShuttleHeaderBreadcrumb, ShuttleHeaderSearchToggle, ShuttleList, Overflow, LoadingList, EmptyMessage, ShuttleFooter, ShuttleFooterActions, ShuttleFooterCounter } from '../classedComponents.js';
+import ShuttleListPanel from './ShuttleListPanel.js';
+import VirtualizedList from './VirtualizedList.js';
+import { getActiveIdFromHierarchy } from '../helper.js';
+import AnimationContext from '../AnimationState.js';
+import SearchState from '../SearchState.js';
+import VirtualizedSortableList from './VirtualizedSortableList.js';
+import LoadingIndicator from './LoadingIndicator.js';
+import { jsx } from 'react/jsx-runtime';
+
+const _excluded = ["item"];
+
+var _Search, _LoadingList, _ArrowShortRight, _ShuttleInfiniteScrol;
+
+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 noop = () => {};
+
+function ShuttleSource(_ref) {
+  let {
+    items = [],
+    checkedItems = [],
+    // build Map() and memoize it for better performance
+    hierarchy = [],
+    onMoveItem = noop,
+    onCheckItem = noop,
+    onMoveCheckedItems = noop,
+    onNavigateTo = noop,
+    onClearCheckedItems = noop,
+    emptyMessage = 'No items found',
+    composeSourceItemProps = noop,
+    loading = false,
+    onSearch = noop,
+    onSearchClose = noop,
+    onSearchOpen = noop,
+    sourceSortable = false,
+    onSortEnd = noop,
+    sourceClearItemsText = 'CLEAR ALL',
+    searchPlaceholder,
+    renderSourceCounter = amount => "".concat(amount, " items"),
+    onGetMoreItems = () => {},
+    moreItemsLoading = false,
+    hasNextPage = false
+  } = _ref;
+  const {
+    state: {
+      isMovingBack = false,
+      isMoving
+    }
+  } = useContext(AnimationContext.Context);
+  const {
+    state: {
+      searching,
+      searchTerm
+    },
+    setSearchTerm,
+    reset: resetSearch,
+    toggleSearchBox
+  } = useContext(SearchState.Context);
+  const hashedCheckedItems = useMemo(() => checkedItems.reduce((result, item) => _objectSpread(_objectSpread({}, result), {}, {
+    [item]: true
+  }), {}), [checkedItems]);
+  const handleCloseSearch = useCallback(() => {
+    setSearchTerm('');
+    runAll(resetSearch, onSearchClose)();
+  }, [searching]);
+  const handleToggleSearch = useCallback(() => {
+    toggleSearchBox(!searching);
+
+    if (searching) {
+      handleCloseSearch();
+    } else {
+      onSearchOpen();
+    }
+  }, [searching]);
+  const ComponentList = useMemo(() => sourceSortable ? VirtualizedSortableList : VirtualizedList, [sourceSortable]);
+
+  const handleSortEnd = _ref2 => {
+    let {
+      oldIndex,
+      newIndex
+    } = _ref2;
+    onSortEnd({
+      sourceItem: items[oldIndex],
+      targetItem: items[newIndex]
+    });
+  };
+
+  const isEmpty = !items.length;
+  const hasContent = !loading && !isEmpty;
+  const contentIsEmpty = !loading && isEmpty;
+  return /*#__PURE__*/_jsx(ShuttleWrapper, {}, void 0, /*#__PURE__*/_jsx(ShuttleHeader, {}, void 0, /*#__PURE__*/_jsx(ShuttleHeaderBreadcrumb, {
+    hierarchy: hierarchy,
+    onNavigateTo: onNavigateTo
+  }), /*#__PURE__*/_jsx(ShuttleHeaderSearchToggle, {
+    buttonType: "text",
+    icon: _Search || (_Search = /*#__PURE__*/_jsx(Search, {})),
+    onClick: handleToggleSearch,
+    containerProps: {
+      'data-testid': 'shuttle-header-search-toggle'
+    }
+  })), /*#__PURE__*/_jsx(ShuttleList, {
+    classProps: {
+      showPulse: isMovingBack
+    },
+    style: {
+      pointerEvents: isMoving ? 'none' : null
+    }
+  }, void 0, /*#__PURE__*/_jsx(ShuttleSearchBox, {
+    isOpen: searching,
+    onClose: runAll(() => toggleSearchBox(false), handleCloseSearch),
+    onFilter: runAll(setSearchTerm, onSearch),
+    placeholder: searchPlaceholder,
+    value: searchTerm
+  }, searching), hasContent ? /*#__PURE__*/_jsx(Overflow, {
+    activeHierarchy: getActiveIdFromHierarchy(hierarchy).id,
+    classProps: {
+      searching,
+      empty: isEmpty
+    }
+  }, void 0, /*#__PURE__*/_jsx(ComponentList, {
+    helperClass: "drag-helper",
+    itemRenderer: _ref3 => {
+      let {
+        item
+      } = _ref3,
+          rest = _objectWithoutProperties(_ref3, _excluded);
+
+      return /*#__PURE__*/jsx(ShuttleSourceListItem, _objectSpread(_objectSpread(_objectSpread({
+        "data-testid": "source-list-item"
+      }, rest), composeSourceItemProps(item, rest)), {}, {
+        isChecked: !!hashedCheckedItems[item.id],
+        item: item,
+        onItemCheck: onCheckItem,
+        onMoveToTarget: onMoveItem,
+        onNavigateOnSourceTo: onNavigateTo,
+        showSortHandler: sourceSortable
+      }));
+    },
+    items: items,
+    onSortEnd: handleSortEnd,
+    getMoreItems: onGetMoreItems,
+    hasNextPage: hasNextPage
+  }, searchTerm)) : null, contentIsEmpty ? /*#__PURE__*/_jsx(LoadingList, {
+    "data-testid": "shuttle__loading-list"
+  }, void 0, /*#__PURE__*/_jsx(EmptyMessage, {}, void 0, emptyMessage)) : null, loading ? _LoadingList || (_LoadingList = /*#__PURE__*/_jsx(LoadingList, {
+    "data-testid": "shuttle__loading-list"
+  }, void 0, /*#__PURE__*/_jsx(LoadingIndicator, {}))) : null, /*#__PURE__*/_jsx(ShuttleListPanel, {
+    onClick: onMoveCheckedItems,
+    open: checkedItems.length > 1
+  }, void 0, _ArrowShortRight || (_ArrowShortRight = /*#__PURE__*/_jsx(ArrowShortRight, {}))), moreItemsLoading ? _ShuttleInfiniteScrol || (_ShuttleInfiniteScrol = /*#__PURE__*/_jsx(ShuttleInfiniteScrollIndicator, {
+    isOpen: true
+  })) : null), /*#__PURE__*/_jsx(ShuttleFooter, {}, void 0, /*#__PURE__*/_jsx(ShuttleFooterActions, {}, void 0, !!checkedItems.length && /*#__PURE__*/_jsx(DSButton, {
+    buttonType: "link",
+    labelText: sourceClearItemsText,
+    onClick: onClearCheckedItems
+  })), /*#__PURE__*/_jsx(ShuttleFooterCounter, {}, void 0, renderSourceCounter(checkedItems.length))));
+}
+
+export { ShuttleSource as default };