@workday/canvas-kit-react 6.8.10 → 6.9.0-next.3

package/dist/commonjs/collection/lib/useGridModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGridModel.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useGridModel.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY;IAGrB;;;;;;;;;OASG;;;;;;;;;;;;;;IAIH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAfH;;;;;;;;;OASG;;;;;;;;;;;;;;IAIH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASL,CAAC"}

package/dist/commonjs/collection/lib/useGridModel.js

@@ -0,0 +1,52 @@
+"use strict";
+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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGridModel = void 0;
+var common_1 = require("@workday/canvas-kit-react/common");
+var useCursorListModel_1 = require("./useCursorListModel");
+var useListModel_1 = require("./useListModel");
+var _a = useListModel_1.useListModel.defaultConfig, columnCount = _a.columnCount, orientation = _a.orientation, defaultConfig = __rest(_a, ["columnCount", "orientation"]);
+exports.useGridModel = common_1.createModelHook({
+    defaultConfig: __assign(__assign({}, defaultConfig), { 
+        /**
+         * Controls the state changes when the user sends navigation events to the model. For example,
+         * when the user hits the "right" arrow, a behavior hook will determine directionality
+         * (left-to-right or right-to-left) and call the correct navigation method. In our example, a
+         * left-to-right language would send a `getNext`. The navigation manager may return the next
+         * item in the list. Different managers can be created for slightly different use cases. The
+         * default navigation manager will stop when the end of a row/column is detected. For example,
+         * `getNext` will return the same item the cursor was previously on if the cursor is on the last
+         * item of a row.
+         */
+        navigation: useCursorListModel_1.navigationManager }),
+    requiredConfig: __assign({ 
+        /**
+         * The number of columns represented in a grid
+         */
+        columnCount: 1 }, useListModel_1.useListModel.requiredConfig),
+    contextOverride: useListModel_1.useListModel.Context,
+})(function (config) {
+    var list = useListModel_1.useListModel(config);
+    return list;
+});

package/dist/commonjs/collection/lib/useListItemRegister.d.ts

@@ -0,0 +1,75 @@
+import React from 'react';
+import { Item } from './useBaseListModel';
+import { VirtualItem } from './react-virtual';
+/**
+ * Registers an item with a list. It will return elemProps with a `data-id` which can be used by other
+ * hooks to identify the item in the list.
+ */
+export declare const useListItemRegister: <P extends {}, R>(model: {
+    state: {
+        selectedIds: import("./useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    };
+    events: {
+        select(data: {
+            id: string;
+        }): void;
+        selectAll(): void;
+        unselectAll(): void;
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
+        goTo(data: {
+            id: string;
+        }): void;
+        goToNext(): void;
+        goToPrevious(): void;
+        goToPreviousRow(): void;
+        goToNextRow(): void;
+        goToFirst(): void;
+        goToLast(): void;
+        goToFirstOfRow(): void;
+        goToLastOfRow(): void;
+        goToNextPage(): void;
+        goToPreviousPage(): void;
+        unregisterItem(data: {
+            id: string;
+        }): void;
+        updateItemHeight(data: {
+            value: number;
+        }): void;
+    };
+    selection: import("./useSelectionListModel").SelectionManager;
+    navigation: import("./useCursorListModel").NavigationManager;
+    getId: (item: any) => string;
+}, elemProps?: P | undefined, ref?: ((instance: R | null) => void) | React.RefObject<R> | null | undefined) => {
+    ref: (instance: HTMLElement | null) => void;
+    'data-id': string;
+    disabled: boolean | undefined;
+    item: null;
+    virtual: null;
+    'aria-setsize': number | undefined;
+    'aria-posinset': number | undefined;
+    style: React.CSSProperties;
+} & P & (R extends HTMLOrSVGElement ? {
+    ref: React.Ref<R>;
+} : {});
+//# sourceMappingURL=useListItemRegister.d.ts.map

package/dist/commonjs/collection/lib/useListItemRegister.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListItemRegister.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useListItemRegister.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsB,MAAM,OAAO,CAAC;AAS3C,OAAO,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAG5C;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmE/B,CAAC"}

package/dist/commonjs/collection/lib/useListItemRegister.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useListItemRegister = void 0;
+var react_1 = __importDefault(require("react"));
+var common_1 = require("@workday/canvas-kit-react/common");
+var useListModel_1 = require("./useListModel");
+/**
+ * Registers an item with a list. It will return elemProps with a `data-id` which can be used by other
+ * hooks to identify the item in the list.
+ */
+exports.useListItemRegister = common_1.createElemPropsHook(useListModel_1.useListModel)(function (_a, ref, elemProps) {
+    var _b, _c, _d;
+    var state = _a.state, events = _a.events, getId = _a.getId;
+    if (elemProps === void 0) { elemProps = {}; }
+    var _e = react_1.default.useState(elemProps['data-id'] || ((_b = elemProps.item) === null || _b === void 0 ? void 0 : _b.id) || ''), localId = _e[0], setLocalId = _e[1];
+    var _f = common_1.useLocalRef(common_1.useForkRef(ref, (_c = elemProps.virtual) === null || _c === void 0 ? void 0 : _c.measureRef)), localRef = _f.localRef, elementRef = _f.elementRef;
+    // if the list is virtual, force the correct styling. Without this, weird things happen...
+    var style = elemProps.virtual
+        ? {
+            position: 'absolute',
+            top: 0,
+            left: 0,
+            transform: "translateY(" + elemProps.virtual.start + "px)",
+        }
+        : {};
+    common_1.useMountLayout(function () {
+        var _a, _b;
+        if (((_a = elemProps.virtual) === null || _a === void 0 ? void 0 : _a.index) === 0 && ((_b = localRef.current) === null || _b === void 0 ? void 0 : _b.clientHeight)) {
+            // TODO: This update doesn't seem to be working correctly
+            // events.updateItemHeight?.(localRef.current!.clientHeight);
+        }
+        // if an item is already provided, there's nothing left to do
+        if (elemProps.item) {
+            return;
+        }
+        var defaultId = state.indexRef.current;
+        var itemId = localId || String(defaultId);
+        // TODO: Better lookup that using `items.find`. We need a more generic collection to handle seeing if an item already exists
+        // bail early if item already exists. This happens if items were already provided.
+        if (state.items.find(function (item) { return getId(item) === itemId; })) {
+            return;
+        }
+        events.registerItem({
+            item: {
+                id: itemId,
+            },
+            textValue: typeof elemProps.children === 'string' ? elemProps.children : '',
+        });
+        setLocalId(itemId);
+        return function () {
+            events.unregisterItem({ id: itemId });
+        };
+    });
+    return {
+        ref: elementRef,
+        'data-id': localId,
+        disabled: elemProps.disabled || state.nonInteractiveIds.includes(localId) ? true : undefined,
+        item: null,
+        virtual: null,
+        'aria-setsize': (_d = elemProps.virtual) === null || _d === void 0 ? void 0 : _d.size,
+        'aria-posinset': elemProps.virtual ? elemProps.item.index + 1 : undefined,
+        style: style,
+    };
+});

package/dist/commonjs/collection/lib/useListItemRovingFocus.d.ts

@@ -0,0 +1,88 @@
+import React from 'react';
+export declare const orientationKeyMap: {
+    readonly horizontal: {
+        readonly ArrowLeft: "goToPrevious";
+        readonly Left: "goToPrevious";
+        readonly ArrowRight: "goToNext";
+        readonly Right: "goToNext";
+        readonly Home: "goToFirst";
+        readonly End: "goToLast";
+        readonly PageDown: "goToNextPage";
+        readonly PageUp: "goToPreviousPage";
+    };
+    readonly vertical: {
+        readonly ArrowUp: "goToPrevious";
+        readonly Up: "goToPrevious";
+        readonly ArrowDown: "goToNext";
+        readonly Down: "goToNext";
+        readonly Home: "goToFirst";
+        readonly End: "goToLast";
+        readonly PageDown: "goToNextPage";
+        readonly PageUp: "goToPreviousPage";
+    };
+};
+/**
+ * Handles the roving focus behavior of a Cursor model. It should be added to the element
+ * representing a list item.
+ *
+ * @see https://www.w3.org/TR/wai-aria-practices/#kbd_roving_tabindex
+ */
+export declare const useListItemRovingFocus: <P extends {}, R>(model: {
+    state: {
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("./react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("./useBaseListModel").Item<any>[];
+    };
+    events: {
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
+        goTo(data: {
+            id: string;
+        }): void;
+        goToNext(): void;
+        goToPrevious(): void;
+        goToPreviousRow(): void;
+        goToNextRow(): void;
+        goToFirst(): void;
+        goToLast(): void;
+        goToFirstOfRow(): void;
+        goToLastOfRow(): void;
+        goToNextPage(): void;
+        goToPreviousPage(): void;
+        unregisterItem(data: {
+            id: string;
+        }): void;
+        updateItemHeight(data: {
+            value: number;
+        }): void;
+    };
+    navigation: import("./useCursorListModel").NavigationManager;
+    getId: (item: any) => string;
+}, elemProps?: P | undefined, ref?: ((instance: R | null) => void) | React.RefObject<R> | null | undefined) => {
+    onKeyDown(event: React.KeyboardEvent): void;
+    onFocus(): void;
+    onBlur(): void;
+    onClick(): void;
+    'data-focus-id': string;
+    tabIndex: number;
+    ref: ((instance: any) => void) | React.RefObject<any> | null | undefined;
+} & P & (R extends HTMLOrSVGElement ? {
+    ref: React.Ref<R>;
+} : {});
+//# sourceMappingURL=useListItemRovingFocus.d.ts.map

package/dist/commonjs/collection/lib/useListItemRovingFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListItemRovingFocus.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useListItemRovingFocus.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;CAqBpB,CAAC;AA+BX;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCZ,mBAAmB;;;;;;;;;OA+CzC,CAAC"}

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

@@ -0,0 +1,142 @@
+"use strict";
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useListItemRovingFocus = exports.orientationKeyMap = void 0;
+var react_1 = __importDefault(require("react"));
+var common_1 = require("@workday/canvas-kit-react/common");
+var useCursorListModel_1 = require("./useCursorListModel");
+exports.orientationKeyMap = {
+    horizontal: {
+        ArrowLeft: 'goToPrevious',
+        Left: 'goToPrevious',
+        ArrowRight: 'goToNext',
+        Right: 'goToNext',
+        Home: 'goToFirst',
+        End: 'goToLast',
+        PageDown: 'goToNextPage',
+        PageUp: 'goToPreviousPage',
+    },
+    vertical: {
+        ArrowUp: 'goToPrevious',
+        Up: 'goToPrevious',
+        ArrowDown: 'goToNext',
+        Down: 'goToNext',
+        Home: 'goToFirst',
+        End: 'goToLast',
+        PageDown: 'goToNextPage',
+        PageUp: 'goToPreviousPage',
+    },
+};
+var rightToLeftMap = {
+    ArrowLeft: 'ArrowRight',
+    Left: 'Right',
+    ArrowRight: 'ArrowLeft',
+    Right: 'Left',
+    Home: 'Home',
+    End: 'End',
+    PageDown: 'PageDown',
+    PageUp: 'PageUp',
+};
+var gridKeyMap = __assign(__assign({}, exports.orientationKeyMap.horizontal), { Home: 'goToFirstOfRow', End: 'goToLastOfRow', ArrowUp: 'goToPreviousRow', Up: 'goToPreviousRow', ArrowDown: 'goToNextRow', Down: 'goToNextRow' });
+var ctrlKeyMap = {
+    Home: 'goToFirst',
+    End: 'goToLast',
+};
+var keys = function (obj) { return Object.keys(obj); };
+var hasOwnKey = function (obj, key) { return obj.hasOwnProperty(key); };
+/**
+ * Handles the roving focus behavior of a Cursor model. It should be added to the element
+ * representing a list item.
+ *
+ * @see https://www.w3.org/TR/wai-aria-practices/#kbd_roving_tabindex
+ */
+exports.useListItemRovingFocus = common_1.createElemPropsHook(useCursorListModel_1.useCursorListModel)(function (_a, ref, elemProps) {
+    var state = _a.state, events = _a.events, getId = _a.getId, navigation = _a.navigation;
+    if (elemProps === void 0) { 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_1.default.useRef(false);
+    var getIdRef = react_1.default.useRef(getId);
+    // 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_1.default.useRef(state);
+    stateRef.current = state;
+    var keyDownRef = react_1.default.useRef(false);
+    var isRTL = common_1.useIsRTL();
+    react_1.default.useEffect(function () {
+        if (keyDownRef.current) {
+            var item_1 = navigation.getItem(state.cursorId, { state: state });
+            if (state.isVirtualized) {
+                state.UNSTABLE_virtual.scrollToIndex(item_1.index);
+            }
+            requestAnimationFrame(function () {
+                var _a;
+                (_a = document
+                    .querySelector("[data-focus-id=\"" + (state.id + "-" + getIdRef.current(item_1)) + "\"]")) === null || _a === void 0 ? void 0 : _a.focus();
+            });
+            keyDownRef.current = false;
+        }
+        // we only want to run this effect if the cursor changes and not any other time
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.cursorId]);
+    return {
+        onKeyDown: function (event) {
+            var _a;
+            // Test ctrl key first
+            if (event.ctrlKey) {
+                for (var key in ctrlKeyMap) {
+                    if (hasOwnKey(ctrlKeyMap, key)) {
+                        if (event.key === key) {
+                            keyDownRef.current = true;
+                            (_a = events[ctrlKeyMap[key]]) === null || _a === void 0 ? void 0 : _a.call(events);
+                            event.preventDefault();
+                            return;
+                        }
+                    }
+                }
+            }
+            // Try regular keys
+            keys(state.columnCount > 0 ? gridKeyMap : exports.orientationKeyMap[state.orientation]).forEach(function (key) {
+                var _a;
+                if (isRTL ? event.key === rightToLeftMap[key] : event.key === key) {
+                    var eventName = state.columnCount > 0 ? gridKeyMap[key] : exports.orientationKeyMap[state.orientation][key];
+                    keyDownRef.current = true;
+                    if (events[eventName]) {
+                        (_a = events[eventName]) === null || _a === void 0 ? void 0 : _a.call(events);
+                        event.preventDefault();
+                    }
+                }
+            });
+        },
+        onFocus: function () {
+            focusRef.current = true;
+        },
+        onBlur: function () {
+            focusRef.current = false;
+        },
+        onClick: function () {
+            events.goTo({ 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,
+    };
+});

package/dist/commonjs/collection/lib/useListItemSelect.d.ts

@@ -0,0 +1,62 @@
+import React from 'react';
+export declare const useListItemSelect: <P extends {}, R>(model: {
+    state: {
+        selectedIds: import("./useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("./react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("./useBaseListModel").Item<any>[];
+    };
+    events: {
+        select(data: {
+            id: string;
+        }): void;
+        selectAll(): void;
+        unselectAll(): void;
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
+        goTo(data: {
+            id: string;
+        }): void;
+        goToNext(): void;
+        goToPrevious(): void;
+        goToPreviousRow(): void;
+        goToNextRow(): void;
+        goToFirst(): void;
+        goToLast(): void;
+        goToFirstOfRow(): void;
+        goToLastOfRow(): void;
+        goToNextPage(): void;
+        goToPreviousPage(): void;
+        unregisterItem(data: {
+            id: string;
+        }): void;
+        updateItemHeight(data: {
+            value: number;
+        }): void;
+    };
+    selection: import("./useSelectionListModel").SelectionManager;
+    navigation: import("./useCursorListModel").NavigationManager;
+    getId: (item: any) => string;
+}, elemProps?: P | undefined, ref?: ((instance: R | null) => void) | React.RefObject<R> | null | undefined) => {
+    onClick: (event: React.MouseEvent<HTMLElement>) => void;
+} & P & (R extends HTMLOrSVGElement ? {
+    ref: React.Ref<R>;
+} : {});
+//# sourceMappingURL=useListItemSelect.d.ts.map

package/dist/commonjs/collection/lib/useListItemSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListItemSelect.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useListItemSelect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAGF,gBAAgB,CAAC,WAAW,CAAC;;;OAYxD,CAAC"}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useListItemSelect = void 0;
+var common_1 = require("@workday/canvas-kit-react/common");
+var useListModel_1 = require("./useListModel");
+exports.useListItemSelect = common_1.createElemPropsHook(useListModel_1.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) {
+        if (state.nonInteractiveIds.includes(name) ||
+            event.currentTarget.hasAttribute('aria-disabled')) {
+            return;
+        }
+        events.select({ id: name });
+    };
+    return { onClick: onClick };
+});