@jobber/components 4.92.0 → 4.92.1-JOB-91143.4

package/dist/DataList-Cu_Ae-fT.js

@@ -0,0 +1,141 @@
+'use strict';
+
+var tslib_es6 = require('./tslib.es6-CjmNBqgv.js');
+var React = require('react');
+var DataList$1 = require('./DataList-BNQqXKIC.js');
+var DataListTotalCount = require('./DataListTotalCount-Ba0aAw-B.js');
+var DataListLoadingState = require('./DataListLoadingState-CSKfVetd.js');
+var DataListLayout = require('./DataListLayout-DZynXNte.js');
+var DataListHeader = require('./DataListHeader-B5iRESYw.js');
+var DataListFilters = require('./DataListFilters-NOmECi3p.js');
+var DataListStickyHeader = require('./DataListStickyHeader-MBgJBBb6.js');
+var DataListSearch = require('./DataListSearch-CjjEiz9Q.js');
+var DataListEmptyState = require('./DataListEmptyState-zgu3AGxu.js');
+var DataListLoadMore = require('./DataListLoadMore-CjCviC3F.js');
+var DataListItemActions = require('./DataListItemActions-D5wUuHMv.js');
+var DataListAction = require('./DataListAction-CGHgpeIN.js');
+var DataListLayoutActions = require('./DataListLayoutActions-DeJK3JlE.js');
+var DataListContext = require('./DataListContext-DikZuZOD.js');
+var DataList_utils = require('./DataList.utils-C_f0XZRT.js');
+var DataList_const = require('./DataList.const-Bhvz7Luy.js');
+var DataListBulkActions = require('./DataListBulkActions-CImnK1P5.js');
+var DataListStatusBar = require('./DataListStatusBar-C5HWzkA7.js');
+var Heading = require('./Heading-BhKK7vho.js');
+var Spinner = require('./Spinner-4_B4sbFF.js');
+
+function DataList(_a) {
+    var { selected = [], sorting } = _a, props = tslib_es6.__rest(_a, ["selected", "sorting"]);
+    const [layouts, setLayouts] = React.useState({});
+    const layoutBreakpoints = React.useMemo(() => DataList_utils.sortBreakpoints(Object.keys(layouts)), [layouts]);
+    const searchComponent = DataList_utils.getCompoundComponent(props.children, DataListSearch.DataListSearch);
+    const filterComponent = DataList_utils.getCompoundComponent(props.children, DataListFilters.DataListFilters);
+    const layoutComponents = DataList_utils.getCompoundComponents(props.children, DataListLayout.DataListLayout);
+    const emptyStateComponents = DataList_utils.getCompoundComponents(props.children, DataListEmptyState.DataListEmptyState);
+    const itemActionComponent = DataList_utils.getCompoundComponent(props.children, DataListItemActions.DataListItemActions);
+    const bulkActionsComponent = DataList_utils.getCompoundComponent(props.children, DataListBulkActions.DataListBulkActions);
+    const headerCount = Object.keys(props.headers).length;
+    const shouldRenderStickyHeader = !!filterComponent || !!searchComponent || headerCount > 0;
+    return (React.createElement(DataListContext.DataListContext.Provider, { value: Object.assign(Object.assign({ searchComponent,
+            filterComponent,
+            layoutComponents,
+            emptyStateComponents,
+            itemActionComponent,
+            bulkActionsComponent,
+            layoutBreakpoints,
+            layouts,
+            registerLayout }, props), { selected, 
+            // T !== DataListObject
+            sorting: sorting }) },
+        React.createElement(InternalDataList, { shouldRenderStickyHeader: shouldRenderStickyHeader })));
+    function registerLayout(size, children) {
+        setLayouts(prev => (Object.assign(Object.assign({}, prev), { [size]: children })));
+    }
+}
+function InternalDataList({ shouldRenderStickyHeader, }) {
+    const { data, title, totalCount, loadingState = "none", layoutComponents, } = DataListContext.useDataListContext();
+    const backToTopRef = React.useRef(null);
+    const initialLoading = loadingState === "initial";
+    const showEmptyState = !initialLoading && data.length === 0;
+    const shouldRenderLoadMoreTrigger = !initialLoading && !showEmptyState;
+    return (React.createElement("div", { className: DataList$1.styles.wrapper },
+        React.createElement("div", { className: DataList$1.styles.titleContainer },
+            title && React.createElement(Heading.Heading, { level: 3 }, title),
+            React.createElement(DataListTotalCount.DataListTotalCount, { totalCount: totalCount, loading: initialLoading })),
+        React.createElement("div", { ref: backToTopRef }),
+        shouldRenderStickyHeader && (React.createElement(DataListStickyHeader.DataListStickyHeader, null,
+            React.createElement("div", { className: DataList$1.styles.headerFilters },
+                React.createElement(DataListFilters.InternalDataListFilters, null),
+                React.createElement(DataListSearch.InternalDataListSearch, null)),
+            React.createElement(DataListStatusBar.InternalDataListStatusBar, null),
+            React.createElement(DataListHeader.DataListHeader, null))),
+        initialLoading && React.createElement(DataListLoadingState.DataListLoadingState, null),
+        showEmptyState && React.createElement(DataListEmptyState.InternalDataListEmptyState, null),
+        layoutComponents,
+        loadingState === "filtering" && (React.createElement("div", { "data-testid": DataList_const.DATA_LIST_FILTERING_SPINNER_TEST_ID, className: DataList$1.styles.filtering },
+            React.createElement("div", { className: DataList$1.styles.filteringSpinner },
+                React.createElement(Spinner.Spinner, { size: "small" })))),
+        shouldRenderLoadMoreTrigger && (React.createElement(DataListLoadMore.DataListLoadMore, { onBackToTop: handleBackToTop }))));
+    function handleBackToTop() {
+        var _a;
+        // For testing purposes since jest doesn't know scrollIntoView.
+        // This prevents consumer's tests from needing to mock scrollIntoView.
+        if (!window.HTMLElement.prototype.scrollIntoView)
+            return;
+        (_a = backToTopRef.current) === null || _a === void 0 ? void 0 : _a.scrollIntoView({
+            behavior: "smooth",
+            block: "nearest",
+            inline: "start",
+        });
+    }
+}
+/**
+ * Sets the layout that the DataList item and header will use.
+ */
+DataList.Layout = DataListLayout.DataListLayout;
+/**
+ * By using this component, we can render the actions anywhere in the layout
+ * instead of being added automatically on hover.
+ */
+DataList.LayoutActions = DataListLayoutActions.DataListLayoutActions;
+/**
+ * When the DataList is either empty and/or filtered, this component will be
+ * rendered.
+ */
+DataList.EmptyState = DataListEmptyState.DataListEmptyState;
+/**
+ * Adds the filter components of your choosing to the DataList.
+ */
+DataList.Filters = DataListFilters.DataListFilters;
+/**
+ * Enables the search functionality of the DataList.
+ *
+ * Since the debounce is implemented within the component, it can only be an
+ * uncontrolled component. Thus the lack of a `value` prop.
+ */
+DataList.Search = DataListSearch.DataListSearch;
+/**
+ * Defines the group actions you could do on a single DataList item.
+ */
+DataList.ItemActions = DataListItemActions.DataListItemActions;
+/**
+ * Defines the action in a DataList. This should be used inside the
+ * DataListItemActions component.
+ */
+DataList.ItemAction = DataListAction.DataListAction;
+/**
+ * Defines the group actions you could do on multiple DataList items.
+ */
+DataList.BatchActions = DataListBulkActions.DataListBulkActions;
+/**
+ * Defines the batch action in a DataList. This should be used inside the
+ * DataListBatchActions component.
+ */
+DataList.BatchAction = function DataListBatchAction(props) {
+    return React.createElement(DataListAction.DataListAction, Object.assign({}, props));
+};
+/**
+ * Defines a status bar that is rendered between the filters and the header.
+ */
+DataList.StatusBar = DataListStatusBar.DataListStatusBar;
+
+exports.DataList = DataList;

package/dist/DataList.const-Bhvz7Luy.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var design = require('@jobber/design');
+
+const EMPTY_RESULTS_MESSAGE = "List is looking empty";
+const EMPTY_FILTER_RESULTS_MESSAGE = "No results for selected filters";
+const EMPTY_STATE_ACTION_BUTTON_ONLY_ERROR = "DataListEmptyState action prop must be a Button component";
+/**
+ * Breakpoints that we support
+ */
+const BREAKPOINTS = ["xs", "sm", "md", "lg", "xl"];
+const BREAKPOINT_SIZES = {
+    xs: 0,
+    sm: 490,
+    md: 768,
+    lg: 1080,
+    xl: 1440,
+};
+const SEARCH_DEBOUNCE_DELAY = design.tokens["timing-slowest"];
+const DATA_LIST_FILTERING_SPINNER_TEST_ID = "ATL-DataList-filteringSpinner";
+const DATA_LIST_LOADING_MORE_SPINNER_TEST_ID = "ATL-DataList-loadingMoreSpinner";
+const DATA_LOAD_MORE_TEST_ID = "ATL-DataList-LoadMore-trigger";
+const DATA_LIST_STICKY_HEADER_TEST_ID = "ATL-DataList-stickyHeader";
+const TRANSITION_DURATION_IN_SECONDS = design.tokens["timing-base"] / 1000;
+const TRANSITION_DELAY_IN_SECONDS = design.tokens["timing-quick"] / 1000;
+
+exports.BREAKPOINTS = BREAKPOINTS;
+exports.BREAKPOINT_SIZES = BREAKPOINT_SIZES;
+exports.DATA_LIST_FILTERING_SPINNER_TEST_ID = DATA_LIST_FILTERING_SPINNER_TEST_ID;
+exports.DATA_LIST_LOADING_MORE_SPINNER_TEST_ID = DATA_LIST_LOADING_MORE_SPINNER_TEST_ID;
+exports.DATA_LIST_STICKY_HEADER_TEST_ID = DATA_LIST_STICKY_HEADER_TEST_ID;
+exports.DATA_LOAD_MORE_TEST_ID = DATA_LOAD_MORE_TEST_ID;
+exports.EMPTY_FILTER_RESULTS_MESSAGE = EMPTY_FILTER_RESULTS_MESSAGE;
+exports.EMPTY_RESULTS_MESSAGE = EMPTY_RESULTS_MESSAGE;
+exports.EMPTY_STATE_ACTION_BUTTON_ONLY_ERROR = EMPTY_STATE_ACTION_BUTTON_ONLY_ERROR;
+exports.SEARCH_DEBOUNCE_DELAY = SEARCH_DEBOUNCE_DELAY;
+exports.TRANSITION_DELAY_IN_SECONDS = TRANSITION_DELAY_IN_SECONDS;
+exports.TRANSITION_DURATION_IN_SECONDS = TRANSITION_DURATION_IN_SECONDS;

package/dist/DataList.const-C329b2_o.js

@@ -0,0 +1,25 @@
+import { tokens } from '@jobber/design';
+
+const EMPTY_RESULTS_MESSAGE = "List is looking empty";
+const EMPTY_FILTER_RESULTS_MESSAGE = "No results for selected filters";
+const EMPTY_STATE_ACTION_BUTTON_ONLY_ERROR = "DataListEmptyState action prop must be a Button component";
+/**
+ * Breakpoints that we support
+ */
+const BREAKPOINTS = ["xs", "sm", "md", "lg", "xl"];
+const BREAKPOINT_SIZES = {
+    xs: 0,
+    sm: 490,
+    md: 768,
+    lg: 1080,
+    xl: 1440,
+};
+const SEARCH_DEBOUNCE_DELAY = tokens["timing-slowest"];
+const DATA_LIST_FILTERING_SPINNER_TEST_ID = "ATL-DataList-filteringSpinner";
+const DATA_LIST_LOADING_MORE_SPINNER_TEST_ID = "ATL-DataList-loadingMoreSpinner";
+const DATA_LOAD_MORE_TEST_ID = "ATL-DataList-LoadMore-trigger";
+const DATA_LIST_STICKY_HEADER_TEST_ID = "ATL-DataList-stickyHeader";
+const TRANSITION_DURATION_IN_SECONDS = tokens["timing-base"] / 1000;
+const TRANSITION_DELAY_IN_SECONDS = tokens["timing-quick"] / 1000;
+
+export { BREAKPOINTS as B, DATA_LIST_FILTERING_SPINNER_TEST_ID as D, EMPTY_FILTER_RESULTS_MESSAGE as E, SEARCH_DEBOUNCE_DELAY as S, TRANSITION_DURATION_IN_SECONDS as T, DATA_LIST_STICKY_HEADER_TEST_ID as a, EMPTY_RESULTS_MESSAGE as b, EMPTY_STATE_ACTION_BUTTON_ONLY_ERROR as c, TRANSITION_DELAY_IN_SECONDS as d, BREAKPOINT_SIZES as e, DATA_LOAD_MORE_TEST_ID as f, DATA_LIST_LOADING_MORE_SPINNER_TEST_ID as g };

package/dist/DataList.utils-C_f0XZRT.js

@@ -0,0 +1,168 @@
+'use strict';
+
+var React = require('react');
+var _commonjsHelpers = require('./_commonjsHelpers-xAV1A7i5.js');
+var _getTag = require('./_getTag-BKCeVxsL.js');
+var DataList_const = require('./DataList.const-Bhvz7Luy.js');
+var DataListTags = require('./DataListTags-DhUvQkt9.js');
+var DataListHeaderTile = require('./DataListHeaderTile-CZIjDn8L.js');
+var FormatDate = require('./FormatDate-CE_p3d5L.js');
+var Text = require('./Text-CqfEADu0.js');
+var Heading = require('./Heading-BhKK7vho.js');
+
+var baseKeys = _getTag._baseKeys,
+    getTag = _getTag._getTag,
+    isArguments = _getTag.isArguments_1,
+    isArray = _getTag.isArray_1,
+    isArrayLike = _getTag.isArrayLike_1,
+    isBuffer = _getTag.isBufferExports,
+    isPrototype = _getTag._isPrototype,
+    isTypedArray = _getTag.isTypedArray_1;
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+    setTag = '[object Set]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * jQuery-like collections are considered empty if they have a `length` of `0`.
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty(null);
+ * // => true
+ *
+ * _.isEmpty(true);
+ * // => true
+ *
+ * _.isEmpty(1);
+ * // => true
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({ 'a': 1 });
+ * // => false
+ */
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (isArrayLike(value) &&
+      (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
+        isBuffer(value) || isTypedArray(value) || isArguments(value))) {
+    return !value.length;
+  }
+  var tag = getTag(value);
+  if (tag == mapTag || tag == setTag) {
+    return !value.size;
+  }
+  if (isPrototype(value)) {
+    return !baseKeys(value).length;
+  }
+  for (var key in value) {
+    if (hasOwnProperty.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+var isEmpty_1 = isEmpty;
+
+var isEmpty$1 = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(isEmpty_1);
+
+/**
+ * Return the child component that matches the `type` provided
+ */
+function getCompoundComponent(children, type) {
+    const childrenArray = React.Children.toArray(children);
+    const element = childrenArray.find(child => React.isValidElement(child) && child.type === type);
+    // Comply with the return type without casting it
+    return React.isValidElement(element) ? element : undefined;
+}
+/**
+ * Return all instances child component that matches the `type` provided
+ */
+function getCompoundComponents(children, type) {
+    const childrenArray = React.Children.toArray(children);
+    const elements = childrenArray.filter((child) => React.isValidElement(child) && child.type === type);
+    return elements;
+}
+/**
+ * Generate the default element the DataList would use on the data provided.
+ */
+function generateListItemElement(item) {
+    return Object.keys(item).reduce((acc, key) => {
+        const currentItem = item[key];
+        if (!currentItem) {
+            return acc;
+        }
+        if (key === "tags" && Array.isArray(currentItem)) {
+            acc[key] = React.createElement(DataListTags.DataListTags, { items: currentItem });
+        }
+        else if (key === "label" && typeof currentItem === "string") {
+            acc[key] = React.createElement(Heading.Heading, { level: 5 }, currentItem);
+        }
+        else if (React.isValidElement(currentItem)) {
+            acc[key] = currentItem;
+        }
+        else if (currentItem instanceof Date) {
+            acc[key] = (React.createElement(Text.Text, null,
+                React.createElement(FormatDate.FormatDate, { date: currentItem })));
+        }
+        else {
+            acc[key] = React.createElement(Text.Text, null, currentItem);
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Generate the header elements with the default styling
+ */
+function generateHeaderElements(headers) {
+    const headerElements = Object.keys(headers).reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: React.createElement(DataListHeaderTile.DataListHeaderTile, { headers: headers, headerKey: key, visible: true }) })), {});
+    return isEmpty$1(headerElements) ? undefined : headerElements;
+}
+function sortBreakpoints(sizeProp) {
+    return sizeProp.sort((a, b) => DataList_const.BREAKPOINTS.indexOf(a) - DataList_const.BREAKPOINTS.indexOf(b));
+}
+function getExposedActions(childrenArray, childCount = 2) {
+    const firstNChildren = childrenArray.slice(0, childCount);
+    return firstNChildren.reduce((result, child, i) => {
+        const hasIcon = Boolean(child.props.icon);
+        if (!hasIcon)
+            return result; // If the child does not have an icon, continue.
+        const isLastChildAdded = result.length === i;
+        // If it's the first child or if the previous child was added, then add this child.
+        if (i === 0 || (i < childCount && isLastChildAdded)) {
+            return [...result, child];
+        }
+        return result;
+    }, []);
+}
+
+exports.generateHeaderElements = generateHeaderElements;
+exports.generateListItemElement = generateListItemElement;
+exports.getCompoundComponent = getCompoundComponent;
+exports.getCompoundComponents = getCompoundComponents;
+exports.getExposedActions = getExposedActions;
+exports.sortBreakpoints = sortBreakpoints;

package/dist/DataList.utils-hr_HVCYl.js

@@ -0,0 +1,161 @@
+import React, { Children, isValidElement } from 'react';
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-C-Wbr7RH.js';
+import { _ as _baseKeys, a as _getTag, i as isArguments_1, b as isArray_1, c as isArrayLike_1, d as isBufferExports, e as _isPrototype, f as isTypedArray_1 } from './_getTag-DpOqMBPJ.js';
+import { B as BREAKPOINTS } from './DataList.const-C329b2_o.js';
+import { D as DataListTags } from './DataListTags-BG05pYRr.js';
+import { D as DataListHeaderTile } from './DataListHeaderTile-CT3k41HG.js';
+import { F as FormatDate } from './FormatDate-Brr2_Lfu.js';
+import { T as Text } from './Text-9Y0IeH0M.js';
+import { H as Heading } from './Heading-CN8xip8K.js';
+
+var baseKeys = _baseKeys,
+    getTag = _getTag,
+    isArguments = isArguments_1,
+    isArray = isArray_1,
+    isArrayLike = isArrayLike_1,
+    isBuffer = isBufferExports,
+    isPrototype = _isPrototype,
+    isTypedArray = isTypedArray_1;
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+    setTag = '[object Set]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * jQuery-like collections are considered empty if they have a `length` of `0`.
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty(null);
+ * // => true
+ *
+ * _.isEmpty(true);
+ * // => true
+ *
+ * _.isEmpty(1);
+ * // => true
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({ 'a': 1 });
+ * // => false
+ */
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (isArrayLike(value) &&
+      (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
+        isBuffer(value) || isTypedArray(value) || isArguments(value))) {
+    return !value.length;
+  }
+  var tag = getTag(value);
+  if (tag == mapTag || tag == setTag) {
+    return !value.size;
+  }
+  if (isPrototype(value)) {
+    return !baseKeys(value).length;
+  }
+  for (var key in value) {
+    if (hasOwnProperty.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+var isEmpty_1 = isEmpty;
+
+var isEmpty$1 = /*@__PURE__*/getDefaultExportFromCjs(isEmpty_1);
+
+/**
+ * Return the child component that matches the `type` provided
+ */
+function getCompoundComponent(children, type) {
+    const childrenArray = Children.toArray(children);
+    const element = childrenArray.find(child => isValidElement(child) && child.type === type);
+    // Comply with the return type without casting it
+    return isValidElement(element) ? element : undefined;
+}
+/**
+ * Return all instances child component that matches the `type` provided
+ */
+function getCompoundComponents(children, type) {
+    const childrenArray = Children.toArray(children);
+    const elements = childrenArray.filter((child) => isValidElement(child) && child.type === type);
+    return elements;
+}
+/**
+ * Generate the default element the DataList would use on the data provided.
+ */
+function generateListItemElement(item) {
+    return Object.keys(item).reduce((acc, key) => {
+        const currentItem = item[key];
+        if (!currentItem) {
+            return acc;
+        }
+        if (key === "tags" && Array.isArray(currentItem)) {
+            acc[key] = React.createElement(DataListTags, { items: currentItem });
+        }
+        else if (key === "label" && typeof currentItem === "string") {
+            acc[key] = React.createElement(Heading, { level: 5 }, currentItem);
+        }
+        else if (isValidElement(currentItem)) {
+            acc[key] = currentItem;
+        }
+        else if (currentItem instanceof Date) {
+            acc[key] = (React.createElement(Text, null,
+                React.createElement(FormatDate, { date: currentItem })));
+        }
+        else {
+            acc[key] = React.createElement(Text, null, currentItem);
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Generate the header elements with the default styling
+ */
+function generateHeaderElements(headers) {
+    const headerElements = Object.keys(headers).reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: React.createElement(DataListHeaderTile, { headers: headers, headerKey: key, visible: true }) })), {});
+    return isEmpty$1(headerElements) ? undefined : headerElements;
+}
+function sortBreakpoints(sizeProp) {
+    return sizeProp.sort((a, b) => BREAKPOINTS.indexOf(a) - BREAKPOINTS.indexOf(b));
+}
+function getExposedActions(childrenArray, childCount = 2) {
+    const firstNChildren = childrenArray.slice(0, childCount);
+    return firstNChildren.reduce((result, child, i) => {
+        const hasIcon = Boolean(child.props.icon);
+        if (!hasIcon)
+            return result; // If the child does not have an icon, continue.
+        const isLastChildAdded = result.length === i;
+        // If it's the first child or if the previous child was added, then add this child.
+        if (i === 0 || (i < childCount && isLastChildAdded)) {
+            return [...result, child];
+        }
+        return result;
+    }, []);
+}
+
+export { getCompoundComponents as a, getExposedActions as b, generateHeaderElements as c, generateListItemElement as d, getCompoundComponent as g, sortBreakpoints as s };

package/dist/DataListAction-CGHgpeIN.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var React = require('react');
+var Typography = require('./Typography-CBz3Bwzs.js');
+var Icon = require('./Icon-DjU29wkY.js');
+var DataListLayoutContext = require('./DataListLayoutContext-D23XP8tN.js');
+
+var styles = {"action":"iyg43v-S9yU-","label":"AUJNqz93ZDA-"};
+
+function DataListAction({ label, icon, destructive, visible = () => true, onClick, }) {
+    const { activeItem } = DataListLayoutContext.useDataListLayoutActionsContext();
+    // Don't render if the item is not visible
+    if (activeItem && !visible(activeItem)) {
+        return null;
+    }
+    const color = destructive ? "critical" : "heading";
+    function getActionLabel() {
+        if (typeof label === "string") {
+            return label;
+        }
+        if (activeItem) {
+            return label(activeItem);
+        }
+    }
+    return (React.createElement("button", { type: "button", className: styles.action, onClick: handleClick },
+        React.createElement(Typography.Typography, { textColor: color },
+            React.createElement("span", { className: styles.label }, getActionLabel())),
+        icon && React.createElement(Icon.Icon, { name: icon, color: color })));
+    function handleClick() {
+        if (activeItem) {
+            onClick === null || onClick === void 0 ? void 0 : onClick(activeItem);
+        }
+        else {
+            onClick === null || onClick === void 0 ? void 0 : onClick();
+        }
+    }
+}
+
+exports.DataListAction = DataListAction;

package/dist/DataListAction-ymAGmjKg.js

@@ -0,0 +1,37 @@
+import React from 'react';
+import { T as Typography } from './Typography-DBA8fJ4I.js';
+import { I as Icon } from './Icon-BJUSeqrr.js';
+import { u as useDataListLayoutActionsContext } from './DataListLayoutContext--JcgS5I5.js';
+
+var styles = {"action":"iyg43v-S9yU-","label":"AUJNqz93ZDA-"};
+
+function DataListAction({ label, icon, destructive, visible = () => true, onClick, }) {
+    const { activeItem } = useDataListLayoutActionsContext();
+    // Don't render if the item is not visible
+    if (activeItem && !visible(activeItem)) {
+        return null;
+    }
+    const color = destructive ? "critical" : "heading";
+    function getActionLabel() {
+        if (typeof label === "string") {
+            return label;
+        }
+        if (activeItem) {
+            return label(activeItem);
+        }
+    }
+    return (React.createElement("button", { type: "button", className: styles.action, onClick: handleClick },
+        React.createElement(Typography, { textColor: color },
+            React.createElement("span", { className: styles.label }, getActionLabel())),
+        icon && React.createElement(Icon, { name: icon, color: color })));
+    function handleClick() {
+        if (activeItem) {
+            onClick === null || onClick === void 0 ? void 0 : onClick(activeItem);
+        }
+        else {
+            onClick === null || onClick === void 0 ? void 0 : onClick();
+        }
+    }
+}
+
+export { DataListAction as D };

package/dist/DataListActions-2RjU1dqb.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var React = require('react');
+var Tooltip = require('./Tooltip-D2U8LSaI.js');
+var Button = require('./Button-DE6Du5Wv.js');
+var DataListOverflowFade = require('./DataListOverflowFade-DRoqry1j.js');
+var DataList_utils = require('./DataList.utils-C_f0XZRT.js');
+var DataListLayoutContext = require('./DataListLayoutContext-D23XP8tN.js');
+var DataListItemActionsOverflow = require('./DataListItemActionsOverflow-DIzayDpq.js');
+
+function DataListActions({ children, itemsToExpose = 2, }) {
+    const { activeItem } = DataListLayoutContext.useDataListLayoutActionsContext();
+    const childrenArray = React.Children.toArray(children).filter(React.isValidElement);
+    const exposedActions = DataList_utils.getExposedActions(childrenArray, itemsToExpose);
+    childrenArray.splice(0, exposedActions.length);
+    return (React.createElement(DataListOverflowFade.DataListOverflowFade, null,
+        exposedActions.map(({ props }) => {
+            if (props.visible && !props.visible(activeItem))
+                return null;
+            if (!props.icon)
+                return null;
+            function getActionLabel() {
+                if (typeof props.label === "string") {
+                    return props.label;
+                }
+                if (activeItem) {
+                    return props.label(activeItem);
+                }
+            }
+            const actionLabel = getActionLabel();
+            return (React.createElement(Tooltip.Tooltip, { key: actionLabel, message: actionLabel },
+                React.createElement(Button.Button, { icon: props.icon, ariaLabel: actionLabel, onClick: () => {
+                        var _a, _b;
+                        if (activeItem) {
+                            (_a = props.onClick) === null || _a === void 0 ? void 0 : _a.call(props, activeItem);
+                        }
+                        else {
+                            (_b = props.onClick) === null || _b === void 0 ? void 0 : _b.call(props);
+                        }
+                    }, type: "secondary", variation: "subtle" })));
+        }),
+        React.createElement(DataListItemActionsOverflow.DataListItemActionsOverflow, { actions: childrenArray })));
+}
+
+exports.DataListActions = DataListActions;