@jobber/components 4.81.4 → 4.81.5-fix-inline.5

package/dist/InputTime/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var InputTime = require('../InputTime-DwoJcrJB.js');
+require('../tslib.es6-B4nBbkFK.js');
+require('react');
+require('@std-proposal/temporal');
+require('../debounce-1muae-Ut.js');
+require('../_commonjsHelpers-C9K4YQdM.js');
+require('../isObjectLike-YWtFvxic.js');
+require('../isSymbol-CJDTfNDS.js');
+require('../FormField-dnMo50u0.js');
+require('react-hook-form');
+require('classnames');
+require('../Button-jIxCW0ny.js');
+require('react-router-dom');
+require('../Icon-BrJTp9Vt.js');
+require('@jobber/design');
+require('../Typography-CM061MDN.js');
+require('../Text-DSPNdx-G.js');
+require('../InputValidation-B42k7Thv.js');
+require('framer-motion');
+require('../Spinner-CybMa8fZ.js');
+
+
+
+exports.InputTime = InputTime.InputTime;

package/dist/InputTime/index.mjs

@@ -0,0 +1,20 @@
+export { I as InputTime } from '../InputTime-p9hjiI5q.js';
+import '../tslib.es6-CI8-zPBP.js';
+import 'react';
+import '@std-proposal/temporal';
+import '../debounce-D_4D9mM0.js';
+import '../_commonjsHelpers-BXnGpbsa.js';
+import '../isObjectLike-C3_86EK7.js';
+import '../isSymbol-DbK65Wqh.js';
+import '../FormField-CvUwWHYU.js';
+import 'react-hook-form';
+import 'classnames';
+import '../Button-D4ylkMVt.js';
+import 'react-router-dom';
+import '../Icon-DroGZxeN.js';
+import '@jobber/design';
+import '../Typography-DLd7_kJN.js';
+import '../Text-BCjpwsQZ.js';
+import '../InputValidation-B-4mgs5R.js';
+import 'framer-motion';
+import '../Spinner-WydT8fKP.js';

package/dist/{InputTime/index.js → InputTime-DwoJcrJB.js}

@@ -1,31 +1,10 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var tslib_es6 = require('../tslib.es6-754e2961.js');
+var tslib_es6 = require('./tslib.es6-B4nBbkFK.js');
 var React = require('react');
 var temporal = require('@std-proposal/temporal');
-var debounce = require('lodash/debounce');
-var FormField = require('../FormField-b4e6c549.js');
-require('uuid');
-require('react-hook-form');
-require('../style-inject.es-9d2f5f4e.js');
-require('classnames');
-require('@jobber/hooks/useShowClear');
-require('../Button-b73a5e01.js');
-require('react-router-dom');
-require('../Icon-405a216c.js');
-require('@jobber/design');
-require('../Typography-c45bf216.js');
-require('../Text-259af966.js');
-require('../InputValidation-05e839fa.js');
-require('framer-motion');
-require('../Spinner-9d8fc7ff.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var debounce__default = /*#__PURE__*/_interopDefaultLegacy(debounce);
+var debounce = require('./debounce-1muae-Ut.js');
+var FormField = require('./FormField-dnMo50u0.js');
 
 function civilTimeToHTMLTime(civilTime) {
     if (civilTime == undefined) {
@@ -45,15 +24,18 @@ function htmlTimeToCivilTime(timeString) {
 
 const DEBOUNCE_TIME = 300;
 function useTimePredict({ value, handleChange }) {
-    const IS_12_HOUR_FORMAT = React.useRef(Intl.DateTimeFormat(navigator.language, {
-        hour: "numeric",
-    }).resolvedOptions().hour12);
+    const [IS_12_HOUR_FORMAT, set12HourFormat] = React.useState(false);
     const [typedTime, setTypedTime] = React.useState("");
-    const predictTime = React.useCallback(debounce__default["default"](() => {
+    const predictTime = React.useCallback(debounce.debounce(() => {
         if (value)
             return;
-        handleChange(predictHours(typedTime, IS_12_HOUR_FORMAT.current));
-    }, DEBOUNCE_TIME), [typedTime, value, handleChange]);
+        handleChange(predictHours(typedTime, IS_12_HOUR_FORMAT));
+    }, DEBOUNCE_TIME), [typedTime, value, handleChange, IS_12_HOUR_FORMAT]);
+    React.useEffect(() => {
+        set12HourFormat(Boolean(Intl.DateTimeFormat(navigator.language, {
+            hour: "numeric",
+        }).resolvedOptions().hour12));
+    }, []);
     /**
      * Predict the hour when user types a number
      */
@@ -186,7 +168,7 @@ function InputTime(_a) {
     const ref = React.useRef(null);
     const { setTypedTime } = useTimePredict({ value, handleChange });
     const fieldProps = Object.assign(Object.assign(Object.assign({ onChange: handleChange }, (defaultValue && { defaultValue: civilTimeToHTMLTime(defaultValue) })), (!defaultValue && { value: civilTimeToHTMLTime(value) })), params);
-    return (React__default["default"].createElement(FormField.FormField, Object.assign({ inputRef: ref, type: "time" }, fieldProps, { onBlur: handleBlur, onKeyUp: e => {
+    return (React.createElement(FormField.FormField, Object.assign({ inputRef: ref, type: "time" }, fieldProps, { onBlur: handleBlur, onKeyUp: e => {
             var _a;
             (_a = fieldProps.onKeyUp) === null || _a === void 0 ? void 0 : _a.call(fieldProps, e);
             !isNaN(parseInt(e.key, 10)) && setTypedTime(prev => prev + e.key);

package/dist/InputTime-p9hjiI5q.js

@@ -0,0 +1,190 @@
+import { _ as __rest } from './tslib.es6-CI8-zPBP.js';
+import React, { useState, useCallback, useEffect, useRef } from 'react';
+import { CivilTime } from '@std-proposal/temporal';
+import { d as debounce } from './debounce-D_4D9mM0.js';
+import { F as FormField } from './FormField-CvUwWHYU.js';
+
+function civilTimeToHTMLTime(civilTime) {
+    if (civilTime == undefined) {
+        return "";
+    }
+    const timeString = civilTime.toString();
+    return timeString.slice(0, 5);
+}
+function htmlTimeToCivilTime(timeString) {
+    try {
+        return CivilTime.fromString(timeString + ":00.000000000");
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+
+const DEBOUNCE_TIME = 300;
+function useTimePredict({ value, handleChange }) {
+    const [IS_12_HOUR_FORMAT, set12HourFormat] = useState(false);
+    const [typedTime, setTypedTime] = useState("");
+    const predictTime = useCallback(debounce(() => {
+        if (value)
+            return;
+        handleChange(predictHours(typedTime, IS_12_HOUR_FORMAT));
+    }, DEBOUNCE_TIME), [typedTime, value, handleChange, IS_12_HOUR_FORMAT]);
+    useEffect(() => {
+        set12HourFormat(Boolean(Intl.DateTimeFormat(navigator.language, {
+            hour: "numeric",
+        }).resolvedOptions().hour12));
+    }, []);
+    /**
+     * Predict the hour when user types a number
+     */
+    useEffect(() => {
+        /**
+         * Don't try to predict if the user types 0 as the user would almost always
+         * type another number after 0.
+         */
+        if (typedTime && typedTime !== "0") {
+            predictTime();
+            if ((IS_12_HOUR_FORMAT && typedTime !== "1") || typedTime.length === 2) {
+                // Immediately predict the hour
+                predictTime.flush();
+            }
+        }
+        return predictTime.cancel;
+    }, [typedTime]);
+    /**
+     * Reset typed time when the value changed
+     */
+    useEffect(() => {
+        setTypedTime("");
+    }, [value]);
+    return {
+        setTypedTime,
+    };
+}
+function predictHours(time, is12HourFormat = false) {
+    const today = new Date();
+    const currentHour = today.getHours();
+    const parsedTime = parseInt(time, 10);
+    let predictedTime;
+    if (is12HourFormat) {
+        predictedTime = predict12Hours(parsedTime, currentHour);
+    }
+    else {
+        predictedTime = predict24Hours(time, parsedTime, currentHour);
+    }
+    return formatHour(predictedTime);
+}
+function predict12Hours(parsedTime, currentHour) {
+    /**
+     * We need to predict what the user wants when they type 1 since it could be
+     * 10, 11, 12, or 1.
+     *
+     * If the current hour is over 12PM, we can skip this and go to the next logic.
+     */
+    if (parsedTime === 1 && currentHour < 12) {
+        if (currentHour < 10) {
+            return 10;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 1-5 predicts that the user want that exact hour on the afternoon.
+     */
+    if (parsedTime <= 5) {
+        return parsedTime + 12;
+    }
+    /**
+     * Typing 13-15 predicts that the user want the 2nd number as the minute interval.
+     */
+    if (parsedTime > 12 && parsedTime <= 15) {
+        const timeArray = parsedTime.toString().split("").map(Number); // 13 -> [1, 3]
+        const convertToHoursAndMinutes = timeArray.map((time, i) => {
+            if (i === 0)
+                return time + 12; // 1 -> 13 as 1PM
+            if (i === 1)
+                return time * 10; // 3 -> 30 as 30 minutes
+        });
+        return Number(convertToHoursAndMinutes.join("")); // [13, 30] -> 1330
+    }
+    /**
+     * Anything after 5 will be predicted to be set as AM.
+     */
+    return parsedTime;
+}
+function predict24Hours(time, parsedTime, currentHour) {
+    /**
+     * Typing 1 could be predicted from 10 to 19.
+     * Typing 01 skips this logic and sets the time to 01:00.
+     */
+    if (parsedTime === 1 && time !== "01") {
+        if (currentHour < 10 || currentHour > 19) {
+            return 10;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 2 could be predicted from 20 to 24.
+     * Typing 02 skips this logic and sets the time to 02:00.
+     */
+    if (parsedTime === 2 && time !== "02") {
+        if (currentHour < 20) {
+            return 20;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 24 or 00 is set to midnight. This ensures the time doesn't get set
+     * to 24 as that would be invalid.
+     */
+    if (parsedTime === 24 || time === "00") {
+        return 0;
+    }
+    return parsedTime;
+}
+function formatHour(time) {
+    if (time > 99) {
+        const splitTime = time.toString().split("");
+        if (splitTime.length === 3)
+            splitTime.unshift("0"); // 130 -> 0130
+        splitTime.splice(2, 0, ":"); // 0130 -> 01:30
+        return splitTime.join("");
+    }
+    if (time < 10) {
+        return `0${time}:00`;
+    }
+    return `${time}:00`;
+}
+
+function InputTime(_a) {
+    var { defaultValue, value, onChange } = _a, params = __rest(_a, ["defaultValue", "value", "onChange"]);
+    const ref = useRef(null);
+    const { setTypedTime } = useTimePredict({ value, handleChange });
+    const fieldProps = Object.assign(Object.assign(Object.assign({ onChange: handleChange }, (defaultValue && { defaultValue: civilTimeToHTMLTime(defaultValue) })), (!defaultValue && { value: civilTimeToHTMLTime(value) })), params);
+    return (React.createElement(FormField, Object.assign({ inputRef: ref, type: "time" }, fieldProps, { onBlur: handleBlur, onKeyUp: e => {
+            var _a;
+            (_a = fieldProps.onKeyUp) === null || _a === void 0 ? void 0 : _a.call(fieldProps, e);
+            !isNaN(parseInt(e.key, 10)) && setTypedTime(prev => prev + e.key);
+        } })));
+    function handleChange(newValue) {
+        onChange === null || onChange === void 0 ? void 0 : onChange(htmlTimeToCivilTime(newValue));
+    }
+    function handleBlur() {
+        var _a;
+        (_a = params.onBlur) === null || _a === void 0 ? void 0 : _a.call(params);
+        // Time inputs doesn't clear the typed value when it's invalid. This should
+        // force it to reset the input value when the typed value is invalid.
+        if (ref.current) {
+            if (!ref.current.checkValidity()) {
+                ref.current.value = "";
+            }
+        }
+    }
+}
+
+export { InputTime as I };

package/dist/InputValidation/index.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var InputValidation = require('../InputValidation-B42k7Thv.js');
+require('react');
+require('framer-motion');
+require('../Text-DSPNdx-G.js');
+require('../Typography-CM061MDN.js');
+require('classnames');
+require('../Icon-BrJTp9Vt.js');
+require('@jobber/design');
+
+
+
+exports.InputValidation = InputValidation.InputValidation;

package/dist/InputValidation/index.mjs

@@ -0,0 +1,8 @@
+export { I as InputValidation } from '../InputValidation-B-4mgs5R.js';
+import 'react';
+import 'framer-motion';
+import '../Text-BCjpwsQZ.js';
+import '../Typography-DLd7_kJN.js';
+import 'classnames';
+import '../Icon-DroGZxeN.js';
+import '@jobber/design';

package/dist/InputValidation-B-4mgs5R.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import { AnimatePresence, motion } from 'framer-motion';
+import { T as Text } from './Text-BCjpwsQZ.js';
+import { I as Icon } from './Icon-DroGZxeN.js';
+
+var styles = {"hasValidationMessage":"sc-bFJieXBA-","message":"xybhC5Y6mk4-"};
+
+function InputValidation({ message }) {
+    const messages = [message];
+    const variants = {
+        slideOut: { y: "5%", opacity: 0 },
+        slideIn: { y: 0, opacity: 1 },
+    };
+    return (React.createElement(React.Fragment, null, messages && messages.length > 0 && (React.createElement(AnimatePresence, { mode: "wait" }, messages.map(msg => (React.createElement(motion.div, { key: `validation-${msg}`, variants: variants, initial: "slideOut", animate: "slideIn", exit: "slideOut", transition: { duration: 0.2 } },
+        React.createElement("div", { className: styles.message, "aria-live": "assertive", role: "alert", tabIndex: 0 },
+            React.createElement(Icon, { name: "alert", size: "small", color: "critical" }),
+            React.createElement(Text, { size: "small", variation: "error" }, msg)))))))));
+}
+
+export { InputValidation as I };

package/dist/InputValidation-B42k7Thv.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var React = require('react');
+var framerMotion = require('framer-motion');
+var Text = require('./Text-DSPNdx-G.js');
+var Icon = require('./Icon-BrJTp9Vt.js');
+
+var styles = {"hasValidationMessage":"sc-bFJieXBA-","message":"xybhC5Y6mk4-"};
+
+function InputValidation({ message }) {
+    const messages = [message];
+    const variants = {
+        slideOut: { y: "5%", opacity: 0 },
+        slideIn: { y: 0, opacity: 1 },
+    };
+    return (React.createElement(React.Fragment, null, messages && messages.length > 0 && (React.createElement(framerMotion.AnimatePresence, { mode: "wait" }, messages.map(msg => (React.createElement(framerMotion.motion.div, { key: `validation-${msg}`, variants: variants, initial: "slideOut", animate: "slideIn", exit: "slideOut", transition: { duration: 0.2 } },
+        React.createElement("div", { className: styles.message, "aria-live": "assertive", role: "alert", tabIndex: 0 },
+            React.createElement(Icon.Icon, { name: "alert", size: "small", color: "critical" }),
+            React.createElement(Text.Text, { size: "small", variation: "error" }, msg)))))))));
+}
+
+exports.InputValidation = InputValidation;

package/dist/InternalChipDismissible-0-v3-oGh.js

@@ -0,0 +1,152 @@
+import React, { useRef, useState, useEffect } from 'react';
+import { a as useInternalChipDismissibleInput, d as useScrollToActive, b as useInView, c as useRepositionMenu, u as useInternalChipDismissible } from './useScrollToActive-B0zEdKly.js';
+import './isObjectLike-C3_86EK7.js';
+import '@jobber/design';
+import 'react-popper';
+import { d as debounce } from './debounce-D_4D9mM0.js';
+import classnames from 'classnames';
+import { T as Text } from './Text-BCjpwsQZ.js';
+import { B as Button } from './Button-D4ylkMVt.js';
+import { S as Spinner } from './Spinner-WydT8fKP.js';
+import { u as useAssert_2 } from './useAssert-B6G0d8Ic.js';
+import { I as Icon } from './Icon-DroGZxeN.js';
+import { A as Avatar } from './Avatar-DDSUdhLG.js';
+import { T as Typography } from './Typography-DLd7_kJN.js';
+import { T as Tooltip } from './Tooltip-CwOW1hGg.js';
+
+var styles$1 = {"wrapper":"zn6onyiQVmA-","chip":"PEnZzMEgbhU-","hasPrefix":"dtysUhwYdG4-","hasSuffix":"xGaMCAYsdwA-","clickable":"SNT7gGV-h-o-","input":"W4D98cvEth4-","active":"_0hEzaTXK9M0-","invalid":"JApS2787BU8-","disabled":"Kg0c8WVgMpg-","button":"_0-ZWexS4Gfg-","icon":"DQPnZP4UZpw-"};
+
+function InternalChipButton({ icon, invalid, disabled, label, onClick, }) {
+    const buttonRef = useRef();
+    return (React.createElement("div", { ref: buttonRef, className: styles$1.button, tabIndex: 0, onKeyUp: handleKeyUp, onKeyDown: handleKeyDown, onClick: handleClick, role: "button", "aria-label": `Remove ${label}`, "aria-hidden": true, "aria-disabled": disabled, "data-testid": "remove-chip-button" },
+        React.createElement(Icon, { name: icon, color: getColor() })));
+    function handleKeyUp(event) {
+        if (document.activeElement === buttonRef.current &&
+            (event.key === " " || event.key === "Enter")) {
+            event.stopPropagation();
+            buttonRef.current.click();
+        }
+    }
+    function handleKeyDown(event) {
+        if (document.activeElement === buttonRef.current && event.key === " ") {
+            // Don't scroll down
+            event.preventDefault();
+        }
+    }
+    function getColor() {
+        if (disabled)
+            return "disabled";
+        if (invalid)
+            return "critical";
+        return "greyBlue";
+    }
+    function handleClick(event) {
+        event.stopPropagation();
+        onClick === null || onClick === void 0 ? void 0 : onClick(event);
+    }
+}
+
+function InternalChipAffix({ affix, active, invalid, disabled, }) {
+    assertProps();
+    if ((affix === null || affix === void 0 ? void 0 : affix.type) === Avatar) {
+        return React.createElement(Avatar, Object.assign({}, affix.props, { size: "small" }));
+    }
+    if ((affix === null || affix === void 0 ? void 0 : affix.type) === Icon) {
+        return renderChipIcon(affix);
+    }
+    if ((affix === null || affix === void 0 ? void 0 : affix.type) === InternalChipButton) {
+        return React.createElement(InternalChipButton, Object.assign({}, affix.props));
+    }
+    return React.createElement(React.Fragment, null);
+    function renderChipIcon(icon) {
+        const color = getIconColor();
+        return (React.createElement("div", { className: styles$1.icon }, React.cloneElement(icon, Object.assign({ size: "base" }, (color && { color: color })))));
+    }
+    function getIconColor() {
+        if (disabled && !active)
+            return "disabled";
+        if (invalid && !disabled)
+            return "critical";
+        if (active)
+            return "white";
+        return;
+    }
+    function assertProps() {
+        const isAvatar = (affix === null || affix === void 0 ? void 0 : affix.type) === Avatar || false;
+        const isIcon = (affix === null || affix === void 0 ? void 0 : affix.type) === Icon || false;
+        const isChipButton = (affix === null || affix === void 0 ? void 0 : affix.type) === InternalChipButton || false;
+        useAssert_2(!!affix && !(isAvatar || isIcon || isChipButton), `Prefix prop only accepts "<Avatar />" or "<Icon />" component. You have "${affix === null || affix === void 0 ? void 0 : affix.type}".`);
+    }
+}
+
+function InternalChip({ label, active = false, disabled = false, invalid = false, prefix, suffix, tabIndex, ariaLabel, onClick, onKeyDown, }) {
+    const [truncateRef, setTruncateRef] = useState();
+    const isClickable = onClick && !disabled;
+    const classNames = classnames(styles$1.chip, {
+        [styles$1.clickable]: isClickable,
+        [styles$1.active]: active,
+        [styles$1.disabled]: disabled,
+        [styles$1.invalid]: invalid,
+        [styles$1.hasPrefix]: prefix,
+        [styles$1.hasSuffix]: suffix,
+    });
+    const affixProps = { active, invalid, disabled };
+    const Tag = onClick ? "button" : "div";
+    const chip = (React.createElement(Tag, Object.assign({ className: classNames }, (isClickable && { onClick, disabled }), { onKeyDown: onKeyDown, "data-testid": "chip-wrapper", "aria-label": ariaLabel, tabIndex: tabIndex, role: tabIndex !== undefined ? "option" : undefined }),
+        React.createElement(InternalChipAffix, Object.assign({ affix: prefix }, affixProps)),
+        React.createElement(Typography, { element: "span", numberOfLines: 1, size: "base" },
+            React.createElement("span", { ref: setTruncateRef }, label)),
+        React.createElement(InternalChipAffix, Object.assign({ affix: suffix }, affixProps))));
+    return isTruncated() ? React.createElement(Tooltip, { message: label }, chip) : chip;
+    function isTruncated() {
+        var _a;
+        const truncateParentHeight = ((_a = truncateRef === null || truncateRef === void 0 ? void 0 : truncateRef.parentElement) === null || _a === void 0 ? void 0 : _a.offsetHeight) || 0;
+        const truncateChildHeight = (truncateRef === null || truncateRef === void 0 ? void 0 : truncateRef.offsetHeight) || 0;
+        return truncateChildHeight >= truncateParentHeight * 2;
+    }
+}
+
+var styles = {"wrapper":"sCNIjluCskc-","input":"MFUlz1WQLdk-","menu":"V9eYJdjPAeY-","menuList":"LdytkOeCU9c-","menuListOption":"y7Cz2u8BuNE-","loadingIndicator":"_-7bmao8Q9As-","activeOption":"iCwWdcmtInc-"};
+
+function InternalChipDismissibleInput(props) {
+    const { activator = React.createElement(Button, { icon: "add", type: "secondary", ariaLabel: "Add" }), attachTo, isLoadingMore = false, onLoadMore, } = props;
+    const { activeIndex, allOptions, hasAvailableOptions, inputRef, menuId, menuOpen, searchValue, generateDescendantId, handleBlur, handleOpenMenu, handleSearchChange, handleCancelBlur, handleEnableBlur, handleSetActiveOnMouseOver, handleKeyDown, handleSelectOption, handleDebouncedSearch, } = useInternalChipDismissibleInput(props);
+    const menuRef = useScrollToActive(activeIndex);
+    const { ref: visibleChildRef, isInView } = useInView();
+    const { styles: popperStyles, attributes, update, setPositionedElementRef, } = useRepositionMenu(attachTo);
+    useEffect(() => {
+        if (menuOpen && update)
+            update();
+    }, [allOptions]);
+    useEffect(() => {
+        handleDebouncedSearch();
+        return handleDebouncedSearch.cancel;
+    }, [searchValue]);
+    useEffect(() => {
+        isInView && onLoadMore && onLoadMore(searchValue);
+    }, [isInView]);
+    if (!menuOpen) {
+        return React.cloneElement(activator, { onClick: handleOpenMenu });
+    }
+    return (React.createElement(React.Fragment, null,
+        React.createElement("input", { ref: inputRef, className: styles.input, type: "text", role: "combobox", "aria-label": "Press up and down arrow to cycle through the options or type to narrow down the results", "aria-autocomplete": "list", "aria-owns": menuId, "aria-expanded": hasAvailableOptions, "aria-activedescendant": generateDescendantId(activeIndex), value: searchValue, onChange: handleSearchChange, onKeyDown: handleKeyDown, onBlur: debounce(handleBlur, 200), onFocus: handleOpenMenu, autoFocus: true }),
+        (hasAvailableOptions || isLoadingMore) && (React.createElement("div", Object.assign({ ref: setPositionedElementRef, className: styles.menu, style: popperStyles.popper }, attributes.popper),
+            React.createElement("div", { ref: menuRef, role: "listbox", id: menuId, className: styles.menuList, "data-testid": "chip-menu" },
+                allOptions.map((option, i) => (React.createElement("button", { key: option.value, role: "option", type: "button", id: generateDescendantId(i), className: classnames(styles.menuListOption, {
+                        [styles.activeOption]: activeIndex === i,
+                    }), onClick: () => handleSelectOption(option), onMouseEnter: handleSetActiveOnMouseOver(i), onMouseDown: handleCancelBlur, onMouseUp: handleEnableBlur },
+                    React.createElement("span", { "aria-hidden": true }, option.prefix),
+                    React.createElement(Text, null, option.label)))),
+                React.createElement("div", { ref: visibleChildRef }),
+                isLoadingMore && (React.createElement("div", { className: styles.loadingIndicator },
+                    React.createElement(Spinner, { size: "small", inline: true }))))))));
+}
+
+function InternalChipDismissible(props) {
+    const { availableChipOptions, ref: wrapperRef, sortedVisibleChipOptions, handleChipAdd, handleChipClick, handleChipKeyDown, handleChipRemove, handleCustomAdd, handleWrapperKeyDown, } = useInternalChipDismissible(props);
+    return (React.createElement("div", { ref: wrapperRef, className: styles.wrapper, "data-testid": "dismissible-chips", onKeyDown: handleWrapperKeyDown, role: "listbox" },
+        sortedVisibleChipOptions.map(chip => (React.createElement(InternalChip, Object.assign({ key: chip.value }, chip, { onKeyDown: handleChipKeyDown(chip.value), onClick: handleChipClick(chip.value), ariaLabel: `${chip.label}. Press delete or backspace to remove ${chip.label}`, tabIndex: 0, suffix: React.createElement(InternalChipButton, { icon: "remove", invalid: chip.invalid, disabled: chip.disabled, label: chip.label, onClick: handleChipRemove(chip.value) }) })))),
+        React.createElement(InternalChipDismissibleInput, { activator: props.activator, attachTo: wrapperRef, isLoadingMore: props.isLoadingMore, options: availableChipOptions, onOptionSelect: handleChipAdd, onCustomOptionSelect: handleCustomAdd, onSearch: props.onSearch, onLoadMore: props.onLoadMore })));
+}
+
+export { InternalChipDismissible as I, InternalChip as a, InternalChipButton as b, styles$1 as s };