@jobber/components 4.91.2-retheme-fe.1 → 4.91.2-retheme-fe.3

package/dist/AnimatedPresence/{index.js → index.cjs}

@@ -1,8 +1,6 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var AnimatedPresence = require('../AnimatedPresence-20a02aaa.js');
+var AnimatedPresence = require('../AnimatedPresence-kepj98O9.js');
 require('react');
 require('framer-motion');
 require('@jobber/design');

package/dist/AnimatedPresence/index.mjs

@@ -0,0 +1,4 @@
+export { A as AnimatedPresence } from '../AnimatedPresence-Dg0rSWmK.js';
+import 'react';
+import 'framer-motion';
+import '@jobber/design';

package/dist/AnimatedPresence-Dg0rSWmK.js

@@ -0,0 +1,98 @@
+import React, { useState, useEffect, Children } from 'react';
+import { useReducedMotion, AnimatePresence, motion } from 'framer-motion';
+import { tokens } from '@jobber/design';
+
+const TIMING_QUICK = toSeconds(tokens["timing-quick"]);
+const TIMING_BASE = toSeconds(tokens["timing-base"]);
+const baseTransition = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const fade = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const popIn = {
+    visible: Object.assign({ scale: 1 }, baseTransition.visible),
+    hidden: Object.assign({ scale: 0.95 }, baseTransition.hidden),
+};
+const fromTop = {
+    visible: Object.assign({ y: 0 }, baseTransition.visible),
+    hidden: Object.assign({ y: -tokens["space-base"] }, baseTransition.hidden),
+};
+const fromBottom = {
+    visible: Object.assign({ y: 0 }, baseTransition.visible),
+    hidden: Object.assign({ y: tokens["space-base"] }, baseTransition.hidden),
+};
+const fromLeft = {
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: -tokens["space-base"] }, baseTransition.hidden),
+};
+const fromRight = {
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: tokens["space-base"] }, baseTransition.hidden),
+};
+const fromLeftToRight = {
+    initial: Object.assign({ x: -tokens["space-base"] }, baseTransition.hidden),
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: tokens["space-base"] }, baseTransition.hidden),
+};
+const fromRightToLeft = {
+    initial: Object.assign({ x: tokens["space-base"] }, baseTransition.hidden),
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: -tokens["space-base"] }, baseTransition.hidden),
+};
+function toSeconds(ms) {
+    return ms / 1000;
+}
+
+function usePreviousValue(value) {
+    const [previousValue, setPreviousValue] = useState(value);
+    useEffect(() => {
+        setPreviousValue(value);
+    }, [value]);
+    return [previousValue, setPreviousValue];
+}
+
+const transitions = {
+    fromBottom,
+    fromTop,
+    fromLeft,
+    fromRight,
+    popIn,
+    fromLeftToRight,
+    fromRightToLeft,
+    fade,
+};
+function AnimatedPresence(props) {
+    const shouldReduceMotion = useReducedMotion();
+    if (shouldReduceMotion) {
+        return React.createElement(React.Fragment, null, props.children);
+    }
+    return React.createElement(InternalAnimatedPresence, Object.assign({}, props));
+}
+function InternalAnimatedPresence({ transition = "fromTop", initial = false, children, }) {
+    const transitionVariation = transitions[transition];
+    const hasInitialTransition = "initial" in transitionVariation;
+    const childCount = Children.count(children);
+    // Set the initial value to 0 so it staggers the animation on mount when
+    // initial is true.
+    const [lastChildIndex, setLastChildIndex] = usePreviousValue(0);
+    // Whenever the children count changes, update the last index.
+    useEffect(() => {
+        setLastChildIndex(childCount - 1);
+    }, [childCount]);
+    return (React.createElement(AnimatePresence, { initial: initial, mode: "popLayout" }, Children.map(children, (child, i) => child && (React.createElement(motion.div, { layout: true, variants: transitionVariation, initial: hasInitialTransition ? "initial" : "hidden", animate: "visible", exit: "hidden", transition: {
+            duration: TIMING_BASE,
+            delay: generateDelayTime(i),
+        } }, child)))));
+    function generateDelayTime(index) {
+        // Don't add a delay if it's already rendered.
+        if (lastChildIndex > index)
+            return 0;
+        // Stagger the animation starting after the previous last child index.
+        return (index - lastChildIndex) * TIMING_QUICK;
+    }
+}
+
+export { AnimatedPresence as A };

package/dist/{AnimatedPresence-20a02aaa.js → AnimatedPresence-kepj98O9.js}

@@ -4,10 +4,6 @@ var React = require('react');
 var framerMotion = require('framer-motion');
 var design = require('@jobber/design');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
 const TIMING_QUICK = toSeconds(design.tokens["timing-quick"]);
 const TIMING_BASE = toSeconds(design.tokens["timing-base"]);
 const baseTransition = {
@@ -73,9 +69,9 @@ const transitions = {
 function AnimatedPresence(props) {
     const shouldReduceMotion = framerMotion.useReducedMotion();
     if (shouldReduceMotion) {
-        return React__default["default"].createElement(React__default["default"].Fragment, null, props.children);
+        return React.createElement(React.Fragment, null, props.children);
     }
-    return React__default["default"].createElement(InternalAnimatedPresence, Object.assign({}, props));
+    return React.createElement(InternalAnimatedPresence, Object.assign({}, props));
 }
 function InternalAnimatedPresence({ transition = "fromTop", initial = false, children, }) {
     const transitionVariation = transitions[transition];
@@ -88,7 +84,7 @@ function InternalAnimatedPresence({ transition = "fromTop", initial = false, chi
     React.useEffect(() => {
         setLastChildIndex(childCount - 1);
     }, [childCount]);
-    return (React__default["default"].createElement(framerMotion.AnimatePresence, { initial: initial, mode: "popLayout" }, React.Children.map(children, (child, i) => child && (React__default["default"].createElement(framerMotion.motion.div, { layout: true, variants: transitionVariation, initial: hasInitialTransition ? "initial" : "hidden", animate: "visible", exit: "hidden", transition: {
+    return (React.createElement(framerMotion.AnimatePresence, { initial: initial, mode: "popLayout" }, React.Children.map(children, (child, i) => child && (React.createElement(framerMotion.motion.div, { layout: true, variants: transitionVariation, initial: hasInitialTransition ? "initial" : "hidden", animate: "visible", exit: "hidden", transition: {
             duration: TIMING_BASE,
             delay: generateDelayTime(i),
         } }, child)))));

package/dist/AnimatedSwitcher/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var AnimatedSwitcher = require('../AnimatedSwitcher-DkWeBaXx.js');
+require('react');
+require('framer-motion');
+require('../Icon-5T1h0cSC.js');
+require('@jobber/design');
+
+
+
+exports.AnimatedSwitcher = AnimatedSwitcher.AnimatedSwitcher;

package/dist/AnimatedSwitcher/index.mjs

@@ -0,0 +1,5 @@
+export { A as AnimatedSwitcher } from '../AnimatedSwitcher-B5GlT1r8.js';
+import 'react';
+import 'framer-motion';
+import '../Icon-zn-zanGs.js';
+import '@jobber/design';

package/dist/AnimatedSwitcher-B5GlT1r8.js

@@ -0,0 +1,90 @@
+import React, { useState } from 'react';
+import { AnimatePresence, motion } from 'framer-motion';
+import { I as Icon } from './Icon-zn-zanGs.js';
+
+const DURATION_SIMPLE = 0.1;
+const DURATION_AVERAGE = 0.2;
+const FADE = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const SLIDE_IN_UP = {
+    visible: { y: 0, opacity: 1 },
+    hidden: { y: "10%", opacity: 0 },
+};
+const SLIDE_IN_DOWN = {
+    visible: { y: 0, opacity: 1 },
+    hidden: { y: "-10%", opacity: 0 },
+};
+const SPIN_COUNTER_CLOCK_WISE = {
+    visible: {
+        rotate: 0,
+        scale: 1,
+        transition: { duration: DURATION_AVERAGE, ease: "easeOut" },
+    },
+    hidden: {
+        rotate: 180,
+        scale: 0.6,
+        transition: { duration: DURATION_AVERAGE, ease: "easeIn" },
+    },
+};
+const SPIN_CLOCK_WISE = {
+    visible: {
+        rotate: 0,
+        scale: 1,
+        transition: { duration: DURATION_AVERAGE, ease: "easeOut" },
+    },
+    hidden: {
+        rotate: -180,
+        scale: 0.6,
+        transition: { duration: DURATION_AVERAGE, ease: "easeIn" },
+    },
+};
+
+function AnimatedSwitcher({ initialChild, switched, switchTo, type = "slideFromBottom", }) {
+    const [ref, setRef] = useState(null);
+    const isSwitchingBetweenIcons = initialChild.type === Icon && switchTo.type === Icon;
+    const { key, transition, child, duration } = getChildData();
+    return (React.createElement(AnimatePresence, { mode: "wait", initial: false },
+        React.createElement(motion.div, { ref: setRef, key: key, variants: transition, initial: "hidden", animate: "visible", exit: "hidden", transition: { duration }, style: { display: getDisplayValue() } }, child)));
+    function getDisplayValue() {
+        if (ref === null || ref === void 0 ? void 0 : ref.firstElementChild) {
+            return window.getComputedStyle(ref.firstElementChild).display;
+        }
+    }
+    function getChildData() {
+        let data = { key: `${initialChild.type}_1`, child: initialChild };
+        if (switched) {
+            data = { key: `${switchTo.type}_2`, child: switchTo };
+        }
+        return Object.assign(Object.assign({}, data), { transition: getTransitionType(), duration: getTransitionDuration() });
+    }
+    function getTransitionType() {
+        if (isSwitchingBetweenIcons) {
+            if (switched)
+                return SPIN_COUNTER_CLOCK_WISE;
+            return SPIN_CLOCK_WISE;
+        }
+        else if (type === "fade") {
+            return FADE;
+        }
+        else {
+            if (switched)
+                return SLIDE_IN_UP;
+            return SLIDE_IN_DOWN;
+        }
+    }
+    function getTransitionDuration() {
+        switch (type) {
+            case "fade":
+                return DURATION_AVERAGE;
+            default:
+                return DURATION_SIMPLE;
+        }
+    }
+}
+AnimatedSwitcher.Icon = function AnimatedSwitcherIcon({ switchToIcon, switched, initialIcon, }) {
+    return (React.createElement(AnimatedSwitcher, { switched: switched, initialChild: React.createElement(Icon, { name: initialIcon }), switchTo: React.createElement(Icon, { name: switchToIcon }) }));
+};
+
+export { AnimatedSwitcher as A };

package/dist/{AnimatedSwitcher-3d45ec5d.js → AnimatedSwitcher-DkWeBaXx.js}

@@ -2,11 +2,7 @@
 
 var React = require('react');
 var framerMotion = require('framer-motion');
-var Icon = require('./Icon-405a216c.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var Icon = require('./Icon-5T1h0cSC.js');
 
 const DURATION_SIMPLE = 0.1;
 const DURATION_AVERAGE = 0.2;
@@ -51,8 +47,8 @@ function AnimatedSwitcher({ initialChild, switched, switchTo, type = "slideFromB
     const [ref, setRef] = React.useState(null);
     const isSwitchingBetweenIcons = initialChild.type === Icon.Icon && switchTo.type === Icon.Icon;
     const { key, transition, child, duration } = getChildData();
-    return (React__default["default"].createElement(framerMotion.AnimatePresence, { mode: "wait", initial: false },
-        React__default["default"].createElement(framerMotion.motion.div, { ref: setRef, key: key, variants: transition, initial: "hidden", animate: "visible", exit: "hidden", transition: { duration }, style: { display: getDisplayValue() } }, child)));
+    return (React.createElement(framerMotion.AnimatePresence, { mode: "wait", initial: false },
+        React.createElement(framerMotion.motion.div, { ref: setRef, key: key, variants: transition, initial: "hidden", animate: "visible", exit: "hidden", transition: { duration }, style: { display: getDisplayValue() } }, child)));
     function getDisplayValue() {
         if (ref === null || ref === void 0 ? void 0 : ref.firstElementChild) {
             return window.getComputedStyle(ref.firstElementChild).display;
@@ -90,7 +86,7 @@ function AnimatedSwitcher({ initialChild, switched, switchTo, type = "slideFromB
     }
 }
 AnimatedSwitcher.Icon = function AnimatedSwitcherIcon({ switchToIcon, switched, initialIcon, }) {
-    return (React__default["default"].createElement(AnimatedSwitcher, { switched: switched, initialChild: React__default["default"].createElement(Icon.Icon, { name: initialIcon }), switchTo: React__default["default"].createElement(Icon.Icon, { name: switchToIcon }) }));
+    return (React.createElement(AnimatedSwitcher, { switched: switched, initialChild: React.createElement(Icon.Icon, { name: initialIcon }), switchTo: React.createElement(Icon.Icon, { name: switchToIcon }) }));
 };
 
 exports.AnimatedSwitcher = AnimatedSwitcher;

package/dist/AtlantisContext/{index.js → index.cjs}

@@ -1,8 +1,6 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var AtlantisContext = require('../AtlantisContext-64608897.js');
+var AtlantisContext = require('../AtlantisContext-k356LtVM.js');
 require('react');
 
 

package/dist/AtlantisContext/index.mjs

@@ -0,0 +1,2 @@
+export { A as AtlantisContext, a as atlantisContextDefaultValues, u as useAtlantisContext } from '../AtlantisContext-BB6fVGP7.js';
+import 'react';

package/dist/AtlantisContext-BB6fVGP7.js

@@ -0,0 +1,18 @@
+import { createContext, useContext } from 'react';
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const atlantisContextDefaultValues = {
+    dateFormat: "P",
+    // The system time is "p"
+    timeFormat: "p",
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    floatSeparators: { group: ",", decimal: "." },
+    currencySymbol: "$",
+    locale: "en",
+};
+const AtlantisContext = createContext(atlantisContextDefaultValues);
+function useAtlantisContext() {
+    return useContext(AtlantisContext);
+}
+
+export { AtlantisContext as A, atlantisContextDefaultValues as a, useAtlantisContext as u };

package/dist/Autocomplete/index.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var Autocomplete = require('../Autocomplete-4jTEXjzp.js');
+require('../tslib.es6-6dmIhJTi.js');
+require('react');
+require('../debounce-BIIhPHgB.js');
+require('../_commonjsHelpers-DAuvc7SO.js');
+require('../isObjectLike-BlLIuFVH.js');
+require('../isSymbol-BxsxMlnF.js');
+require('classnames');
+require('react-dom');
+require('react-popper');
+require('../useOnKeyDown-DN2YGzzl.js');
+require('../useSafeLayoutEffect-DOMGt2wv.js');
+require('../useIsMounted-Dcw7g7-d.js');
+require('../Text-C0pm--c0.js');
+require('../Typography-BCKgZ_gv.js');
+require('../Icon-5T1h0cSC.js');
+require('@jobber/design');
+require('../Heading-D39OfHbk.js');
+require('../InputText-DJvMLtTA.js');
+require('../FormField-Dc7XoE3A.js');
+require('react-hook-form');
+require('../Button-CrxxoYQF.js');
+require('react-router-dom');
+require('../InputValidation-BxaW-DOL.js');
+require('framer-motion');
+require('../Spinner-DBuwcAqL.js');
+
+
+
+exports.Autocomplete = Autocomplete.Autocomplete;

package/dist/Autocomplete/index.mjs

@@ -0,0 +1,26 @@
+export { A as Autocomplete } from '../Autocomplete-B892iXrS.js';
+import '../tslib.es6-sBHgrKO6.js';
+import 'react';
+import '../debounce-D4EqvIGN.js';
+import '../_commonjsHelpers-jBnpF2iq.js';
+import '../isObjectLike-CAV2cIfa.js';
+import '../isSymbol-C2J0yjld.js';
+import 'classnames';
+import 'react-dom';
+import 'react-popper';
+import '../useOnKeyDown-DrmWnz2G.js';
+import '../useSafeLayoutEffect-BQD8SqX2.js';
+import '../useIsMounted-CYEXH1zH.js';
+import '../Text-CyaxiLeN.js';
+import '../Typography-C0YR4XBl.js';
+import '../Icon-zn-zanGs.js';
+import '@jobber/design';
+import '../Heading-CLboCN8l.js';
+import '../InputText-DAp8GDBJ.js';
+import '../FormField-CDoeGp9o.js';
+import 'react-hook-form';
+import '../Button-DzwBVzGv.js';
+import 'react-router-dom';
+import '../InputValidation-B0ocr1XO.js';
+import 'framer-motion';
+import '../Spinner-CRjrJ0LO.js';

package/dist/Autocomplete-4jTEXjzp.js

@@ -0,0 +1,192 @@
+'use strict';
+
+var tslib_es6 = require('./tslib.es6-6dmIhJTi.js');
+var React = require('react');
+var debounce = require('./debounce-BIIhPHgB.js');
+var classnames = require('classnames');
+var ReactDOM = require('react-dom');
+var reactPopper = require('react-popper');
+var useOnKeyDown = require('./useOnKeyDown-DN2YGzzl.js');
+var useSafeLayoutEffect = require('./useSafeLayoutEffect-DOMGt2wv.js');
+var useIsMounted = require('./useIsMounted-Dcw7g7-d.js');
+var Text = require('./Text-C0pm--c0.js');
+var Icon = require('./Icon-5T1h0cSC.js');
+var Heading = require('./Heading-D39OfHbk.js');
+var InputText = require('./InputText-DJvMLtTA.js');
+
+var styles = {"autocomplete":"v0Cys9vQ-NE-","options":"CX-N-e0e6og-","visible":"_4PlUaegVpkk-","option":"ucQtG0iwqbo-","active":"r8HS-ma79QE-","separator":"ydwLX44YFZc-","heading":"PvUgNoAUG7A-","icon":"DAOOFUZ1BRM-","text":"cjKJFup6hGY-","label":"hG5zNBuI2wA-","details":"_3CwjFCbhqi4-"};
+
+var IndexChange;
+(function (IndexChange) {
+    IndexChange[IndexChange["Previous"] = -1] = "Previous";
+    IndexChange[IndexChange["Next"] = 1] = "Next";
+})(IndexChange || (IndexChange = {}));
+// Adding useIsMounted is what tipped this to 13 statements.
+// Any additions beyond useIsMounted should probably see this component refactored a bit
+// eslint-disable-next-line max-statements
+function Menu({ visible, options, selectedOption, onOptionSelect, attachTo, }) {
+    const [highlightedIndex, setHighlightedIndex] = React.useState(0);
+    const { menuRef, setMenuRef, styles: popperStyles, attributes, targetWidth, } = useRepositionMenu(attachTo, visible);
+    const detectSeparatorCondition = (option) => option.description || option.details;
+    const detectGroups = (option) => option.options;
+    const addSeparators = options.some(detectSeparatorCondition);
+    const initialHighlight = options.some(detectGroups) ? 1 : 0;
+    setupKeyListeners();
+    React.useEffect(() => setHighlightedIndex(initialHighlight), [options]);
+    const mounted = useIsMounted.useIsMounted_2();
+    const menu = (React.createElement("div", Object.assign({ className: classnames(styles.options, { [styles.visible]: visible }), ref: setMenuRef, style: Object.assign(Object.assign({}, popperStyles.popper), { width: targetWidth }) }, attributes.popper), options.map((option, index) => {
+        const optionClass = classnames(styles.option, {
+            [styles.active]: index === highlightedIndex,
+            [styles.separator]: addSeparators,
+        });
+        if (isGroup(option)) {
+            return (React.createElement("div", { key: option.label, className: styles.heading },
+                React.createElement(Heading.Heading, { level: 5 }, option.label)));
+        }
+        return (React.createElement("button", { className: optionClass, key: option.value, onMouseDown: onOptionSelect.bind(undefined, option) },
+            React.createElement("div", { className: styles.icon }, isOptionSelected(selectedOption, option) && (React.createElement(Icon.Icon, { name: "checkmark", size: "small" }))),
+            React.createElement("div", { className: styles.text },
+                React.createElement("div", { className: styles.label },
+                    React.createElement(Text.Text, null, option.label),
+                    option.description !== undefined && (React.createElement(Text.Text, { variation: "subdued" }, option.description))),
+                option.details !== undefined && (React.createElement("div", { className: styles.details },
+                    React.createElement(Text.Text, null, option.details))))));
+    })));
+    return mounted.current ? ReactDOM.createPortal(menu, document.body) : menu;
+    function setupKeyListeners() {
+        React.useEffect(() => {
+            var _a, _b;
+            (_b = (_a = menuRef === null || menuRef === void 0 ? void 0 : menuRef.children[highlightedIndex]) === null || _a === void 0 ? void 0 : _a.scrollIntoView) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                behavior: "smooth",
+                block: "nearest",
+                inline: "start",
+            });
+        }, [highlightedIndex]);
+        useOnKeyDown.useOnKeyDown_2((event) => {
+            const indexChange = arrowKeyPress(event, IndexChange.Next);
+            if (indexChange) {
+                setHighlightedIndex(Math.min(options.length - 1, highlightedIndex + indexChange));
+            }
+        }, "ArrowDown");
+        useOnKeyDown.useOnKeyDown_2((event) => {
+            const indexChange = arrowKeyPress(event, IndexChange.Previous);
+            if (indexChange) {
+                setHighlightedIndex(Math.max(0, highlightedIndex + indexChange));
+            }
+        }, "ArrowUp");
+        useOnKeyDown.useOnKeyDown_2((event) => {
+            if (!visible)
+                return;
+            if (isGroup(options[highlightedIndex]))
+                return;
+            event.preventDefault();
+            onOptionSelect(options[highlightedIndex]);
+        }, "Enter");
+    }
+    function arrowKeyPress(event, direction) {
+        if (!visible)
+            return;
+        event.preventDefault();
+        const requestedIndex = options[highlightedIndex + direction];
+        return requestedIndex && isGroup(requestedIndex)
+            ? direction + direction
+            : direction;
+    }
+}
+function isOptionSelected(selectedOption, option) {
+    return selectedOption && selectedOption.value === option.value;
+}
+function isGroup(option) {
+    if (option.options)
+        return true;
+    return false;
+}
+function useRepositionMenu(attachTo, visible = false) {
+    var _a;
+    const [menuRef, setMenuRef] = React.useState();
+    const popper = reactPopper.usePopper(attachTo.current, menuRef, {
+        modifiers: [
+            { name: "offset", options: { offset: [0, 8] } },
+            { name: "flip", options: { fallbackPlacements: ["top"] } },
+        ],
+    });
+    useSafeLayoutEffect.useSafeLayoutEffect_1(() => {
+        var _a;
+        (_a = popper === null || popper === void 0 ? void 0 : popper.update) === null || _a === void 0 ? void 0 : _a.call(popper);
+    }, [visible]);
+    const targetWidth = (_a = attachTo.current) === null || _a === void 0 ? void 0 : _a.clientWidth;
+    return Object.assign(Object.assign({}, popper), { menuRef, setMenuRef, targetWidth });
+}
+
+// Max statements increased to make room for the debounce functions
+/* eslint max-statements: ["error", 14] */
+function AutocompleteInternal(_a, ref) {
+    var _b;
+    var { initialOptions = [], value, allowFreeForm = true, size = undefined, debounce: debounceRate = 300, onChange, getOptions, placeholder, onBlur, onFocus, validations } = _a, inputProps = tslib_es6.__rest(_a, ["initialOptions", "value", "allowFreeForm", "size", "debounce", "onChange", "getOptions", "placeholder", "onBlur", "onFocus", "validations"]);
+    const [options, setOptions] = React.useState(initialOptions);
+    const [menuVisible, setMenuVisible] = React.useState(false);
+    const [inputText, setInputText] = React.useState((_b = value === null || value === void 0 ? void 0 : value.label) !== null && _b !== void 0 ? _b : "");
+    const autocompleteRef = React.useRef(null);
+    const delayedSearch = debounce.debounce(updateSearch, debounceRate);
+    React.useEffect(() => {
+        delayedSearch();
+        return delayedSearch.cancel;
+    }, [inputText]);
+    React.useEffect(() => {
+        var _a;
+        updateInput((_a = value === null || value === void 0 ? void 0 : value.label) !== null && _a !== void 0 ? _a : "");
+    }, [value]);
+    return (React.createElement("div", { className: styles.autocomplete, ref: autocompleteRef },
+        React.createElement(InputText.InputText, Object.assign({ ref: ref, autocomplete: false, size: size, value: inputText, onChange: handleInputChange, placeholder: placeholder, onFocus: handleInputFocus, onBlur: handleInputBlur, validations: validations }, inputProps)),
+        menuVisible && (React.createElement(Menu, { attachTo: autocompleteRef, visible: menuVisible && options.length > 0, options: options, selectedOption: value, onOptionSelect: handleMenuChange }))));
+    function updateInput(newText) {
+        setInputText(newText);
+        if (newText === "") {
+            setOptions(mapToOptions(initialOptions));
+        }
+    }
+    function updateSearch() {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const updatedOptions = yield getOptions(inputText);
+            const filteredOptions = updatedOptions.filter((option) => "options" in option && option.options ? option.options.length > 0 : true);
+            setOptions(mapToOptions(filteredOptions));
+        });
+    }
+    function handleMenuChange(chosenOption) {
+        onChange(chosenOption);
+        updateInput(chosenOption.label);
+        setMenuVisible(false);
+    }
+    function handleInputChange(newText) {
+        updateInput(newText);
+        if (allowFreeForm) {
+            onChange({ label: newText });
+        }
+    }
+    function handleInputBlur() {
+        setMenuVisible(false);
+        if (value == undefined || value.label !== inputText) {
+            setInputText("");
+            onChange(undefined);
+        }
+        onBlur && onBlur();
+    }
+    function handleInputFocus() {
+        setMenuVisible(true);
+        if (onFocus) {
+            onFocus();
+        }
+    }
+}
+function mapToOptions(items) {
+    return items.reduce(function (result, item) {
+        result = result.concat([item]);
+        if (item.options) {
+            result = result.concat(item.options);
+        }
+        return result;
+    }, []);
+}
+const Autocomplete = React.forwardRef(AutocompleteInternal);
+
+exports.Autocomplete = Autocomplete;