@elliemae/ds-shuttle 1.55.0-next.7 → 2.0.0-alpha.10

package/esm/updateShuttleStateFromProps.js

@@ -1,86 +1,78 @@
-import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import { compose, isEqual, hashArray } from '@elliemae/ds-utilities/utils';
 import { getItemsById, pipe, prepareItems } from './helper.js';
 import { addToTarget, resetMovedItems } from './Shuttle.actions.js';
-import 'treetabular';
-import './utils.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-var mergeToPrevState = function mergeToPrevState(prevState, nextState) {
-  return _objectSpread(_objectSpread(_objectSpread({}, prevState), nextState), {}, {
-    prevProps: _objectSpread(_objectSpread({}, prevState.prevProps), nextState.prevProps)
-  });
-};
+const mergeToPrevState = (prevState, nextState) => _objectSpread(_objectSpread(_objectSpread({}, prevState), nextState), {}, {
+  prevProps: _objectSpread(_objectSpread({}, prevState.prevProps), nextState.prevProps)
+});
 
 function compareSelectedItems(nextProps, prevProps) {
-  var selectedItems = nextProps.selectedItems,
-      idField = nextProps.idField;
-  return function (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;
-    var preparedItems = nextState.preparedItems;
-    var prevSelectedItemsHash = hashArray(prevProps.selectedItems || []);
-    var itemsToMove = getItemsById(selectedItems, preparedItems);
-    var actions = itemsToMove.map(function (item) {
-      return prevSelectedItemsHash[item[idField]] ? addToTarget(item, nextState.targetItems) : addToTarget(item);
-    });
-    return mergeToPrevState(nextState, _objectSpread(_objectSpread({}, pipe([resetMovedItems()].concat(_toConsumableArray(actions)))(nextState, nextProps)), {}, {
+    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, _objectSpread(_objectSpread({}, pipe([resetMovedItems(), ...actions])(nextState, nextProps)), {}, {
       prevProps: _objectSpread(_objectSpread({}, nextState.prevProps), {}, {
-        selectedItems: selectedItems
+        selectedItems
       })
     }));
   };
 }
 
 function compareItems(nextProps, prevProps) {
-  var items = nextProps.items;
-  return function (nextState) {
-    var preparedItems = prepareItems(items);
-    var isControlledV2 = nextProps.nonSelectedItems; // TODO make controlledV2 the default behavior for controlled shuttle
+  const {
+    items
+  } = nextProps;
+  return nextState => {
+    const preparedItems = prepareItems(items);
+    const isControlledV2 = nextProps.nonSelectedItems; // TODO make controlledV2 the default behavior for controlled shuttle
 
     if (isControlledV2) {
-      var targetItems = nextProps.selectedItems.map(function (id) {
-        return preparedItems.find(function (it) {
-          return it.id === id;
-        });
-      });
+      const targetItems = nextProps.selectedItems.map(id => preparedItems.find(it => it.id === id));
       return mergeToPrevState(nextState, {
-        preparedItems: preparedItems,
+        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: targetItems,
+        targetItems,
         movedItems: targetItems,
         prevProps: {
-          items: items
+          items
         }
       });
     }
 
     if (isEqual(items, prevProps.items)) return nextState;
     return mergeToPrevState(nextState, {
-      preparedItems: preparedItems,
+      preparedItems,
       prevProps: {
-        items: items
+        items
       }
     });
   };
 }
 
 function updateShuttleStateFromProps (nextProps, prevState) {
-  var stateReducers = [compareSelectedItems, compareItems].map(function (fn) {
-    return fn(nextProps, prevState.prevProps);
-  });
-  var nextState = compose.apply(void 0, _toConsumableArray(stateReducers))(prevState);
+  const stateReducers = [compareSelectedItems, compareItems].map(fn => fn(nextProps, prevState.prevProps));
+  const nextState = compose(...stateReducers)(prevState);
   return !isEqual(nextState, prevState) ? nextState : null;
 }
 
 export { updateShuttleStateFromProps as default };
-//# sourceMappingURL=updateShuttleStateFromProps.js.map

package/esm/utils.js

@@ -7,10 +7,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 var utils = _objectSpread({
-  prepareItems: function prepareItems$1(items, options) {
-    return compose(tree.fixOrder(options), prepareItems)(items);
-  }
+  prepareItems: (items, options) => compose(tree.fixOrder(options), prepareItems)(items)
 }, tree);
 
 export { utils as default };
-//# sourceMappingURL=utils.js.map

package/esm/withProviders.js

@@ -1,24 +1,17 @@
-import React from 'react';
+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 '@babel/runtime/helpers/esm/slicedToArray';
-import 'constate';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import './helper.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import '@elliemae/ds-utilities/utils';
-import 'treetabular';
-import './Shuttle.actions.js';
-import './utils.js';
+import { jsx } from 'react/jsx-runtime';
 
-/* eslint-disable react/display-name */
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 function withProviders(Component) {
-  return function (props) {
-    return /*#__PURE__*/React.createElement(useShuttleState.Provider, null, /*#__PURE__*/React.createElement(AnimationContext.Provider, null, /*#__PURE__*/React.createElement(SearchState.Provider, null, /*#__PURE__*/React.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)))));
 }
 
 export { withProviders as default };
-//# sourceMappingURL=withProviders.js.map

package/package.json

@@ -1,14 +1,150 @@
 {
   "name": "@elliemae/ds-shuttle",
-  "version": "1.55.0-next.7",
+  "version": "2.0.0-alpha.10",
   "license": "MIT",
-  "description": "Ellie Mae - Dim Sum - Shuttle",
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
+  "description": "ICE MT - Dimsum - Shuttle",
+  "module": "./esm/index.js",
+  "main": "./cjs/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./withProviders": {
+      "import": "./esm/withProviders.js",
+      "require": "./cjs/withProviders.js"
+    },
+    "./utils": {
+      "import": "./esm/utils.js",
+      "require": "./cjs/utils.js"
+    },
+    "./updateShuttleStateFromProps": {
+      "import": "./esm/updateShuttleStateFromProps.js",
+      "require": "./cjs/updateShuttleStateFromProps.js"
+    },
+    "./tests/utils": {
+      "import": "./esm/tests/utils.js",
+      "require": "./cjs/tests/utils.js"
+    },
+    "./ShuttleState": {
+      "import": "./esm/ShuttleState.js",
+      "require": "./cjs/ShuttleState.js"
+    },
+    "./ShuttleRenderer": {
+      "import": "./esm/ShuttleRenderer.js",
+      "require": "./cjs/ShuttleRenderer.js"
+    },
+    "./ShuttleImpl": {
+      "import": "./esm/ShuttleImpl.js",
+      "require": "./cjs/ShuttleImpl.js"
+    },
+    "./ShuttleContainer": {
+      "import": "./esm/ShuttleContainer.js",
+      "require": "./cjs/ShuttleContainer.js"
+    },
+    "./Shuttle.actions": {
+      "import": "./esm/Shuttle.actions.js",
+      "require": "./cjs/Shuttle.actions.js"
+    },
+    "./SearchState": {
+      "import": "./esm/SearchState.js",
+      "require": "./cjs/SearchState.js"
+    },
+    "./helper": {
+      "import": "./esm/helper.js",
+      "require": "./cjs/helper.js"
+    },
+    "./DSShuttle": {
+      "import": "./esm/DSShuttle.js",
+      "require": "./cjs/DSShuttle.js"
+    },
+    "./components/VirtualizedSortableList": {
+      "import": "./esm/components/VirtualizedSortableList.js",
+      "require": "./cjs/components/VirtualizedSortableList.js"
+    },
+    "./components/VirtualizedList": {
+      "import": "./esm/components/VirtualizedList.js",
+      "require": "./cjs/components/VirtualizedList.js"
+    },
+    "./components/VirtualizedItem": {
+      "import": "./esm/components/VirtualizedItem.js",
+      "require": "./cjs/components/VirtualizedItem.js"
+    },
+    "./components/ShuttleTarget": {
+      "import": "./esm/components/ShuttleTarget.js",
+      "require": "./cjs/components/ShuttleTarget.js"
+    },
+    "./components/ShuttleSource": {
+      "import": "./esm/components/ShuttleSource.js",
+      "require": "./cjs/components/ShuttleSource.js"
+    },
+    "./components/ShuttleSearchBox": {
+      "import": "./esm/components/ShuttleSearchBox.js",
+      "require": "./cjs/components/ShuttleSearchBox.js"
+    },
+    "./components/ShuttleListPanel": {
+      "import": "./esm/components/ShuttleListPanel.js",
+      "require": "./cjs/components/ShuttleListPanel.js"
+    },
+    "./components/ShuttleListItem/ShuttleTargetListItem": {
+      "import": "./esm/components/ShuttleListItem/ShuttleTargetListItem.js",
+      "require": "./cjs/components/ShuttleListItem/ShuttleTargetListItem.js"
+    },
+    "./components/ShuttleListItem/ShuttleSourceListItem": {
+      "import": "./esm/components/ShuttleListItem/ShuttleSourceListItem.js",
+      "require": "./cjs/components/ShuttleListItem/ShuttleSourceListItem.js"
+    },
+    "./components/ShuttleListItem/ShuttleListItem": {
+      "import": "./esm/components/ShuttleListItem/ShuttleListItem.js",
+      "require": "./cjs/components/ShuttleListItem/ShuttleListItem.js"
+    },
+    "./components/ShuttleListItem/ActionButtons": {
+      "import": "./esm/components/ShuttleListItem/ActionButtons.js",
+      "require": "./cjs/components/ShuttleListItem/ActionButtons.js"
+    },
+    "./components/ShuttleInfiniteScrollIndicator": {
+      "import": "./esm/components/ShuttleInfiniteScrollIndicator.js",
+      "require": "./cjs/components/ShuttleInfiniteScrollIndicator.js"
+    },
+    "./components/ShuttleBreadcrumb": {
+      "import": "./esm/components/ShuttleBreadcrumb.js",
+      "require": "./cjs/components/ShuttleBreadcrumb.js"
+    },
+    "./components/OverflowList": {
+      "import": "./esm/components/OverflowList.js",
+      "require": "./cjs/components/OverflowList.js"
+    },
+    "./components/LoadingIndicator": {
+      "import": "./esm/components/LoadingIndicator.js",
+      "require": "./cjs/components/LoadingIndicator.js"
+    },
+    "./classedComponents": {
+      "import": "./esm/classedComponents.js",
+      "require": "./cjs/classedComponents.js"
+    },
+    "./AnimationState": {
+      "import": "./esm/AnimationState.js",
+      "require": "./cjs/AnimationState.js"
+    },
+    "./animation/animationConfig": {
+      "import": "./esm/animation/animationConfig.js",
+      "require": "./cjs/animation/animationConfig.js"
+    }
+  },
   "sideEffects": [
     "*.css",
     "*.scss"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://git.elliemae.io/platform-ui/dimsum.git"
+  },
+  "engines": {
+    "npm": ">=7",
+    "node": ">=14"
+  },
+  "author": "ICE MT",
   "scripts": {
     "dev": "cross-env NODE_ENV=development && node ../../scripts/build/build.js -w",
     "prebuild": "exit 0",
@@ -16,25 +152,26 @@
     "build": "node ../../scripts/build/build.js"
   },
   "dependencies": {
-    "@elliemae/ds-basic": "1.55.0-next.7",
-    "@elliemae/ds-classnames": "1.55.0-next.7",
-    "@elliemae/ds-utilities": "1.55.0-next.7",
+    "@elliemae/ds-basic": "2.0.0-alpha.10",
+    "@elliemae/ds-classnames": "2.0.0-alpha.10",
+    "@elliemae/ds-utilities": "2.0.0-alpha.10",
     "constate": "~1.3.2",
     "memoize-one": "~4.0.3",
     "prop-types": "~15.7.2",
     "react-sortable-hoc": "~1.9.1",
     "react-spring": "~8.0.27",
-    "react-window": "~1.8.5",
-    "react-window-infinite-loader": "~1.0.5",
+    "react-window": "~1.8.6",
+    "react-window-infinite-loader": "~1.0.7",
     "treetabular": "~3.6.0"
   },
   "publishConfig": {
     "access": "public",
-    "directory": "dist"
+    "directory": "dist",
+    "generateSubmodules": true
   },
   "peerDependencies": {
-    "lodash": "^4.17.20",
-    "react": "~17.0.1",
-    "react-dom": "^17.0.1"
+    "lodash": "^4.17.21",
+    "react": "~17.0.2",
+    "react-dom": "^17.0.2"
   }
 }

package/types/AnimationState.d.ts

@@ -0,0 +1,26 @@
+declare const _default: import("constate/dist/ts/src/types").ContextHookReturn<unknown, {
+    state: {
+        isMoving: boolean;
+        isMovingBack: boolean;
+        isDrillingDown: boolean;
+    };
+    setIsMoving: () => void;
+    setIsMovingBack: () => void;
+    setIsDrillingDown: () => void;
+    reset: () => void;
+}, [(value: {
+    state: {
+        isMoving: boolean;
+        isMovingBack: boolean;
+        isDrillingDown: boolean;
+    };
+    setIsMoving: () => void;
+    setIsMovingBack: () => void;
+    setIsDrillingDown: () => void;
+    reset: () => void;
+}) => {
+    isMoving: boolean;
+    isMovingBack: boolean;
+    isDrillingDown: boolean;
+}[]]>;
+export default _default;

package/types/DSShuttle.d.ts

@@ -0,0 +1,119 @@
+/// <reference types="react" />
+import utils from './utils';
+declare const DSShuttle: {
+    ({ containerProps, idField, parentIdField, showIcons, items, selectedItems, nonSelectedItems, onSearch, onSearchOpen, onSearchClose, onDrillDown, onDrillDownTarget, onTargetSortEnd, setGetStatus, targetSortable, sourceEmptyMessage, sourceRootTitle, targetEmptyMessage, targetRootTitle, composeSourceItemProps, composeTargetItemProps, onAddToTarget, onAddCheckedItems, onRemoveFromTarget, onRemoveAllFromTarget, onChange, renderSourceCounter, renderTargetCounter, sourceClearItemsText, targetClearItemsText, searchPlaceholder, loadingSource, loadingTarget, onGetMoreItems, hasNextPage, moreItemsLoading, }: {
+        containerProps?: {} | undefined;
+        idField?: string | undefined;
+        parentIdField?: string | undefined;
+        showIcons?: boolean | undefined;
+        items?: never[] | undefined;
+        selectedItems?: undefined;
+        nonSelectedItems?: undefined;
+        onSearch?: (() => void) | undefined;
+        onSearchOpen?: (() => void) | undefined;
+        onSearchClose?: (() => void) | undefined;
+        onDrillDown?: (() => void) | undefined;
+        onDrillDownTarget?: (() => void) | undefined;
+        onTargetSortEnd?: (() => void) | undefined;
+        setGetStatus?: (() => void) | undefined;
+        targetSortable?: boolean | undefined;
+        sourceEmptyMessage?: string | undefined;
+        sourceRootTitle?: string | undefined;
+        targetEmptyMessage?: string | undefined;
+        targetRootTitle?: string | undefined;
+        composeSourceItemProps?: (() => {}) | undefined;
+        composeTargetItemProps?: (() => {}) | undefined;
+        onAddToTarget?: (() => void) | undefined;
+        onAddCheckedItems?: (() => void) | undefined;
+        onRemoveFromTarget?: (() => void) | undefined;
+        onRemoveAllFromTarget?: (() => void) | undefined;
+        onChange?: (() => void) | undefined;
+        renderSourceCounter?: (() => void) | undefined;
+        renderTargetCounter?: (() => void) | undefined;
+        sourceClearItemsText?: string | undefined;
+        targetClearItemsText?: string | undefined;
+        searchPlaceholder?: string | undefined;
+        loadingSource?: boolean | undefined;
+        loadingTarget?: boolean | undefined;
+        onGetMoreItems?: (() => null) | undefined;
+        hasNextPage?: boolean | undefined;
+        moreItemsLoading: any;
+    }): JSX.Element;
+    propTypes: {
+        /** inject props to shuttle wrapper */
+        containerProps: any;
+        /** The identifier field for the item object */
+        idField: any;
+        /** The parent identifier field for the item object */
+        parentIdField: any;
+        /** Whether to show the icons or not */
+        showIcons: any;
+        /** List of items */
+        items: any;
+        /** Array of item ids that are selected. If passed the component behaves as controlled */
+        selectedItems: any;
+        /** Array of item ids that aren't selected. Should include ALL non selected items, even those not rendered */
+        nonSelectedItems: any;
+        /** Handler on search */
+        onSearch: any;
+        /** Handler when the searchbox is visible */
+        onSearchOpen: any;
+        /** Handler when the searchbox is not visible */
+        onSearchClose: any;
+        /** Source handler when a user navigates to a level down on the nested structure. First param: item drilled. Second param: direction ("up" | "down")  */
+        onDrillDown: any;
+        /** Target handler when a user navigates to a level down on the nested structure. First param: item drilled. Second param: direction ("up" | "down") */
+        onDrillDownTarget: any;
+        /** Target handler when user stops dragging an item */
+        onTargetSortEnd: any;
+        /** Callback function that gets more items for Infinite Scroll */
+        onGetMoreItems: any;
+        /** Wheter there are mor items loading for Infinite Scroll */
+        moreItemsLoading: any;
+        /** Wheter there is a next page for Infinite Scroll, controls when to trigger onGetMoreItems */
+        hasNextPage: any;
+        /** Function that takes as a parameter an internal getter for the state */
+        setGetStatus: any;
+        /** Whether the target can be sortable with DnD */
+        targetSortable: any;
+        /** Handler when the searchbox is visible */
+        sourceRootTitle: any;
+        /** Source text when there is no items */
+        sourceEmptyMessage: any;
+        /** Target text when there is no items */
+        targetEmptyMessage: any;
+        /** Target text for the first hierarchy item */
+        targetRootTitle: any;
+        /** Function that allow to compose the item props in the source */
+        composeSourceItemProps: any;
+        /** Function that allow to compose the item props in the target */
+        composeTargetItemProps: any;
+        /** Handler when a users moves an item to the target */
+        onAddToTarget: any;
+        /** Handler when a users moves all the 'checked' items to the target */
+        onAddCheckedItems: any;
+        /** Handler when a user removes an item from the target */
+        onRemoveFromTarget: any;
+        /** Handler when a user removes all the items from the target */
+        onRemoveAllFromTarget: any;
+        /** Handler for every change on the state */
+        onChange: any;
+        /** Function that returns an element for the source counter */
+        renderSourceCounter: any;
+        /** Function that returns an element for the target counter */
+        renderTargetCounter: any;
+        /** Source text for the clear items button */
+        sourceClearItemsText: any;
+        /** Target text for the clear items button */
+        targetClearItemsText: any;
+        /** Searchbox placeholder */
+        searchPlaceholder: any;
+        /** Displays loading indicator on source section */
+        loadingSource: any;
+        /** Displays loading indicator on target section */
+        loadingTarget: any;
+    };
+};
+declare const DSShuttleWithSchema: any;
+export { utils, DSShuttleWithSchema };
+export default DSShuttle;

package/types/SearchState.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+declare const _default: import("constate/dist/ts/src/types").ContextHookReturn<unknown, {
+    state: {
+        searchTerm: string;
+        searching: boolean;
+    };
+    setSearchTerm: import("react").Dispatch<import("react").SetStateAction<string>>;
+    toggleSearchBox: (userVisible: any) => void;
+    reset: () => void;
+}, [(value: {
+    state: {
+        searchTerm: string;
+        searching: boolean;
+    };
+    setSearchTerm: import("react").Dispatch<import("react").SetStateAction<string>>;
+    toggleSearchBox: (userVisible: any) => void;
+    reset: () => void;
+}) => {
+    searchTerm: string;
+    searching: boolean;
+}[]]>;
+export default _default;

package/types/Shuttle.actions.d.ts

@@ -0,0 +1,11 @@
+export function toggleItemSelection(itemId: any): (state: any) => any;
+export function navigateTo(item: any, dest: any): (state: any) => any;
+export function moveItem(item: any): (state: any) => any;
+export function addToTarget(itemToAdd: any, collection: any): (state: any, { idField }: {
+    idField: any;
+}) => any;
+export function removeFromTarget(itemToRemove: any): (state: any, { idField }: {
+    idField: any;
+}) => any;
+export function resetCheckedItems(): (state: any) => any;
+export function resetMovedItems(): (state: any) => any;

package/types/ShuttleContainer.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: (props: any) => JSX.Element;
+export default _default;

package/types/ShuttleImpl.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: (props: any) => JSX.Element;
+export default _default;

package/types/ShuttleRenderer.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="react" />
+declare function ShuttleRenderer({ containerProps, onNavigateOnTargetTo, onNavigateOnSourceTo, onMoveItemToSource, onMoveItemToTarget, onClearMovedItems, onMoveCheckedItems, onClearCheckedItems, onToggleSearch, onSearch, onSearchClose, onSearchOpen, searching, onCheckItem, hierarchy, hierarchyDest, checkedItems, sourceItems, targetItems, sourceEmptyMessage, targetEmptyMessage, composeTargetItemProps, composeSourceItemProps, targetSortable, sourceSortable, onSourceSortEnd, onTargetSortEnd, loadingSource, loadingTarget, onGetMoreItems, moreItemsLoading, hasNextPage, ...otherProps }: {
+    [x: string]: any;
+    containerProps: any;
+    onNavigateOnTargetTo?: (() => void) | undefined;
+    onNavigateOnSourceTo?: (() => void) | undefined;
+    onMoveItemToSource?: (() => void) | undefined;
+    onMoveItemToTarget?: (() => void) | undefined;
+    onClearMovedItems?: (() => void) | undefined;
+    onMoveCheckedItems?: (() => void) | undefined;
+    onClearCheckedItems?: (() => void) | undefined;
+    onToggleSearch?: (() => void) | undefined;
+    onSearch?: (() => void) | undefined;
+    onSearchClose?: (() => void) | undefined;
+    onSearchOpen?: (() => void) | undefined;
+    searching?: boolean | undefined;
+    onCheckItem?: (() => void) | undefined;
+    hierarchy?: never[] | undefined;
+    hierarchyDest?: never[] | undefined;
+    checkedItems?: never[] | undefined;
+    sourceItems?: never[] | undefined;
+    targetItems?: never[] | undefined;
+    sourceEmptyMessage: any;
+    targetEmptyMessage: any;
+    composeTargetItemProps: any;
+    composeSourceItemProps: any;
+    targetSortable: any;
+    sourceSortable: any;
+    onSourceSortEnd: any;
+    onTargetSortEnd: any;
+    loadingSource?: boolean | undefined;
+    loadingTarget?: boolean | undefined;
+    onGetMoreItems?: (() => void) | undefined;
+    moreItemsLoading?: boolean | undefined;
+    hasNextPage?: boolean | undefined;
+}): JSX.Element;
+export default ShuttleRenderer;

package/types/ShuttleState.d.ts

@@ -0,0 +1,53 @@
+declare const _default: import("constate/dist/ts/src/types").ContextHookReturn<unknown, {
+    state: {
+        checkedItems: never[];
+        movedItems: {};
+        hierarchy: {
+            name: string;
+            id: null;
+        }[];
+        hierarchyDest: {
+            name: string;
+            id: null;
+        }[];
+    };
+    toggleItemSelection: (item: any) => void;
+    moveCheckedItems: (items: any, dest?: boolean) => void;
+    moveItem: (item: any, dest: any) => void;
+    resetMovedItems: () => void;
+    resetCheckedItems: () => void;
+    navigate: (item: any, dest: any) => void;
+    setMovedItems: (itemsIds?: never[], items?: never[]) => void;
+}, [(value: {
+    state: {
+        checkedItems: never[];
+        movedItems: {};
+        hierarchy: {
+            name: string;
+            id: null;
+        }[];
+        hierarchyDest: {
+            name: string;
+            id: null;
+        }[];
+    };
+    toggleItemSelection: (item: any) => void;
+    moveCheckedItems: (items: any, dest?: boolean) => void;
+    moveItem: (item: any, dest: any) => void;
+    resetMovedItems: () => void;
+    resetCheckedItems: () => void;
+    navigate: (item: any, dest: any) => void;
+    setMovedItems: (itemsIds?: never[], items?: never[]) => void;
+}) => {
+    checkedItems: never[];
+    movedItems: {};
+    hierarchy: {
+        name: string;
+        id: null;
+    }[];
+    hierarchyDest: {
+        name: string;
+        id: null;
+    }[];
+}[]]>;
+export default _default;