genassist-chat-react 1.0.37 → 1.0.38

package/dist/hooks/useFileAttachments.js

@@ -0,0 +1,183 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { useState, useRef, useEffect } from 'react';
+export function useFileAttachments(_a) {
+    var _this = this;
+    var uploadFile = _a.uploadFile, t = _a.t;
+    var _b = useState([]), attachments = _b[0], setAttachments = _b[1];
+    var _c = useState(new Set()), uploadingFiles = _c[0], setUploadingFiles = _c[1];
+    var _d = useState(null), fileErrorToast = _d[0], setFileErrorToast = _d[1];
+    var fileErrorToastTimeoutRef = useRef(null);
+    var fileInputRef = useRef(null);
+    useEffect(function () {
+        return function () {
+            if (fileErrorToastTimeoutRef.current) {
+                clearTimeout(fileErrorToastTimeoutRef.current);
+            }
+        };
+    }, []);
+    var handleFileChange = function (e) { return __awaiter(_this, void 0, void 0, function () {
+        var newFiles_1, newAttachments_1, newUploadingFiles_1, settled, fileToAttachmentMap_1, failedFileKeys_1, hasFailedUploads, error_1, finalUploadingFiles_1;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(e.target.files && e.target.files.length > 0)) return [3 /*break*/, 5];
+                    newFiles_1 = Array.from(e.target.files);
+                    newAttachments_1 = newFiles_1.map(function (file) { return ({ file: file, attachment: null }); });
+                    setAttachments(function (prev) { return __spreadArray(__spreadArray([], prev, true), newAttachments_1, true); });
+                    newUploadingFiles_1 = new Set(uploadingFiles);
+                    newFiles_1.forEach(function (file) { return newUploadingFiles_1.add(file.name); });
+                    setUploadingFiles(newUploadingFiles_1);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    return [4 /*yield*/, Promise.allSettled(newFiles_1.map(function (file) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = { file: file };
+                                        return [4 /*yield*/, uploadFile(file)];
+                                    case 1: return [2 /*return*/, (_a.attachment = _b.sent(), _a)];
+                                }
+                            });
+                        }); }))];
+                case 2:
+                    settled = _a.sent();
+                    fileToAttachmentMap_1 = new Map();
+                    failedFileKeys_1 = new Set();
+                    settled.forEach(function (result, index) {
+                        var file = newFiles_1[index];
+                        if (!file)
+                            return;
+                        var fileKey = "".concat(file.name, ":").concat(file.size, ":").concat(file.lastModified);
+                        if (result.status === 'rejected') {
+                            fileToAttachmentMap_1.set(fileKey, null);
+                            failedFileKeys_1.add(fileKey);
+                            return;
+                        }
+                        var attachment = result.value.attachment;
+                        fileToAttachmentMap_1.set(fileKey, attachment);
+                        if (attachment === null) {
+                            failedFileKeys_1.add(fileKey);
+                        }
+                    });
+                    hasFailedUploads = failedFileKeys_1.size > 0;
+                    setAttachments(function (prev) {
+                        return prev
+                            .filter(function (att) {
+                            var fileKey = "".concat(att.file.name, ":").concat(att.file.size, ":").concat(att.file.lastModified);
+                            return !failedFileKeys_1.has(fileKey);
+                        })
+                            .map(function (att) {
+                            var fileKey = "".concat(att.file.name, ":").concat(att.file.size, ":").concat(att.file.lastModified);
+                            var uploadedAttachment = fileToAttachmentMap_1.get(fileKey);
+                            if (uploadedAttachment !== undefined) {
+                                return __assign(__assign({}, att), { attachment: uploadedAttachment });
+                            }
+                            return att;
+                        });
+                    });
+                    if (hasFailedUploads) {
+                        if (fileErrorToastTimeoutRef.current) {
+                            clearTimeout(fileErrorToastTimeoutRef.current);
+                        }
+                        setFileErrorToast(t('fileUpload.fileTypeNotSupported', 'This file type is not supported.'));
+                        fileErrorToastTimeoutRef.current = setTimeout(function () {
+                            setFileErrorToast(null);
+                            fileErrorToastTimeoutRef.current = null;
+                        }, 4000);
+                    }
+                    return [3 /*break*/, 5];
+                case 3:
+                    error_1 = _a.sent();
+                    console.error('Error uploading file', error_1);
+                    return [3 /*break*/, 5];
+                case 4:
+                    finalUploadingFiles_1 = new Set(uploadingFiles);
+                    newFiles_1.forEach(function (file) { return finalUploadingFiles_1.delete(file.name); });
+                    setUploadingFiles(finalUploadingFiles_1);
+                    if (fileInputRef.current) {
+                        fileInputRef.current.value = '';
+                    }
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+    var handleRemoveAttachment = function (fileName) {
+        setAttachments(function (prev) { return prev.filter(function (att) { return att.file.name !== fileName; }); });
+    };
+    var clearAttachments = function () {
+        setAttachments([]);
+        if (fileInputRef.current) {
+            fileInputRef.current.value = '';
+        }
+    };
+    return {
+        attachments: attachments,
+        setAttachments: setAttachments,
+        uploadingFiles: uploadingFiles,
+        fileErrorToast: fileErrorToast,
+        fileInputRef: fileInputRef,
+        handleFileChange: handleFileChange,
+        handleRemoveAttachment: handleRemoveAttachment,
+        clearAttachments: clearAttachments,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"useFileAttachments.js","sourceRoot":"","sources":["../../src/hooks/useFileAttachments.ts"],"names":[],"mappings":"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","sourcesContent":["import { useState, useRef, useEffect } from 'react';\nimport { Attachment, AttachmentWithFile } from '../types';\n\ninterface UseFileAttachmentsOptions {\n  uploadFile: (file: File) => Promise<Attachment | null>;\n  t: (key: string, fallback?: string) => string;\n}\n\nexport function useFileAttachments({ uploadFile, t }: UseFileAttachmentsOptions) {\n  const [attachments, setAttachments] = useState<AttachmentWithFile[]>([]);\n  const [uploadingFiles, setUploadingFiles] = useState<Set<string>>(new Set());\n  const [fileErrorToast, setFileErrorToast] = useState<string | null>(null);\n  const fileErrorToastTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const fileInputRef = useRef<HTMLInputElement>(null);\n\n  useEffect(() => {\n    return () => {\n      if (fileErrorToastTimeoutRef.current) {\n        clearTimeout(fileErrorToastTimeoutRef.current);\n      }\n    };\n  }, []);\n\n  const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {\n    if (e.target.files && e.target.files.length > 0) {\n      const newFiles = Array.from(e.target.files);\n\n      const newAttachments: AttachmentWithFile[] = newFiles.map(file => ({ file, attachment: null }));\n      setAttachments(prev => [...prev, ...newAttachments]);\n\n      const newUploadingFiles = new Set(uploadingFiles);\n      newFiles.forEach(file => newUploadingFiles.add(file.name));\n      setUploadingFiles(newUploadingFiles);\n\n      try {\n        const settled = await Promise.allSettled(\n          newFiles.map(async (file) => ({ file, attachment: await uploadFile(file) }))\n        );\n\n        const fileToAttachmentMap = new Map<string, Attachment | null>();\n        const failedFileKeys = new Set<string>();\n        settled.forEach((result, index) => {\n          const file = newFiles[index];\n          if (!file) return;\n          const fileKey = `${file.name}:${file.size}:${file.lastModified}`;\n          if (result.status === 'rejected') {\n            fileToAttachmentMap.set(fileKey, null);\n            failedFileKeys.add(fileKey);\n            return;\n          }\n          const { attachment } = result.value;\n          fileToAttachmentMap.set(fileKey, attachment);\n          if (attachment === null) {\n            failedFileKeys.add(fileKey);\n          }\n        });\n\n        const hasFailedUploads = failedFileKeys.size > 0;\n\n        setAttachments(prev => {\n          return prev\n            .filter(att => {\n              const fileKey = `${att.file.name}:${att.file.size}:${att.file.lastModified}`;\n              return !failedFileKeys.has(fileKey);\n            })\n            .map(att => {\n              const fileKey = `${att.file.name}:${att.file.size}:${att.file.lastModified}`;\n              const uploadedAttachment = fileToAttachmentMap.get(fileKey);\n              if (uploadedAttachment !== undefined) {\n                return { ...att, attachment: uploadedAttachment };\n              }\n              return att;\n            });\n        });\n\n        if (hasFailedUploads) {\n          if (fileErrorToastTimeoutRef.current) {\n            clearTimeout(fileErrorToastTimeoutRef.current);\n          }\n          setFileErrorToast(t('fileUpload.fileTypeNotSupported', 'This file type is not supported.'));\n          fileErrorToastTimeoutRef.current = setTimeout(() => {\n            setFileErrorToast(null);\n            fileErrorToastTimeoutRef.current = null;\n          }, 4000);\n        }\n      } catch (error) {\n        console.error('Error uploading file', error);\n      } finally {\n        const finalUploadingFiles = new Set(uploadingFiles);\n        newFiles.forEach(file => finalUploadingFiles.delete(file.name));\n        setUploadingFiles(finalUploadingFiles);\n        if (fileInputRef.current) {\n          fileInputRef.current!.value = '';\n        }\n      }\n    }\n  };\n\n  const handleRemoveAttachment = (fileName: string) => {\n    setAttachments(prev => prev.filter(att => att.file.name !== fileName));\n  };\n\n  const clearAttachments = () => {\n    setAttachments([]);\n    if (fileInputRef.current) {\n      fileInputRef.current.value = '';\n    }\n  };\n\n  return {\n    attachments,\n    setAttachments,\n    uploadingFiles,\n    fileErrorToast,\n    fileInputRef,\n    handleFileChange,\n    handleRemoveAttachment,\n    clearAttachments,\n  };\n}\n"]}

package/dist/hooks/useScrollManagement.d.ts

@@ -0,0 +1,15 @@
+import { ChatMessage } from '../types';
+interface UseScrollManagementOptions {
+    messages: ChatMessage[];
+    isAgentTyping: boolean;
+    currentThinkingPartIndex: number;
+    currentThinkingPartsLength: number;
+    conversationId: string | null | undefined;
+    isFloatingOpen: boolean;
+    mode: string;
+}
+export declare function useScrollManagement({ messages, isAgentTyping, currentThinkingPartIndex, currentThinkingPartsLength, conversationId, isFloatingOpen, mode, }: UseScrollManagementOptions): {
+    messagesEndRef: import("react").RefObject<HTMLDivElement>;
+    chatContainerRef: import("react").RefObject<HTMLDivElement>;
+};
+export {};

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":"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","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.