@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/stores/ui_store.js

@@ -0,0 +1,496 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import "../../../js/4101.js";
+import { signals_core_module_r, signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { snakify } from "../../../src/utils.js";
+import "../../telemetry/index.js";
+import { REPLICA_NAMES, MARKETING_PIPER_REPLICA_ID } from "../constants.js";
+import { createAllowedConversationModeSignal } from "../signals/allowed_conversation_mode_signal.js";
+import { createLayoutSignal } from "../signals/layout_signal.js";
+import { extractPersistedUIState, createUIStateSignal } from "../signals/ui_state_signal.js";
+import { withFlipAnimation } from "../utils/flip_animation.js";
+import { isMobile } from "../utils/media_queries.js";
+import { ConversationMode as types_ConversationMode, LoadingState as types_LoadingState, OpenedDisplayMode as types_OpenedDisplayMode, DisplayMode as types_DisplayMode, MaximizedState as types_MaximizedState, InitialDisplayMode as types_InitialDisplayMode } from "../types.js";
+import { BaseStore } from "./base_store.js";
+import { metrics } from "../../telemetry/metrics.js";
+
+const debounce = __webpack_require__("37753");
+var debounce_default = /*#__PURE__*/__webpack_require__.n(debounce);
+const isMatch = __webpack_require__("45349");
+var isMatch_default = /*#__PURE__*/__webpack_require__.n(isMatch);
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+const REDIRECT_DISMISSED_UI_STATE_KEY = "__qualified_redirect_dismissed_ui_state";
+const REDIRECT_DISMISSED_UI_STATE_TTL_MS = 30000;
+const VALID_DISPLAY_MODES = new Set(Object.values(types_DisplayMode));
+class UIStore extends BaseStore {
+    // --- Derived ---
+    get displayMode() {
+        return this.uiState.displayMode;
+    }
+    get openedDisplayMode() {
+        return this.uiState.openedDisplayMode;
+    }
+    get conversationMode() {
+        return this.uiState.conversationMode;
+    }
+    get input() {
+        return this.uiState.input;
+    }
+    get artifact() {
+        return this.uiState.artifact;
+    }
+    get userHasIgnoredMultimodal() {
+        return this.uiState.userHasIgnoredMultimodal;
+    }
+    persistRedirectDismissedUIState() {
+        var _persistedUIState_displayMode;
+        this.visitor.setMultimodalRedirectDismissalWithExpiry(REDIRECT_DISMISSED_UI_STATE_TTL_MS);
+        const persistedUIState = extractPersistedUIState(this.uiState.peek());
+        this.writeRedirectDismissedUIState({
+            displayMode: (_persistedUIState_displayMode = persistedUIState.displayMode) != null ? _persistedUIState_displayMode : this.displayMode.peek(),
+            userHasDismissed: persistedUIState.userHasDismissed,
+            userHasIgnoredMultimodal: persistedUIState.userHasIgnoredMultimodal,
+            expiresAt: this.currentTimeMs() + REDIRECT_DISMISSED_UI_STATE_TTL_MS
+        });
+    }
+    consumeRedirectDismissedUIState() {
+        const state = this.peekRedirectDismissedUIState();
+        this.writeRedirectDismissedUIState(null);
+        if (state) {
+            this.visitor.clearMultimodalRedirectDismissal();
+            const uiState = {
+                displayMode: state.displayMode
+            };
+            if (typeof state.userHasDismissed === "boolean") {
+                uiState.userHasDismissed = state.userHasDismissed;
+            }
+            if (typeof state.userHasIgnoredMultimodal === "boolean") {
+                uiState.userHasIgnoredMultimodal = state.userHasIgnoredMultimodal;
+            }
+            return uiState;
+        }
+        if (!this.visitor.hasPendingMultimodalRedirectDismissal) return null;
+        this.visitor.clearMultimodalRedirectDismissal();
+        return {
+            displayMode: types_DisplayMode.CLOSED,
+            userHasDismissed: true
+        };
+    }
+    hasPendingRedirectDismissedUIState() {
+        return this.peekRedirectDismissedUIState() != null || this.visitor.hasPendingMultimodalRedirectDismissal;
+    }
+    readRedirectDismissedUIState() {
+        try {
+            const raw = window.sessionStorage.getItem(REDIRECT_DISMISSED_UI_STATE_KEY);
+            if (!raw) return null;
+            const state = this.parseRedirectDismissedUIState(JSON.parse(raw));
+            if (state) return state;
+        } catch (unused) {
+        // Ignore malformed session state and fall back to the visitor-scoped dismissal flag.
+        }
+        this.writeRedirectDismissedUIState(null);
+        return null;
+    }
+    peekRedirectDismissedUIState() {
+        const state = this.readRedirectDismissedUIState();
+        if (!state) return null;
+        if (state.expiresAt < this.currentTimeMs()) {
+            this.writeRedirectDismissedUIState(null);
+            return null;
+        }
+        return state;
+    }
+    writeRedirectDismissedUIState(state) {
+        try {
+            if (state) {
+                window.sessionStorage.setItem(REDIRECT_DISMISSED_UI_STATE_KEY, JSON.stringify(state));
+            } else {
+                window.sessionStorage.removeItem(REDIRECT_DISMISSED_UI_STATE_KEY);
+            }
+        } catch (unused) {
+        // Ignore storage failures; server persistence still handles non-redirect cases.
+        }
+    }
+    parseRedirectDismissedUIState(raw) {
+        if (!raw || typeof raw !== "object") return null;
+        const state = raw;
+        if (!Number.isFinite(state.expiresAt) || !VALID_DISPLAY_MODES.has(state.displayMode)) {
+            return null;
+        }
+        const parsedState = {
+            displayMode: state.displayMode,
+            expiresAt: state.expiresAt
+        };
+        if (typeof state.userHasDismissed === "boolean") {
+            parsedState.userHasDismissed = state.userHasDismissed;
+        }
+        if (typeof state.userHasIgnoredMultimodal === "boolean") {
+            parsedState.userHasIgnoredMultimodal = state.userHasIgnoredMultimodal;
+        }
+        return parsedState;
+    }
+    currentTimeMs() {
+        return this.visitor.widget.dateProvider.now();
+    }
+    constructor(rootStore){
+        super(rootStore), this.rootStore = rootStore, this.uiState = createUIStateSignal(this.rootStore), this.layout = createLayoutSignal(this.rootStore), this.maximizedState = withFlipAnimation(signals_core_module_d(types_MaximizedState.NONE)), this.initialDisplayMode = signals_core_module_d(types_InitialDisplayMode.COLLAPSED_CENTER), this.launcherImageUrl = signals_core_module_d(null), this.orbConfig = signals_core_module_d(null), this.demoFeatures = signals_core_module_d(null), this.previewVideoSrc = signals_core_module_d(null), this.selectedReplicaId = signals_core_module_d(null), this.allowedConversationModes = createAllowedConversationModeSignal(this.rootStore), this.allowVoiceVideoToggle = signals_core_module_w(()=>{
+            var _ref;
+            var _this_demoFeatures_value;
+            const modality = this.rootStore.modalityPreference.value;
+            if (modality === "video" || modality === "voice" || modality === "text") return false;
+            if (!this.allowedConversationModes.video.value) return false;
+            return (_ref = (_this_demoFeatures_value = this.demoFeatures.value) == null ? void 0 : _this_demoFeatures_value.allowVoiceVideoToggle) != null ? _ref : false;
+        }), this.previewVideoConfig = signals_core_module_w(()=>{
+            var _REPLICA_NAMES_replicaId;
+            const src = this.previewVideoSrc.value;
+            if (!src) return null;
+            const isAnam = this.rootStore.featureFlags.piperXAnam;
+            const replicaId = this.selectedReplicaId.value;
+            // Custom replicas aren't in REPLICA_NAMES — fall back to the external id so
+            // the cache key matches what AssetsPreloader wrote for it.
+            const name = isAnam ? "anam" : replicaId ? (_REPLICA_NAMES_replicaId = REPLICA_NAMES[replicaId]) != null ? _REPLICA_NAMES_replicaId : replicaId : REPLICA_NAMES["default"];
+            const loopStart = name === "Piper" || name === "piper-anim" || name === "piper-informatica" || replicaId === MARKETING_PIPER_REPLICA_ID ? 3 : null;
+            return {
+                name,
+                src,
+                loopStart
+            };
+        }), this.isPiP = signals_core_module_w(()=>{
+            const adapter = this.rootStore.getCallUiAdapter();
+            const isInCall = adapter.state.isInCall.value || adapter.state.isVideoLoading.value;
+            return isInCall && this.rootStore.displayMode.closed.value;
+        }), this.setUIState = (uiState)=>{
+            const validatedUIState = this.validateUIState(_extends({}, this.uiState.value, uiState));
+            if (isMatch_default()(this.uiState.value, validatedUIState)) {
+                return;
+            }
+            this.uiState.value = validatedUIState;
+            this.saveUIState();
+        }, this.ensureValidUIState = ()=>{
+            this.setUIState(_extends({}, this.uiState.value));
+        }, this.setDisplayMode = (displayMode)=>{
+            signals_core_module_r(()=>{
+                // Entering DOCKED must also remember it as the opened position, else
+                // closing then reopening falls back to a stale SIDEBAR and the pinned chat
+                // reopens floating. Only the DOCKED direction is synced: nothing flips a
+                // live widget DOCKED→SIDEBAR, so a genuine SIDEBAR preference is kept.
+                const uiState = displayMode === types_DisplayMode.DOCKED ? {
+                    displayMode,
+                    openedDisplayMode: types_OpenedDisplayMode.DOCKED
+                } : {
+                    displayMode
+                };
+                this.setUIState(uiState);
+            });
+        }, /**
+   * Persists the position the widget reopens to (SIDEBAR or DOCKED) when it is
+   * next expanded from a minimized state via setOpenedDisplayMode. Stored on the
+   * persisted uiState so the choice survives a page refresh.
+   */ this.updateOpenedDisplayMode = (openedDisplayMode)=>{
+            this.setUIState({
+                openedDisplayMode
+            });
+        }, /**
+   * Expands the widget to the opened display mode (SIDEBAR or DOCKED based on theme config).
+   */ this.setOpenedDisplayMode = ()=>{
+            if (this.displayMode.minimized.value) {
+                const targetMode = this.openedDisplayMode.value === types_OpenedDisplayMode.DOCKED ? types_DisplayMode.DOCKED : types_DisplayMode.SIDEBAR;
+                this.setDisplayMode(targetMode);
+            }
+        }, this.setConversationMode = (conversationMode)=>{
+            this.setUIState({
+                conversationMode
+            });
+        }, /**
+   * Toggles between VIDEO and VOICE conversation modes.
+   * Also handles camera state: turns camera off when entering voice mode,
+   * turns camera on when entering video mode.
+   */ this.toggleVideoMode = (mode)=>{
+            if (mode === this.conversationMode.value) {
+                return;
+            }
+            this.setConversationMode(mode);
+        }, /**
+   * Sets the maximized state.
+   */ this.setMaximizedState = (state)=>{
+            if (state === this.maximizedState.peek()) {
+                return;
+            }
+            this.maximizedState.value = state;
+            if (state !== types_MaximizedState.ARTIFACT && this.rootStore.artifact.messageId.peek()) {
+                this.setUIState({
+                    artifactMessageId: null
+                });
+            }
+        }, /**
+   * Clears the maximized state.
+   */ this.clearMaximizedState = (param)=>{
+            let { when } = param === void 0 ? {} : param;
+            if (!when || this.maximizedState.peek() === when) {
+                this.setMaximizedState(types_MaximizedState.NONE);
+            }
+        }, /**
+   * Resets the widget to the initial display mode from theme config.
+   */ this.resetToStartingPosition = ()=>{
+            const initial = this.initialDisplayMode.value;
+            switch(initial){
+                case types_InitialDisplayMode.OPENED:
+                    this.setDisplayMode(this.openedDisplayMode.value === types_OpenedDisplayMode.DOCKED ? types_DisplayMode.DOCKED : types_DisplayMode.SIDEBAR);
+                    break;
+                case types_InitialDisplayMode.COLLAPSED_RIGHT:
+                    this.setDisplayMode(types_DisplayMode.COLLAPSED_RIGHT);
+                    break;
+                case types_InitialDisplayMode.CLOSED:
+                    this.setDisplayMode(types_DisplayMode.CLOSED);
+                    break;
+                case types_InitialDisplayMode.COLLAPSED_CENTER:
+                default:
+                    this.setDisplayMode(types_DisplayMode.COLLAPSED_CENTER);
+                    break;
+            }
+        }, /**
+   * Dismisses the widget to CLOSED state and marks that the user has manually dismissed.
+   * Once dismissed, subsequent close actions will always return to CLOSED instead of
+   * the configured starting position.
+   */ this.dismissWidget = ()=>{
+            signals_core_module_r(()=>{
+                this.rootStore.clearElementConversationState();
+                this.rootStore.closeLightbox();
+                this.setUIState({
+                    userHasDismissed: true
+                });
+                this.setDisplayMode(types_DisplayMode.CLOSED);
+            });
+            this.saveUIState.flush();
+            this.persistRedirectDismissedUIState();
+        }, /**
+   * Closes the widget, respecting the user's previous dismiss preference.
+   * If the user has previously dismissed the widget (userHasDismissed), goes to CLOSED.
+   * Otherwise, goes to the configured starting position.
+   */ this.closeWidget = ()=>{
+            signals_core_module_r(()=>{
+                this.rootStore.clearElementConversationState();
+                this.rootStore.closeLightbox();
+                this.rootStore.clearArtifact();
+                if (this.uiState.userHasDismissed.value || this.initialDisplayMode.value === types_InitialDisplayMode.OPENED) {
+                    this.setDisplayMode(types_DisplayMode.CLOSED);
+                } else {
+                    this.resetToStartingPosition();
+                }
+            });
+        }, this.primeRedirectDismissedUIState = ()=>{
+            if (!this.uiState.userHasDismissed.peek() || !this.displayMode.minimized.peek()) {
+                return;
+            }
+            this.persistRedirectDismissedUIState();
+        }, /**
+   * Handles UI-related fields from the init_state message.
+   */ this.handleInitState = (initialState)=>{
+            var _initialState_selectedReplicaId, _initialState_previewVideoSrc;
+            const wasOpened = this.displayMode.opened.peek();
+            const previousDisplayMode = this.displayMode.peek();
+            const redirectDismissedUIState = this.consumeRedirectDismissedUIState();
+            const hasRedirectDismissedUIState = redirectDismissedUIState != null;
+            if (initialState.themeConfig) {
+                var _themeConfig_launcherImageUrl;
+                const { themeConfig } = initialState;
+                this.launcherImageUrl.value = (_themeConfig_launcherImageUrl = themeConfig.launcherImageUrl) != null ? _themeConfig_launcherImageUrl : null;
+                if (themeConfig.openedDisplayMode) {
+                    this.setUIState({
+                        openedDisplayMode: themeConfig.openedDisplayMode
+                    });
+                }
+                if (themeConfig.initialDisplayMode) {
+                    this.initialDisplayMode.value = isMobile.peek() ? types_InitialDisplayMode.CLOSED : themeConfig.initialDisplayMode;
+                }
+                if (!initialState.uiState) {
+                    this.resetToStartingPosition();
+                }
+            }
+            if (initialState.orbConfig) {
+                this.orbConfig.value = initialState.orbConfig;
+            }
+            if (initialState.multimodalStartingConversationMode) {
+                this.setUIState({
+                    conversationMode: initialState.multimodalStartingConversationMode
+                });
+            }
+            if (initialState.uiState) {
+                this.setUIState(extractPersistedUIState(initialState.uiState));
+            }
+            if (redirectDismissedUIState) {
+                this.setUIState(redirectDismissedUIState);
+            }
+            this.applyModalityPreferenceToConversationMode(initialState.multimodalModalityPreference);
+            const hasPersistedMinimizedUIState = initialState.uiState != null && this.displayMode.minimized.value;
+            if (this.rootStore.dockingStore.isDocked() && !this.displayMode.docked.value && !hasPersistedMinimizedUIState && !hasRedirectDismissedUIState) {
+                this.setDisplayMode(types_DisplayMode.DOCKED);
+            }
+            if (isMobile.peek()) {
+                this.setDisplayMode(types_DisplayMode.CLOSED);
+            }
+            this.selectedReplicaId.value = (_initialState_selectedReplicaId = initialState.selectedReplicaId) != null ? _initialState_selectedReplicaId : null;
+            this.previewVideoSrc.value = (_initialState_previewVideoSrc = initialState.previewVideoSrc) != null ? _initialState_previewVideoSrc : null;
+            if (initialState.demoFeatures) {
+                var _initialState_demoFeatures_allowVoiceVideoToggle;
+                this.demoFeatures.value = {
+                    allowVoiceVideoToggle: (_initialState_demoFeatures_allowVoiceVideoToggle = initialState.demoFeatures.allowVoiceVideoToggle) != null ? _initialState_demoFeatures_allowVoiceVideoToggle : false
+                };
+            }
+            // Latch on the first initState whether or not we landed in DOCKED mode.
+            // If the widget never lands docked (cookie says undocked, the docking
+            // hard-abort already fired, or `dockingStore.enable()` is still mid-await),
+            // skip permanently — otherwise a later initState (reconnect, SPA nav, etc.)
+            // could log a delta of "time since page load", producing the millions-of-ms
+            // p95 we saw on `multimodal_time_to_replace_gutter_ms`.
+            if (this.rootStore.dockingStore.isDocked() && this.displayMode.docked.value) {
+                metrics.multimodal.timeToReplaceGutter.log();
+            } else {
+                metrics.multimodal.timeToReplaceGutter.skip();
+            }
+            if (wasOpened) {
+                this.setOpenedDisplayMode();
+            }
+            if (this.rootStore.isReconnecting.peek()) {
+                this.setDisplayMode(previousDisplayMode);
+            }
+        }, /**
+   * Applies the resolved starting state (mode, modality, and profile-derived
+   * avatar/orb assets) from a stateUpdate. Used when a multimodal experience starts
+   * after a delay: initState was served with fallback values, so this re-applies the
+   * resolved state before the widget becomes visible (on the startChatBot event).
+   * Each field is guarded so unrelated stateUpdates are a no-op.
+   */ this.applyMultimodalStartState = (state)=>{
+            var _state_themeConfig;
+            if (state.multimodalStartingConversationMode) {
+                this.setUIState({
+                    conversationMode: state.multimodalStartingConversationMode
+                });
+            }
+            this.applyModalityPreferenceToConversationMode(state.multimodalModalityPreference);
+            if (state.orbConfig) {
+                this.orbConfig.value = state.orbConfig;
+            }
+            if (state.selectedReplicaId !== undefined) {
+                var _state_selectedReplicaId;
+                this.selectedReplicaId.value = (_state_selectedReplicaId = state.selectedReplicaId) != null ? _state_selectedReplicaId : null;
+            }
+            if (state.previewVideoSrc !== undefined) {
+                var _state_previewVideoSrc;
+                this.previewVideoSrc.value = (_state_previewVideoSrc = state.previewVideoSrc) != null ? _state_previewVideoSrc : null;
+            }
+            const initialDisplayMode = (_state_themeConfig = state.themeConfig) == null ? void 0 : _state_themeConfig.initialDisplayMode;
+            if (initialDisplayMode) {
+                this.initialDisplayMode.value = isMobile.peek() ? types_InitialDisplayMode.CLOSED : initialDisplayMode;
+                this.resetToStartingPosition();
+            }
+        }, this.applyModalityPreferenceToConversationMode = (modality)=>{
+            if (modality === "video" || modality === "visitor_choice") {
+                this.setUIState({
+                    conversationMode: types_ConversationMode.VIDEO
+                });
+            } else if (modality === "voice") {
+                this.setUIState({
+                    conversationMode: types_ConversationMode.VOICE
+                });
+            } else if (modality === "text") {
+                this.setUIState({
+                    conversationMode: types_ConversationMode.TEXT
+                });
+            }
+        }, this.validateConversationMode = (mode)=>{
+            var _UIStore_FALLBACK_ORDER_find;
+            const allowed = this.allowedConversationModes.value;
+            if (allowed.includes(mode)) return mode;
+            return (_UIStore_FALLBACK_ORDER_find = UIStore.FALLBACK_ORDER.find((m)=>allowed.includes(m))) != null ? _UIStore_FALLBACK_ORDER_find : types_ConversationMode.TEXT;
+        }, this.validateUIState = (uiState)=>{
+            const conversationMode = this.validateConversationMode(uiState.conversationMode);
+            return conversationMode === uiState.conversationMode ? uiState : _extends({}, uiState, {
+                conversationMode
+            });
+        }, this.saveUIState = debounce_default()(()=>{
+            // Redirect-triggered form experiences can enqueue a loading overlay before the
+            // first initState arrives. Do not persist that pre-init fallback UI state.
+            if (!this.rootStore.initialized.peek() && this.rootStore.loadingState.peek() !== types_LoadingState.NONE) {
+                return;
+            }
+            this.channel.perform("save_ui_state", snakify(this.uiState.persisted.peek()));
+        }, 500), this.handleDisplayModeChange = (newMode)=>{
+            if (!this.rootStore.initialized.peek()) {
+                return;
+            }
+            signals_core_module_r(()=>{
+                const isMinimized = newMode === types_DisplayMode.CLOSED || newMode === types_DisplayMode.COLLAPSED_CENTER || newMode === types_DisplayMode.COLLAPSED_RIGHT;
+                if (!isMinimized) {
+                    this.visitor.clearMultimodalRedirectDismissal();
+                    this.writeRedirectDismissedUIState(null);
+                    if (!this.rootStore.messages.hasOpenEvent.peek()) {
+                        this.rootStore.sendMessage({
+                            type: "event",
+                            eventType: "open"
+                        });
+                    }
+                    this.rootStore.markMessagesAsRead();
+                }
+                if (newMode === types_DisplayMode.DOCKED && this.layout.root.visible.peek()) {
+                    this.rootStore.dockingStore.enable({
+                        confirm: ()=>this.displayMode.peek() === types_DisplayMode.DOCKED && this.layout.root.visible.peek()
+                    });
+                } else {
+                    this.rootStore.dockingStore.disable();
+                }
+            });
+        }, this.handleRootVisibilityChange = (visible)=>{
+            if (!this.rootStore.initialized.peek()) {
+                return;
+            }
+            if (!visible) {
+                this.rootStore.dockingStore.disable();
+            } else if (this.displayMode.peek() === types_DisplayMode.DOCKED) {
+                this.rootStore.dockingStore.enable({
+                    confirm: ()=>this.displayMode.peek() === types_DisplayMode.DOCKED && this.layout.root.visible.peek()
+                });
+            }
+        };
+        this.displayMode.subscribe(this.handleDisplayModeChange);
+        this.layout.root.visible.subscribe(this.handleRootVisibilityChange);
+        this.rootStore.activeConversation.subscribe((conversation)=>{
+            if (!this.rootStore.initialized.peek()) return;
+            if (!conversation && this.displayMode.docked.peek()) {
+                this.closeWidget();
+            }
+        });
+    }
+}
+UIStore.FALLBACK_ORDER = [
+    types_ConversationMode.VIDEO,
+    types_ConversationMode.VOICE,
+    types_ConversationMode.TEXT
+];
+
+export { UIStore };

package/widget/multimodal_v2/stores/waiting_store.js

@@ -0,0 +1,159 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import { signals_core_module_r, signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { isEventMessage } from "../signals/messages_signal.js";
+import "../../utils/native_globals.js";
+import { parseISO } from "../../../js/date-fns.js";
+
+/* provided dependency */ var __nativeWindowRemoveEventListener = __webpack_require__(68034).kZ;
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+/* provided dependency */ var waiting_store_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var waiting_store_clearTimeout = __webpack_require__(68034).Kj;
+
+
+
+class WaitingStore {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(rootStore){
+        this.rootStore = rootStore;
+        // Private state
+        this.timeoutId = null;
+        this.unsubscribeMessageListener = null;
+        this.scrollListener = null;
+        // State
+        this.scriptWaitingMessage = signals_core_module_d(null);
+        // Derived state
+        this.isWaiting = signals_core_module_w(()=>this.scriptWaitingMessage.value !== null);
+        this.isWaitingForTimeout = signals_core_module_w(()=>{
+            const waitingMessage = this.scriptWaitingMessage.value;
+            return (waitingMessage == null ? void 0 : waitingMessage.waitingEvent) === "timeout" && !(waitingMessage == null ? void 0 : waitingMessage.notProcessing);
+        });
+        // Actions
+        this.handleWaitingMessage = (message)=>{
+            signals_core_module_r(()=>{
+                // Clear any existing waiting state
+                this.clearWaitingState();
+                this.scriptWaitingMessage.value = message;
+                // Show typing indicator if waiting for timeout and not notProcessing
+                if (message.waitingEvent === "timeout" && !message.notProcessing) {
+                    this.rootStore.setTypingIndicator(true);
+                }
+                // Set up timeout if waitingUntil is present
+                if (message.waitingUntil) {
+                    this.setupTimeout(message);
+                }
+                // Start observing messages for the resolving event
+                if (message.waitingEvent) {
+                    this.setupMessageListener();
+                }
+                // Start listening for scroll if scrollPercentage is set
+                if (message.scrollPercentage != null) {
+                    this.setupScrollListener();
+                }
+            });
+        };
+        this.dispose = ()=>{
+            this.clearWaitingState();
+        };
+        this.clearWaitingState = ()=>{
+            signals_core_module_r(()=>{
+                this.clearTimeoutTimer();
+                this.clearMessagesSubscription();
+                this.clearScrollListener();
+                this.scriptWaitingMessage.value = null;
+                this.rootStore.setTypingIndicator(false);
+            });
+        };
+        this.clearMessagesSubscription = ()=>{
+            this.unsubscribeMessageListener == null ? void 0 : this.unsubscribeMessageListener.call(this);
+            this.unsubscribeMessageListener = null;
+        };
+        this.clearScrollListener = ()=>{
+            if (this.scrollListener) {
+                __nativeWindowRemoveEventListener("scroll", this.scrollListener);
+                this.scrollListener = null;
+            }
+        };
+        this.setupScrollListener = ()=>{
+            this.scrollListener = ()=>{
+                const scrollPercent = this.getScrollPercentage();
+                const waitingMessage = this.scriptWaitingMessage.value;
+                if ((waitingMessage == null ? void 0 : waitingMessage.scrollPercentage) != null && scrollPercent > waitingMessage.scrollPercentage) {
+                    const payload = {
+                        type: "event",
+                        eventType: "scrollPercentage",
+                        replyToId: waitingMessage.id
+                    };
+                    this.rootStore.sendMessage(payload);
+                    this.clearWaitingState();
+                }
+            };
+            __nativeWindowAddEventListener("scroll", this.scrollListener, {
+                passive: true
+            });
+        };
+        this.getScrollPercentage = ()=>{
+            const { scrollTop: hScrollTop, scrollHeight: hScrollHeight, clientHeight } = document.documentElement;
+            const { scrollTop: bScrollTop, scrollHeight: bScrollHeight } = document.body;
+            const scrollTop = hScrollTop || bScrollTop;
+            const scrollHeight = hScrollHeight || bScrollHeight;
+            const percent = scrollTop / (scrollHeight - clientHeight) * 100;
+            return Number.isNaN(percent) ? 100 : percent;
+        };
+        this.setupTimeout = (message)=>{
+            // Clear any existing timeout
+            this.clearTimeoutTimer();
+            if (!message.waitingUntil) return;
+            // Schedule only the time actually left, not the full configured delay. A delayed experience
+            // can hand off from the legacy messenger to this one partway through its wait; measuring from
+            // createdAt would rearm the whole delay at that moment and fire a duplicate timeout long
+            // after the wait was already resolved. See QAI-5640.
+            const timeoutMs = parseISO(message.waitingUntil).getTime() - Date.now();
+            // If the timeout is negative, it'll execute immediately
+            this.timeoutId = waiting_store_setTimeout(()=>{
+                this.timeoutId = null;
+                const payload = {
+                    type: "event",
+                    eventType: "timeout",
+                    forWait: message.waitingUntil,
+                    replyToId: message.id
+                };
+                if (message.aiStrategyIds) {
+                    payload.aiStrategyIds = message.aiStrategyIds;
+                }
+                this.rootStore.sendMessage(payload);
+                this.clearWaitingState();
+            }, timeoutMs);
+        };
+        this.clearTimeoutTimer = ()=>{
+            if (this.timeoutId) {
+                waiting_store_clearTimeout(this.timeoutId);
+                this.timeoutId = null;
+            }
+        };
+        this.setupMessageListener = ()=>{
+            this.unsubscribeMessageListener = this.rootStore.messages.subscribe(()=>{
+                this.checkForResolvingEvent();
+            });
+        };
+        this.checkForResolvingEvent = ()=>{
+            const waitingMessage = this.scriptWaitingMessage.value;
+            if (!waitingMessage) return;
+            const messages = this.rootStore.messages.value;
+            // Reverse iterate to find a matching event, stop if we hit the waiting message
+            for(let i = messages.length - 1; i >= 0; i--){
+                const message = messages[i];
+                // If we hit the waiting message, no resolving event was found after it
+                if (message.id === waitingMessage.id) return;
+                // If we hit the resolving event, clear the waiting state
+                if (isEventMessage(message, waitingMessage.waitingEvent)) {
+                    this.clearWaitingState();
+                    return;
+                }
+            }
+        };
+    }
+}
+/* export default */ const waiting_store = (WaitingStore);
+
+export { WaitingStore };
+export default waiting_store;