@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/components/multimodal/useAudioLevelMonitoring.js

@@ -0,0 +1,96 @@
+import { __webpack_require__ } from "../../../../js/runtime.js";
+import { hooks_module_y, signals_module_useSignal, hooks_module_A } from "../../../../js/multimodal_v2.js";
+import "../../../utils/native_globals.js";
+
+/* provided dependency */ var requestAnimationFrame = __webpack_require__(68034).gj;
+/* provided dependency */ var cancelAnimationFrame = __webpack_require__(68034).pP;
+
+
+const FFT_SIZE = 256;
+const SMOOTHING_FACTOR = 0.25;
+const AUDIO_THRESHOLD = 0.05;
+const SCALE_INCREASE_THRESHOLD = 0.008;
+const RING_COOLDOWN_MS = 2000;
+const useAudioLevelMonitoring = (param)=>{
+    let { audioTrack, disabled, scaleMultiplier, suppressScaling, targetElementRef, onScaleThresholdCrossed } = param;
+    const audioLevel = signals_module_useSignal(0);
+    const audioContextRef = hooks_module_A(null);
+    const analyserRef = hooks_module_A(null);
+    const animationFrameRef = hooks_module_A(null);
+    const previousScaleRef = hooks_module_A(1);
+    const lastRingTimeRef = hooks_module_A(0);
+    hooks_module_y(()=>{
+        if (!audioTrack || disabled) {
+            audioLevel.value = 0;
+            return;
+        }
+        try {
+            const audioContext = new AudioContext();
+            if (audioContext.state === "suspended") {
+                void audioContext.resume();
+            }
+            const analyser = audioContext.createAnalyser();
+            analyser.fftSize = FFT_SIZE;
+            const source = audioContext.createMediaStreamSource(new MediaStream([
+                audioTrack
+            ]));
+            source.connect(analyser);
+            audioContextRef.current = audioContext;
+            analyserRef.current = analyser;
+            const dataArray = new Uint8Array(analyser.fftSize);
+            let smoothedLevel = 0;
+            const updateAudioLevel = ()=>{
+                if (!analyserRef.current) return;
+                analyserRef.current.getByteTimeDomainData(dataArray);
+                const sumSquares = dataArray.reduce((sum, sample)=>{
+                    const normalizedSample = (sample - 128) / 128;
+                    return sum + normalizedSample * normalizedSample;
+                }, 0);
+                const rms = Math.sqrt(sumSquares / dataArray.length);
+                const normalizedLevel = Math.min(rms, 1);
+                smoothedLevel += (normalizedLevel - smoothedLevel) * SMOOTHING_FACTOR;
+                audioLevel.value = smoothedLevel;
+                if (targetElementRef.current) {
+                    if (!suppressScaling && smoothedLevel > AUDIO_THRESHOLD) {
+                        const scale = 1 + smoothedLevel * scaleMultiplier;
+                        targetElementRef.current.style.transform = "scale(" + scale + ")";
+                        const scaleIncrease = scale - previousScaleRef.current;
+                        const now = Date.now();
+                        const timeSinceLastRing = now - lastRingTimeRef.current;
+                        if (scaleIncrease >= SCALE_INCREASE_THRESHOLD && timeSinceLastRing >= RING_COOLDOWN_MS && onScaleThresholdCrossed) {
+                            onScaleThresholdCrossed();
+                            lastRingTimeRef.current = now;
+                        }
+                        previousScaleRef.current = scale;
+                    } else {
+                        targetElementRef.current.style.transform = "scale(1)";
+                        previousScaleRef.current = 1;
+                    }
+                }
+                animationFrameRef.current = requestAnimationFrame(updateAudioLevel);
+            };
+            animationFrameRef.current = requestAnimationFrame(updateAudioLevel);
+        } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error("Failed to setup audio level monitoring:", error);
+        }
+        return ()=>{
+            if (animationFrameRef.current) {
+                cancelAnimationFrame(animationFrameRef.current);
+            }
+            if (audioContextRef.current) {
+                audioContextRef.current.close();
+            }
+        };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        audioTrack,
+        disabled,
+        scaleMultiplier,
+        suppressScaling,
+        targetElementRef
+    ]);
+    return audioLevel;
+};
+
+export { useAudioLevelMonitoring };

package/widget/multimodal_v2/components/multimodal/useMultimodal.js

@@ -0,0 +1,434 @@
+import { useComputed } from "../../../../js/multimodal_v2.js";
+import { isMobile } from "../../utils/media_queries.js";
+import { t, useLocalization } from "../helpers/Localization.js";
+import { ConversationMode as types_ConversationMode, MaximizedState as types_MaximizedState, DisplayMode as types_DisplayMode } from "../../types.js";
+
+
+
+
+
+// ============================================================================
+// Main Hook
+// ============================================================================
+function useMultimodal(param) {
+    let { rootStore } = param;
+    const adapter = useCallAdapter(rootStore);
+    const variant = useVariant(rootStore, adapter);
+    const tracks = useTracks(rootStore);
+    const visibility = useVisibility(rootStore, adapter);
+    const avatar = useAvatarConfig(rootStore, adapter, tracks, variant);
+    const status = useStatusConfig(rootStore, variant, visibility);
+    const controls = useControlsConfig(rootStore, adapter, variant, visibility);
+    const idleAction = useIdleActionConfig(rootStore, adapter, variant, visibility);
+    const container = useContainer(rootStore, idleAction);
+    return {
+        variant: variant.value,
+        audioTracks: [
+            tracks.coffeeAudio,
+            tracks.avatarAudio
+        ],
+        avatar,
+        container,
+        controls,
+        idleAction,
+        status
+    };
+}
+function useCallAdapter(rootStore) {
+    return useComputed(()=>{
+        void rootStore.debugScenarioStore.value;
+        return rootStore.getCallUiAdapter();
+    });
+}
+function useTracks(rootStore) {
+    const coffeeAudio = useComputed(()=>{
+        var _callStore_participantStore_coffeeAgentParticipant_value_tracks_audio, _callStore_participantStore_coffeeAgentParticipant_value_tracks, _callStore_participantStore_coffeeAgentParticipant_value;
+        const callStore = rootStore.callStore.value;
+        return callStore == null ? void 0 : (_callStore_participantStore_coffeeAgentParticipant_value = callStore.participantStore.coffeeAgentParticipant.value) == null ? void 0 : (_callStore_participantStore_coffeeAgentParticipant_value_tracks = _callStore_participantStore_coffeeAgentParticipant_value.tracks) == null ? void 0 : (_callStore_participantStore_coffeeAgentParticipant_value_tracks_audio = _callStore_participantStore_coffeeAgentParticipant_value_tracks.audio) == null ? void 0 : _callStore_participantStore_coffeeAgentParticipant_value_tracks_audio.persistentTrack;
+    });
+    const avatarAudio = useComputed(()=>{
+        var _callStore_participantStore_avatarParticipant_value_tracks_audio, _callStore_participantStore_avatarParticipant_value_tracks, _callStore_participantStore_avatarParticipant_value;
+        const callStore = rootStore.callStore.value;
+        return callStore == null ? void 0 : (_callStore_participantStore_avatarParticipant_value = callStore.participantStore.avatarParticipant.value) == null ? void 0 : (_callStore_participantStore_avatarParticipant_value_tracks = _callStore_participantStore_avatarParticipant_value.tracks) == null ? void 0 : (_callStore_participantStore_avatarParticipant_value_tracks_audio = _callStore_participantStore_avatarParticipant_value_tracks.audio) == null ? void 0 : _callStore_participantStore_avatarParticipant_value_tracks_audio.persistentTrack;
+    });
+    const video = useComputed(()=>{
+        var _videoParticipant_tracks_video, _videoParticipant_tracks;
+        const callStore = rootStore.callStore.value;
+        const videoParticipant = callStore == null ? void 0 : callStore.participantStore.videoParticipant.value;
+        return videoParticipant == null ? void 0 : (_videoParticipant_tracks = videoParticipant.tracks) == null ? void 0 : (_videoParticipant_tracks_video = _videoParticipant_tracks.video) == null ? void 0 : _videoParticipant_tracks_video.persistentTrack;
+    });
+    return {
+        coffeeAudio,
+        avatarAudio,
+        video
+    };
+}
+function useVariant(rootStore, adapter) {
+    return useComputed(()=>{
+        var _rootStore_postCallSurveyStore_value;
+        const isVoiceMode = rootStore.conversationMode.voice.value || adapter.value.state.conversationMode.value === types_ConversationMode.VOICE;
+        const isOpened = rootStore.displayMode.opened.value;
+        const userHasIgnoredMultimodal = rootStore.userHasIgnoredMultimodal.value;
+        const maximizedState = rootStore.maximizedState.value;
+        const isMaximized = maximizedState === types_MaximizedState.MULTIMODAL && isOpened;
+        if (isMaximized) return "maximized";
+        const isMobileArtifact = isMobile.value && maximizedState === types_MaximizedState.ARTIFACT;
+        if (isMobileArtifact) return isOpened ? "pill" : "compact";
+        if (rootStore.displayMode.minimized.value && rootStore.conversationMode.video.value) return "compact";
+        const adapterState = adapter.value.state;
+        const isVideoInCall = isMobile.value && rootStore.conversationMode.video.value && (adapterState.isInCall.value || adapterState.isVideoLoading.value);
+        if (isVideoInCall) return "maximized";
+        if ((_rootStore_postCallSurveyStore_value = rootStore.postCallSurveyStore.value) == null ? void 0 : _rootStore_postCallSurveyStore_value.isActive.value) return "compact";
+        if (!isMaximized && (isVoiceMode || userHasIgnoredMultimodal && isOpened)) return "pill";
+        return "compact";
+    });
+}
+function useVisibility(rootStore, adapter) {
+    // Status visibility:
+    // - Show when connecting/loading (video not ready) and NOT yet in call
+    // - Show when reconnecting (but not during silent restart)
+    // - Show when blurred video is active (transitional state: audio joined, video not yet ready)
+    const isConnecting = useComputed(()=>{
+        const { state } = adapter.value;
+        return state.isVideoLoading.value;
+    });
+    const showReconnecting = useComputed(()=>{
+        const { state } = adapter.value;
+        return state.isReconnecting.value && !state.isSilentRestart.value;
+    });
+    const showStatus = useComputed(()=>{
+        const { state } = adapter.value;
+        return isConnecting.value || showReconnecting.value || state.isBlurredVideoActive.value;
+    });
+    // Controls should be visible when in call and not collapsed, even during blurred video state
+    const showControls = useComputed(()=>{
+        const { state } = adapter.value;
+        // Show controls when in call (including during blurred video) as long as not collapsed
+        return state.isInCall.value && !rootStore.displayMode.collapsed.value && !(isConnecting.value || showReconnecting.value);
+    });
+    // IdleAction visibility depends on mode:
+    // - Video mode: show "Speak now" when video is ready and not in call
+    // - Voice mode collapsed: show "Speak now" when not in call
+    // - Voice mode opened: show "Ask...a question" FAB when idle (not in call, not connecting)
+    // - Never show when Status is visible
+    const showIdleAction = useComputed(()=>{
+        var _rootStore_postCallSurveyStore_value;
+        const { state } = adapter.value;
+        const isInCall = state.isInCall.value;
+        const isVideoLoading = state.isVideoLoading.value;
+        const isVoiceMode = rootStore.conversationMode.voice.value;
+        const isCollapsed = rootStore.displayMode.collapsed.value;
+        const isOpened = rootStore.displayMode.opened.value;
+        const showIdleActionVideo = !isInCall && !isVoiceMode;
+        const showIdleActionVoiceCollapsed = isVoiceMode && isCollapsed && !isInCall;
+        const showIdleActionVoiceOpened = isOpened && isVoiceMode && !isInCall && !isVideoLoading;
+        if (((_rootStore_postCallSurveyStore_value = rootStore.postCallSurveyStore.value) == null ? void 0 : _rootStore_postCallSurveyStore_value.isActive.value) && !isCollapsed) return false;
+        return (showIdleActionVideo || showIdleActionVoiceCollapsed || showIdleActionVoiceOpened) && !showStatus.value;
+    });
+    return {
+        isConnecting,
+        showReconnecting,
+        showStatus,
+        showControls,
+        showIdleAction
+    };
+}
+// ============================================================================
+// Avatar Config Hook
+// ============================================================================
+function useAvatarConfig(rootStore, adapter, tracks, variant) {
+    const isVoiceMode = useComputed(()=>{
+        return rootStore.conversationMode.voice.value || adapter.value.state.conversationMode.value === types_ConversationMode.VOICE;
+    });
+    // Determine avatar type:
+    // - Voice mode: always use "orb" (OrbAvatar may render an image via orbConfig.orbImageUrl)
+    // - Video mode: always use "video"
+    const avatarType = useComputed(()=>{
+        return isVoiceMode.value ? "orb" : "video";
+    });
+    const liveVideoConfig = useComputed(()=>{
+        var _ref;
+        var _rootStore_previewVideoConfig_value;
+        const track = tracks.video.value;
+        const adapterVal = adapter.value;
+        const isInCallVal = adapterVal.state.isInCall.value;
+        const isDebugSimulatedCall = adapterVal.isDebugMode && isInCallVal;
+        if (!track && !isDebugSimulatedCall) return null;
+        if (track) return {
+            type: "track",
+            track
+        };
+        return {
+            type: "src",
+            src: (_ref = (_rootStore_previewVideoConfig_value = rootStore.previewVideoConfig.value) == null ? void 0 : _rootStore_previewVideoConfig_value.src) != null ? _ref : ""
+        };
+    });
+    const isBlurredVideoActive = useComputed(()=>adapter.value.state.isBlurredVideoActive.value);
+    // Video is "unlocked" when the backend reports video_status === "active":
+    // in-call, not loading, and not in the blurred transitional state.
+    const isVideoUnlocked = useComputed(()=>adapter.value.state.isInCall.value && !adapter.value.state.isVideoLoading.value && !adapter.value.state.isBlurredVideoActive.value);
+    const videoConfig = {
+        previewVideoConfig: rootStore.previewVideoConfig,
+        liveVideoConfig,
+        isBlurredVideoActive,
+        isVideoUnlocked
+    };
+    const audioMonitoringConfig = useComputed(()=>({
+            enabled: adapter.value.state.isInCall.value && isVoiceMode.value,
+            audioTracks: [
+                tracks.coffeeAudio.value,
+                tracks.avatarAudio.value
+            ]
+        }));
+    const isBotResponding = useComputed(()=>rootStore.typingIndicatorState.value);
+    const orbName = useComputed(()=>{
+        var _ref;
+        var _rootStore_activeConversation_aiSdr_value;
+        return (_ref = (_rootStore_activeConversation_aiSdr_value = rootStore.activeConversation.aiSdr.value) == null ? void 0 : _rootStore_activeConversation_aiSdr_value.name) != null ? _ref : undefined;
+    });
+    const orbConfig = {
+        audioMonitoringConfig,
+        isSpeaking: isBotResponding,
+        orbConfig: rootStore.orbConfig,
+        name: orbName
+    };
+    const props = useComputed(()=>{
+        switch(avatarType.value){
+            case "video":
+                return {
+                    type: "video",
+                    config: videoConfig
+                };
+            case "orb":
+                return {
+                    type: "orb",
+                    config: orbConfig
+                };
+        }
+    });
+    const roundedCorners = useComputed(()=>{
+        if (variant.value === "maximized") return "none";
+        const isRounded = variant.value === "compact" && avatarType.value !== "orb";
+        return isRounded ? rootStore.displayMode.collapsedCenter.value ? "topLeft" : "all" : "none";
+    });
+    const visible = useComputed(()=>{
+        var _rootStore_postCallSurveyStore_value;
+        return !((_rootStore_postCallSurveyStore_value = rootStore.postCallSurveyStore.value) == null ? void 0 : _rootStore_postCallSurveyStore_value.isActive.value) || !isVoiceMode.value;
+    });
+    return {
+        props: props.value,
+        roundedCorners,
+        visible
+    };
+}
+// ============================================================================
+// Status Config Hook
+// ============================================================================
+function useStatusConfig(rootStore, variant, visibility) {
+    var _rootStore_companyName_value;
+    var _rootStore_activeConversation_aiSdr_value;
+    const adapter = useComputed(()=>rootStore.getCallUiAdapter());
+    const { isConnecting, showReconnecting, showStatus } = visibility;
+    const aiSdrName = ((_rootStore_activeConversation_aiSdr_value = rootStore.activeConversation.aiSdr.value) == null ? void 0 : _rootStore_activeConversation_aiSdr_value.name) || t("video.yourAssistant");
+    const companyName = (_rootStore_companyName_value = rootStore.companyName.value) != null ? _rootStore_companyName_value : "";
+    const isBlurredVideo = useComputed(()=>adapter.value.state.isBlurredVideoActive.value);
+    const mainText = useComputed(()=>{
+        if (isBlurredVideo.value) return t("video.connectingToVideo");
+        if (showReconnecting.value) return t("video.weakConnection");
+        return t("video.connectingTo", {
+            name: aiSdrName
+        });
+    });
+    // Subtext only shown during connecting, not reconnecting, blurred video, or pill mode
+    const subText = useComputed(()=>showReconnecting.value || isBlurredVideo.value || variant.value === "pill" ? undefined : t("video.askAnythingAbout", {
+            company: companyName
+        }));
+    // Show spinner during connecting, but not during reconnecting or blurred video
+    const showSpinner = isConnecting.value && !showReconnecting.value;
+    const loadingIndicator = showSpinner ? variant.value === "pill" ? "dots" : "spinner" : null;
+    // Determine status variant (layout) and colorScheme (appearance)
+    // - Blurred video: pill + overlayText (white text floats over blurred video)
+    // - Reconnecting: pill + translucent (pill with backdrop)
+    // - Compact mode: overlay + dark
+    // - Pill mode: always inline + light
+    const statusVariant = variant.value === "pill" ? "inline" : showReconnecting.value || isBlurredVideo.value ? "pill" : "overlay";
+    const colorScheme = variant.value === "pill" ? "light" : isBlurredVideo.value ? "overlayText" : showReconnecting.value ? "translucent" : "dark";
+    return {
+        visible: showStatus,
+        props: {
+            variant: statusVariant,
+            colorScheme,
+            mainText,
+            subText,
+            loadingIndicator
+        }
+    };
+}
+// ============================================================================
+// Controls Config Hook
+// ============================================================================
+function useControlsConfig(rootStore, adapter, variant, visibility) {
+    const { showControls } = visibility;
+    // Access adapter.value for state and actions
+    const adapterVal = adapter.value;
+    const { state: adapterState, actions } = adapterVal;
+    const controlsVariant = useComputed(()=>{
+        if (variant.value === "pill") return "pill";
+        if (variant.value === "maximized") return "compactInside";
+        return rootStore.conversationMode.video.value ? "compactInside" : "compactOutside";
+    });
+    // Computed signals for controls props
+    const conversationModeVisible = useComputed(()=>rootStore.allowVoiceVideoToggle.value && !adapterState.isBlurredVideoActive.value && rootStore.maximizedState.value !== types_MaximizedState.MULTIMODAL && !rootStore.displayMode.minimized.value);
+    const micIsOn = useComputed(()=>!adapterState.isMicMuted.value);
+    const micHasDevicesAvailable = useComputed(()=>adapterState.microphoneDevices.value.length > 0);
+    const micDevices = useComputed(()=>adapterState.microphoneDevices.value.map((d)=>({
+                label: d.label || "Unnamed Mic",
+                value: d.deviceId
+            })));
+    const maximizeVisible = useComputed(()=>adapterState.showMicControls.value && rootStore.conversationMode.video.value && rootStore.maximizedState.value !== types_MaximizedState.ARTIFACT);
+    const isMaximized = useComputed(()=>rootStore.maximizedState.value === types_MaximizedState.MULTIMODAL);
+    const minimizeToCornerVisible = useComputed(()=>!rootStore.conversationMode.text.value && adapterState.showMicControls.value);
+    const endCallVisible = useComputed(()=>true);
+    const props = {
+        connectingStatus: {
+            visible: adapterState.showConnecting
+        },
+        conversationMode: {
+            visible: conversationModeVisible,
+            currentMode: adapterState.conversationMode,
+            onChange: (mode)=>actions.toggleVideoMode(mode)
+        },
+        mic: {
+            visible: adapterState.showMicControls,
+            isOn: micIsOn,
+            hasDevicesAvailable: micHasDevicesAvailable,
+            devices: micDevices,
+            selectedDeviceId: adapterState.selectedMicId,
+            onToggle: ()=>actions.toggleMic(),
+            onDeviceChange: (deviceId)=>actions.selectMic(deviceId)
+        },
+        maximize: {
+            visible: maximizeVisible,
+            isMaximized,
+            onToggle: ()=>{
+                const current = rootStore.maximizedState.value;
+                if (current === types_MaximizedState.MULTIMODAL) {
+                    rootStore.clearMaximizedState();
+                } else {
+                    if (rootStore.displayMode.minimized.value) {
+                        rootStore.setOpenedDisplayMode();
+                    }
+                    rootStore.setMaximizedState(types_MaximizedState.MULTIMODAL);
+                }
+            }
+        },
+        minimizeToCorner: {
+            visible: minimizeToCornerVisible,
+            isClosed: rootStore.displayMode.closed,
+            onToggle: ()=>{
+                if (rootStore.displayMode.closed.value) {
+                    rootStore.setOpenedDisplayMode();
+                } else {
+                    rootStore.clearMaximizedState({
+                        when: types_MaximizedState.MULTIMODAL
+                    });
+                    rootStore.setDisplayMode(types_DisplayMode.CLOSED);
+                }
+            }
+        },
+        endCall: {
+            visible: endCallVisible,
+            onClick: ()=>{
+                rootStore.clearMaximizedState();
+                actions.endCall();
+            }
+        }
+    };
+    return {
+        visible: showControls,
+        variant: controlsVariant,
+        props
+    };
+}
+// ============================================================================
+// Idle Action Config Hook
+// ============================================================================
+function useIdleActionConfig(rootStore, adapter, variant, visibility) {
+    var _rootStore_activeConversation_aiSdr_value;
+    const { showIdleAction } = visibility;
+    const aiSdrName = ((_rootStore_activeConversation_aiSdr_value = rootStore.activeConversation.aiSdr.value) == null ? void 0 : _rootStore_activeConversation_aiSdr_value.name) || t("video.yourAssistant");
+    const text = useComputed(()=>{
+        return rootStore.displayMode.opened.value ? t("chat.speakWithName", {
+            name: aiSdrName
+        }) : t("video.speakNow");
+    });
+    const visualOnly = useComputed(()=>{
+        return variant.value === "pill";
+    });
+    const alreadyInCall = useComputed(()=>adapter.value.state.alreadyInCall.value);
+    return {
+        visible: showIdleAction,
+        variant: variant.value === "pill" ? "minimal" : "primary",
+        onClick: ()=>{
+            rootStore.emitChatViewIfEligible({
+                fromUserIntent: true
+            });
+            adapter.value.actions.startCall();
+        },
+        text,
+        visualOnly,
+        alreadyInCall
+    };
+}
+// ============================================================================
+// Container Config Hook
+// ============================================================================
+function useContainer(rootStore, idleAction) {
+    // Container is button-like when idle action is visible, not already in a call,
+    // and the post-call survey is not active
+    const isButtonLike = useComputed(()=>{
+        var _rootStore_postCallSurveyStore_value;
+        return idleAction.visible.value && !idleAction.alreadyInCall.value && !((_rootStore_postCallSurveyStore_value = rootStore.postCallSurveyStore.value) == null ? void 0 : _rootStore_postCallSurveyStore_value.isActive.value);
+    });
+    const ariaLabel = useLocalization(idleAction.text);
+    const handleClick = (e)=>{
+        // Only handle clicks when container is button-like
+        if (!isButtonLike.value) return;
+        const target = e.target;
+        const interactiveEl = target.closest('button, a, input, [role="button"]');
+        // If clicking on a nested interactive element (not the container itself), let it handle the event
+        if (interactiveEl && interactiveEl !== e.currentTarget) {
+            return;
+        }
+        idleAction.onClick == null ? void 0 : idleAction.onClick.call(idleAction);
+    };
+    const handleKeyDown = (e)=>{
+        if (!isButtonLike.value) return;
+        // Activate on Enter or Space (standard button behavior)
+        if (e.key === "Enter" || e.key === " ") {
+            // Prevent default keydown
+            e.preventDefault();
+            idleAction.onClick == null ? void 0 : idleAction.onClick.call(idleAction);
+        }
+    };
+    // Compute accessibility props based on isButtonLike state
+    const accessibilityProps = useComputed(()=>{
+        if (!isButtonLike.value) {
+            return {};
+        }
+        return {
+            role: "button",
+            tabIndex: 0,
+            ariaLabel,
+            title: ariaLabel
+        };
+    });
+    return {
+        isButtonLike,
+        accessibilityProps: accessibilityProps.value,
+        handleClick,
+        handleKeyDown
+    };
+}
+
+export { useMultimodal };