@alan-ai/alan-sdk-web 1.8.97 → 1.8.98

package/dist/alan_lib.js

@@ -93426,6 +93426,76 @@ code.hljs {
     viewportWidth: 0,
     viewportHeight: 0
   };
+  function getDomPath(element) {
+    if (!element || element.nodeType !== Node.ELEMENT_NODE) {
+      return "";
+    }
+    const pathSegments = [];
+    let current2 = element;
+    while (current2 && current2.nodeType === Node.ELEMENT_NODE) {
+      let selector = current2.nodeName.toLowerCase();
+      if (current2.id) {
+        selector += `#${current2.id}`;
+        pathSegments.unshift(selector);
+        break;
+      }
+      let siblingIndex = 1;
+      let sibling2 = current2.previousElementSibling;
+      while (sibling2) {
+        if (sibling2.nodeName === current2.nodeName) {
+          siblingIndex++;
+        }
+        sibling2 = sibling2.previousElementSibling;
+      }
+      if (siblingIndex > 1) {
+        selector += `:nth-of-type(${siblingIndex})`;
+      }
+      pathSegments.unshift(selector);
+      current2 = current2.parentElement;
+    }
+    return pathSegments.join(" > ");
+  }
+  function collectScrollableElementStates() {
+    if (typeof document === "undefined") {
+      return [];
+    }
+    const elements = /* @__PURE__ */ new Set();
+    document.querySelectorAll("*").forEach((el) => elements.add(el));
+    if (document.body) elements.add(document.body);
+    if (document.documentElement) elements.add(document.documentElement);
+    if (document.scrollingElement) elements.add(document.scrollingElement);
+    const scrollableStates = [];
+    const overflowRegex = /(auto|scroll|overlay)/i;
+    elements.forEach((element) => {
+      if (!(element instanceof HTMLElement)) {
+        return;
+      }
+      const scrollHeight = element.scrollHeight;
+      const clientHeight = element.clientHeight;
+      const scrollWidth = element.scrollWidth;
+      const clientWidth = element.clientWidth;
+      if (clientHeight === 0 && clientWidth === 0) {
+        return;
+      }
+      const computedStyle = window.getComputedStyle(element);
+      const overflowY = computedStyle.overflowY;
+      const overflowX = computedStyle.overflowX;
+      const isRootElement = element === document.body || element === document.documentElement || element === document.scrollingElement;
+      const canScrollVertically = scrollHeight - clientHeight > 1;
+      const canScrollHorizontally = scrollWidth - clientWidth > 1;
+      const allowsVerticalScroll = isRootElement || overflowRegex.test(overflowY);
+      const allowsHorizontalScroll = isRootElement || overflowRegex.test(overflowX);
+      if (!(canScrollVertically && allowsVerticalScroll || canScrollHorizontally && allowsHorizontalScroll)) {
+        return;
+      }
+      scrollableStates.push({
+        path: getDomPath(element),
+        scrollTop: element.scrollTop,
+        scrollLeft: element.scrollLeft
+      });
+    });
+    return scrollableStates;
+  }
   function generateContentHash(content) {
     let hash = 0;
     for (let i = 0; i < content.length; i++) {
@@ -93465,7 +93535,7 @@ code.hljs {
       window.removeEventListener(ALAN_BTN_PAGE_SYNC_EVENT, listenForPageChanges);
     }
   }
-  async function attemptPageStateSync(onSendCb, forceUpdate = false) {
+  async function attemptPageStateSync(onSendCb, forceUpdate = false, reason) {
     const currentTime = performance.now();
     const timeSinceLastCall = currentTime - lastSendPageStateTime;
     if (timeSinceLastCall < SEND_PAGE_STATE_THROTTLE_MS && !forceUpdate) {
@@ -93477,7 +93547,7 @@ code.hljs {
       pendingSyncTimeout = setTimeout(() => {
         pendingSync = false;
         pendingSyncTimeout = null;
-        sendPageState(onSendCb, true);
+        sendPageState(onSendCb, true, reason);
       }, delayMs);
       return;
     }
@@ -93486,48 +93556,55 @@ code.hljs {
       pendingSyncTimeout = null;
       pendingSync = false;
     }
-    await sendPageState(onSendCb, forceUpdate);
+    await sendPageState(onSendCb, forceUpdate, reason);
   }
-  function syncPageState(onSendCb, forceUpdate) {
-    attemptPageStateSync(onSendCb, forceUpdate);
+  function syncPageState(onSendCb, forceUpdate, reason) {
+    attemptPageStateSync(onSendCb, forceUpdate, reason);
   }
   function listenForPageChanges() {
     sendPageState();
   }
-  async function captureScreenshot(requestId) {
+  async function captureScreenshot(requestId, reason) {
     if (!document.body) {
       throw new Error("Document body not available");
     }
-    const bodyRect = document.body.getBoundingClientRect();
-    const maxWidth = 1280;
-    const maxHeight = 1024;
-    const scale = Math.min(maxWidth / bodyRect.width, maxHeight / bodyRect.height, 1);
     try {
-      const canvas = await html2canvas(document.body, {
-        logging: false,
-        scale,
-        useCORS: false,
-        allowTaint: false,
-        backgroundColor: "#ffffff",
-        removeContainer: true,
-        ignoreElements: (element) => {
-          if (!element || !element.tagName) return false;
-          if (element.classList) {
-            if (element.classList.contains("hidden")) return true;
-          }
-          return false;
-        }
-      });
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      const dataURL = canvas.toDataURL("image/jpeg", 0.8);
-      canvas.width = 0;
-      canvas.height = 0;
-      return dataURL;
-    } catch (error) {
-      throw error;
+      const html3 = document.documentElement.outerHTML;
+      const maxWidth = 1280;
+      const maxHeight = 1024;
+      const scrollStates = collectScrollableElementStates();
+      let res;
+      try {
+        res = await new Promise((resolve, reject) => {
+          window.tutorProject.call(
+            "generateScreenshot",
+            {
+              html: html3,
+              baseHref: window.location.origin,
+              width: Math.min(window.innerWidth, maxWidth),
+              height: Math.min(window.innerHeight, maxHeight),
+              fullPage: true,
+              imageType: "jpeg",
+              quality: 85,
+              scrollStates
+            },
+            (err, screenshot) => {
+              if (err) reject(err);
+              else resolve(screenshot);
+            }
+          );
+        });
+      } catch (err) {
+        console.error("Screenshot failed", err);
+        return "";
+      }
+      return res.screenshot;
+    } catch (err) {
+      console.error("Screenshot error:", err);
+      throw err;
     }
   }
-  async function sendPageState(onSendCb, forceUpdate) {
+  async function sendPageState(onSendCb, forceUpdate, reason) {
     lastSendPageStateTime = performance.now();
     const currentRequestId = ++requestCounter;
     try {
@@ -93574,7 +93651,7 @@ code.hljs {
         return;
       }
       if (uiState10.pageState?.screenshot?.enabled) {
-        params.screenshot = await captureScreenshot(currentRequestId);
+        params.screenshot = await captureScreenshot(currentRequestId, reason);
       }
       window.tutorProject.call("syncPageState", params);
     } catch (error) {
@@ -101617,8 +101694,8 @@ code.hljs {
   // alan_btn/alan_btn.ts
   (function(ns) {
     const uiState10 = getUIState();
-    uiState10.lib.version = "alan-version.1.8.97".replace("alan-version.", "");
-    window.alanLib = { version: "alan-version.1.8.97".replace("alan-version.", "") };
+    uiState10.lib.version = "alan-version.1.8.98".replace("alan-version.", "");
+    window.alanLib = { version: "alan-version.1.8.98".replace("alan-version.", "") };
     if (window.alanBtn) {
       console.warn("Alan: the Alan Button source code has already added (v." + uiState10.lib.version + ")");
     }
@@ -103386,16 +103463,13 @@ ${getSavedDialogId() || "-"} (prev. dialog)`);
             }
             console.info(`Alan: curDialogId:
 ${curDialogId}`);
-          }
-          if (!isTutorMode()) {
-            sendSyncPageState();
+            sendSyncPageState(null, "onConnectStatusChange");
           }
         }
         if (options.onConnectionStatus) {
           options.onConnectionStatus(res);
         }
         isMsgTypingInProcess = false;
-        sendSyncPageState(true);
       }
       function onMicAllowed() {
         sendClientEvent({ micAllowed: true });
@@ -104480,6 +104554,7 @@ ${LEARN_MORE_LABEL}
         _sendText(text3);
         textareaHolderEl.classList.add("alan-btn__inactive");
         textChatScrollPosition = null;
+        sendSyncPageState();
       }, 1e3);
       function getMsgElForMathJax(msgInd) {
         const msgEl = document.getElementById("msg-" + msgInd);
@@ -104699,8 +104774,12 @@ ${LEARN_MORE_LABEL}
       }
       function decryptMessage(encryptedMessage, encryptKey) {
         const key = import_sjcl.default.codec.hex.fromBits(import_sjcl.default.hash.sha256.hash(encryptKey || (uiState10.userInfo?.userId || "default")));
-        const decrypted = import_sjcl.default.decrypt(key, JSON.parse(atob(encryptedMessage)));
-        return decrypted;
+        try {
+          const decrypted = import_sjcl.default.decrypt(key, JSON.parse(atob(encryptedMessage)));
+          return decrypted;
+        } catch (e) {
+          return null;
+        }
       }
       function restoreSentMessages() {
         let messages = [];
@@ -104770,11 +104849,11 @@ ${LEARN_MORE_LABEL}
         }
       }
       let isMsgTypingInProcess = false;
-      function sendSyncPageState(forceUpdate = false) {
+      function sendSyncPageState(forceUpdate = false, reason) {
         if (!isMsgTypingInProcess) {
           syncPageState(function() {
             isMsgTypingInProcess = true;
-          }, forceUpdate);
+          }, forceUpdate, reason);
           setTimeout(() => {
             isMsgTypingInProcess = false;
           }, 2e3);