@workday/canvas-kit-react 9.0.0-alpha.368-next.6 → 9.0.0-alpha.382-next.2

package/dist/es6/collection/lib/useListItemRovingFocus.js

@@ -1,18 +1,7 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import React from 'react';
 import { useIsRTL, createElemPropsHook } from '@workday/canvas-kit-react/common';
 import { useCursorListModel } from './useCursorListModel';
-export var orientationKeyMap = {
+export const orientationKeyMap = {
     horizontal: {
         ArrowLeft: 'goToPrevious',
         Left: 'goToPrevious',
@@ -34,7 +23,7 @@ export var orientationKeyMap = {
         PageUp: 'goToPreviousPage',
     },
 };
-var rightToLeftMap = {
+const rightToLeftMap = {
     ArrowLeft: 'ArrowRight',
     Left: 'Right',
     ArrowRight: 'ArrowLeft',
@@ -44,13 +33,21 @@ var rightToLeftMap = {
     PageDown: 'PageDown',
     PageUp: 'PageUp',
 };
-var gridKeyMap = __assign(__assign({}, orientationKeyMap.horizontal), { Home: 'goToFirstOfRow', End: 'goToLastOfRow', ArrowUp: 'goToPreviousRow', Up: 'goToPreviousRow', ArrowDown: 'goToNextRow', Down: 'goToNextRow' });
-var ctrlKeyMap = {
+const gridKeyMap = {
+    ...orientationKeyMap.horizontal,
+    Home: 'goToFirstOfRow',
+    End: 'goToLastOfRow',
+    ArrowUp: 'goToPreviousRow',
+    Up: 'goToPreviousRow',
+    ArrowDown: 'goToNextRow',
+    Down: 'goToNextRow',
+};
+const ctrlKeyMap = {
     Home: 'goToFirst',
     End: 'goToLast',
 };
-var keys = function (obj) { return Object.keys(obj); };
-var hasOwnKey = function (obj, key) { return obj.hasOwnProperty(key); };
+const keys = (obj) => Object.keys(obj);
+const hasOwnKey = (obj, key) => obj.hasOwnProperty(key);
 /**
  * This elemProps hook is used for cursor navigation by using [Roving
  * Tabindex](https://w3c.github.io/aria-practices/#kbd_roving_tabindex). Only a single item in the
@@ -65,29 +62,27 @@ var hasOwnKey = function (obj, key) { return obj.hasOwnProperty(key); };
  * );
 ```
  */
-export var useListItemRovingFocus = createElemPropsHook(useCursorListModel)(function (_a, ref, elemProps) {
-    var state = _a.state, events = _a.events, navigation = _a.navigation;
-    if (elemProps === void 0) { elemProps = {}; }
+export const useListItemRovingFocus = createElemPropsHook(useCursorListModel)(({ state, events, navigation }, ref, elemProps = {}) => {
     // Tracks when this element has focus. If this item is removed while still focused, we have to
     // inform the model to move the cursor to the next item.
-    var focusRef = React.useRef(false);
+    const focusRef = React.useRef(false);
     // Create a ref out of state. We don't want to watch state on unmount, so we use a ref to get the
     // current value at the time of unmounting. Otherwise, `state.items` would be a cached value of an
     // empty array
-    var stateRef = React.useRef(state);
+    const stateRef = React.useRef(state);
     stateRef.current = state;
-    var keyDownRef = React.useRef(false);
-    var isRTL = useIsRTL();
-    React.useEffect(function () {
+    const keyDownRef = React.useRef(false);
+    const isRTL = useIsRTL();
+    React.useEffect(() => {
         if (keyDownRef.current) {
-            var item_1 = navigation.getItem(state.cursorId, { state: state });
+            const item = navigation.getItem(state.cursorId, { state });
             if (state.isVirtualized) {
-                state.UNSTABLE_virtual.scrollToIndex(item_1.index);
+                state.UNSTABLE_virtual.scrollToIndex(item.index);
             }
-            requestAnimationFrame(function () {
+            requestAnimationFrame(() => {
                 var _a;
                 (_a = document
-                    .querySelector("[data-focus-id=\"" + (state.id + "-" + item_1.id) + "\"]")) === null || _a === void 0 ? void 0 : _a.focus();
+                    .querySelector(`[data-focus-id="${`${state.id}-${item.id}`}"]`)) === null || _a === void 0 ? void 0 : _a.focus();
             });
             keyDownRef.current = false;
         }
@@ -95,11 +90,11 @@ export var useListItemRovingFocus = createElemPropsHook(useCursorListModel)(func
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [state.cursorId]);
     return {
-        onKeyDown: function (event) {
+        onKeyDown(event) {
             var _a;
             // Test ctrl key first
             if (event.ctrlKey) {
-                for (var key in ctrlKeyMap) {
+                for (const key in ctrlKeyMap) {
                     if (hasOwnKey(ctrlKeyMap, key)) {
                         if (event.key === key) {
                             keyDownRef.current = true;
@@ -111,10 +106,10 @@ export var useListItemRovingFocus = createElemPropsHook(useCursorListModel)(func
                 }
             }
             // Try regular keys
-            keys(state.columnCount > 0 ? gridKeyMap : orientationKeyMap[state.orientation]).forEach(function (key) {
+            keys(state.columnCount > 0 ? gridKeyMap : orientationKeyMap[state.orientation]).forEach(key => {
                 var _a;
                 if (isRTL ? event.key === rightToLeftMap[key] : event.key === key) {
-                    var eventName = state.columnCount > 0 ? gridKeyMap[key] : orientationKeyMap[state.orientation][key];
+                    const eventName = state.columnCount > 0 ? gridKeyMap[key] : orientationKeyMap[state.orientation][key];
                     keyDownRef.current = true;
                     if (events[eventName]) {
                         (_a = events[eventName]) === null || _a === void 0 ? void 0 : _a.call(events);
@@ -123,21 +118,21 @@ export var useListItemRovingFocus = createElemPropsHook(useCursorListModel)(func
                 }
             });
         },
-        onFocus: function () {
+        onFocus() {
             focusRef.current = true;
         },
-        onBlur: function () {
+        onBlur() {
             focusRef.current = false;
         },
-        onClick: function () {
+        onClick() {
             events.goTo({ id: elemProps['data-id'] });
         },
-        'data-focus-id': state.id + "-" + elemProps['data-id'],
+        'data-focus-id': `${state.id}-${elemProps['data-id']}`,
         tabIndex: !state.cursorId
             ? 0 // cursor isn't known yet, be safe and mark this as focusable
             : !!elemProps['data-id'] && state.cursorId === elemProps['data-id']
                 ? 0 // A name is known and cursor is here
                 : -1,
-        ref: ref,
+        ref,
     };
 });

package/dist/es6/collection/lib/useListItemSelect.js

@@ -12,16 +12,14 @@ import { useListModel } from './useListModel';
  * );
  * ```
  */
-export var useListItemSelect = createElemPropsHook(useListModel)(function (_a, _, elemProps) {
-    var state = _a.state, events = _a.events;
-    if (elemProps === void 0) { elemProps = {}; }
-    var name = elemProps['data-id'] || '';
-    var onClick = function (event) {
+export const useListItemSelect = createElemPropsHook(useListModel)(({ state, events }, _, elemProps = {}) => {
+    const name = elemProps['data-id'] || '';
+    const onClick = (event) => {
         if (state.nonInteractiveIds.includes(name) ||
             event.currentTarget.hasAttribute('aria-disabled')) {
             return;
         }
         events.select({ id: name });
     };
-    return { onClick: onClick };
+    return { onClick };
 });

package/dist/es6/collection/lib/useListModel.js

@@ -31,7 +31,7 @@ import { useSelectionListModel } from './useSelectionListModel';
  * })
  * ```
  */
-export var useListModel = createModelHook({
+export const useListModel = createModelHook({
     defaultConfig: useSelectionListModel.defaultConfig,
     requiredConfig: useSelectionListModel.requiredConfig,
 })(useSelectionListModel);

package/dist/es6/collection/lib/useListRenderItem.js

@@ -14,25 +14,25 @@ import React from 'react';
 ```
  */
 export function useListRenderItems(model, children) {
-    var items = typeof children === 'function'
+    const items = typeof children === 'function'
         ? model.state.isVirtualized
-            ? model.state.UNSTABLE_virtual.virtualItems.map(function (virtual) {
-                var item = model.state.items[virtual.index];
-                var child = children(item.value, virtual.index);
+            ? model.state.UNSTABLE_virtual.virtualItems.map(virtual => {
+                const item = model.state.items[virtual.index];
+                const child = children(item.value, virtual.index);
                 if (React.isValidElement(child)) {
                     return React.cloneElement(child, {
                         // We call this `virtual` instead of `virtualItem` to avoid a React render warning
                         // about capital letters in attributes. React thinks this will be applied to the DOM
                         // element even though we remove it later...
-                        virtual: virtual,
+                        virtual,
                         key: item.id,
-                        item: item,
+                        item,
                     });
                 }
                 return child;
             })
-            : model.state.items.map(function (item) {
-                var child = children(item.value, item.index);
+            : model.state.items.map(item => {
+                const child = children(item.value, item.index);
                 if (React.isValidElement(child)) {
                     return React.cloneElement(child, {
                         key: item.id,

package/dist/es6/collection/lib/useListResetCursorOnBlur.js

@@ -16,20 +16,19 @@ import { useListModel } from './useListModel';
  * );
 ```
  */
-export var useListResetCursorOnBlur = createElemPropsHook(useListModel)(function (_a) {
-    var state = _a.state, events = _a.events;
-    var programmaticFocusRef = React.useRef(false);
+export const useListResetCursorOnBlur = createElemPropsHook(useListModel)(({ state, events }) => {
+    const programmaticFocusRef = React.useRef(false);
     return {
-        onKeyDown: function (event) {
+        onKeyDown(event) {
             // Programmatic focus only on any focus change via keyboard
             if (Object.keys(orientationKeyMap[state.orientation]).indexOf(event.key) !== -1) {
                 programmaticFocusRef.current = true;
             }
         },
-        onFocus: function () {
+        onFocus() {
             programmaticFocusRef.current = false;
         },
-        onBlur: function () {
+        onBlur() {
             if (!programmaticFocusRef.current) {
                 events.goTo({ id: state.selectedIds[0] });
             }

package/dist/es6/collection/lib/useOverflowListItemMeasure.js

@@ -1,6 +1,6 @@
 import { createElemPropsHook, useLocalRef, useMountLayout } from '@workday/canvas-kit-react/common';
 import { useOverflowListModel } from './useOverflowListModel';
-var hiddenStyles = {
+const hiddenStyles = {
     position: 'absolute',
     left: -99999,
 };
@@ -15,13 +15,12 @@ var hiddenStyles = {
  * )
  * ```
  */
-export var useOverflowListItemMeasure = createElemPropsHook(useOverflowListModel)(function (model, ref, elemProps) {
-    if (elemProps === void 0) { elemProps = {}; }
-    var _a = useLocalRef(ref), elementRef = _a.elementRef, localRef = _a.localRef;
-    var name = elemProps['data-id'] || '';
-    useMountLayout(function () {
+export const useOverflowListItemMeasure = createElemPropsHook(useOverflowListModel)((model, ref, elemProps = {}) => {
+    const { elementRef, localRef } = useLocalRef(ref);
+    const name = elemProps['data-id'] || '';
+    useMountLayout(() => {
         if (localRef.current) {
-            var styles = getComputedStyle(localRef.current);
+            const styles = getComputedStyle(localRef.current);
             model.events.addItemWidth({
                 id: name,
                 width: localRef.current.offsetWidth +
@@ -29,11 +28,11 @@ export var useOverflowListItemMeasure = createElemPropsHook(useOverflowListModel
                     parseFloat(styles.marginRight),
             });
         }
-        return function () {
+        return () => {
             model.events.removeItemWidth({ id: name });
         };
     });
-    var hidden = model.state.hiddenIds.includes(name);
+    const hidden = model.state.hiddenIds.includes(name);
     return {
         ref: elementRef,
         'aria-hidden': hidden || undefined,

package/dist/es6/collection/lib/useOverflowListMeasure.js

@@ -5,13 +5,13 @@ import { useOverflowListModel } from './useOverflowListModel';
  * This elemProps hook measures a list and reports it to an `OverflowListModel`. This is used in
  * overflow detection.
  */
-export var useOverflowListMeasure = createElemPropsHook(useOverflowListModel)(function (model, ref) {
-    var localRef = React.useRef(null);
-    var resizeRef = useResizeObserver({
+export const useOverflowListMeasure = createElemPropsHook(useOverflowListModel)((model, ref) => {
+    const localRef = React.useRef(null);
+    const { ref: resizeRef } = useResizeObserver({
         ref: localRef,
         onResize: model.events.setContainerWidth,
-    }).ref;
-    var elementRef = useForkRef(ref, resizeRef);
+    });
+    const elementRef = useForkRef(ref, resizeRef);
     return {
         ref: elementRef,
     };

package/dist/es6/collection/lib/useOverflowListModel.js

@@ -1,29 +1,18 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import React from 'react';
 import { createModelHook } from '@workday/canvas-kit-react/common';
 import { useSelectionListModel } from './useSelectionListModel';
 export function getHiddenIds(containerWidth, overflowTargetWidth, itemWidthCache, selectedIds) {
     /** Allows us to prioritize showing the selected item */
-    var selectedKey;
+    let selectedKey;
     /** Tally of combined item widths. We'll add items that fit until the container is full */
-    var itemWidth = 0;
+    let itemWidth = 0;
     /** Tally ids that won't fit inside the container. These will be used by components to hide
      * elements that won't fit in the container */
-    var hiddenIds = [];
+    const hiddenIds = [];
     if (selectedIds !== 'all' && selectedIds.length) {
         selectedKey = selectedIds[0];
     }
-    if (Object.keys(itemWidthCache).reduce(function (sum, key) { return sum + itemWidthCache[key]; }, 0) <= containerWidth) {
+    if (Object.keys(itemWidthCache).reduce((sum, key) => sum + itemWidthCache[key], 0) <= containerWidth) {
         // All items fit, return empty array
         return [];
     }
@@ -40,7 +29,7 @@ export function getHiddenIds(containerWidth, overflowTargetWidth, itemWidthCache
     else {
         itemWidth += overflowTargetWidth;
     }
-    for (var key in itemWidthCache) {
+    for (const key in itemWidthCache) {
         if (key !== selectedKey) {
             itemWidth += itemWidthCache[key];
             if (itemWidth > containerWidth) {
@@ -50,70 +39,86 @@ export function getHiddenIds(containerWidth, overflowTargetWidth, itemWidthCache
     }
     return hiddenIds;
 }
-export var useOverflowListModel = createModelHook({
-    defaultConfig: __assign(__assign({}, useSelectionListModel.defaultConfig), { initialHiddenIds: [], containerWidth: 0, 
+export const useOverflowListModel = createModelHook({
+    defaultConfig: {
+        ...useSelectionListModel.defaultConfig,
+        initialHiddenIds: [],
+        containerWidth: 0,
         /**
          * Determines if overflow should actually occur. For example, touch devices are better at
          * side-scrolling than mouse devices. In these cases, it makes sense to disable overflowing.
          * @default true
-         */ shouldCalculateOverflow: true }),
+         */ shouldCalculateOverflow: true,
+    },
     requiredConfig: useSelectionListModel.requiredConfig,
     contextOverride: useSelectionListModel.Context,
-})(function (config) {
-    var shouldCalculateOverflow = config.shouldCalculateOverflow === undefined ? true : config.shouldCalculateOverflow;
-    var _a = React.useState(config.initialHiddenIds), hiddenIds = _a[0], setHiddenIds = _a[1];
-    var _b = React.useState({}), itemWidthCache = _b[0], setItemWidthCache = _b[1];
-    var _c = React.useState(0), containerWidth = _c[0], setContainerWidth = _c[1];
-    var containerWidthRef = React.useRef(0);
-    var itemWidthCacheRef = React.useRef(itemWidthCache);
-    var _d = React.useState(0), overflowTargetWidth = _d[0], setOverflowTargetWidth = _d[1];
-    var overflowTargetWidthRef = React.useRef(0);
-    var internalHiddenIds = shouldCalculateOverflow ? hiddenIds : [];
+})(config => {
+    const shouldCalculateOverflow = config.shouldCalculateOverflow === undefined ? true : config.shouldCalculateOverflow;
+    const [hiddenIds, setHiddenIds] = React.useState(config.initialHiddenIds);
+    const [itemWidthCache, setItemWidthCache] = React.useState({});
+    const [containerWidth, setContainerWidth] = React.useState(0);
+    const containerWidthRef = React.useRef(0);
+    const itemWidthCacheRef = React.useRef(itemWidthCache);
+    const [overflowTargetWidth, setOverflowTargetWidth] = React.useState(0);
+    const overflowTargetWidthRef = React.useRef(0);
+    const internalHiddenIds = shouldCalculateOverflow ? hiddenIds : [];
     // Cursors skip over disabled ids, but know nothing of hidden ids. We'll go ahead and disable
     // hidden ids as well
-    var nonInteractiveIds = (config.nonInteractiveIds || []).concat(internalHiddenIds);
-    var model = useSelectionListModel(__assign(__assign({}, config), { nonInteractiveIds: nonInteractiveIds }));
-    var state = __assign(__assign({}, model.state), { hiddenIds: internalHiddenIds, itemWidthCache: itemWidthCache,
-        containerWidth: containerWidth,
-        overflowTargetWidth: overflowTargetWidth });
-    var events = __assign(__assign({}, model.events), { select: function (data) {
-            var selectedIds = model.selection.select(data.id, state).selectedIds;
-            var ids = getHiddenIds(containerWidthRef.current, overflowTargetWidthRef.current, itemWidthCacheRef.current, selectedIds);
+    const nonInteractiveIds = (config.nonInteractiveIds || []).concat(internalHiddenIds);
+    const model = useSelectionListModel({
+        ...config,
+        nonInteractiveIds,
+    });
+    const state = {
+        ...model.state,
+        hiddenIds: internalHiddenIds,
+        itemWidthCache,
+        containerWidth,
+        overflowTargetWidth,
+    };
+    const events = {
+        ...model.events,
+        select(data) {
+            const { selectedIds } = model.selection.select(data.id, state);
+            const ids = getHiddenIds(containerWidthRef.current, overflowTargetWidthRef.current, itemWidthCacheRef.current, selectedIds);
             model.events.select(data);
             setHiddenIds(ids);
         },
-        setContainerWidth: function (data) {
+        setContainerWidth(data) {
             containerWidthRef.current = data.width || 0;
             setContainerWidth(data.width || 0);
-            var ids = getHiddenIds(containerWidthRef.current, overflowTargetWidthRef.current, itemWidthCacheRef.current, state.selectedIds);
+            const ids = getHiddenIds(containerWidthRef.current, overflowTargetWidthRef.current, itemWidthCacheRef.current, state.selectedIds);
             setHiddenIds(ids);
         },
-        setOverflowTargetWidth: function (data) {
+        setOverflowTargetWidth(data) {
             overflowTargetWidthRef.current = data.width;
             setOverflowTargetWidth(data.width);
         },
-        addItemWidth: function (data) {
-            var _a;
-            itemWidthCacheRef.current = __assign(__assign({}, itemWidthCacheRef.current), (_a = {}, _a[data.id] = data.width, _a));
+        addItemWidth(data) {
+            itemWidthCacheRef.current = {
+                ...itemWidthCacheRef.current,
+                [data.id]: data.width,
+            };
             setItemWidthCache(itemWidthCacheRef.current);
-            var ids = getHiddenIds(containerWidthRef.current, overflowTargetWidthRef.current, itemWidthCacheRef.current, state.selectedIds);
+            const ids = getHiddenIds(containerWidthRef.current, overflowTargetWidthRef.current, itemWidthCacheRef.current, state.selectedIds);
             setHiddenIds(ids);
         },
-        removeItemWidth: function (data) {
-            var newCache = __assign({}, itemWidthCacheRef.current);
+        removeItemWidth(data) {
+            const newCache = { ...itemWidthCacheRef.current };
             delete newCache[data.id];
             itemWidthCacheRef.current = newCache;
             setItemWidthCache(itemWidthCacheRef.current);
-            var ids = getHiddenIds(containerWidthRef.current, overflowTargetWidthRef.current, itemWidthCacheRef.current, state.selectedIds !== 'all'
-                ? state.selectedIds.filter(function (sId) { return data.id !== sId; })
+            const ids = getHiddenIds(containerWidthRef.current, overflowTargetWidthRef.current, itemWidthCacheRef.current, state.selectedIds !== 'all'
+                ? state.selectedIds.filter(sId => data.id !== sId)
                 : state.selectedIds);
             setHiddenIds(ids);
         },
-        addHiddenKey: function (data) {
-            setHiddenIds(function (ids) { return ids.concat(data.id); });
+        addHiddenKey(data) {
+            setHiddenIds(ids => ids.concat(data.id));
         },
-        removeHiddenKey: function (data) {
-            setHiddenIds(function (ids) { return ids.filter(function (key) { return key !== data.id; }); });
-        } });
-    return __assign(__assign({}, model), { state: state, events: events });
+        removeHiddenKey(data) {
+            setHiddenIds(ids => ids.filter(key => key !== data.id));
+        },
+    };
+    return { ...model, state, events };
 });

package/dist/es6/collection/lib/useOverflowListTarget.js

@@ -2,7 +2,7 @@ import React from 'react';
 import { createElemPropsHook, useMountLayout, useLocalRef } from '@workday/canvas-kit-react/common';
 import { useOverflowListModel } from './useOverflowListModel';
 // use a hidden style instead of `hidden` attribute for measurement purposes. `hidden` elements have no dimensions
-var hiddenStyle = {
+const hiddenStyle = {
     position: 'absolute',
     left: -99999,
 };
@@ -10,14 +10,14 @@ var hiddenStyle = {
  * This elemProps hook measures an overflow list target and reports it to an `OverflowListModel`.
  * This is used in overflow detection.
  */
-export var useOverflowListTarget = createElemPropsHook(useOverflowListModel)(function (model, ref) {
-    var _a = useLocalRef(ref), elementRef = _a.elementRef, localRef = _a.localRef;
+export const useOverflowListTarget = createElemPropsHook(useOverflowListModel)((model, ref) => {
+    const { elementRef, localRef } = useLocalRef(ref);
     // track first render to force correct size calculations
-    var firstRender = React.useRef(true);
-    useMountLayout(function () {
+    const firstRender = React.useRef(true);
+    useMountLayout(() => {
         firstRender.current = false;
         if (localRef.current) {
-            var styles = getComputedStyle(localRef.current);
+            const styles = getComputedStyle(localRef.current);
             model.events.setOverflowTargetWidth({
                 width: localRef.current.offsetWidth +
                     parseFloat(styles.marginLeft) +
@@ -25,7 +25,7 @@ export var useOverflowListTarget = createElemPropsHook(useOverflowListModel)(fun
             });
         }
     });
-    var isHidden = !model.state.hiddenIds.length;
+    const isHidden = !model.state.hiddenIds.length;
     return {
         ref: elementRef,
         'aria-hidden': isHidden,

package/dist/es6/collection/lib/useSelectionListModel.js

@@ -1,64 +1,57 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import React from 'react';
 import { createModelHook } from '@workday/canvas-kit-react/common';
 import { useCursorListModel } from './useCursorListModel';
-export var isSelected = function (id, _a) {
-    var selectedIds = _a.selectedIds, unselectedIds = _a.unselectedIds;
+export const isSelected = (id, { selectedIds, unselectedIds }) => {
     if (selectedIds === 'all') {
         return !unselectedIds.includes(id);
     }
     return selectedIds.includes(id);
 };
-export var singleSelectionManager = {
-    select: function (id) {
+export const singleSelectionManager = {
+    select(id) {
         return { selectedIds: [id], unselectedIds: [] };
     },
 };
-export var multiSelectionManager = {
-    select: function (id, _a) {
-        var selectedIds = _a.selectedIds, unselectedIds = _a.unselectedIds;
+export const multiSelectionManager = {
+    select(id, { selectedIds, unselectedIds }) {
         if (selectedIds === 'all') {
             // If we have all selected, start adding/removing from `unselectedIds`
-            var existingKey = unselectedIds.includes(id);
+            const existingKey = unselectedIds.includes(id);
             return {
                 selectedIds: 'all',
                 unselectedIds: existingKey
-                    ? unselectedIds.filter(function (key) { return key !== id; })
+                    ? unselectedIds.filter(key => key !== id)
                     : unselectedIds.concat(id),
             };
         }
         else {
-            var existingKey = selectedIds.includes(id);
+            const existingKey = selectedIds.includes(id);
             return {
-                selectedIds: existingKey ? selectedIds.filter(function (key) { return key !== id; }) : selectedIds.concat(id),
+                selectedIds: existingKey ? selectedIds.filter(key => key !== id) : selectedIds.concat(id),
                 unselectedIds: [],
             };
         }
     },
 };
-export var useSelectionListModel = createModelHook({
-    defaultConfig: __assign(__assign({}, useCursorListModel.defaultConfig), { initialSelectedIds: [], initialUnselectedIds: [], selection: singleSelectionManager }),
+export const useSelectionListModel = createModelHook({
+    defaultConfig: {
+        ...useCursorListModel.defaultConfig,
+        initialSelectedIds: [],
+        initialUnselectedIds: [],
+        selection: singleSelectionManager,
+    },
     requiredConfig: useCursorListModel.requiredConfig,
-})(function (config) {
-    var cursor = useCursorListModel(config);
-    var _a = React.useState(config.initialSelectedIds), selectedIds = _a[0], setSelectedIds = _a[1];
-    var _b = React.useState(config.initialUnselectedIds), unselectedIds = _b[0], setUnselectedIds = _b[1];
-    var selection = config.selection;
-    var state = __assign(__assign({}, cursor.state), { selectedIds: selectedIds, unselectedIds: unselectedIds });
-    var events = __assign(__assign({}, cursor.events), { 
+})(config => {
+    const cursor = useCursorListModel(config);
+    const [selectedIds, setSelectedIds] = React.useState(config.initialSelectedIds);
+    const [unselectedIds, setUnselectedIds] = React.useState(config.initialUnselectedIds);
+    const selection = config.selection;
+    const state = { ...cursor.state, selectedIds, unselectedIds };
+    const events = {
+        ...cursor.events,
         /** Select a specific item by its identifier. */
-        select: function (data) {
-            var _a = selection.select(data.id, state), selectedIds = _a.selectedIds, unselectedIds = _a.unselectedIds;
+        select(data) {
+            const { selectedIds, unselectedIds } = selection.select(data.id, state);
             setSelectedIds(selectedIds);
             setUnselectedIds(unselectedIds);
         },
@@ -66,14 +59,15 @@ export var useSelectionListModel = createModelHook({
          * Select all items. This will set `selectedIds` to `'all'` and remove all `unselectedIds`.
          * This is especially useful for virtual lists where not all items are loaded in memory.
          */
-        selectAll: function () {
+        selectAll() {
             setSelectedIds('all');
         },
         /**
          * Unselect all items.
          */
-        unselectAll: function () {
+        unselectAll() {
             setSelectedIds([]);
-        } });
-    return __assign(__assign({}, cursor), { state: state, events: events, selection: selection });
+        },
+    };
+    return { ...cursor, state, events, selection };
 });