@enigma-lake/tower-play-controller-sdk 2.0.14 → 2.0.15

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import React, { createContext, useContext, useRef, useMemo, useCallback, useEffect, useState, Fragment as Fragment$1 } from 'react';
+import React, { createContext, useContext, useRef, useCallback, useEffect, useMemo, useState, Fragment as Fragment$1 } from 'react';
 import cx$1 from 'classnames';
 import { Currency, sendSetUserCurrencyEvent, sendSetUserCurrencyEventV2, setToggleGameWidgetsVisibility, setToggleGameWidgetsExpansion, getUserInformationEvent, EVENTS, sendOpenHighPlayModalEvent } from '@enigma-lake/zoot-platform-sdk';
 import { Menu, MenuButton, MenuItems, MenuItem, Switch as Switch$1 } from '@headlessui/react';
@@ -40,19 +40,8 @@ const format = (value, decimals) => {
     if (isNaN(num)) {
         return value;
     }
-    const raw = typeof value === "string" ? value.replace(/,/g, "") : num.toString();
-    const match = raw.match(/^(-?)(\d+)(?:\.(\d+))?$/);
-    const normalized = match ? raw : num.toFixed(decimals + 6);
-    const parts = normalized.split(".");
-    const sign = parts[0]?.startsWith("-") ? "-" : "";
-    const integerPart = parts[0]?.replace("-", "") ?? "0";
-    const fractionPart = parts[1] ?? "";
-    const truncatedFraction = fractionPart
-        .slice(0, decimals)
-        .padEnd(decimals, "0");
-    const truncated = Number(decimals > 0
-        ? `${sign}${integerPart}.${truncatedFraction}`
-        : `${sign}${integerPart}`);
+    const factor = Math.pow(10, decimals);
+    const truncated = Math.trunc(num * factor) / factor;
     return truncated.toLocaleString("en-US", {
         minimumFractionDigits: decimals,
         maximumFractionDigits: decimals,
@@ -71,6 +60,11 @@ var AUTO_PLAY_STATE;
     AUTO_PLAY_STATE["SELECTING"] = "selecting";
     AUTO_PLAY_STATE["PLAYING"] = "playing";
 })(AUTO_PLAY_STATE || (AUTO_PLAY_STATE = {}));
+var DOUBLE_OR_NOTHING_STATE;
+(function (DOUBLE_OR_NOTHING_STATE) {
+    DOUBLE_OR_NOTHING_STATE["IDLE"] = "idle";
+    DOUBLE_OR_NOTHING_STATE["PROGRESS"] = "progress";
+})(DOUBLE_OR_NOTHING_STATE || (DOUBLE_OR_NOTHING_STATE = {}));
 
 var WIDGET;
 (function (WIDGET) {
@@ -78,15 +72,64 @@ var WIDGET;
     WIDGET["SIDE"] = "side";
 })(WIDGET || (WIDGET = {}));
 
+const isManualCashoutDisabled = ({ disabledController, isPlaying, cashoutDisabled, }) => disabledController || !isPlaying || cashoutDisabled;
+const createManualCashoutClickHandler = ({ cashoutDisabled, onCashout, }) => {
+    return () => {
+        if (cashoutDisabled) {
+            return;
+        }
+        onCashout();
+    };
+};
+const canAutoplaySpaceTrigger = ({ state, cashoutDisabled, isDisabled, }) => {
+    return state === AUTO_PLAY_STATE.PLAYING ? !cashoutDisabled : !isDisabled;
+};
+const isAutoplayButtonDisabled = ({ state, cashoutDisabled, isDisabled, isValidPlayAmount, }) => {
+    return state === AUTO_PLAY_STATE.PLAYING
+        ? cashoutDisabled
+        : isDisabled || !isValidPlayAmount;
+};
+const createAutoplayButtonAction = ({ state, cashoutDisabled, onStopPlay, onPlay, }) => {
+    return () => {
+        if (state === AUTO_PLAY_STATE.PLAYING) {
+            if (cashoutDisabled) {
+                return;
+            }
+            onStopPlay();
+            return;
+        }
+        onPlay();
+    };
+};
+
 const AutoManualPlayStateContext = createContext(undefined);
 const useAutoManualPlayState = () => {
     const context = useContext(AutoManualPlayStateContext);
     if (!context) {
-        throw new Error("useAutoManualPlayStateState must be used within a AutoManualPlayStateProvider");
+        throw new Error("useAutoManualPlayState must be used within AutoManualPlayProvider");
     }
     return context;
 };
 
+const getNextPlayAmount = ({ currentAmount, defaultBetOptions, direction, }) => {
+    if (!defaultBetOptions.length) {
+        return currentAmount;
+    }
+    const sorted = [...defaultBetOptions].sort((a, b) => a - b);
+    const currentIndex = sorted.findIndex((value) => value === currentAmount);
+    if (currentIndex !== -1) {
+        const targetIndex = currentIndex + direction;
+        if (targetIndex >= 0 && targetIndex < sorted.length) {
+            return sorted[targetIndex];
+        }
+        return sorted[currentIndex];
+    }
+    sorted.push(currentAmount);
+    sorted.sort((a, b) => a - b);
+    const insertedIndex = sorted.indexOf(currentAmount);
+    return sorted[insertedIndex + direction] ?? currentAmount;
+};
+
 /**
  * Type guard: full mode (risk + autoplay enabled)
  *
@@ -100,7 +143,7 @@ function isFullMode(config) {
 const usePlayController = () => {
     const { config, autoPlay: { setNumberOfPlays, numberOfPlays, setPlayedRounds, playedRounds, selection, setState, state, }, playValues: { displayPlayAmountView, setDisplayPlayAmountView, togglePlayAmountView, }, } = useAutoManualPlayState();
     const { current } = config.currencyOptions;
-    const { isPlaying, canCashout, disabledController, playHook, totalBalance } = config.playOptions;
+    const { isPlaying, canCashout, disabledCashout = false, disabledController, playHook, totalBalance, } = config.playOptions;
     // --- Autoplay-related values only valid in full mode ---
     const autoplayEnabled = isFullMode(config);
     const showAutoPlayToast = autoplayEnabled
@@ -169,31 +212,15 @@ const usePlayController = () => {
         if (isDisabled()) {
             return;
         }
-        const opts = playLimits?.[current.code]?.defaultBetOptions ?? [];
-        if (!opts.length) {
+        const options = playLimits?.[current.code]?.defaultBetOptions ?? [];
+        if (!options.length) {
             return;
         }
-        // Ensure options sorted ascending
-        const sorted = [...opts].sort((a, b) => a - b);
-        const currentIndex = sorted.findIndex((o) => o === playAmount);
-        let newAmount;
-        if (currentIndex === -1) {
-            // If current isn't exactly in list, insert it logically
-            sorted.push(playAmount);
-            sorted.sort((a, b) => a - b);
-            const idx = sorted.indexOf(playAmount);
-            newAmount = sorted[idx + direction] ?? playAmount;
-        }
-        else {
-            const targetIdx = currentIndex + direction;
-            if (targetIdx >= 0 && targetIdx < sorted.length) {
-                newAmount = sorted[targetIdx];
-            }
-            else {
-                // clamp if out of bounds
-                newAmount = sorted[currentIndex];
-            }
-        }
+        const newAmount = getNextPlayAmount({
+            currentAmount: playAmount,
+            defaultBetOptions: options,
+            direction,
+        });
         setPlayAmount(newAmount);
     };
     const onChangeAmount = (playValue) => {
@@ -220,6 +247,7 @@ const usePlayController = () => {
             isDisabled,
             onPlay: config.onPlay,
             canCashout,
+            cashoutDisabled: disabledCashout,
         },
         // autoplay
         autoPlay: {
@@ -227,6 +255,7 @@ const usePlayController = () => {
             state,
             onPlay: handleAutoPlay,
             onStopPlay: stopAutoplay,
+            cashoutDisabled: disabledCashout,
         },
         // UI state for play amount view
         playValues: {
@@ -237,7 +266,7 @@ const usePlayController = () => {
     };
 };
 
-var styles_button = {"base":"Button-module__base___muNxk","base__theme-ghost":"Button-module__base__theme-ghost___I5-LJ","base__theme-primary":"Button-module__base__theme-primary___Zuswb","base__state-disabled":"Button-module__base__state-disabled___EU5tH","buttonPlayAmount":"Button-module__buttonPlayAmount___GMy3F","buttonCashout":"Button-module__buttonCashout___LG-Yr","buttonPlayAmount__active":"Button-module__buttonPlayAmount__active___e0nGe","buttonCashout__active":"Button-module__buttonCashout__active___qnE3h","buttonSweeps":"Button-module__buttonSweeps___0snDQ","buttonSweeps__active":"Button-module__buttonSweeps__active___PXIFH","buttonGold":"Button-module__buttonGold___DAj-d","buttonGold__active":"Button-module__buttonGold__active___vsi7m","buttonDefault":"Button-module__buttonDefault___QENXy","buttonDefault__active":"Button-module__buttonDefault__active___oS6gd"};
+var styles_button = {"base":"Button-module__base___muNxk","base__theme-ghost":"Button-module__base__theme-ghost___I5-LJ","base__theme-primary":"Button-module__base__theme-primary___Zuswb","base__state-disabled":"Button-module__base__state-disabled___EU5tH","buttonPlayAmount":"Button-module__buttonPlayAmount___GMy3F","buttonCashout":"Button-module__buttonCashout___LG-Yr","buttonPlayAmount__active":"Button-module__buttonPlayAmount__active___e0nGe","buttonCashout__active":"Button-module__buttonCashout__active___qnE3h","buttonSweeps":"Button-module__buttonSweeps___0snDQ","buttonSweeps__active":"Button-module__buttonSweeps__active___PXIFH","buttonGold":"Button-module__buttonGold___DAj-d","buttonGold__active":"Button-module__buttonGold__active___vsi7m","buttonDefault":"Button-module__buttonDefault___QENXy","buttonDefault__active":"Button-module__buttonDefault__active___oS6gd","buttonDON":"Button-module__buttonDON___ROWdX","buttonDON__active":"Button-module__buttonDON__active___QeoiQ","buttonDON__disabled":"Button-module__buttonDON__disabled___98v7-","buttonDON__title":"Button-module__buttonDON__title___sbNMd","buttonDON__subtitle":"Button-module__buttonDON__subtitle___sgpdf","buttonDON__content":"Button-module__buttonDON__content___sJ-pz","buttonRow":"Button-module__buttonRow___gYuQ0","buttonRow__cashout":"Button-module__buttonRow__cashout___8QZ-4","buttonRow__don":"Button-module__buttonRow__don___tYZKN"};
 
 const themes = {
     primary: "primary",
@@ -348,57 +377,45 @@ const PlayAmountControl = ({ isDisabled }) => {
                     state === AUTO_PLAY_STATE.PLAYING, onClick: handleTogglePlayAmount, children: jsx(SelectMenu, { disabled: isDisabled() }) }), jsx(Button, { className: styles_group.groupItem, onClick: () => adjustPlayAmount({ direction: -1 }), theme: "ghost", disabled: isDisabled(), children: jsx("span", { className: styles_group.x2, children: "-" }) }), jsx(Button, { className: styles_group.groupItem, onClick: () => adjustPlayAmount({ direction: 1 }), theme: "ghost", disabled: isDisabled(), children: jsx("span", { className: cx$1(styles_group.x2, styles_group.last), children: "+" }) })] }));
 };
 
+const getDefaultButtonClassName = (currencyCode, styles) => {
+    if (currencyCode === Currency.GOLD) {
+        return styles.buttonGold;
+    }
+    if (currencyCode === Currency.SWEEPS) {
+        return styles.buttonSweeps;
+    }
+    return styles.buttonDefault;
+};
+const getActiveButtonClassName = (currencyCode, styles) => {
+    if (currencyCode === Currency.GOLD) {
+        return styles.buttonGold__active;
+    }
+    if (currencyCode === Currency.SWEEPS) {
+        return styles.buttonSweeps__active;
+    }
+    return styles.buttonDefault__active;
+};
+
 var AUTOPLAY_LABEL;
 (function (AUTOPLAY_LABEL) {
     AUTOPLAY_LABEL["START"] = "START AUTOPLAY";
     AUTOPLAY_LABEL["STOP"] = "STOP AUTOPLAY";
 })(AUTOPLAY_LABEL || (AUTOPLAY_LABEL = {}));
 
-const AutoPlayController = () => {
-    const { config } = useAutoManualPlayState();
-    const { isValidPlayAmount, playValues: { displayPlayAmountView, togglePlayAmountView }, autoPlay: { isDisabled, state, onPlay, onStopPlay }, } = usePlayController();
-    const { current } = config.currencyOptions;
-    const roleButton = GAME_MODE.AUTOPLAY;
-    const buttonLabel = state === AUTO_PLAY_STATE.PLAYING
-        ? AUTOPLAY_LABEL.STOP
-        : AUTOPLAY_LABEL.START;
-    const activeClassName = useMemo(() => {
-        if (current.code === Currency.GOLD) {
-            return styles_button.buttonGold__active;
-        }
-        if (current.code === Currency.SWEEPS) {
-            return styles_button.buttonSweeps__active;
-        }
-        return styles_button.buttonDefault__active;
-    }, [current.code]);
-    const defaultClassName = useMemo(() => {
-        if (buttonLabel === AUTOPLAY_LABEL.STOP) {
-            return styles_button.buttonCashout;
-        }
-        if (current.code === Currency.GOLD) {
-            return styles_button.buttonGold;
-        }
-        if (current.code === Currency.SWEEPS) {
-            return styles_button.buttonSweeps;
-        }
-        return styles_button.buttonDefault;
-    }, [buttonLabel, current.code]);
+const useSpacebarButtonTrigger = ({ roleButton, activeClassName, canTrigger, }) => {
     const handleKeyPress = useCallback((event) => {
         if (event.code !== "Space") {
             return;
         }
         const button = selectButton(roleButton);
-        if (!button) {
+        if (!button || !canTrigger()) {
             return;
         }
         event.preventDefault();
         event.stopPropagation();
-        const canTrigger = !isDisabled() || state === AUTO_PLAY_STATE.PLAYING;
-        if (canTrigger) {
-            addPressedClass(roleButton, activeClassName);
-            button.click();
-        }
-    }, [activeClassName, isDisabled, roleButton, state]);
+        addPressedClass(roleButton, activeClassName);
+        button.click();
+    }, [activeClassName, canTrigger, roleButton]);
     const handleKeyUp = useCallback((event) => {
         if (event.code !== "Space") {
             return;
@@ -419,10 +436,44 @@ const AutoPlayController = () => {
             window.removeEventListener("keyup", handleKeyUp, true);
         };
     }, [handleKeyPress, handleKeyUp]);
-    const isButtonDisabled = state === AUTO_PLAY_STATE.PLAYING
-        ? false
-        : isDisabled() || !isValidPlayAmount;
-    const buttonAction = state === AUTO_PLAY_STATE.PLAYING ? onStopPlay : onPlay;
+};
+
+const AutoPlayController = () => {
+    const { config } = useAutoManualPlayState();
+    const { isValidPlayAmount, playValues: { displayPlayAmountView, togglePlayAmountView }, autoPlay: { isDisabled, state, onPlay, onStopPlay, cashoutDisabled }, } = usePlayController();
+    const { current } = config.currencyOptions;
+    const roleButton = GAME_MODE.AUTOPLAY;
+    const buttonLabel = state === AUTO_PLAY_STATE.PLAYING
+        ? AUTOPLAY_LABEL.STOP
+        : AUTOPLAY_LABEL.START;
+    const activeClassName = getActiveButtonClassName(current.code, styles_button);
+    const defaultClassName = useMemo(() => {
+        if (buttonLabel === AUTOPLAY_LABEL.STOP) {
+            return styles_button.buttonCashout;
+        }
+        return getDefaultButtonClassName(current.code, styles_button);
+    }, [buttonLabel, current.code]);
+    useSpacebarButtonTrigger({
+        roleButton,
+        activeClassName,
+        canTrigger: () => canAutoplaySpaceTrigger({
+            state,
+            cashoutDisabled,
+            isDisabled: isDisabled(),
+        }),
+    });
+    const isButtonDisabled = isAutoplayButtonDisabled({
+        state,
+        cashoutDisabled,
+        isDisabled: isDisabled(),
+        isValidPlayAmount,
+    });
+    const buttonAction = useMemo(() => createAutoplayButtonAction({
+        state,
+        cashoutDisabled,
+        onStopPlay,
+        onPlay,
+    }), [cashoutDisabled, onPlay, onStopPlay, state]);
     const handleTogglePlayAmount = useCallback(() => {
         setToggleGameWidgetsVisibility();
         togglePlayAmountView();
@@ -468,80 +519,71 @@ const useIsRunningExternal = () => {
 };
 
 const ManualPlayController = () => {
-    const { config } = useAutoManualPlayState();
+    const { config, doubleOrNothing } = useAutoManualPlayState();
     const { isRunningExternal } = useIsRunningExternal();
-    const { isValidPlayAmount, playValues: { displayPlayAmountView, togglePlayAmountView }, manualPlay: { isDisabled, onPlay, canCashout }, } = usePlayController();
+    const { isValidPlayAmount, playValues: { displayPlayAmountView, togglePlayAmountView }, manualPlay: { isDisabled, onPlay, canCashout, cashoutDisabled }, } = usePlayController();
     const { current } = config.currencyOptions;
     const roleButton = GAME_MODE.MANUAL;
-    const activeClassName = useMemo(() => {
-        if (current.code === Currency.GOLD) {
-            return styles_button.buttonGold__active;
-        }
-        if (current.code === Currency.SWEEPS) {
-            return styles_button.buttonSweeps__active;
-        }
-        return styles_button.buttonDefault__active;
-    }, [current.code]);
-    const defaultClassName = useMemo(() => {
-        if (current.code === Currency.GOLD) {
-            return styles_button.buttonGold;
-        }
-        if (current.code === Currency.SWEEPS) {
-            return styles_button.buttonSweeps;
-        }
-        return styles_button.buttonDefault;
-    }, [current.code]);
-    const handleKeyPress = useCallback((event) => {
-        if (event.code !== "Space") {
-            return;
-        }
-        const button = selectButton(roleButton);
-        if (!button || isDisabled()) {
-            return;
-        }
-        event.preventDefault();
-        event.stopPropagation();
-        addPressedClass(roleButton, activeClassName);
-        button.click();
-    }, [roleButton, isDisabled, activeClassName]);
-    const handleKeyUp = useCallback((event) => {
-        if (event.code !== "Space") {
-            return;
-        }
-        const button = selectButton(roleButton);
-        if (!button) {
-            return;
-        }
-        event.preventDefault();
-        event.stopPropagation();
-        removePressedClass(roleButton, activeClassName);
-    }, [roleButton, activeClassName]);
-    useEffect(() => {
-        window.addEventListener("keydown", handleKeyPress, true);
-        window.addEventListener("keyup", handleKeyUp, true);
-        return () => {
-            window.removeEventListener("keydown", handleKeyPress, true);
-            window.removeEventListener("keyup", handleKeyUp, true);
-        };
-    }, [handleKeyPress, handleKeyUp]);
+    const activeClassName = getActiveButtonClassName(current.code, styles_button);
+    const defaultClassName = getDefaultButtonClassName(current.code, styles_button);
+    useSpacebarButtonTrigger({
+        roleButton,
+        activeClassName,
+        canTrigger: () => !isDisabled(),
+    });
     const isButtonDisabled = isDisabled() || !isValidPlayAmount;
     const handleTogglePlayAmount = useCallback(() => {
         setToggleGameWidgetsVisibility();
         togglePlayAmountView();
         setToggleGameWidgetsExpansion();
     }, [togglePlayAmountView]);
+    const handleDoubleOrNothingClick = useCallback(() => {
+        if (config.playOptions.disabledController) {
+            return;
+        }
+        if (!config.doubleOrNothing?.display) {
+            return;
+        }
+        if (config.doubleOrNothing?.disabled) {
+            return;
+        }
+        doubleOrNothing.startDoubleOrNothing();
+    }, [
+        config.playOptions.disabledController,
+        config.doubleOrNothing?.display,
+        config.doubleOrNothing?.disabled,
+        doubleOrNothing,
+    ]);
+    const handleCashoutClick = useMemo(() => createManualCashoutClickHandler({
+        cashoutDisabled,
+        onCashout: config.onCashout,
+    }), [cashoutDisabled, config.onCashout]);
     const renderButton = useMemo(() => {
         if (displayPlayAmountView) {
             return (jsx(Button, { className: styles_button.buttonPlayAmount, onClick: handleTogglePlayAmount, roleType: roleButton, children: "SELECT PLAY AMOUNT" }));
         }
         if (canCashout) {
-            return (jsxs(Button, { disabled: config.playOptions.disabledController ||
-                    !config.playOptions.isPlaying, className: styles_button.buttonCashout, onClick: config.onCashout, roleType: roleButton, children: [isRunningExternal ? "COLLECT" : "CASHOUT", " ", format(current.possibleWin ?? 0, current.decimals), " ", current.abbr] }));
+            const isCashoutDisabled = isManualCashoutDisabled({
+                disabledController: config.playOptions.disabledController,
+                isPlaying: config.playOptions.isPlaying,
+                cashoutDisabled,
+            });
+            const showDoubleOrNothing = !!config.doubleOrNothing?.display;
+            const isDoubleOrNothingDisabled = isCashoutDisabled ||
+                !!config.doubleOrNothing?.disabled ||
+                doubleOrNothing.state === DOUBLE_OR_NOTHING_STATE.PROGRESS;
+            return (jsxs("div", { className: styles_button.buttonRow, children: [jsxs(Button, { disabled: isCashoutDisabled, className: cx$1(styles_button.buttonCashout, {
+                            [styles_button.buttonRow__cashout]: showDoubleOrNothing,
+                        }), onClick: handleCashoutClick, roleType: roleButton, children: [isRunningExternal ? "COLLECT" : "CASHOUT", " ", format(current.possibleWin ?? 0, current.decimals), " ", current.abbr] }), showDoubleOrNothing ? (jsx(Button, { disabled: isDoubleOrNothingDisabled, className: cx$1(styles_button.buttonDON, styles_button.buttonRow__don, {
+                            [styles_button.buttonDON__disabled]: isDoubleOrNothingDisabled,
+                        }), onClick: handleDoubleOrNothingClick, roleType: roleButton, children: jsxs("div", { className: styles_button.buttonDON__content, children: [jsx("p", { className: styles_button.buttonDON__title, children: "DOUBLE" }), jsx("p", { className: styles_button.buttonDON__subtitle, children: "OR NOTHING" })] }) })) : null] }));
         }
         return (jsx(Button, { disabled: isButtonDisabled, className: defaultClassName, onClick: onPlay, roleType: roleButton, children: "PLAY NOW" }));
     }, [
         canCashout,
-        config.onCashout,
+        cashoutDisabled,
+        config.doubleOrNothing?.disabled,
+        config.doubleOrNothing?.display,
         config.playOptions.disabledController,
         config.playOptions.isPlaying,
         current.abbr,
@@ -549,11 +591,14 @@ const ManualPlayController = () => {
         current.possibleWin,
         defaultClassName,
         displayPlayAmountView,
+        doubleOrNothing.state,
+        handleDoubleOrNothingClick,
+        handleCashoutClick,
         handleTogglePlayAmount,
         isButtonDisabled,
+        isRunningExternal,
         onPlay,
         roleButton,
-        isRunningExternal,
     ]);
     return (jsxs(Fragment, { children: [jsx(PlayAmountControl, { isDisabled: isDisabled || displayPlayAmountView }), renderButton] }));
 };
@@ -838,11 +883,16 @@ const PlayValueList = () => {
 const AutoManualPlayProvider = ({ children, config, }) => {
     const [mode, setMode] = useState(GAME_MODE.MANUAL);
     const [autoplayState, setAutoplayState] = useState(AUTO_PLAY_STATE.IDLE);
+    const [doubleOrNothingState, setDoubleOrNothingState] = useState(DOUBLE_OR_NOTHING_STATE.IDLE);
     const [isAutoPlaying, setIsAutoPlaying] = useState(false);
     const [playedRounds, setPlayedRounds] = useState(0);
     const [numberOfPlays, setNumberOfPlays] = useState(AUTOPLAY_DEFAULT_PLAY_ROUNDS_COUNT);
     const [selection, setSelection] = useState([]);
     const [displayPlayAmountView, setDisplayPlayAmountView] = useState(false);
+    const isControllerDisabled = config.playOptions.disabledController;
+    const isGamePlaying = config.playOptions.isPlaying;
+    const isAutoplayPlaying = autoplayState === AUTO_PLAY_STATE.PLAYING;
+    const isSimplified = config.withoutRiskAndAutoplay === true;
     const togglePlayAmountView = useCallback(() => {
         setDisplayPlayAmountView((v) => !v);
     }, []);
@@ -857,6 +907,20 @@ const AutoManualPlayProvider = ({ children, config, }) => {
         setAutoplayState(AUTO_PLAY_STATE.IDLE);
         setIsAutoPlaying(false);
     }, []);
+    const startDoubleOrNothing = useCallback(() => {
+        if (config.doubleOrNothing?.disabled) {
+            return null;
+        }
+        setDoubleOrNothingState(DOUBLE_OR_NOTHING_STATE.PROGRESS);
+        config.doubleOrNothing?.onDoubleOrNothingOpen();
+    }, [config.doubleOrNothing]);
+    const stopDoubleOrNothing = useCallback(() => {
+        if (config.doubleOrNothing?.disabled) {
+            return null;
+        }
+        setDoubleOrNothingState(DOUBLE_OR_NOTHING_STATE.IDLE);
+        config.doubleOrNothing?.onDoubleOrNothingClose();
+    }, [config.doubleOrNothing]);
     const updateAutoplayState = useCallback((newState) => setAutoplayState(newState), []);
     const playManualMode = useCallback(() => {
         setMode(GAME_MODE.MANUAL);
@@ -864,20 +928,19 @@ const AutoManualPlayProvider = ({ children, config, }) => {
     }, []);
     const resetState = useCallback(() => {
         setMode(GAME_MODE.MANUAL);
+        setDoubleOrNothingState(DOUBLE_OR_NOTHING_STATE.IDLE);
         setAutoplayState(AUTO_PLAY_STATE.IDLE);
         setPlayedRounds(0);
         setNumberOfPlays(0);
         setSelection([]);
     }, []);
     const toggleMode = useCallback(() => {
-        if (config.playOptions.isPlaying ||
-            config.playOptions.disabledController ||
-            autoplayState === AUTO_PLAY_STATE.PLAYING) {
+        if (isGamePlaying || isControllerDisabled || isAutoplayPlaying) {
             return;
         }
         setNumberOfPlays(AUTOPLAY_DEFAULT_PLAY_ROUNDS_COUNT);
         setMode((prevMode) => prevMode === GAME_MODE.MANUAL ? GAME_MODE.AUTOPLAY : GAME_MODE.MANUAL);
-    }, [autoplayState, config.playOptions]);
+    }, [isAutoplayPlaying, isControllerDisabled, isGamePlaying]);
     const updateSelection = useCallback((values) => {
         if (!isAutoPlaying) {
             setSelection(values);
@@ -886,6 +949,7 @@ const AutoManualPlayProvider = ({ children, config, }) => {
     const contextValue = useMemo(() => ({
         mode,
         config,
+        withoutRiskAndAutoplay: config.withoutRiskAndAutoplay,
         manual: { playManualMode },
         autoPlay: {
             state: autoplayState,
@@ -902,6 +966,11 @@ const AutoManualPlayProvider = ({ children, config, }) => {
             setNumberOfPlays,
             setState: setAutoplayState,
         },
+        doubleOrNothing: {
+            state: doubleOrNothingState,
+            startDoubleOrNothing,
+            stopDoubleOrNothing,
+        },
         reset: resetState,
         toggleMode,
         playValues: {
@@ -922,12 +991,14 @@ const AutoManualPlayProvider = ({ children, config, }) => {
         stopAutoplay,
         updateSelection,
         updateAutoplayState,
+        doubleOrNothingState,
+        startDoubleOrNothing,
+        stopDoubleOrNothing,
         resetState,
         toggleMode,
         displayPlayAmountView,
         togglePlayAmountView,
     ]);
-    const isSimplified = config.withoutRiskAndAutoplay === true;
     return (jsxs(AutoManualPlayStateContext.Provider, { value: contextValue, children: [typeof children === "function" ? children(contextValue) : children, config.playOptions.displayController && (jsx("div", { className: cx$1(styles_ui.base, styles_ui.betForm), style: {
                     "--play-bottom": config.panel.bottom ?? 0,
                     "--play-panel-bg": hexToRgb(config.panel.bgColorHex ?? "#01243A"),
@@ -935,19 +1006,16 @@ const AutoManualPlayProvider = ({ children, config, }) => {
                     "--play-panel-bg-opacity": config.panel.bgColorOpacity ?? 0.5,
                 }, children: jsxs("div", { className: cx$1(styles_ui.container), children: [jsx(PlayValueList, {}), !isSimplified ? (jsxs("div", { className: cx$1(styles_ui.auto), children: [jsx(DifficultySelector, { playOptions: {
                                         ...config.playOptions,
-                                        disabledMenu: config.playOptions.disabledController ||
-                                            config.playOptions.disabledMenu,
-                                    }, dropdownConfig: config.dropdown }), jsx(InputWithSwitch, { value: numberOfPlays === Infinity ? 0 : numberOfPlays, type: "number", onChange: (e) => setNumberOfPlays(Number(e.currentTarget.value)), placeholder: "Number of Plays", min: 0, max: 99, disabled: config.playOptions.disabledController ||
-                                        mode === GAME_MODE.MANUAL, switcherConfig: {
+                                        disabledMenu: isControllerDisabled || config.playOptions.disabledMenu,
+                                    }, dropdownConfig: config.dropdown }), jsx(InputWithSwitch, { value: numberOfPlays === Infinity ? 0 : numberOfPlays, type: "number", onChange: (e) => setNumberOfPlays(Number(e.currentTarget.value)), placeholder: "Number of Plays", min: 0, max: 99, disabled: isControllerDisabled || mode === GAME_MODE.MANUAL, switcherConfig: {
                                         onSwitch: toggleMode,
-                                        isPlaying: isAutoPlaying || config.playOptions.isPlaying,
+                                        isPlaying: isAutoPlaying || isGamePlaying,
                                         enabled: mode !== GAME_MODE.MANUAL,
-                                        disabled: config.playOptions.disabledController ||
-                                            autoplayState === AUTO_PLAY_STATE.PLAYING,
+                                        disabled: isControllerDisabled || isAutoplayPlaying,
                                     }, children: jsx("span", { className: cx$1({
                                             [styles_ui.disabled]: mode !== GAME_MODE.AUTOPLAY ||
                                                 numberOfPlays !== Infinity ||
-                                                autoplayState === AUTO_PLAY_STATE.PLAYING,
+                                                isAutoplayPlaying,
                                         }), children: "\u221E" }) })] })) : null, mode === GAME_MODE.MANUAL ? (jsx(ManualPlayController, {})) : (jsx(AutoPlayController, {})), jsx(WidgetContainer, { state: autoplayState, displayPlayAmountView: displayPlayAmountView, widgets: {
                                 left: config.leftWidgets,
                                 center: config.centerWidgets,
@@ -955,5 +1023,5 @@ const AutoManualPlayProvider = ({ children, config, }) => {
                             } })] }) }))] }));
 };
 
-export { AUTO_PLAY_STATE, AutoManualPlayProvider, GAME_MODE, WIDGET, format };
+export { AUTO_PLAY_STATE, AutoManualPlayProvider, DOUBLE_OR_NOTHING_STATE, GAME_MODE, WIDGET, canAutoplaySpaceTrigger, createAutoplayButtonAction, createManualCashoutClickHandler, format, isAutoplayButtonDisabled, isManualCashoutDisabled };
 //# sourceMappingURL=index.mjs.map