@ringcentral/spring-ui 1.7.0

package/Dialer.js

@@ -0,0 +1,587 @@
+import { createContext, useContext, cloneElement, useRef, useEffect, forwardRef, useCallback, useImperativeHandle, useLayoutEffect, useMemo } from 'react';
+import { useLongPress, useForkRef, useWindowContext, useId, useClasses, useEventCallback, useAudio, logInDev, useOnlyOneFocusable, useKeyboardMoveFocus, globalStateClasses, getSelectionPosition, setSelectionPosition, useKeyDownOnce, useSleep, combineProps } from '@ringcentral/spring-base';
+import { useThemeProps } from '@ringcentral/spring-theme';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { V as VisuallyHidden } from './chunks/VisuallyHidden.js';
+import { I as IconButton } from './chunks/IconButtonLabel.js';
+import { DialButton1Lg, DialButton1Sm, DialButton2Lg, DialButton2Sm, DialButton3Lg, DialButton3Sm, DialButton4Lg, DialButton4Sm, DialButton5Lg, DialButton5Sm, DialButton6Lg, DialButton6Sm, DialButton7Lg, DialButton7Sm, DialButton8Lg, DialButton8Sm, DialButton9Lg, DialButton9Sm, AsteriskMd, DialButton0Lg, DialButton0Sm, HashMd } from '@ringcentral/spring-icon';
+import { T as TextField } from './chunks/TextField.js';
+import '@mui/base';
+import './chunks/Icon.js';
+import './chunks/Squircle.js';
+import './chunks/withTooltip.js';
+import './chunks/Tooltip.js';
+import 'framer-motion';
+import 'clsx';
+import './chunks/usePrefersReducedMotion.js';
+import './chunks/getFade.js';
+import './Popper.js';
+import '@floating-ui/react-dom';
+import './chunks/Modal.js';
+import './chunks/useFocusTrapStack.js';
+import './chunks/Backdrop.js';
+import './chunks/PopperPaper.js';
+import './chunks/ShowHideEye.js';
+import './chunks/useMotionSafeTransition.js';
+import './chunks/useHelperTextId.js';
+
+const DialerContext = createContext({});
+const useDialerContext = () => useContext(DialerContext);
+
+const holdTime = 1000;
+const DialDelete = (inProps) => {
+    const props = useThemeProps({ props: inProps, name: 'DialDelete' });
+    const { onDelete, onClear, children } = props;
+    const { onClearRef, onDeleteRef } = useDialerContext();
+    const handleClear = (e, reason) => {
+        onClear?.(e, reason);
+        onClearRef?.current?.(e, reason);
+    };
+    const handleDelete = (e, reason) => {
+        onDelete?.(e, reason);
+        onDeleteRef?.current?.(e, reason);
+    };
+    const { ref, ...events } = useLongPress({ onTap: handleDelete, onPress: handleClear }, children.props, { delay: holdTime, externalWindow: props.externalWindow });
+    const forkEleRef = useForkRef(children.props.ref, ref);
+    return cloneElement(children, {
+        ref: forkEleRef,
+        ...events,
+    });
+};
+DialDelete.displayName = 'SuiDialDelete';
+
+var DialPadButton$1 = {"sui-dial-pad-button-root":"sui-dial-pad-button-root","sui-icon":"sui-icon","sui-dial-pad-button-medium":"sui-dial-pad-button-medium","sui-dial-pad-button-large":"sui-dial-pad-button-large","sui-dial-pad-button-label-container":"sui-dial-pad-button-label-container"};
+
+const emptyFunction = () => {
+    //
+};
+const DialPadButton = (props) => {
+    const { value, classes, longPressValue, longPressDelay = 1000, onKeyEffect = emptyFunction, className, iconSize = 'medium', size = 'xxlarge', label, ...rest } = props;
+    const { externalWindow } = useWindowContext();
+    const labelId = useId();
+    const isPressEvent = typeof longPressDelay === 'number' && typeof longPressValue === 'string';
+    const { ref, ...events } = useLongPress({
+        onTap: (e, reason) => {
+            onKeyEffect(value, reason);
+        },
+        onPress: isPressEvent
+            ? (e, reason) => {
+                onKeyEffect(longPressValue, reason);
+            }
+            : undefined,
+    }, rest, { delay: longPressDelay, externalWindow });
+    const cls = useClasses('dial-pad-button', classes, className);
+    const button = (jsx(IconButton, { ref: ref, color: "secondary", variant: "outlined", "aria-labelledby": label ? labelId : undefined, className: cls('root', iconSize), ...rest, ...events, size: size }));
+    return label ? (jsxs("div", { id: labelId, className: cls('label-container'), children: [button, jsx("span", { children: label })] })) : (button);
+};
+DialPadButton.displayName = 'SuiDialPadButton';
+
+var DialPad$1 = {"sui-dial-pad-root":"sui-dial-pad-root","sui-dial-pad-auto-size":"sui-dial-pad-auto-size","sui-dial-pad-button":"sui-dial-pad-button"};
+
+const DIALER_PAD_ICONS = [
+    [DialButton1Lg, DialButton1Sm, '1'],
+    [DialButton2Lg, DialButton2Sm, '2', 'A B C'],
+    [DialButton3Lg, DialButton3Sm, '3', 'D E F'],
+    [DialButton4Lg, DialButton4Sm, '4', 'G H I'],
+    [DialButton5Lg, DialButton5Sm, '5', 'J K L'],
+    [DialButton6Lg, DialButton6Sm, '6', 'M N O'],
+    [DialButton7Lg, DialButton7Sm, '7', 'P Q R S'],
+    [DialButton8Lg, DialButton8Sm, '8', 'T U V'],
+    [DialButton9Lg, DialButton9Sm, '9', 'W X Y Z'],
+    [AsteriskMd, AsteriskMd, '*'],
+    [DialButton0Lg, DialButton0Sm, '0', '+'],
+    [HashMd, HashMd, '#'],
+];
+const DIALER_PAD_PLUS = '+';
+const ACCEPTABLE_KEYS = [
+    ...DIALER_PAD_ICONS.map(([, , value]) => value),
+    DIALER_PAD_PLUS,
+];
+
+/**
+ * Provide you can get event apply on trigger events area
+ * @param options onKeyDown, onKeyUp that you also want apply on target
+ * @returns  onKeyDown, onKeyUp, control
+ */
+const useDialKeyboard = ({ onKeyDown: onKeyDownArg, onKeyUp: onKeyUpArg, } = {}) => {
+    const control = useRef(null);
+    // we need `onKeyup` & `onKeydown` to get called in same amount, but also make sure of the performance.
+    const keyBufferRef = useRef([]);
+    const onKeyDown = useEventCallback((e) => {
+        onKeyDownArg?.(e);
+        const key = e.key;
+        if (!ACCEPTABLE_KEYS.includes(key))
+            return;
+        e.preventDefault();
+        e.stopPropagation();
+        const buffer = keyBufferRef.current;
+        if (!buffer.includes(key)) {
+            keyBufferRef.current = [...buffer, key];
+            control.current?.handleKeyboardEffect(key, false);
+        }
+    });
+    const onKeyUp = useEventCallback((e) => {
+        onKeyUpArg?.(e);
+        const key = e.key;
+        if (!ACCEPTABLE_KEYS.includes(key))
+            return;
+        e.preventDefault();
+        e.stopPropagation();
+        keyBufferRef.current = keyBufferRef.current.filter((bufferedKey) => bufferedKey !== key);
+        control.current?.handleKeyboardEffect(key, true);
+    });
+    return { onKeyDown, onKeyUp, control };
+};
+
+/**
+ * Custom hook that handles playing audio for key presses in a dial pad.
+ *
+ * @param audioOption - The audio options for configuring the hook.
+ * @returns A function that plays the audio for a given key.
+ */
+const useKeyAudio = ({ sounds, processor }) => {
+    const audio = useAudio();
+    const lastPlayRef = useRef();
+    useEffect(() => {
+        processor?.(audio);
+    }, [audio, processor]);
+    const play = async (src) => {
+        const lastPlay = lastPlayRef.current;
+        /* https://developers.google.com/web/updates/2017/06/play-request-was-interrupted
+         * prevent play request interrupted
+         */
+        if (lastPlay)
+            await lastPlay;
+        audio.currentTime = 0;
+        audio.src = src;
+        lastPlayRef.current = audio.play().catch((reason) => {
+            if (process.env.NODE_ENV !== 'production') {
+                logInDev({ scope: 'DialerPad', message: reason });
+            }
+        });
+    };
+    return (key) => {
+        if (!sounds)
+            return false;
+        const playTarget = (key === DIALER_PAD_PLUS ? '0' : key);
+        const sound = sounds[playTarget];
+        if (sound) {
+            return play(sound);
+        }
+        return false;
+    };
+};
+
+const DialPad = forwardRef((inProps, ref) => {
+    const props = useThemeProps({ props: inProps, name: 'DialPad' });
+    const { size = 'large', sounds, autoSize, classes, onChange: onChangeProp, action, control, getDialPadButtonProps, sinkId, persistBgTime = 200, volume = 1, muted = false, longPressDelay = 1000, className, ...divProps } = props;
+    const { externalWindow } = useWindowContext();
+    const cls = useClasses('dial-pad', classes, className);
+    const containerRef = useRef(null);
+    const hiddenRef = useRef(null);
+    const keyTimerMapRef = useRef({});
+    const forkRef = useForkRef(containerRef, ref);
+    const { onInsertRef, dialPadActionRef } = useDialerContext();
+    const focusedIndexRef = useRef(0);
+    const { focusIndex, getItemProps, moveFocusedId } = useOnlyOneFocusable({
+        focusedIndexRef,
+        containerRef,
+    });
+    const dialButtonKey = `${moveFocusedId}-dial-button`;
+    const { onKeyFocusedIndexHandle } = useKeyboardMoveFocus({
+        options: DIALER_PAD_ICONS,
+        focusedIndexRef,
+        infinite: true,
+        columns: 3,
+        onFocusedIndexChange: (event, toIndex) => {
+            focusedIndexRef.current = toIndex;
+            focusIndex(toIndex);
+            event.preventDefault();
+        },
+    });
+    const audioProcessor = useCallback((audio) => {
+        if (typeof volume !== 'undefined')
+            audio.volume = volume;
+        if (typeof muted !== 'undefined')
+            audio.muted = muted;
+        if (typeof audio['setSinkId'] === 'function')
+            audio['setSinkId'](
+            // when pass undefined, use '' to remove sinkId to default
+            sinkId || '');
+    }, [muted, sinkId, volume]);
+    const play = useKeyAudio({
+        sounds,
+        processor: audioProcessor,
+    });
+    const playAudio = useEventCallback((value) => {
+        const key = value === DIALER_PAD_PLUS ? '0' : value;
+        const keyButtonElm = containerRef.current?.querySelector(`[${dialButtonKey}="${key}"]`);
+        if (keyButtonElm) {
+            // * to keep color when quick trigger insert key or click very quick
+            const oldTimer = keyTimerMapRef.current[key];
+            if (oldTimer)
+                clearTimeout(oldTimer);
+            keyButtonElm.classList.add(globalStateClasses.active);
+            keyTimerMapRef.current[key] = window.setTimeout(() => {
+                keyButtonElm.classList.remove(globalStateClasses.active);
+                delete keyTimerMapRef.current[key];
+            }, persistBgTime);
+        }
+        return play(value);
+    });
+    const handleChange = (value, reason) => {
+        playAudio(value);
+        onInsertRef?.current?.(value, reason);
+        onChangeProp?.(value, reason);
+    };
+    const handleKeyboardEffect = useEventCallback((value, isKeyup) => {
+        if (isKeyup) {
+            handleChange(value, 'customKeyboard');
+            const toIndex = ACCEPTABLE_KEYS.findIndex((x) => x === value);
+            focusedIndexRef.current = toIndex;
+            // * mean that current focus on that dialPad, move focus to dialPad container
+            if (externalWindow &&
+                externalWindow.document.activeElement?.getAttribute(dialButtonKey) !==
+                    null) {
+                hiddenRef.current?.focus();
+            }
+        }
+    });
+    const handleKeyEffect = useEventCallback((value, reason) => {
+        handleChange(value, reason);
+    });
+    const forkActionRef = useForkRef(dialPadActionRef, action);
+    useImperativeHandle(forkActionRef, () => ({ playAudio }), [playAudio]);
+    useImperativeHandle(control, () => ({ handleKeyboardEffect }), [
+        handleKeyboardEffect,
+    ]);
+    // * clean when unmount
+    useEffect(() => () => {
+        for (const timer of Object.values(keyTimerMapRef.current)) {
+            clearTimeout(timer);
+        }
+    }, []);
+    return (jsxs("div", { ref: forkRef, className: cls('root', { 'auto-size': autoSize }), ...divProps, children: [jsx(VisuallyHidden, { ref: hiddenRef, tabIndex: -1 }), DIALER_PAD_ICONS.map(([lgIcon, smIcon, key, additionLabel], index) => {
+                const ariaLabelArr = additionLabel
+                    ? [key, additionLabel]
+                    : [key];
+                const iconSize = isNaN(parseInt(key))
+                    ? 'medium'
+                    : 'large';
+                const icon = size === 'large' ? lgIcon : smIcon;
+                return (jsx(DialPadButton, { classes: classes, symbol: icon, value: key, onKeyEffect: handleKeyEffect, ...getItemProps(index), "aria-label": ariaLabelArr.join(', '), onKeyDown: onKeyFocusedIndexHandle, ...{ [dialButtonKey]: key }, ...getDialPadButtonProps?.(key), ...(key === '0'
+                        ? {
+                            longPressValue: DIALER_PAD_PLUS,
+                            longPressDelay,
+                        }
+                        : {}), size: size === 'large' ? 'xxxlarge' : 'xxlarge', iconSize: iconSize }, key));
+            })] }));
+});
+DialPad.displayName = 'SuiDialPad';
+
+var DialerPadSoundsOGG = {
+    '0': 'data:audio/ogg;base64,T2dnUwACAAAAAAAAAACDysA+AAAAACIxnH8BHgF2b3JiaXMAAAAAAUSsAAAAAAAAMKkDAAAAAAC4AU9nZ1MAAAAAAAAAAAAAg8rAPgEAAAAQY/YRET3////////////////////VA3ZvcmJpcy0AAABYaXBoLk9yZyBsaWJWb3JiaXMgSSAyMDEwMTEwMSAoU2NoYXVmZW51Z2dldCkAAAAAAQV2b3JiaXMrQkNWAQAIAAAAMUwgxYDQkFUAABAAAGAkKQ6TZkkppZShKHmYlEhJKaWUxTCJmJSJxRhjjDHGGGOMMcYYY4wgNGQVAAAEAIAoCY6j5klqzjlnGCeOcqA5aU44pyAHilHgOQnC9SZjbqa0pmtuziklCA1ZBQAAAgBASCGFFFJIIYUUYoghhhhiiCGHHHLIIaeccgoqqKCCCjLIIINMMumkk0466aijjjrqKLTQQgsttNJKTDHVVmOuvQZdfHPOOeecc84555xzzglCQ1YBACAAAARCBhlkEEIIIYUUUogppphyCjLIgNCQVQAAIACAAAAAAEeRFEmxFMuxHM3RJE/yLFETNdEzRVNUTVVVVVV1XVd2Zdd2ddd2fVmYhVu4fVm4hVvYhV33hWEYhmEYhmEYhmH4fd/3fd/3fSA0ZBUAIAEAoCM5luMpoiIaouI5ogOEhqwCAGQAAAQAIAmSIimSo0mmZmquaZu2aKu2bcuyLMuyDISGrAIAAAEABAAAAAAAoGmapmmapmmapmmapmmapmmapmmaZlmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVlAaMgqAEACAEDHcRzHcSRFUiTHciwHCA1ZBQDIAAAIAEBSLMVyNEdzNMdzPMdzPEd0RMmUTM30TA8IDVkFAAACAAgAAAAAAEAxHMVxHMnRJE9SLdNyNVdzPddzTdd1XVdVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVgdCQVQAABAAAIZ1mlmqACDOQYSA0ZBUAgAAAABihCEMMCA1ZBQAABAAAiKHkIJrQmvPNOQ6a5aCpFJvTwYlUmye5qZibc84555xszhnjnHPOKcqZxaCZ0JpzzkkMmqWgmdCac855EpsHranSmnPOGeecDsYZYZxzzmnSmgep2Vibc85Z0JrmqLkUm3POiZSbJ7W5VJtzzjnnnHPOOeecc86pXpzOwTnhnHPOidqba7kJXZxzzvlknO7NCeGcc84555xzzjnnnHPOCUJDVgEAQAAABGHYGMadgiB9jgZiFCGmIZMedI8Ok6AxyCmkHo2ORkqpg1BSGSeldILQkFUAACAAAIQQUkghhRRSSCGFFFJIIYYYYoghp5xyCiqopJKKKsoos8wyyyyzzDLLrMPOOuuwwxBDDDG00kosNdVWY4215p5zrjlIa6W11lorpZRSSimlIDRkFQAAAgBAIGSQQQYZhRRSSCGGmHLKKaegggoIDVkFAAACAAgAAADwJM8RHdERHdERHdERHdERHc/xHFESJVESJdEyLVMzPVVUVVd2bVmXddu3hV3Ydd/Xfd/XjV8XhmVZlmVZlmVZlmVZlmVZlmUJQkNWAQAgAAAAQgghhBRSSCGFlGKMMcecg05CCYHQkFUAACAAgAAAAABHcRTHkRzJkSRLsiRN0izN8jRP8zTRE0VRNE1TFV3RFXXTFmVTNl3TNWXTVWXVdmXZtmVbt31Ztn3f933f933f933f933f13UgNGQVACABAKAjOZIiKZIiOY7jSJIEhIasAgBkAAAEAKAojuI4jiNJkiRZkiZ5lmeJmqmZnumpogqEhqwCAAABAAQAAAAAAKBoiqeYiqeIiueIjiiJlmmJmqq5omzKruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6QGjIKgBAAgBAR3IkR3IkRVIkRXIkBwgNWQUAyAAACADAMRxDUiTHsixN8zRP8zTREz3RMz1VdEUXCA1ZBQAAAgAIAAAAAADAkAxLsRzN0SRRUi3VUjXVUi1VVD1VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXVNE3TNIHQkJUAABkAAOjFCCGEEJKjlloQvlfKOSg1914xZhTE3nulmEGOcvCZYko5KLWnzjGliJFcWyuRIsRhDjpVTimoQefWSQgtB0JDVgQAUQAAAEKIMcQYYoxByCBEjDEIGYSIMQYhg9BBCCWFlDIIIZWQUsQYg9BBySCElEJJGZSQUkilAACAAAcAgAALodCQFQFAnAAAgpBziDEIFWMQOgipdBBSqhiDkDknJXMOSiglpRBKShVjEDLnJGTOSQklpBRKSamDkFIopaVQSmoppRhTSi12EFIKpaQUSmkptRRbSi3GijEImXNSMuekhFJaCqWkljknpYOQUgehlJJSa6Wk1jLnpHTQSekglFJSaamU1FooJbWSUmslldZaazGm1mIMpaQUSmmtpNRiaim21lqsFWMQMuekZM5JCaWkFEpJLXNOSgchlc5BKSWV1kpJqWXOSekglNJBKKWk0lpJpbVQSkslpdZCKa211mJMqbUaSkmtpNRaSam11FqtrbUYOwgphVJaCqW0llqKMaUWYyiltZJSayWl1lprtbbWYgyltFRSaa2k1FpqrcbWWqyppRhTazG21mqNMcYcY805pRRjainG1FqMLbYcY6w1dxBSCqWkFkpJLbUUY2otxlBKaiWV1kpJLbbWakytxRpKaa2k1FpJqbXWWo2ttRpTSjGm1mpMqcUYY8y1tRhzai3G1lqsqbUYY6w1xxhrLQAAYMABACDAhDJQaMhKACAKAAAxBiHGnDMIKcUYhMYgpRiDECnFmHMQIqUYcw5CxphzEErJGHMOQikdhBJKSamDEEopKRUAAFDgAAAQYIOmxOIAhYasBABCAgAYhJRizDnnIJSSUoSQUow55xyEUlKKEFKKMeecg1BKSpVSTDHmHIRSUmqpUkoxxpyDUEpKqWWMMeYchBBKSam1jDHGnIMQQikptdY55xx0EkpJpaXYOuecgxBKKSWl1lrnHIQQSkmlpdZi65yDEEIpJaXUWoshhFJKSSWllmKLMYRSSiklpZRaizGWVFJKqaXWYouxxlJKSiml1lqLMcaaUmqptdZijLHGWlNKqbXWWosxxlprAQAABw4AAAFG0ElGlUXYaMKFB6DQkBUBQBQAAGAMYgwxhpxzEDIIkXMMQgchcs5J6aRkUkJpIaVMSkglpBY556R0UjIpoaVQUiYlpFRaKQAA7MABAOzAQig0ZCUAkAcAACGkFGOMMYaUUooxxhxDSinFGGOMKaUYY4wx55RSjDHGmHOMMcYcc845xhhjzDnnHGPMMeecc44xxpxzzjnHHHPOOeecY84555xzzgkAACpwAAAIsFFkc4KRoEJDVgIAqQAAhDFKMeYchFIahRhzzjkIpTRIMeaccxBKqRhzzjkIpZRSMeaccxBKKSVzzjkIIZSSUuaccxBCKCWlzjkIIYRSSkqdcxBCKKGUlEIIpZRSUkqphRBKKaWUVFoqpZSSUkqptVZKKSWllFpqrQAA8AQHAKACG1ZHOCkaCyw0ZCUAkAEAwBiDkEEGIWMQQgghhBBCCAkAABhwAAAIMKEMFBqyEgBIBQAADFKKMQelpBQpxZhzEEpJKVKKMecglJJSxZhzEEpJqbWKMecglJJSa51zEEpJqbUYO+cglJJSazGGEEpJqbUYYwwhlJJSazHWWkpJqbUYa8y1lJJSazHWWmtKrbUYa60155RaazHWWnPOBQAgNDgAgB3YsDrCSdFYYKEhKwGAPAAASCnGGGOMMaUUY4wxxphSijHGGGOMMcYYY4wxphhjjDHGGGOMMcYYY4wxxhhjjDHGGGOMMeYYY4wxxhhjzDnGGGOMOeYcY4wxxpxzTgAAUIEDAECAjSKbE4wEFRqyEgAIBwAAjGHMOecglJBKo5RzEEIoJZVWGqWcgxJCKSm1ljknJaVSUmottsw5KSmVklJrLXYSUmotpdZirLGDkFJrqbUWY40dhFJaii3GGnPtIJSSWmsxxlprKKWl2GKssdaaQymptRZjrTXnXFJqLcZaa82155JSazHGWmutuafWYqyx1lxz7z21FmONteace84FAJg8OABAJdg4w0rSWeFocKEhKwGA3AAARinGnHMOQgghhBBCCJVSjDnnHIQQQgghhBAqpRhzzjkIIYQQQgghZIw55xx0EEIIIYQQQsgYc845CCGEEEIIIYTQOecchBBCCCGEUEIppXPOOQchhBBCCCGEUErnHIQQQgghhBJKKKWUzjkIIYQQQgilhFJKKSGEEEIIIYQSSimllFI6CCGEEEIIpZRSSimlhBBCCCGEEEoppZRSSgkhhBBCCCGUUkoppZQSQgghhBJKKaWUUkopJYQQQgihlFJKKaWUUkoIIYRSSimllFJKKaWUEEIoIZRSSimllFJKKSGEEkoopZRSSimllFJCCCWUUkoppZRSSimlhBBCKKWUUkoppZRSSgkhlFJKKaWUUkoppZRSAADQgQMAQIARlRZipxlXHoEjChkmoEJDVgIA4QAAACGUUkoppZRSaiSllFJKKaWUUiMlpZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKpZRSSimllFJKKaWUUkoppZRSSimlAKjLDAfA6AkbZ1hJOiscDS40ZCUAkBYAABjDmGOOQSehlJRaa5iCUELopKTSSmyxNUpBCCGEUlJKrbXWMuiolJJKSq3FFmOMmYNSUiolpdRijLHWDkJKLbUWW4ux5lprB6GklFqLLcZaa669g5BKa63lGGOwOefaQSgptdhijDXXWnsOqbQWY4y19lxrzTmIUlKKMdYac80199xLSq3FmmuuNQefcxCmpdhqjTXnnHsQOvjUWo255h500EHnHnRKrdZaa849ByF88Lm1WGvNNefegw86CN9qqzXnXGvvPfeeg24x1lxz0MEHIXzwQbgYa8859xyEDjr4HgwAyI1wAEBcMJKQOsuw0ogbT8AQgRQasgoAiAEAIIxBBiGElFJKKaWUYoopxhhjjDHGGGOMMcYYY4wxxgQAACY4AAAEWMGuzNKqjeKmTvKiDwKf0BGbkSGXUjGTE0GP1FCLlWCHVnCDF4CFhqwEAMgAABCIseZac44QlNZi7blUSjlqseeUIYKctJxLyQxBTlprLWTIKCcxthQyhBS02lrplFKMYquxdIwxSanFlkrnIAAAAIIAAAMRMhMIFECBgQwAOEBIkAIACgsMHcNFQEAuIaPAoHBMOCedNgAAQYjMEImIxSAxoRooKqYDgMUFhnwAyNDYSLu4gC4DXNDFXQdCCEIQglgcQAEJODjhhife8IQbnKBTVOogAAAAAAAQAOABACDZACKimZnj6PD4AAkRGSEpMTlBSVEJAAAAAAAgAPgAAEhWgIhoZuY4Ojw+QEJERkhKTE5QUlQCAAAAAAAAAACAgIAAAAAAAEAAAACAgE9nZ1MABNcZAAAAAAAAg8rAPgIAAAAxnIFhCT+MbWrc/6wBAWTZ+Evw/ho7cMnGPSs7KM691xaACcDCt6An5xY4vn60/ee7fBDIvv/9pZ8gk+id3DlOjvqoG+/D8DixatJ5EVoVJMsuEvC4WKpMFeTlGAbTZLjf/b/H/V84AAtAkn7IHXvGwhEAAAAAjGQUAKDdmUfKcebS+Cx8d/sjEx4ckz89PHzBcaaA/fezjK56847A1lpG4bYebN+NhOn8/BWzzf+66osgima3VfNafB2OEcC1Qcp41hgXIRjiZTh5f29T9932YITrxIrLEFABXiXkPg7fg/zSlkp9KN5gRk0SYHx8HAiAJNkOAAAAAAAIMJIBAAAAACBo8oWYvhsXG2CcmgP7r6PBSAAAAAAAABhIS0bC2tdV5IciAKrG3OaLfQ6MflwUo13ornCmM0//NGSB6JCYFwihFoABAF4l5D4OP9cPqavUxUtk1CQB9hFwACTJTgAAAAAAgDEGAAAAAACmcVrww9p29vcM+8dXAfavtWQrAQAAAAAAIObBmuBGzrth/h+4CgCqxr72edYiQBWucPNrjK1ljeSjV79qN+8GvcqCVQG+JSTM6QfcL11fpfLYtSM5OXw9RLM4PbPUwOBG1wAAIElTqkYBAgCAAmC8TTIAKEUS1+hmf+jDEfbfSGC/j1YMjvfU/9RKgffRWqP1cr8O2VSv6750EGOtNeHxfz2X/+b3DmrjN5k2ACU6cFC4/05eBx0Utk7UjumHWPcY/t/x2LANN5MZr+L++nDSsL759s5Ejf34338fGuv33PnRjwQ+fPzffx8f9c23P7pnxovH9w/NCdswM5kRtOLxfY/Qw2SiNbZ+pXP4QPnB1r+T10EZ//4b676MM8+0tiACPoTj+bsdpC/9b074kd0fR3Vl+vTs5OSk7IzFnT3hEuPpjSZNtU04/tCPWLws7VF9OKIZpmkhOI5XM8aV8/P7Q8355/v+UDPnL/b9Ifb5i33+Ifb5i8fnH+JyftUPY1zO54dKBiDMtvalbUaofdlUxPRYaIdIdMZAfxR/kVqI9CUqVk77G1bPsMZZ3uiv4fv1YHD5FFuc5vs/7fpXa7jxOM7uT4eHT9HkpzXc/Le4v0Wt/yDuPoSDy2dG7X90eLiG79eajeUzbHE67H+16/v1cOO36N6PDn/WxerweRX4jR+8d5oqh1949or9K+K33nnLLbeopqdPn36mDSXp6J57feR2//6hYNPp1LnJ3zlU0aMfv735vz3U4KMfP2v+78wZfIKmYn3+d+YsPrqp6MIhtYtPUG3657+jffvjn/qch8PhEMJNb+/O+tje7t+fL4x3f/zju36+nT7z9Aqd797yzlv2UsqnvvT/vnSmL3rr7/497ziOnD71hWc/s4JIdm+5ZYyCy6XTp5dqxG/v3p06bG/35w8FN502Vffzv6Nd9gQV+PrrcDw861sOAA4O',
+    '1': 'data:audio/ogg;base64,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',
+    '2': 'data:audio/ogg;base64,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',
+    '3': 'data:audio/ogg;base64,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',
+    '4': 'data:audio/ogg;base64,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',
+    '5': 'data:audio/ogg;base64,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',
+    '6': 'data:audio/ogg;base64,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',
+    '7': 'data:audio/ogg;base64,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',
+    '8': 'data:audio/ogg;base64,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',
+    '9': 'data:audio/ogg;base64,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',
+    '*': 'data:audio/ogg;base64,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',
+    '#': 'data:audio/ogg;base64,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',
+};
+
+var DialerPadSoundsMPEG = {
+    '0': 'data:audio/mpeg;base64,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',
+    '1': 'data:audio/mpeg;base64,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',
+    '2': 'data:audio/mpeg;base64,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',
+    '3': 'data:audio/mpeg;base64,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',
+    '4': 'data:audio/mpeg;base64,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',
+    '5': 'data:audio/mpeg;base64,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',
+    '6': 'data:audio/mpeg;base64,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',
+    '7': 'data:audio/mpeg;base64,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',
+    '8': 'data:audio/mpeg;base64,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',
+    '9': 'data:audio/mpeg;base64,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',
+    '#': 'data:audio/mpeg;base64,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',
+    '*': 'data:audio/mpeg;base64,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',
+};
+
+// ! alway new Regex for regex will have index issue
+// https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/RegExp
+/**
+ * return regex with only allow dialPad value `1234567890*+#-`
+ */
+function getDialPadValueOnlyRegex() {
+    return /[1234567890*+#]+/g;
+}
+
+/**
+ * bind with ref, let input can always focus at end of latest character
+ */
+const useFixedEndSelection = () => {
+    const ref = useRef(null);
+    const keypadModeFixedAtLatest = useEventCallback(() => {
+        const { position, isSelectRange } = getSelectionPosition(ref);
+        const value = ref.current?.value || '';
+        if (isSelectRange || position.start < value.length) {
+            const targetPosition = value.length;
+            setSelectionPosition(ref, {
+                start: targetPosition,
+                end: targetPosition,
+                scrollIntoView: true,
+            });
+        }
+    });
+    const onKeyDown = (e) => {
+        if ([
+            'ArrowUp',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowDown',
+            'PageUp',
+            'PageDown',
+            'Home',
+            'End',
+        ].includes(e.key)) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+        keypadModeFixedAtLatest();
+    };
+    return {
+        ref,
+        onFocus: keypadModeFixedAtLatest,
+        onClick: keypadModeFixedAtLatest,
+        onKeyDown,
+    };
+};
+
+const DialTextField = forwardRef((inProps, ref) => {
+    const props = useThemeProps({ props: inProps, name: 'DialTextField' });
+    const { value, onChange, onEmit, onKeyDown, onKeyUp, inputRef: inputRefProp, inputProps: inputPropsProp, keypadMode, onlyAllowKeypadValue = keypadMode, externalWindow = window, 
+    // textVariant = 'headline1',
+    ...rest } = props;
+    const dialerContext = useDialerContext();
+    const playAudio = (key) => {
+        dialerContext.dialPadActionRef?.current?.playAudio(key);
+    };
+    const { ref: inputRef, onFocus: onKeypadModeFocus, onKeyDown: onKeypadModeKeyDown, onClick: onKeypadModeClick, } = useFixedEndSelection();
+    const forkContextRef = useForkRef(dialerContext.inputRef, inputRef);
+    const forkInputRef = useForkRef(inputRefProp, forkContextRef);
+    const scrollToPositionRef = useRef();
+    const isNotTriggerRefocusRef = useRef(false);
+    const maxLength = keypadMode ? undefined : inputPropsProp?.maxLength || 30;
+    const checkNotReFocus = useEventCallback((reason, isFocus) => {
+        const elm = inputRef.current;
+        const isInputFocus = isFocus ?? externalWindow.document.activeElement === elm;
+        if (reason !== 'click' && !isInputFocus) {
+            // ! both keydown and touch, only when focus need re-focus
+            isNotTriggerRefocusRef.current = true;
+        }
+    });
+    /**
+     * outside clear via this method, with check current input state
+     */
+    useImperativeHandle(dialerContext.onClearRef, () => (e, reason) => {
+        // * when clear from keyboard,
+        // * must need re-focus, so not check,
+        if (reason !== 'keyboard') {
+            checkNotReFocus(reason);
+        }
+        scrollToPositionRef.current = 0;
+        onChange?.('');
+    }, [checkNotReFocus, onChange]);
+    /**
+     * outside delete value via this method, with check current input state
+     */
+    useImperativeHandle(dialerContext.onDeleteRef, () => (e, reason) => {
+        const elm = inputRef.current;
+        if (elm && value?.length) {
+            const isFocus = externalWindow.document.activeElement === elm;
+            let toPosition;
+            let toValue;
+            if (isFocus) {
+                const { position, isSelectRange } = getSelectionPosition(inputRef);
+                if (isSelectRange) {
+                    toPosition = position.start;
+                    toValue =
+                        value.slice(0, position.start) + value.slice(position.end);
+                }
+                else if (position.start > 0) {
+                    toPosition = position.start - 1;
+                    toValue = value.slice(0, toPosition) + value.slice(position.end);
+                }
+            }
+            else {
+                toPosition = value.length - 1;
+                toValue = value.slice(0, -1);
+            }
+            if (toValue !== undefined) {
+                // * when delete from keyboard and value to be empty,
+                // * must need re-focus, so not check,
+                if (!(reason === 'keyboard' && toValue === '')) {
+                    checkNotReFocus(reason);
+                }
+                scrollToPositionRef.current = toPosition;
+                onChange?.(toValue);
+            }
+        }
+    }, [checkNotReFocus, externalWindow, inputRef, onChange, value]);
+    /**
+     * outside change value via this method, with check current input state
+     */
+    useImperativeHandle(dialerContext.onInsertRef, () => (addValue, reason) => {
+        const elm = inputRef.current;
+        if (elm) {
+            const isFocus = externalWindow.document.activeElement === elm;
+            let toPosition;
+            let toValue;
+            // * when keypadMode also add value at latest
+            if (!isFocus || keypadMode) {
+                toValue = value + addValue;
+                toPosition = toValue.length;
+            }
+            else {
+                const { position } = getSelectionPosition(inputRef);
+                toValue =
+                    value.slice(0, position.start) +
+                        addValue +
+                        value.slice(position.end);
+                toPosition = position.start + 1;
+            }
+            if (maxLength === undefined ||
+                (maxLength !== undefined && toValue.length <= maxLength)) {
+                checkNotReFocus(reason, isFocus);
+                scrollToPositionRef.current = toPosition;
+                onChange?.(toValue);
+                onEmit?.(addValue, reason);
+            }
+        }
+    }, [
+        checkNotReFocus,
+        externalWindow,
+        inputRef,
+        keypadMode,
+        maxLength,
+        onChange,
+        onEmit,
+        value,
+    ]);
+    useLayoutEffect(() => {
+        const scrollToPosition = scrollToPositionRef.current;
+        if (!isNotTriggerRefocusRef.current && scrollToPosition !== undefined) {
+            setSelectionPosition(inputRef, {
+                start: scrollToPosition,
+                end: scrollToPosition,
+                scrollIntoView: true,
+            });
+        }
+        scrollToPositionRef.current = undefined;
+        isNotTriggerRefocusRef.current = false;
+    });
+    const events = useKeyDownOnce(ACCEPTABLE_KEYS, {
+        onKeyDown: (e) => {
+            playAudio(e.key);
+            if (keypadMode) {
+                if (['Delete', 'Backspace'].includes(e.key)) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                }
+                onKeypadModeKeyDown(e);
+            }
+            onKeyDown?.(e);
+        },
+        onKeyUp,
+    });
+    const { sleep } = useSleep();
+    const handleChange = useEventCallback((e) => {
+        const currValue = e.target.value;
+        // * handle copy paste
+        if (onlyAllowKeypadValue) {
+            const filterValue = (currValue.match(getDialPadValueOnlyRegex()) || []).join('');
+            if (filterValue === value)
+                return;
+            if (onEmit) {
+                const emitValues = filterValue.replace(value, '');
+                const valueArr = emitValues.split('');
+                if (valueArr.length > 1) {
+                    (async () => {
+                        for (let i = 0; i < valueArr.length; i++) {
+                            playAudio(valueArr[i]);
+                            onChange(value + valueArr.slice(0, i + 1).join(''));
+                            if (i !== valueArr.length - 1) {
+                                await sleep(300);
+                            }
+                            else {
+                                onEmit(emitValues, 'keyboard');
+                            }
+                        }
+                    })();
+                }
+                else {
+                    playAudio(valueArr[0]);
+                    onChange(filterValue);
+                    onEmit(emitValues, 'keyboard');
+                }
+                return;
+            }
+            onChange(filterValue);
+            return;
+        }
+        onChange(currValue);
+    });
+    const handleKeyPress = useEventCallback((e) => {
+        inputPropsProp?.onKeyPress?.(e);
+        if (onlyAllowKeypadValue) {
+            const isMatch = getDialPadValueOnlyRegex().test(e.key);
+            if (!isMatch) {
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        }
+    });
+    const inputProps = useMemo(() => combineProps({
+        onFocus: keypadMode ? onKeypadModeFocus : undefined,
+        onClick: keypadMode ? onKeypadModeClick : undefined,
+        onKeyPress: handleKeyPress,
+        onChange: handleChange,
+        onKeyDown: events.onKeyDown,
+        onKeyUp: events.onKeyUp,
+        maxLength,
+        // in dialer not need autoComplete
+        autoComplete: 'off',
+    }, inputPropsProp), [
+        keypadMode,
+        onKeypadModeFocus,
+        onKeypadModeClick,
+        handleKeyPress,
+        handleChange,
+        events.onKeyDown,
+        events.onKeyUp,
+        maxLength,
+        inputPropsProp,
+    ]);
+    return (jsx(TextField, { ref: ref, inputRef: forkInputRef, clearBtn: false, inputProps: inputProps, value: value, variant: "quiet", onChange: handleChange, ...rest }));
+});
+DialTextField.displayName = 'SuiDialTextField';
+
+const Dialer = ({ children }) => {
+    const dialPadActionRef = useRef(null);
+    const onInsertRef = useRef(null);
+    const inputRef = useRef(null);
+    const onDeleteRef = useRef(null);
+    const onClearRef = useRef(null);
+    return (jsx(DialerContext.Provider, { value: {
+            dialPadActionRef,
+            onInsertRef,
+            onDeleteRef,
+            inputRef,
+            onClearRef,
+        }, children: children }));
+};
+Dialer.displayName = 'SuiDialer';
+
+export { ACCEPTABLE_KEYS, DIALER_PAD_ICONS, DIALER_PAD_PLUS, DialDelete, DialPad, DialPadButton, DialTextField, Dialer, DialerContext, DialerPadSoundsMPEG, DialerPadSoundsOGG, DialPadButton$1 as dialPadButtonStyle, DialPad$1 as dialPadStyle, getDialPadValueOnlyRegex, useDialKeyboard, useDialerContext, useFixedEndSelection, useKeyAudio };