@jobber/components 4.92.0 → 5.0.1

package/dist/DataListHeaderTile-BsycPdAH.js

@@ -0,0 +1,79 @@
+import React, { useState, useRef } from 'react';
+import classnames from 'classnames';
+import { u as useFocusTrap_2 } from './useFocusTrap-DIF2JjIO.js';
+import { u as useRefocusOnActivator_2 } from './useRefocusOnActivator-0eNF7eV7.js';
+import { D as DataListSortingOptions } from './DataListSortingOptions-CozrvIh9.js';
+import { T as Text } from './Text-B1bIoWYr.js';
+import { u as useDataListContext } from './DataListContext-tYtmL4Rx.js';
+
+var styles$1 = {"headerLabel":"fLmJZJJqMcE-","sortable":"UG8cHUT3Hds-"};
+
+var styles = {"sortIcon":"AN5egORYy-0-","active":"F1uTDCK0Sb0-","inactive":"_6KYeQXWXLQ8-"};
+
+const SORTING_ICON_TEST_ID = "ATL-DataList-Sorting-Icon";
+function DataListSortingArrows({ order }) {
+    return (React.createElement("div", { className: styles.sortIcon, "data-testid": SORTING_ICON_TEST_ID },
+        React.createElement("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg" },
+            React.createElement("path", { className: getActiveClassName("asc"), d: "M16.2929 10.6661C15.9024 11.0566 15.2692 11.0566 14.8787 10.6661L12.2891 8.14263L9.70711 10.6661C9.31658 11.0566 8.68342 11.0566 8.29289 10.6661C7.90237 10.2756 7.90237 9.64239 8.29289 9.25186L11.5858 5.95897C11.9763 5.56845 12.6095 5.56845 13 5.95897L16.2929 9.25186C16.6834 9.64239 16.6834 10.2756 16.2929 10.6661Z" }),
+            React.createElement("path", { className: getActiveClassName("desc"), d: "M8.29292 13.3339C8.68345 12.9434 9.31661 12.9434 9.70714 13.3339L12.2968 15.8573L14.8787 13.3339C15.2692 12.9434 15.9024 12.9434 16.2929 13.3339C16.6834 13.7244 16.6834 14.3576 16.2929 14.7481L13 18.041C12.6095 18.4315 11.9763 18.4315 11.5858 18.041L8.29292 14.7481C7.9024 14.3576 7.9024 13.7244 8.29292 13.3339Z" }))));
+    function getActiveClassName(targetOrder) {
+        return order === targetOrder ? styles.active : styles.inactive;
+    }
+}
+
+/* eslint-disable max-statements */
+function DataListHeaderTile({ headers, headerKey, visible = false, }) {
+    useRefocusOnActivator_2(visible);
+    const { sorting } = useDataListContext();
+    const [isDropDownOpen, setIsDropDownOpen] = useState(false);
+    const optionsListRef = useFocusTrap_2(isDropDownOpen);
+    const dataListHeaderTileRef = useRef(null);
+    const sortableItem = sorting === null || sorting === void 0 ? void 0 : sorting.sortable.find(item => item.key === headerKey);
+    const isSortable = Boolean(sortableItem);
+    const sortingState = sorting === null || sorting === void 0 ? void 0 : sorting.state;
+    const Tag = isSortable ? "button" : "div";
+    return (React.createElement(Tag, { className: classnames(styles$1.headerLabel, {
+            [styles$1.sortable]: isSortable,
+        }), onClick: handleOnClick, ref: dataListHeaderTileRef },
+        React.createElement(Text, { maxLines: "single" }, headers[headerKey]),
+        isSortable && (sortableItem === null || sortableItem === void 0 ? void 0 : sortableItem.options) && isDropDownOpen && (React.createElement(DataListSortingOptions, { options: sortableItem.options, selectedOption: (sorting === null || sorting === void 0 ? void 0 : sorting.state) || null, onSelectChange: handleSelectChange, onClose: () => setIsDropDownOpen(false), optionsListRef: optionsListRef, dataListHeaderTileRef: dataListHeaderTileRef })),
+        isSortable && (React.createElement(DataListSortingArrows, { order: (sortingState === null || sortingState === void 0 ? void 0 : sortingState.key) === headerKey ? sortingState.order : "none" }))));
+    function toggleSorting(newSortingKey, newId, newLabel) {
+        const isSameKey = newSortingKey === (sortingState === null || sortingState === void 0 ? void 0 : sortingState.key);
+        const isDescending = (sortingState === null || sortingState === void 0 ? void 0 : sortingState.order) === "desc";
+        if (isSameKey && isDescending) {
+            sorting === null || sorting === void 0 ? void 0 : sorting.onSort(undefined);
+            return;
+        }
+        const sortingOrder = isSameKey ? "desc" : "asc";
+        setSorting(newSortingKey, newId, newLabel, sortingOrder);
+    }
+    function setSorting(newSortingKey, newId, newLabel, newOrder) {
+        sorting === null || sorting === void 0 ? void 0 : sorting.onSort({
+            key: newSortingKey,
+            id: newId,
+            label: newLabel,
+            order: newOrder,
+        });
+    }
+    function handleOnClick() {
+        var _a, _b;
+        if (!isSortable)
+            return;
+        if (sortableItem === null || sortableItem === void 0 ? void 0 : sortableItem.options) {
+            setIsDropDownOpen(!isDropDownOpen);
+        }
+        else {
+            const id = ((_b = (_a = sortableItem === null || sortableItem === void 0 ? void 0 : sortableItem.options) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.id) || headerKey;
+            toggleSorting(id, headerKey, headers[headerKey]);
+        }
+    }
+    function handleSelectChange(newSortOption) {
+        if (sortableItem) {
+            setSorting(sortableItem.key, newSortOption.id, newSortOption.label, newSortOption.order);
+        }
+        setIsDropDownOpen(true);
+    }
+}
+
+export { DataListHeaderTile as D };

package/dist/DataListHeaderTile-DFn6xA5F.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var React = require('react');
+var classnames = require('classnames');
+var useFocusTrap = require('./useFocusTrap-pmlWfXLc.js');
+var useRefocusOnActivator = require('./useRefocusOnActivator-DK92YmNB.js');
+var DataListSortingOptions = require('./DataListSortingOptions-4H3EJUmw.js');
+var Text = require('./Text-B2v3VC_B.js');
+var DataListContext = require('./DataListContext-CjeCQOQO.js');
+
+var styles$1 = {"headerLabel":"fLmJZJJqMcE-","sortable":"UG8cHUT3Hds-"};
+
+var styles = {"sortIcon":"AN5egORYy-0-","active":"F1uTDCK0Sb0-","inactive":"_6KYeQXWXLQ8-"};
+
+const SORTING_ICON_TEST_ID = "ATL-DataList-Sorting-Icon";
+function DataListSortingArrows({ order }) {
+    return (React.createElement("div", { className: styles.sortIcon, "data-testid": SORTING_ICON_TEST_ID },
+        React.createElement("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg" },
+            React.createElement("path", { className: getActiveClassName("asc"), d: "M16.2929 10.6661C15.9024 11.0566 15.2692 11.0566 14.8787 10.6661L12.2891 8.14263L9.70711 10.6661C9.31658 11.0566 8.68342 11.0566 8.29289 10.6661C7.90237 10.2756 7.90237 9.64239 8.29289 9.25186L11.5858 5.95897C11.9763 5.56845 12.6095 5.56845 13 5.95897L16.2929 9.25186C16.6834 9.64239 16.6834 10.2756 16.2929 10.6661Z" }),
+            React.createElement("path", { className: getActiveClassName("desc"), d: "M8.29292 13.3339C8.68345 12.9434 9.31661 12.9434 9.70714 13.3339L12.2968 15.8573L14.8787 13.3339C15.2692 12.9434 15.9024 12.9434 16.2929 13.3339C16.6834 13.7244 16.6834 14.3576 16.2929 14.7481L13 18.041C12.6095 18.4315 11.9763 18.4315 11.5858 18.041L8.29292 14.7481C7.9024 14.3576 7.9024 13.7244 8.29292 13.3339Z" }))));
+    function getActiveClassName(targetOrder) {
+        return order === targetOrder ? styles.active : styles.inactive;
+    }
+}
+
+/* eslint-disable max-statements */
+function DataListHeaderTile({ headers, headerKey, visible = false, }) {
+    useRefocusOnActivator.useRefocusOnActivator_2(visible);
+    const { sorting } = DataListContext.useDataListContext();
+    const [isDropDownOpen, setIsDropDownOpen] = React.useState(false);
+    const optionsListRef = useFocusTrap.useFocusTrap_2(isDropDownOpen);
+    const dataListHeaderTileRef = React.useRef(null);
+    const sortableItem = sorting === null || sorting === void 0 ? void 0 : sorting.sortable.find(item => item.key === headerKey);
+    const isSortable = Boolean(sortableItem);
+    const sortingState = sorting === null || sorting === void 0 ? void 0 : sorting.state;
+    const Tag = isSortable ? "button" : "div";
+    return (React.createElement(Tag, { className: classnames(styles$1.headerLabel, {
+            [styles$1.sortable]: isSortable,
+        }), onClick: handleOnClick, ref: dataListHeaderTileRef },
+        React.createElement(Text.Text, { maxLines: "single" }, headers[headerKey]),
+        isSortable && (sortableItem === null || sortableItem === void 0 ? void 0 : sortableItem.options) && isDropDownOpen && (React.createElement(DataListSortingOptions.DataListSortingOptions, { options: sortableItem.options, selectedOption: (sorting === null || sorting === void 0 ? void 0 : sorting.state) || null, onSelectChange: handleSelectChange, onClose: () => setIsDropDownOpen(false), optionsListRef: optionsListRef, dataListHeaderTileRef: dataListHeaderTileRef })),
+        isSortable && (React.createElement(DataListSortingArrows, { order: (sortingState === null || sortingState === void 0 ? void 0 : sortingState.key) === headerKey ? sortingState.order : "none" }))));
+    function toggleSorting(newSortingKey, newId, newLabel) {
+        const isSameKey = newSortingKey === (sortingState === null || sortingState === void 0 ? void 0 : sortingState.key);
+        const isDescending = (sortingState === null || sortingState === void 0 ? void 0 : sortingState.order) === "desc";
+        if (isSameKey && isDescending) {
+            sorting === null || sorting === void 0 ? void 0 : sorting.onSort(undefined);
+            return;
+        }
+        const sortingOrder = isSameKey ? "desc" : "asc";
+        setSorting(newSortingKey, newId, newLabel, sortingOrder);
+    }
+    function setSorting(newSortingKey, newId, newLabel, newOrder) {
+        sorting === null || sorting === void 0 ? void 0 : sorting.onSort({
+            key: newSortingKey,
+            id: newId,
+            label: newLabel,
+            order: newOrder,
+        });
+    }
+    function handleOnClick() {
+        var _a, _b;
+        if (!isSortable)
+            return;
+        if (sortableItem === null || sortableItem === void 0 ? void 0 : sortableItem.options) {
+            setIsDropDownOpen(!isDropDownOpen);
+        }
+        else {
+            const id = ((_b = (_a = sortableItem === null || sortableItem === void 0 ? void 0 : sortableItem.options) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.id) || headerKey;
+            toggleSorting(id, headerKey, headers[headerKey]);
+        }
+    }
+    function handleSelectChange(newSortOption) {
+        if (sortableItem) {
+            setSorting(sortableItem.key, newSortOption.id, newSortOption.label, newSortOption.order);
+        }
+        setIsDropDownOpen(true);
+    }
+}
+
+exports.DataListHeaderTile = DataListHeaderTile;

package/dist/DataListItem-BO1Wlpy7.js

@@ -0,0 +1,112 @@
+import React, { Children, useMemo, isValidElement, useState } from 'react';
+import { AnimatePresence } from 'framer-motion';
+import classnames from 'classnames';
+import { u as useDataListLayoutContext } from './DataListLayoutContext-DDloSo3U.js';
+import { I as InternalDataListItemActions } from './DataListItemActions-Buc_xbbO.js';
+import { D as DataListActionsMenu } from './DataListActionsMenu-DUzcRsjU.js';
+import { D as DataListLayoutActionsContext } from './DataListLayoutContext-BSOwbjMF.js';
+import { d as generateListItemElement } from './DataList.utils-9ehaD0Qv.js';
+import { C as Checkbox } from './Checkbox-BcFHMjuY.js';
+import { u as useBatchSelect } from './useBatchSelect-C5xEMqrD.js';
+import { s as styles } from './DataList-Cc_fUM76.js';
+import { D as DataListItemClickable } from './DataListItemClickable-CbpEzDTq.js';
+import { u as useDataListContext } from './DataListContext-tYtmL4Rx.js';
+
+function DataListItemInternal({ children, item, }) {
+    const { canSelect, hasAtLeastOneSelected, isSelectAll, selectedIDs, selected, onSelect, } = useBatchSelect();
+    if (!canSelect)
+        return children;
+    return (React.createElement("div", { className: classnames(styles.selectable, {
+            [styles.selected]: hasAtLeastOneSelected,
+        }) },
+        children,
+        React.createElement(Checkbox, { checked: getIsChecked(), onChange: handleChange })));
+    function getIsChecked() {
+        const isItemInSelectedIDs = selectedIDs.includes(item.id);
+        // If we're in a "select all" state, the selectedID's becomes a list of
+        // unchecked ID's.
+        if (isSelectAll)
+            return !isItemInSelectedIDs;
+        // Otherwise, we're in a "select some" state, so we can just check if the
+        // item is in the selectedIDs list.
+        return isItemInSelectedIDs;
+    }
+    function handleChange() {
+        if (isSelectAll)
+            return handleSelectAllChange();
+        return handleSelectSomeChange();
+    }
+    function handleSelectAllChange() {
+        if (!selected || Array.isArray(selected))
+            return;
+        if (selectedIDs === null || selectedIDs === void 0 ? void 0 : selectedIDs.includes(item.id)) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect(Object.assign(Object.assign({}, selected), { unselected: selectedIDs === null || selectedIDs === void 0 ? void 0 : selectedIDs.filter(id => id !== item.id) }));
+        }
+        else if (selectedIDs) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect(Object.assign(Object.assign({}, selected), { unselected: [...selectedIDs, item.id] }));
+        }
+    }
+    function handleSelectSomeChange() {
+        if (selectedIDs === null || selectedIDs === void 0 ? void 0 : selectedIDs.includes(item.id)) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect(selectedIDs === null || selectedIDs === void 0 ? void 0 : selectedIDs.filter(id => id !== item.id));
+        }
+        else if (selectedIDs) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect([...selectedIDs, item.id]);
+        }
+    }
+}
+
+function useGetItemActions(item) {
+    const { itemActionComponent } = useDataListContext();
+    const itemActions = (itemActionComponent === null || itemActionComponent === void 0 ? void 0 : itemActionComponent.props.children) || [];
+    const actionsArray = Children.toArray(itemActions);
+    const actions = useMemo(() => {
+        return actionsArray.filter(action => {
+            if (isValidElement(action) && action.props.visible) {
+                return action.props.visible(item);
+            }
+            return true;
+        });
+    }, [itemActionComponent === null || itemActionComponent === void 0 ? void 0 : itemActionComponent.props.children, item]);
+    return {
+        actions: actions,
+        hasActions: Boolean(actions.length),
+    };
+}
+
+// eslint-disable-next-line max-statements
+function DataListItem({ item, layout, }) {
+    const { hasInLayoutActions } = useDataListLayoutContext();
+    const [showMenu, setShowMenu] = useState(false);
+    const [contextPosition, setContextPosition] = useState();
+    const generatedItem = useMemo(() => generateListItemElement(item), [item]);
+    const { actions, hasActions } = useGetItemActions(item);
+    const isContextMenuVisible = Boolean(contextPosition);
+    const shouldShowContextMenu = showMenu && isContextMenuVisible && hasActions;
+    return (React.createElement(DataListLayoutActionsContext.Provider, { value: { activeItem: item } },
+        React.createElement("div", { onMouseEnter: handleShowMenu, onMouseLeave: handleHideMenu, onFocus: handleShowMenu, onBlur: handleHideMenu, onContextMenu: handleContextMenu, className: classnames(styles.listItem, {
+                [styles.active]: showMenu && isContextMenuVisible,
+            }), key: item.id },
+            React.createElement(DataListItemInternal, { item: item },
+                React.createElement(DataListItemClickable, null, layout(generatedItem))),
+            React.createElement(AnimatePresence, null,
+                showMenu && hasActions && !hasInLayoutActions && (React.createElement(InternalDataListItemActions, { actions: actions })),
+                React.createElement(DataListActionsMenu, { key: item.id, visible: shouldShowContextMenu, position: contextPosition || { x: 0, y: 0 }, onRequestClose: () => setContextPosition(undefined) }, actions)))));
+    function handleShowMenu() {
+        setShowMenu(true);
+    }
+    function handleHideMenu() {
+        setShowMenu(false);
+    }
+    function handleContextMenu(event) {
+        if (!hasActions || isContextMenuVisible)
+            return;
+        event.preventDefault();
+        setContextPosition({
+            x: event.clientX,
+            y: event.clientY,
+        });
+    }
+}
+
+export { DataListItem as D };

package/dist/DataListItem-TBu2bxGW.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var React = require('react');
+var framerMotion = require('framer-motion');
+var classnames = require('classnames');
+var DataListLayoutContext = require('./DataListLayoutContext-Bduu7kVW.js');
+var DataListItemActions = require('./DataListItemActions-DsRsqiO9.js');
+var DataListActionsMenu = require('./DataListActionsMenu-CcPO6xu6.js');
+var DataListLayoutContext$1 = require('./DataListLayoutContext-CRwE525R.js');
+var DataList_utils = require('./DataList.utils-CMa3suIh.js');
+var Checkbox = require('./Checkbox-BshHYo-R.js');
+var useBatchSelect = require('./useBatchSelect-HwBA03k3.js');
+var DataList = require('./DataList-Bmcmjt1A.js');
+var DataListItemClickable = require('./DataListItemClickable-B95HdOlE.js');
+var DataListContext = require('./DataListContext-CjeCQOQO.js');
+
+function DataListItemInternal({ children, item, }) {
+    const { canSelect, hasAtLeastOneSelected, isSelectAll, selectedIDs, selected, onSelect, } = useBatchSelect.useBatchSelect();
+    if (!canSelect)
+        return children;
+    return (React.createElement("div", { className: classnames(DataList.styles.selectable, {
+            [DataList.styles.selected]: hasAtLeastOneSelected,
+        }) },
+        children,
+        React.createElement(Checkbox.Checkbox, { checked: getIsChecked(), onChange: handleChange })));
+    function getIsChecked() {
+        const isItemInSelectedIDs = selectedIDs.includes(item.id);
+        // If we're in a "select all" state, the selectedID's becomes a list of
+        // unchecked ID's.
+        if (isSelectAll)
+            return !isItemInSelectedIDs;
+        // Otherwise, we're in a "select some" state, so we can just check if the
+        // item is in the selectedIDs list.
+        return isItemInSelectedIDs;
+    }
+    function handleChange() {
+        if (isSelectAll)
+            return handleSelectAllChange();
+        return handleSelectSomeChange();
+    }
+    function handleSelectAllChange() {
+        if (!selected || Array.isArray(selected))
+            return;
+        if (selectedIDs === null || selectedIDs === void 0 ? void 0 : selectedIDs.includes(item.id)) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect(Object.assign(Object.assign({}, selected), { unselected: selectedIDs === null || selectedIDs === void 0 ? void 0 : selectedIDs.filter(id => id !== item.id) }));
+        }
+        else if (selectedIDs) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect(Object.assign(Object.assign({}, selected), { unselected: [...selectedIDs, item.id] }));
+        }
+    }
+    function handleSelectSomeChange() {
+        if (selectedIDs === null || selectedIDs === void 0 ? void 0 : selectedIDs.includes(item.id)) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect(selectedIDs === null || selectedIDs === void 0 ? void 0 : selectedIDs.filter(id => id !== item.id));
+        }
+        else if (selectedIDs) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect([...selectedIDs, item.id]);
+        }
+    }
+}
+
+function useGetItemActions(item) {
+    const { itemActionComponent } = DataListContext.useDataListContext();
+    const itemActions = (itemActionComponent === null || itemActionComponent === void 0 ? void 0 : itemActionComponent.props.children) || [];
+    const actionsArray = React.Children.toArray(itemActions);
+    const actions = React.useMemo(() => {
+        return actionsArray.filter(action => {
+            if (React.isValidElement(action) && action.props.visible) {
+                return action.props.visible(item);
+            }
+            return true;
+        });
+    }, [itemActionComponent === null || itemActionComponent === void 0 ? void 0 : itemActionComponent.props.children, item]);
+    return {
+        actions: actions,
+        hasActions: Boolean(actions.length),
+    };
+}
+
+// eslint-disable-next-line max-statements
+function DataListItem({ item, layout, }) {
+    const { hasInLayoutActions } = DataListLayoutContext.useDataListLayoutContext();
+    const [showMenu, setShowMenu] = React.useState(false);
+    const [contextPosition, setContextPosition] = React.useState();
+    const generatedItem = React.useMemo(() => DataList_utils.generateListItemElement(item), [item]);
+    const { actions, hasActions } = useGetItemActions(item);
+    const isContextMenuVisible = Boolean(contextPosition);
+    const shouldShowContextMenu = showMenu && isContextMenuVisible && hasActions;
+    return (React.createElement(DataListLayoutContext$1.DataListLayoutActionsContext.Provider, { value: { activeItem: item } },
+        React.createElement("div", { onMouseEnter: handleShowMenu, onMouseLeave: handleHideMenu, onFocus: handleShowMenu, onBlur: handleHideMenu, onContextMenu: handleContextMenu, className: classnames(DataList.styles.listItem, {
+                [DataList.styles.active]: showMenu && isContextMenuVisible,
+            }), key: item.id },
+            React.createElement(DataListItemInternal, { item: item },
+                React.createElement(DataListItemClickable.DataListItemClickable, null, layout(generatedItem))),
+            React.createElement(framerMotion.AnimatePresence, null,
+                showMenu && hasActions && !hasInLayoutActions && (React.createElement(DataListItemActions.InternalDataListItemActions, { actions: actions })),
+                React.createElement(DataListActionsMenu.DataListActionsMenu, { key: item.id, visible: shouldShowContextMenu, position: contextPosition || { x: 0, y: 0 }, onRequestClose: () => setContextPosition(undefined) }, actions)))));
+    function handleShowMenu() {
+        setShowMenu(true);
+    }
+    function handleHideMenu() {
+        setShowMenu(false);
+    }
+    function handleContextMenu(event) {
+        if (!hasActions || isContextMenuVisible)
+            return;
+        event.preventDefault();
+        setContextPosition({
+            x: event.clientX,
+            y: event.clientY,
+        });
+    }
+}
+
+exports.DataListItem = DataListItem;

package/dist/DataListItemActions-Buc_xbbO.js

@@ -0,0 +1,29 @@
+import React from 'react';
+import { motion } from 'framer-motion';
+import { T as TRANSITION_DURATION_IN_SECONDS, d as TRANSITION_DELAY_IN_SECONDS } from './DataList.const-DZaKGZRx.js';
+import { D as DataListActions } from './DataListActions-C6kLL6bk.js';
+
+var styles = {"menu":"jHcHGQ-HDbk-"};
+
+// This component is meant to capture the props of the DataList.ItemActions
+function DataListItemActions(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_) {
+    return null;
+}
+const variants = {
+    hidden: { opacity: 0, y: 10 },
+    visible: { opacity: 1, y: 0 },
+};
+function InternalDataListItemActions({ actions, }) {
+    return (React.createElement(motion.div, { variants: variants, initial: "hidden", animate: "visible", exit: "hidden", transition: {
+            duration: TRANSITION_DURATION_IN_SECONDS,
+            delay: TRANSITION_DELAY_IN_SECONDS,
+        }, className: styles.menu, onContextMenu: handleContextMenu },
+        React.createElement(DataListActions, null, actions)));
+}
+function handleContextMenu(event) {
+    event.stopPropagation();
+}
+
+export { DataListItemActions as D, InternalDataListItemActions as I };

package/dist/DataListItemActions-DsRsqiO9.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var React = require('react');
+var framerMotion = require('framer-motion');
+var DataList_const = require('./DataList.const-CxX7Gjfz.js');
+var DataListActions = require('./DataListActions-CIGEBlZS.js');
+
+var styles = {"menu":"jHcHGQ-HDbk-"};
+
+// This component is meant to capture the props of the DataList.ItemActions
+function DataListItemActions(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_) {
+    return null;
+}
+const variants = {
+    hidden: { opacity: 0, y: 10 },
+    visible: { opacity: 1, y: 0 },
+};
+function InternalDataListItemActions({ actions, }) {
+    return (React.createElement(framerMotion.motion.div, { variants: variants, initial: "hidden", animate: "visible", exit: "hidden", transition: {
+            duration: DataList_const.TRANSITION_DURATION_IN_SECONDS,
+            delay: DataList_const.TRANSITION_DELAY_IN_SECONDS,
+        }, className: styles.menu, onContextMenu: handleContextMenu },
+        React.createElement(DataListActions.DataListActions, null, actions)));
+}
+function handleContextMenu(event) {
+    event.stopPropagation();
+}
+
+exports.DataListItemActions = DataListItemActions;
+exports.InternalDataListItemActions = InternalDataListItemActions;

package/dist/DataListItemActionsOverflow-By43h0ZT.js

@@ -0,0 +1,33 @@
+import React, { useState } from 'react';
+import { B as Button } from './Button-DK1Px9LS.js';
+import { T as Tooltip } from './Tooltip-BWy3hm6U.js';
+import { D as DataListActionsMenu } from './DataListActionsMenu-DUzcRsjU.js';
+
+function DataListItemActionsOverflow({ actions, }) {
+    const [menuPosition, setMenuPosition] = useState({ x: 0, y: 0 });
+    const [showMenu, setShowMenu] = useState(false);
+    if (actions.length === 0)
+        return null;
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Tooltip, { message: "More actions" },
+            React.createElement(Button, { icon: "more", ariaLabel: "More actions", type: "secondary", variation: "subtle", onClick: handleMoreClick })),
+        React.createElement(DataListActionsMenu, { visible: showMenu, position: menuPosition, onRequestClose: handleClose }, actions)));
+    function handleMoreClick(event) {
+        // Prevent firing the parent's onClick event when it is nested
+        // within a clickable list item
+        event.stopPropagation();
+        // Prevent navigating to the parent's href event when it is nested within a
+        // linked list item
+        event.preventDefault();
+        setShowMenu(true);
+        const rect = event.currentTarget.getBoundingClientRect();
+        const posX = rect.x;
+        const posY = rect.y + rect.height;
+        setMenuPosition({ x: posX, y: posY });
+    }
+    function handleClose() {
+        setShowMenu(false);
+    }
+}
+
+export { DataListItemActionsOverflow as D };

package/dist/DataListItemActionsOverflow-Ca2DLUFZ.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var React = require('react');
+var Button = require('./Button-noDSqvxX.js');
+var Tooltip = require('./Tooltip-CJL2w6Tj.js');
+var DataListActionsMenu = require('./DataListActionsMenu-CcPO6xu6.js');
+
+function DataListItemActionsOverflow({ actions, }) {
+    const [menuPosition, setMenuPosition] = React.useState({ x: 0, y: 0 });
+    const [showMenu, setShowMenu] = React.useState(false);
+    if (actions.length === 0)
+        return null;
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Tooltip.Tooltip, { message: "More actions" },
+            React.createElement(Button.Button, { icon: "more", ariaLabel: "More actions", type: "secondary", variation: "subtle", onClick: handleMoreClick })),
+        React.createElement(DataListActionsMenu.DataListActionsMenu, { visible: showMenu, position: menuPosition, onRequestClose: handleClose }, actions)));
+    function handleMoreClick(event) {
+        // Prevent firing the parent's onClick event when it is nested
+        // within a clickable list item
+        event.stopPropagation();
+        // Prevent navigating to the parent's href event when it is nested within a
+        // linked list item
+        event.preventDefault();
+        setShowMenu(true);
+        const rect = event.currentTarget.getBoundingClientRect();
+        const posX = rect.x;
+        const posY = rect.y + rect.height;
+        setMenuPosition({ x: posX, y: posY });
+    }
+    function handleClose() {
+        setShowMenu(false);
+    }
+}
+
+exports.DataListItemActionsOverflow = DataListItemActionsOverflow;

package/dist/DataListItemClickable-B95HdOlE.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var React = require('react');
+var DataListContext = require('./DataListContext-CjeCQOQO.js');
+var reactRouterDom = require('react-router-dom');
+var DataList = require('./DataList-Bmcmjt1A.js');
+var DataListLayoutContext = require('./DataListLayoutContext-CRwE525R.js');
+
+function DataListItemClickableInternal({ onClick, url, to, children, }) {
+    const { activeItem } = DataListLayoutContext.useDataListLayoutActionsContext();
+    if (!activeItem)
+        return React.createElement(React.Fragment, null, children);
+    if (to) {
+        const computedTo = typeof to === "string" ? to : to(activeItem);
+        return (React.createElement(reactRouterDom.Link, { className: DataList.styles.listItemClickable, to: computedTo, onClick: handleClick }, children));
+    }
+    if (url) {
+        const href = typeof url === "string" ? url : url(activeItem);
+        return (React.createElement("a", { className: DataList.styles.listItemClickable, href: href, onClick: handleClick }, children));
+    }
+    if (onClick) {
+        return (
+        // A button can be nested within the list item. To prevent a button inside
+        // button error, we need to manually declare a div to be a button
+        React.createElement("div", { role: "button", tabIndex: 0, className: DataList.styles.listItemClickable, onClick: handleClick, onKeyDown: e => {
+                if (e.key === "Enter" || e.key === " ") {
+                    e.preventDefault();
+                    handleClick();
+                }
+            } }, children));
+    }
+    return React.createElement(React.Fragment, null, children);
+    function handleClick() {
+        activeItem && (onClick === null || onClick === void 0 ? void 0 : onClick(activeItem));
+    }
+}
+
+function DataListItemClickable({ children }) {
+    const { itemActionComponent } = DataListContext.useDataListContext();
+    if (itemActionComponent) {
+        const props = itemActionComponent.props;
+        return (React.createElement(DataListItemClickableInternal, Object.assign({}, props), children));
+    }
+    return React.createElement(React.Fragment, null, children);
+}
+
+exports.DataListItemClickable = DataListItemClickable;

package/dist/DataListItemClickable-CbpEzDTq.js

@@ -0,0 +1,45 @@
+import React from 'react';
+import { u as useDataListContext } from './DataListContext-tYtmL4Rx.js';
+import { Link } from 'react-router-dom';
+import { s as styles } from './DataList-Cc_fUM76.js';
+import { u as useDataListLayoutActionsContext } from './DataListLayoutContext-BSOwbjMF.js';
+
+function DataListItemClickableInternal({ onClick, url, to, children, }) {
+    const { activeItem } = useDataListLayoutActionsContext();
+    if (!activeItem)
+        return React.createElement(React.Fragment, null, children);
+    if (to) {
+        const computedTo = typeof to === "string" ? to : to(activeItem);
+        return (React.createElement(Link, { className: styles.listItemClickable, to: computedTo, onClick: handleClick }, children));
+    }
+    if (url) {
+        const href = typeof url === "string" ? url : url(activeItem);
+        return (React.createElement("a", { className: styles.listItemClickable, href: href, onClick: handleClick }, children));
+    }
+    if (onClick) {
+        return (
+        // A button can be nested within the list item. To prevent a button inside
+        // button error, we need to manually declare a div to be a button
+        React.createElement("div", { role: "button", tabIndex: 0, className: styles.listItemClickable, onClick: handleClick, onKeyDown: e => {
+                if (e.key === "Enter" || e.key === " ") {
+                    e.preventDefault();
+                    handleClick();
+                }
+            } }, children));
+    }
+    return React.createElement(React.Fragment, null, children);
+    function handleClick() {
+        activeItem && (onClick === null || onClick === void 0 ? void 0 : onClick(activeItem));
+    }
+}
+
+function DataListItemClickable({ children }) {
+    const { itemActionComponent } = useDataListContext();
+    if (itemActionComponent) {
+        const props = itemActionComponent.props;
+        return (React.createElement(DataListItemClickableInternal, Object.assign({}, props), children));
+    }
+    return React.createElement(React.Fragment, null, children);
+}
+
+export { DataListItemClickable as D };

package/dist/DataListItems-CIXSAWsL.js

@@ -0,0 +1,19 @@
+import React, { useState } from 'react';
+import { u as useDataListContext } from './DataListContext-tYtmL4Rx.js';
+import { D as DataListLayoutContext } from './DataListLayoutContext-DDloSo3U.js';
+import { D as DataListItem } from './DataListItem-BO1Wlpy7.js';
+
+function DataListItems({ size = "xs", }) {
+    const { data, layouts } = useDataListContext();
+    const [hasInLayoutActions, setHasInLayoutActions] = useState(false);
+    const layout = layouts[size];
+    if (!layout)
+        return null;
+    return (React.createElement(DataListLayoutContext.Provider, { value: {
+            isInLayoutProvider: true,
+            hasInLayoutActions,
+            setHasInLayoutActions,
+        } }, data.map((child, i) => (React.createElement(DataListItem, { key: data[i].id, index: i, item: child, layout: layout })))));
+}
+
+export { DataListItems as D };

package/dist/DataListItems-TG0MTglA.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var React = require('react');
+var DataListContext = require('./DataListContext-CjeCQOQO.js');
+var DataListLayoutContext = require('./DataListLayoutContext-Bduu7kVW.js');
+var DataListItem = require('./DataListItem-TBu2bxGW.js');
+
+function DataListItems({ size = "xs", }) {
+    const { data, layouts } = DataListContext.useDataListContext();
+    const [hasInLayoutActions, setHasInLayoutActions] = React.useState(false);
+    const layout = layouts[size];
+    if (!layout)
+        return null;
+    return (React.createElement(DataListLayoutContext.DataListLayoutContext.Provider, { value: {
+            isInLayoutProvider: true,
+            hasInLayoutActions,
+            setHasInLayoutActions,
+        } }, data.map((child, i) => (React.createElement(DataListItem.DataListItem, { key: data[i].id, index: i, item: child, layout: layout })))));
+}
+
+exports.DataListItems = DataListItems;