genassist-chat-react 1.0.38-rc.0 → 1.0.39

package/dist/hooks/useScrollManagement.js

@@ -0,0 +1,124 @@
+import { useRef, useLayoutEffect, useEffect } from 'react';
+export function useScrollManagement(_a) {
+    var messages = _a.messages, isAgentTyping = _a.isAgentTyping, currentThinkingPartIndex = _a.currentThinkingPartIndex, currentThinkingPartsLength = _a.currentThinkingPartsLength, conversationId = _a.conversationId, isFloatingOpen = _a.isFloatingOpen, mode = _a.mode;
+    var messagesEndRef = useRef(null);
+    var chatContainerRef = useRef(null);
+    var hasAnchoredHistory = useRef(false);
+    var isUserAtBottomRef = useRef(true);
+    var prevIsFloatingOpenRef = useRef(isFloatingOpen);
+    var anchorHistory = function () {
+        var el = chatContainerRef.current;
+        if (!el || !messages.length || hasAnchoredHistory.current)
+            return;
+        if (el.clientHeight === 0)
+            return;
+        el.scrollTop = el.scrollHeight;
+        hasAnchoredHistory.current = true;
+        isUserAtBottomRef.current = true;
+    };
+    var scrollToBottom = function (behavior, force) {
+        if (behavior === void 0) { behavior = 'smooth'; }
+        if (force === void 0) { force = false; }
+        var container = chatContainerRef.current;
+        var el = messagesEndRef.current;
+        if (!container || !el)
+            return;
+        if (!force && !isUserAtBottomRef.current) {
+            return;
+        }
+        var doScroll = function () {
+            container.scrollTo({ top: container.scrollHeight, behavior: behavior });
+            isUserAtBottomRef.current = true;
+        };
+        if (behavior === 'auto') {
+            doScroll();
+        }
+        else {
+            requestAnimationFrame(doScroll);
+        }
+    };
+    useLayoutEffect(function () {
+        if (!messages.length)
+            return;
+        if (hasAnchoredHistory.current) {
+            scrollToBottom('smooth', false);
+        }
+        else {
+            anchorHistory();
+        }
+    }, [messages]);
+    useLayoutEffect(function () {
+        if (!isAgentTyping)
+            return;
+        scrollToBottom('auto', true);
+    }, [isAgentTyping, currentThinkingPartIndex, currentThinkingPartsLength]);
+    useEffect(function () {
+        hasAnchoredHistory.current = false;
+    }, [conversationId]);
+    useEffect(function () {
+        if ((mode === 'floating' || mode === 'fullscreen') && isFloatingOpen && !prevIsFloatingOpenRef.current && messages.length > 0) {
+            hasAnchoredHistory.current = false;
+            isUserAtBottomRef.current = true;
+            var scrollWhenVisible_1 = function () {
+                var container = chatContainerRef.current;
+                if (!container) {
+                    requestAnimationFrame(scrollWhenVisible_1);
+                    return;
+                }
+                if (container.clientHeight === 0) {
+                    requestAnimationFrame(scrollWhenVisible_1);
+                    return;
+                }
+                container.scrollTop = container.scrollHeight;
+                hasAnchoredHistory.current = true;
+                isUserAtBottomRef.current = true;
+            };
+            requestAnimationFrame(function () {
+                requestAnimationFrame(scrollWhenVisible_1);
+            });
+        }
+        prevIsFloatingOpenRef.current = isFloatingOpen;
+    }, [isFloatingOpen, mode]);
+    useEffect(function () {
+        if (!messages.length)
+            return;
+        var el = chatContainerRef.current;
+        if (!el)
+            return;
+        var resizeObserver = new ResizeObserver(function () {
+            if (isUserAtBottomRef.current) {
+                anchorHistory();
+            }
+        });
+        resizeObserver.observe(el);
+        anchorHistory();
+        return function () {
+            resizeObserver.disconnect();
+        };
+    }, [messages]);
+    useEffect(function () {
+        var container = chatContainerRef.current;
+        if (!container)
+            return;
+        var isAtBottom = function (threshold) {
+            if (threshold === void 0) { threshold = 100; }
+            if (!container)
+                return true;
+            var scrollTop = container.scrollTop, scrollHeight = container.scrollHeight, clientHeight = container.clientHeight;
+            return scrollHeight - scrollTop - clientHeight <= threshold;
+        };
+        var handleScroll = function () {
+            isUserAtBottomRef.current = isAtBottom();
+        };
+        container.addEventListener('scroll', handleScroll, { passive: true });
+        handleScroll();
+        return function () {
+            container.removeEventListener('scroll', handleScroll);
+        };
+    }, []);
+    return {
+        messagesEndRef: messagesEndRef,
+        chatContainerRef: chatContainerRef,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"useScrollManagement.js","sourceRoot":"","sources":["../../src/hooks/useScrollManagement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAa3D,MAAM,UAAU,mBAAmB,CAAC,EAQP;QAP3B,QAAQ,cAAA,EACR,aAAa,mBAAA,EACb,wBAAwB,8BAAA,EACxB,0BAA0B,gCAAA,EAC1B,cAAc,oBAAA,EACd,cAAc,oBAAA,EACd,IAAI,UAAA;IAEJ,IAAM,cAAc,GAAG,MAAM,CAAiB,IAAI,CAAC,CAAC;IACpD,IAAM,gBAAgB,GAAG,MAAM,CAAiB,IAAI,CAAC,CAAC;IACtD,IAAM,kBAAkB,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IACzC,IAAM,iBAAiB,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IACvC,IAAM,qBAAqB,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IAErD,IAAM,aAAa,GAAG;QACpB,IAAM,EAAE,GAAG,gBAAgB,CAAC,OAAO,CAAC;QACpC,IAAI,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,kBAAkB,CAAC,OAAO;YAAE,OAAO;QAClE,IAAI,EAAE,CAAC,YAAY,KAAK,CAAC;YAAE,OAAO;QAClC,EAAE,CAAC,SAAS,GAAG,EAAE,CAAC,YAAY,CAAC;QAC/B,kBAAkB,CAAC,OAAO,GAAG,IAAI,CAAC;QAClC,iBAAiB,CAAC,OAAO,GAAG,IAAI,CAAC;IACnC,CAAC,CAAC;IAEF,IAAM,cAAc,GAAG,UAAC,QAAmC,EAAE,KAAsB;QAA3D,yBAAA,EAAA,mBAAmC;QAAE,sBAAA,EAAA,aAAsB;QACjF,IAAM,SAAS,GAAG,gBAAgB,CAAC,OAAO,CAAC;QAC3C,IAAM,EAAE,GAAG,cAAc,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,SAAS,IAAI,CAAC,EAAE;YAAE,OAAO;QAE9B,IAAI,CAAC,KAAK,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;YACzC,OAAO;QACT,CAAC;QAED,IAAM,QAAQ,GAAG;YACf,SAAS,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,YAAY,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC;YAC9D,iBAAiB,CAAC,OAAO,GAAG,IAAI,CAAC;QACnC,CAAC,CAAC;QACF,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;YACxB,QAAQ,EAAE,CAAC;QACb,CAAC;aAAM,CAAC;YACN,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC;IACH,CAAC,CAAC;IAEF,eAAe,CAAC;QACd,IAAI,CAAC,QAAQ,CAAC,MAAM;YAAE,OAAO;QAC7B,IAAI,kBAAkB,CAAC,OAAO,EAAE,CAAC;YAC/B,cAAc,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAClC,CAAC;aAAM,CAAC;YACN,aAAa,EAAE,CAAC;QAClB,CAAC;IACH,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEf,eAAe,CAAC;QACd,IAAI,CAAC,aAAa;YAAE,OAAO;QAC3B,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC/B,CAAC,EAAE,CAAC,aAAa,EAAE,wBAAwB,EAAE,0BAA0B,CAAC,CAAC,CAAC;IAE1E,SAAS,CAAC;QACR,kBAAkB,CAAC,OAAO,GAAG,KAAK,CAAC;IACrC,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;IAErB,SAAS,CAAC;QACR,IAAI,CAAC,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,YAAY,CAAC,IAAI,cAAc,IAAI,CAAC,qBAAqB,CAAC,OAAO,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9H,kBAAkB,CAAC,OAAO,GAAG,KAAK,CAAC;YACnC,iBAAiB,CAAC,OAAO,GAAG,IAAI,CAAC;YAEjC,IAAM,mBAAiB,GAAG;gBACxB,IAAM,SAAS,GAAG,gBAAgB,CAAC,OAAO,CAAC;gBAC3C,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,qBAAqB,CAAC,mBAAiB,CAAC,CAAC;oBACzC,OAAO;gBACT,CAAC;gBAED,IAAI,SAAS,CAAC,YAAY,KAAK,CAAC,EAAE,CAAC;oBACjC,qBAAqB,CAAC,mBAAiB,CAAC,CAAC;oBACzC,OAAO;gBACT,CAAC;gBAED,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,YAAY,CAAC;gBAC7C,kBAAkB,CAAC,OAAO,GAAG,IAAI,CAAC;gBAClC,iBAAiB,CAAC,OAAO,GAAG,IAAI,CAAC;YACnC,CAAC,CAAC;YAEF,qBAAqB,CAAC;gBACpB,qBAAqB,CAAC,mBAAiB,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;QACL,CAAC;QACD,qBAAqB,CAAC,OAAO,GAAG,cAAc,CAAC;IACjD,CAAC,EAAE,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC;IAE3B,SAAS,CAAC;QACR,IAAI,CAAC,QAAQ,CAAC,MAAM;YAAE,OAAO;QAC7B,IAAM,EAAE,GAAG,gBAAgB,CAAC,OAAO,CAAC;QACpC,IAAI,CAAC,EAAE;YAAE,OAAO;QAEhB,IAAM,cAAc,GAAG,IAAI,cAAc,CAAC;YACxC,IAAI,iBAAiB,CAAC,OAAO,EAAE,CAAC;gBAC9B,aAAa,EAAE,CAAC;YAClB,CAAC;QACH,CAAC,CAAC,CAAC;QACH,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAE3B,aAAa,EAAE,CAAC;QAEhB,OAAO;YACL,cAAc,CAAC,UAAU,EAAE,CAAC;QAC9B,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEf,SAAS,CAAC;QACR,IAAM,SAAS,GAAG,gBAAgB,CAAC,OAAO,CAAC;QAC3C,IAAI,CAAC,SAAS;YAAE,OAAO;QAEvB,IAAM,UAAU,GAAG,UAAC,SAAuB;YAAvB,0BAAA,EAAA,eAAuB;YACzC,IAAI,CAAC,SAAS;gBAAE,OAAO,IAAI,CAAC;YACpB,IAAA,SAAS,GAAiC,SAAS,UAA1C,EAAE,YAAY,GAAmB,SAAS,aAA5B,EAAE,YAAY,GAAK,SAAS,aAAd,CAAe;YAC5D,OAAO,YAAY,GAAG,SAAS,GAAG,YAAY,IAAI,SAAS,CAAC;QAC9D,CAAC,CAAC;QACF,IAAM,YAAY,GAAG;YACnB,iBAAiB,CAAC,OAAO,GAAG,UAAU,EAAE,CAAC;QAC3C,CAAC,CAAC;QACF,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QACtE,YAAY,EAAE,CAAC;QAEf,OAAO;YACL,SAAS,CAAC,mBAAmB,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QACxD,CAAC,CAAC;IACJ,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO;QACL,cAAc,gBAAA;QACd,gBAAgB,kBAAA;KACjB,CAAC;AACJ,CAAC","sourcesContent":["import { useRef, useLayoutEffect, useEffect } from 'react';\nimport { ChatMessage } from '../types';\n\ninterface UseScrollManagementOptions {\n  messages: ChatMessage[];\n  isAgentTyping: boolean;\n  currentThinkingPartIndex: number;\n  currentThinkingPartsLength: number;\n  conversationId: string | null | undefined;\n  isFloatingOpen: boolean;\n  mode: string;\n}\n\nexport function useScrollManagement({\n  messages,\n  isAgentTyping,\n  currentThinkingPartIndex,\n  currentThinkingPartsLength,\n  conversationId,\n  isFloatingOpen,\n  mode,\n}: UseScrollManagementOptions) {\n  const messagesEndRef = useRef<HTMLDivElement>(null);\n  const chatContainerRef = useRef<HTMLDivElement>(null);\n  const hasAnchoredHistory = useRef(false);\n  const isUserAtBottomRef = useRef(true);\n  const prevIsFloatingOpenRef = useRef(isFloatingOpen);\n\n  const anchorHistory = () => {\n    const el = chatContainerRef.current;\n    if (!el || !messages.length || hasAnchoredHistory.current) return;\n    if (el.clientHeight === 0) return;\n    el.scrollTop = el.scrollHeight;\n    hasAnchoredHistory.current = true;\n    isUserAtBottomRef.current = true;\n  };\n\n  const scrollToBottom = (behavior: ScrollBehavior = 'smooth', force: boolean = false) => {\n    const container = chatContainerRef.current;\n    const el = messagesEndRef.current;\n    if (!container || !el) return;\n\n    if (!force && !isUserAtBottomRef.current) {\n      return;\n    }\n\n    const doScroll = () => {\n      container.scrollTo({ top: container.scrollHeight, behavior });\n      isUserAtBottomRef.current = true;\n    };\n    if (behavior === 'auto') {\n      doScroll();\n    } else {\n      requestAnimationFrame(doScroll);\n    }\n  };\n\n  useLayoutEffect(() => {\n    if (!messages.length) return;\n    if (hasAnchoredHistory.current) {\n      scrollToBottom('smooth', false);\n    } else {\n      anchorHistory();\n    }\n  }, [messages]);\n\n  useLayoutEffect(() => {\n    if (!isAgentTyping) return;\n    scrollToBottom('auto', true);\n  }, [isAgentTyping, currentThinkingPartIndex, currentThinkingPartsLength]);\n\n  useEffect(() => {\n    hasAnchoredHistory.current = false;\n  }, [conversationId]);\n\n  useEffect(() => {\n    if ((mode === 'floating' || mode === 'fullscreen') && isFloatingOpen && !prevIsFloatingOpenRef.current && messages.length > 0) {\n      hasAnchoredHistory.current = false;\n      isUserAtBottomRef.current = true;\n\n      const scrollWhenVisible = () => {\n        const container = chatContainerRef.current;\n        if (!container) {\n          requestAnimationFrame(scrollWhenVisible);\n          return;\n        }\n\n        if (container.clientHeight === 0) {\n          requestAnimationFrame(scrollWhenVisible);\n          return;\n        }\n\n        container.scrollTop = container.scrollHeight;\n        hasAnchoredHistory.current = true;\n        isUserAtBottomRef.current = true;\n      };\n\n      requestAnimationFrame(() => {\n        requestAnimationFrame(scrollWhenVisible);\n      });\n    }\n    prevIsFloatingOpenRef.current = isFloatingOpen;\n  }, [isFloatingOpen, mode]);\n\n  useEffect(() => {\n    if (!messages.length) return;\n    const el = chatContainerRef.current;\n    if (!el) return;\n\n    const resizeObserver = new ResizeObserver(() => {\n      if (isUserAtBottomRef.current) {\n        anchorHistory();\n      }\n    });\n    resizeObserver.observe(el);\n\n    anchorHistory();\n\n    return () => {\n      resizeObserver.disconnect();\n    };\n  }, [messages]);\n\n  useEffect(() => {\n    const container = chatContainerRef.current;\n    if (!container) return;\n\n    const isAtBottom = (threshold: number = 100): boolean => {\n      if (!container) return true;\n      const { scrollTop, scrollHeight, clientHeight } = container;\n      return scrollHeight - scrollTop - clientHeight <= threshold;\n    };\n    const handleScroll = () => {\n      isUserAtBottomRef.current = isAtBottom();\n    };\n    container.addEventListener('scroll', handleScroll, { passive: true });\n    handleScroll();\n\n    return () => {\n      container.removeEventListener('scroll', handleScroll);\n    };\n  }, []);\n\n  return {\n    messagesEndRef,\n    chatContainerRef,\n  };\n}\n"]}

package/dist/hooks/useThinkingAnimation.d.ts

@@ -0,0 +1,12 @@
+import type { Translations } from '../types';
+interface UseThinkingAnimationOptions {
+    isAgentTyping: boolean;
+    thinkingPhrases: string[] | undefined;
+    thinkingDelayMs: number | undefined;
+    translations: Translations;
+}
+export declare function useThinkingAnimation({ isAgentTyping, thinkingPhrases, thinkingDelayMs, translations, }: UseThinkingAnimationOptions): {
+    currentThinkingParts: string[];
+    currentThinkingPartIndex: number;
+};
+export {};

package/dist/hooks/useThinkingAnimation.js

@@ -0,0 +1,53 @@
+import { useState, useEffect, useMemo } from 'react';
+import { getTranslationArray } from '../utils/i18n';
+export function useThinkingAnimation(_a) {
+    var isAgentTyping = _a.isAgentTyping, thinkingPhrases = _a.thinkingPhrases, thinkingDelayMs = _a.thinkingDelayMs, translations = _a.translations;
+    var DEFAULT_THINKING_MESSAGES = useMemo(function () { return getTranslationArray('thinking.messages', translations, [
+        "Thinking…",
+        "Analyzing your question…",
+        "Searching knowledge…",
+        "Pulling relevant info…",
+        "Drafting the answer…",
+        "Double‑checking details…",
+        "Tying it together…",
+        "Almost there…",
+    ]); }, [translations]);
+    var _b = useState([]), currentThinkingParts = _b[0], setCurrentThinkingParts = _b[1];
+    var _c = useState(0), currentThinkingPartIndex = _c[0], setCurrentThinkingPartIndex = _c[1];
+    useEffect(function () {
+        if (!isAgentTyping) {
+            setCurrentThinkingParts([]);
+            setCurrentThinkingPartIndex(0);
+            return;
+        }
+        var list = (thinkingPhrases && thinkingPhrases.length > 0) ? thinkingPhrases : DEFAULT_THINKING_MESSAGES;
+        var randomIndex = Math.floor(Math.random() * list.length);
+        var selectedPhrase = list[randomIndex];
+        var parts = selectedPhrase.includes('|')
+            ? selectedPhrase.split('|').map(function (part) { return part.trim(); }).filter(function (part) { return part.length > 0; })
+            : [selectedPhrase.trim()];
+        setCurrentThinkingParts(parts);
+        setCurrentThinkingPartIndex(0);
+        if (parts.length <= 1)
+            return;
+        var rotDelay = Math.max(250, thinkingDelayMs || 1000);
+        var timeoutIds = [];
+        var _loop_1 = function (i) {
+            var timeoutId = setTimeout(function () {
+                setCurrentThinkingPartIndex(i);
+            }, rotDelay * i);
+            timeoutIds.push(timeoutId);
+        };
+        for (var i = 1; i < parts.length; i++) {
+            _loop_1(i);
+        }
+        return function () {
+            timeoutIds.forEach(function (id) { return clearTimeout(id); });
+        };
+    }, [isAgentTyping, thinkingPhrases, thinkingDelayMs]);
+    return {
+        currentThinkingParts: currentThinkingParts,
+        currentThinkingPartIndex: currentThinkingPartIndex,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/useViewportManager.d.ts

@@ -0,0 +1,20 @@
+interface UseViewportManagerOptions {
+    mode: string;
+    widget: boolean;
+    isFloatingOpen: boolean;
+    showResetConfirm: boolean;
+    showLanguageDropdown: boolean;
+    showMenu: boolean;
+    onExitFullscreen?: () => void;
+    setShowResetConfirm: (v: boolean) => void;
+    setShowLanguageDropdown: (v: boolean) => void;
+    setShowMenu: (v: boolean) => void;
+}
+export declare function useViewportManager({ mode, widget, isFloatingOpen, showResetConfirm, showLanguageDropdown, showMenu, onExitFullscreen, setShowResetConfirm, setShowLanguageDropdown, setShowMenu, }: UseViewportManagerOptions): {
+    windowWidth: number;
+    windowHeight: number;
+    isFullscreen: boolean;
+    isFullscreenToggled: boolean;
+    handleFullscreenToggle: () => void;
+};
+export {};

package/dist/hooks/useViewportManager.js

@@ -0,0 +1,100 @@
+import { useState, useEffect, useMemo } from 'react';
+export function useViewportManager(_a) {
+    var mode = _a.mode, widget = _a.widget, isFloatingOpen = _a.isFloatingOpen, showResetConfirm = _a.showResetConfirm, showLanguageDropdown = _a.showLanguageDropdown, showMenu = _a.showMenu, onExitFullscreen = _a.onExitFullscreen, setShowResetConfirm = _a.setShowResetConfirm, setShowLanguageDropdown = _a.setShowLanguageDropdown, setShowMenu = _a.setShowMenu;
+    var _b = useState(typeof window !== 'undefined' ? window.innerWidth : 1024), windowWidth = _b[0], setWindowWidth = _b[1];
+    var _c = useState(typeof window !== 'undefined' ? window.innerHeight : 700), windowHeight = _c[0], setWindowHeight = _c[1];
+    var _d = useState(false), isFullscreenToggled = _d[0], setIsFullscreenToggled = _d[1];
+    var isFullscreen = useMemo(function () {
+        if (mode === 'fullscreen')
+            return true;
+        if (widget)
+            return true;
+        if (isFullscreenToggled)
+            return true;
+        return windowWidth <= 768;
+    }, [windowWidth, widget, isFullscreenToggled, mode]);
+    var handleFullscreenToggle = function () {
+        setIsFullscreenToggled(function (prev) { return !prev; });
+        setShowMenu(false);
+    };
+    useEffect(function () {
+        if (typeof window === 'undefined')
+            return;
+        if (mode === 'floating' && !isFloatingOpen)
+            return;
+        var onKeyDown = function (e) {
+            if (e.key !== 'Escape')
+                return;
+            if (showResetConfirm) {
+                e.preventDefault();
+                setShowResetConfirm(false);
+                return;
+            }
+            if (showLanguageDropdown) {
+                e.preventDefault();
+                setShowLanguageDropdown(false);
+                return;
+            }
+            if (showMenu) {
+                e.preventDefault();
+                setShowMenu(false);
+                return;
+            }
+            if (!isFullscreen)
+                return;
+            if (isFullscreenToggled) {
+                e.preventDefault();
+                setIsFullscreenToggled(false);
+                return;
+            }
+            if (mode === 'fullscreen' && onExitFullscreen) {
+                e.preventDefault();
+                onExitFullscreen();
+            }
+        };
+        window.addEventListener('keydown', onKeyDown);
+        return function () { return window.removeEventListener('keydown', onKeyDown); };
+    }, [
+        isFloatingOpen,
+        isFullscreen,
+        isFullscreenToggled,
+        mode,
+        onExitFullscreen,
+        showLanguageDropdown,
+        showMenu,
+        showResetConfirm,
+    ]);
+    useEffect(function () {
+        var updateViewport = function () {
+            setWindowWidth(window.innerWidth);
+            setWindowHeight(window.innerHeight);
+        };
+        updateViewport();
+        window.addEventListener('resize', updateViewport);
+        var vv = typeof window !== 'undefined' ? window.visualViewport : null;
+        vv === null || vv === void 0 ? void 0 : vv.addEventListener('resize', updateViewport);
+        vv === null || vv === void 0 ? void 0 : vv.addEventListener('scroll', updateViewport);
+        return function () {
+            window.removeEventListener('resize', updateViewport);
+            vv === null || vv === void 0 ? void 0 : vv.removeEventListener('resize', updateViewport);
+            vv === null || vv === void 0 ? void 0 : vv.removeEventListener('scroll', updateViewport);
+        };
+    }, []);
+    useEffect(function () {
+        if (isFullscreen && typeof document !== 'undefined') {
+            var originalStyle_1 = window.getComputedStyle(document.body).overflow;
+            document.body.style.overflow = 'hidden';
+            return function () {
+                document.body.style.overflow = originalStyle_1;
+            };
+        }
+    }, [isFullscreen]);
+    return {
+        windowWidth: windowWidth,
+        windowHeight: windowHeight,
+        isFullscreen: isFullscreen,
+        isFullscreenToggled: isFullscreenToggled,
+        handleFullscreenToggle: handleFullscreenToggle,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"useViewportManager.js","sourceRoot":"","sources":["../../src/hooks/useViewportManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { useState, useEffect, useMemo } from 'react';\n\ninterface UseViewportManagerOptions {\n  mode: string;\n  widget: boolean;\n  isFloatingOpen: boolean;\n  showResetConfirm: boolean;\n  showLanguageDropdown: boolean;\n  showMenu: boolean;\n  onExitFullscreen?: () => void;\n  setShowResetConfirm: (v: boolean) => void;\n  setShowLanguageDropdown: (v: boolean) => void;\n  setShowMenu: (v: boolean) => void;\n}\n\nexport function useViewportManager({\n  mode,\n  widget,\n  isFloatingOpen,\n  showResetConfirm,\n  showLanguageDropdown,\n  showMenu,\n  onExitFullscreen,\n  setShowResetConfirm,\n  setShowLanguageDropdown,\n  setShowMenu,\n}: UseViewportManagerOptions) {\n  const [windowWidth, setWindowWidth] = useState(typeof window !== 'undefined' ? window.innerWidth : 1024);\n  const [windowHeight, setWindowHeight] = useState(typeof window !== 'undefined' ? window.innerHeight : 700);\n  const [isFullscreenToggled, setIsFullscreenToggled] = useState(false);\n\n  const isFullscreen = useMemo(() => {\n    if (mode === 'fullscreen') return true;\n    if (widget) return true;\n    if (isFullscreenToggled) return true;\n    return windowWidth <= 768;\n  }, [windowWidth, widget, isFullscreenToggled, mode]);\n\n  const handleFullscreenToggle = () => {\n    setIsFullscreenToggled(prev => !prev);\n    setShowMenu(false);\n  };\n\n  useEffect(() => {\n    if (typeof window === 'undefined') return;\n    if (mode === 'floating' && !isFloatingOpen) return;\n\n    const onKeyDown = (e: KeyboardEvent) => {\n      if (e.key !== 'Escape') return;\n\n      if (showResetConfirm) {\n        e.preventDefault();\n        setShowResetConfirm(false);\n        return;\n      }\n      if (showLanguageDropdown) {\n        e.preventDefault();\n        setShowLanguageDropdown(false);\n        return;\n      }\n      if (showMenu) {\n        e.preventDefault();\n        setShowMenu(false);\n        return;\n      }\n\n      if (!isFullscreen) return;\n\n      if (isFullscreenToggled) {\n        e.preventDefault();\n        setIsFullscreenToggled(false);\n        return;\n      }\n      if (mode === 'fullscreen' && onExitFullscreen) {\n        e.preventDefault();\n        onExitFullscreen();\n      }\n    };\n\n    window.addEventListener('keydown', onKeyDown);\n    return () => window.removeEventListener('keydown', onKeyDown);\n  }, [\n    isFloatingOpen,\n    isFullscreen,\n    isFullscreenToggled,\n    mode,\n    onExitFullscreen,\n    showLanguageDropdown,\n    showMenu,\n    showResetConfirm,\n  ]);\n\n  useEffect(() => {\n    const updateViewport = () => {\n      setWindowWidth(window.innerWidth);\n      setWindowHeight(window.innerHeight);\n    };\n    updateViewport();\n    window.addEventListener('resize', updateViewport);\n    const vv = typeof window !== 'undefined' ? window.visualViewport : null;\n    vv?.addEventListener('resize', updateViewport);\n    vv?.addEventListener('scroll', updateViewport);\n    return () => {\n      window.removeEventListener('resize', updateViewport);\n      vv?.removeEventListener('resize', updateViewport);\n      vv?.removeEventListener('scroll', updateViewport);\n    };\n  }, []);\n\n  useEffect(() => {\n    if (isFullscreen && typeof document !== 'undefined') {\n      const originalStyle = window.getComputedStyle(document.body).overflow;\n      document.body.style.overflow = 'hidden';\n      return () => {\n        document.body.style.overflow = originalStyle;\n      };\n    }\n  }, [isFullscreen]);\n\n  return {\n    windowWidth,\n    windowHeight,\n    isFullscreen,\n    isFullscreenToggled,\n    handleFullscreenToggle,\n  };\n}\n"]}

package/dist/services/chatService.d.ts

@@ -126,6 +126,7 @@ export declare class ChatService {
     isConversationFinalized(): boolean;
     startConversation(reCaptchaToken?: string | undefined): Promise<string>;
     sendMessage(message: string, attachments?: Attachment[], extraMetadata?: Record<string, any>, reCaptchaToken?: string): Promise<void>;
+    sendAudioMessage(audioBlob: Blob, audioFormat: string, extraMetadata?: Record<string, any>): Promise<void>;
     uploadFile(chatId: string, file: File): Promise<FileUploadResponse | null>;
     /**
      * Process raw WebSocket message data. Called from useChatWebSocket hook.