pdfjs-viewer-highlight-echo 5.4.457 → 5.4.460

package/legacy/web/viewer.mjs

@@ -21,8 +21,8 @@
  */
 
 /**
- * pdfjsVersion = 5.4.457
- * pdfjsBuild = d53d4404b
+ * pdfjsVersion = 5.4.460
+ * pdfjsBuild = 8489d7097
  */
 /******/ var __webpack_modules__ = ({
 
@@ -58,6 +58,45 @@ module.exports = function (argument, usingIterator) {
 };
 
 
+/***/ }),
+
+/***/ 116:
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+
+var $ = __webpack_require__(6518);
+var call = __webpack_require__(9565);
+var iterate = __webpack_require__(2652);
+var aCallable = __webpack_require__(9306);
+var anObject = __webpack_require__(8551);
+var getIteratorDirect = __webpack_require__(1767);
+var iteratorClose = __webpack_require__(9539);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
+
+var findWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('find', TypeError);
+
+// `Iterator.prototype.find` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.find
+$({ target: 'Iterator', proto: true, real: true, forced: findWithoutClosingOnEarlyError }, {
+  find: function find(predicate) {
+    anObject(this);
+    try {
+      aCallable(predicate);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (findWithoutClosingOnEarlyError) return call(findWithoutClosingOnEarlyError, this, predicate);
+
+    var record = getIteratorDirect(this);
+    var counter = 0;
+    return iterate(record, function (value, stop) {
+      if (predicate(value, counter++)) return stop(value);
+    }, { IS_RECORD: true, INTERRUPTED: true }).result;
+  }
+});
+
+
 /***/ }),
 
 /***/ 283:
@@ -12232,6 +12271,7 @@ class PDFFilterView {
       this.eventBus.dispatch("filterhighlightselected", {
         source: this,
         pageNumber: page,
+        id: this.highlightData.id,
         location: {
           x,
           y,
@@ -12379,18 +12419,28 @@ class PDFFilterViewer {
   }
 }
 
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.find.js
+var es_iterator_find = __webpack_require__(116);
 ;// ./web/filter_highlight_overlay.js
+
+
+
+
+
+
 class FilterHighlightOverlay {
   #eventBus = null;
   #currentOverlay = null;
   #uiManager = null;
+  #lastPageNumber = null;
+  #highlightEditorsByPage = new Map();
   constructor(eventBus) {
     this.#eventBus = eventBus;
     this.#addEventListeners();
   }
   #addEventListeners() {
     this.#eventBus._on("filterhighlightselected", evt => {
-      this.showHighlight(evt.pageNumber, evt.location);
+      this.showHighlight(evt.pageNumber, evt.location, evt.id);
     });
     this.#eventBus._on("annotationeditoruimanager", ({
       uiManager
@@ -12398,8 +12448,85 @@ class FilterHighlightOverlay {
       this.#uiManager = uiManager;
     });
   }
-  async showHighlight(pageNumber, location) {
-    this.clearHighlight();
+  storeHighlightEditorsForCurPageNum(id, pageNumber, uiManager) {
+    const editorList = Array.from(uiManager.getEditors(pageNumber - 1));
+    console.log(`DEBUG - Found ${editorList.length} editor(s) for page ${pageNumber}`);
+    let highlightDivIds = [];
+    highlightDivIds = this.#highlightEditorsByPage.get(pageNumber) || [];
+    for (const editor of editorList) {
+      if (editor && editor.constructor.name === 'HighlightEditor') {
+        const divId = editor.div?.id;
+        if (divId) {
+          const exists = highlightDivIds.some(item => item.highlightDivId === divId);
+          if (!exists) {
+            highlightDivIds.push({
+              textId: id,
+              highlightDivId: divId
+            });
+          }
+          console.log(`DEBUG - Found HighlightEditor with div ID:`, {
+            textId: id,
+            highlightDivId: divId
+          });
+        }
+      }
+    }
+    if (highlightDivIds.length > 0) {
+      this.#highlightEditorsByPage.set(pageNumber, highlightDivIds);
+      console.log(`DEBUG - Stored ${highlightDivIds.length} highlight editor(s) for page ${pageNumber}:`, highlightDivIds);
+    }
+  }
+  findHighlightByDivId(divId) {
+    for (const [pageNumber, highlights] of this.#highlightEditorsByPage.entries()) {
+      const found = highlights.find(item => item.highlightDivId === divId);
+      if (found) {
+        return {
+          ...found,
+          pageNumber
+        };
+      }
+    }
+    return null;
+  }
+  findHighlightsByTextId(textId) {
+    const results = [];
+    for (const [pageNumber, highlights] of this.#highlightEditorsByPage.entries()) {
+      const matches = highlights.filter(item => item.textId === textId);
+      matches.forEach(match => results.push({
+        ...match,
+        pageNumber
+      }));
+    }
+    return results;
+  }
+  async showHighlight(pageNumber, location, id) {
+    let highlightDivIds = [];
+    highlightDivIds = this.#highlightEditorsByPage.get(pageNumber) || [];
+    const filteredHighlights = highlightDivIds.filter(item => item.textId === id);
+    if (filteredHighlights.length > 0) {
+      console.log(`DEBUG - Highlights already exist for page ${pageNumber}, textId ${id}, skipping creation.`);
+      filteredHighlights.forEach(item => {
+        const uiManager = this.#uiManager || window.PDFViewerApplication?.pdfViewer?.annotationEditorUIManager;
+        if (uiManager) {
+          const editorList = Array.from(uiManager.getEditors(pageNumber - 1));
+          const editor = editorList.find(e => e.div?.id === item.highlightDivId);
+          if (editor) {
+            console.log("DEBUG - Reusing existing highlight editor:", editor);
+            if (editor.div) {
+              editor.div.style.display = '';
+              editor.div.classList.add('selectedEditor');
+              if (typeof editor.select === 'function') {
+                editor.select();
+              }
+              uiManager.setSelected(editor);
+            }
+          }
+        }
+      });
+      return;
+    }
+    console.log(`DEBUG - No existing highlights for page ${pageNumber}, proceeding to create.`);
+    this.#lastPageNumber = pageNumber;
     const uiManager = this.#uiManager || window.PDFViewerApplication?.pdfViewer?.annotationEditorUIManager;
     if (!uiManager) {
       console.error("UI Manager not initialized. Please enable annotation editing mode.");
@@ -12421,12 +12548,14 @@ class FilterHighlightOverlay {
       console.error("Text layer div not found");
       return;
     }
+    console.log("DEBUG - Text layer before extraction, total spans:", textLayer.querySelectorAll("span[role='presentation']").length);
+    console.log("Extracting text from location:", location);
     const textInfo = this.#extractTextFromLocation(textLayer, pageView, location);
+    console.log("Extracting text Info:", textInfo);
     if (!textInfo) {
       console.error("Could not extract text from location", location);
       return;
     }
-    console.log("Extracted text info:", textInfo);
     const selection = document.getSelection();
     selection.removeAllRanges();
     const range = document.createRange();
@@ -12436,8 +12565,11 @@ class FilterHighlightOverlay {
       selection.addRange(range);
       console.log("Selection created:", selection.toString());
       setTimeout(() => {
-        uiManager.highlightSelection("filter_view");
+        const editor = uiManager.highlightSelection("filter_view");
         selection.removeAllRanges();
+        setTimeout(() => {
+          this.storeHighlightEditorsForCurPageNum(id, pageNumber, uiManager);
+        }, 50);
       }, 100);
     } catch (error) {
       console.error("Error creating selection:", error);
@@ -12491,15 +12623,20 @@ class FilterHighlightOverlay {
     const viewport = pageView.viewport;
     const [x1, y1] = viewport.convertToViewportPoint(x, y + height);
     const [x2, y2] = viewport.convertToViewportPoint(x + width, y);
-    const pageWidth = viewport.width;
-    const pageHeight = viewport.height;
+    const pageRect = pageView.div.getBoundingClientRect();
+    const scaleX = pageRect.width / viewport.width || 1;
+    const scaleY = pageRect.height / viewport.height || 1;
+    const pageWidth = pageRect.width;
+    const pageHeight = pageRect.height;
     const minX = Math.min(x1, x2);
     const minY = Math.min(y1, y2);
+    const boxWidth = Math.abs(x2 - x1);
+    const boxHeight = Math.abs(y2 - y1);
     return [{
-      x: minX / pageWidth,
-      y: minY / pageHeight,
-      width: Math.abs(x2 - x1) / pageWidth,
-      height: Math.abs(y2 - y1) / pageHeight
+      x: minX * scaleX / pageWidth,
+      y: minY * scaleY / pageHeight,
+      width: boxWidth * scaleX / pageWidth,
+      height: boxHeight * scaleY / pageHeight
     }];
   }
   #extractTextFromLocation(textLayer, pageView, location) {
@@ -12518,38 +12655,130 @@ class FilterHighlightOverlay {
     const overlayHeight = Math.abs(y2 - y1);
     const pageRect = pageView.div.getBoundingClientRect();
     const textLayerRect = textLayer.getBoundingClientRect();
-    const textElements = textLayer.querySelectorAll("span[role='presentation']");
-    let firstNode = null;
-    let firstOffset = 0;
-    let lastNode = null;
-    let lastOffset = 0;
-    let collectedText = "";
+    console.log("DEBUG - pageRect:", {
+      left: pageRect.left,
+      top: pageRect.top,
+      width: pageRect.width,
+      height: pageRect.height
+    });
+    console.log("DEBUG - viewport:", {
+      width: viewport.width,
+      height: viewport.height
+    });
+    const scaleX = pageRect.width / viewport.width || 1;
+    const scaleY = pageRect.height / viewport.height || 1;
+    const overlayPageLeft = overlayLeft * scaleX;
+    const overlayPageTop = overlayTop * scaleY;
+    const overlayPageRight = overlayPageLeft + overlayWidth * scaleX;
+    const overlayPageBottom = overlayPageTop + overlayHeight * scaleY;
+    console.log("DEBUG - overlay bounds (page-relative):", {
+      left: overlayPageLeft,
+      top: overlayPageTop,
+      right: overlayPageRight,
+      bottom: overlayPageBottom
+    });
+    const textElements = Array.from(textLayer.querySelectorAll("span[role='presentation']"));
+    console.log("DEBUG - total text spans:", textElements.length);
+    const candidates = [];
+    let debugSkipped = 0;
     for (const span of textElements) {
       const rect = span.getBoundingClientRect();
-      const spanLeft = rect.left - pageRect.left;
-      const spanTop = rect.top - pageRect.top;
-      const spanRight = rect.right - pageRect.left;
-      const spanBottom = rect.bottom - pageRect.top;
-      if (spanRight > overlayLeft && spanLeft < overlayLeft + overlayWidth && spanBottom > overlayTop && spanTop < overlayTop + overlayHeight) {
-        const textNode = span.firstChild;
-        if (textNode && textNode.nodeType === Node.TEXT_NODE) {
-          if (!firstNode) {
-            firstNode = textNode;
-            firstOffset = 0;
-          }
-          lastNode = textNode;
-          lastOffset = textNode.textContent.length;
-          collectedText += textNode.textContent;
-        }
+      const spanPageLeft = rect.left - pageRect.left;
+      const spanPageTop = rect.top - pageRect.top;
+      const spanPageRight = rect.right - pageRect.left;
+      const spanPageBottom = rect.bottom - pageRect.top;
+      if (spanPageRight <= overlayPageLeft || spanPageLeft >= overlayPageRight || spanPageBottom <= overlayPageTop || spanPageTop >= overlayPageBottom) {
+        debugSkipped++;
+        continue;
+      }
+      const textNode = span.firstChild;
+      if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+        continue;
       }
+      candidates.push({
+        span,
+        rect: {
+          left: spanPageLeft,
+          top: spanPageTop,
+          right: spanPageRight,
+          bottom: spanPageBottom,
+          width: rect.width,
+          height: rect.height
+        },
+        textNode
+      });
     }
-    if (!firstNode || !lastNode) {
+    console.log("DEBUG - candidates found:", candidates.length, "skipped:", debugSkipped);
+    if (candidates.length > 0) {
+      console.log("DEBUG - first candidate:", {
+        text: candidates[0].textNode.textContent.substring(0, 20),
+        rect: candidates[0].rect
+      });
+      console.log("DEBUG - last candidate:", {
+        text: candidates[candidates.length - 1].textNode.textContent.substring(0, 20),
+        rect: candidates[candidates.length - 1].rect
+      });
+    }
+    if (candidates.length === 0) {
       return null;
     }
+    candidates.sort((a, b) => {
+      const topDiff = a.rect.top - b.rect.top;
+      if (Math.abs(topDiff) > 1) return topDiff;
+      return a.rect.left - b.rect.left;
+    });
+    const first = candidates[0];
+    const last = candidates[candidates.length - 1];
+    const makeOffset = (candidate, overlayL, overlayR, isStart) => {
+      const textLen = candidate.textNode.textContent.length || 0;
+      const rectWidth = candidate.rect.width || 0;
+      const rectLeft = candidate.rect.left;
+      const rectRight = candidate.rect.right;
+      if (textLen === 0 || rectWidth === 0) {
+        return isStart ? 0 : textLen;
+      }
+      const coveredLeft = Math.max(rectLeft, overlayL);
+      const coveredRight = Math.min(rectRight, overlayR);
+      const coveredWidth = Math.max(0, coveredRight - coveredLeft);
+      const coverageRatio = coveredWidth / rectWidth;
+      if (isStart) {
+        if (overlayL <= rectLeft + rectWidth * 0.1) {
+          return 0;
+        }
+        const relStart = Math.max(0, overlayL - rectLeft);
+        const startRatio = Math.max(0, Math.min(1, relStart / rectWidth));
+        return Math.floor(startRatio * textLen);
+      } else {
+        if (overlayR >= rectRight - rectWidth * 0.1) {
+          return textLen;
+        }
+        const relEnd = Math.min(rectRight, overlayR) - rectLeft;
+        const endRatio = Math.max(0, Math.min(1, relEnd / rectWidth));
+        return Math.ceil(endRatio * textLen);
+      }
+    };
+    const firstOffset = makeOffset(first, overlayPageLeft, overlayPageRight, true);
+    const lastOffset = makeOffset(last, overlayPageLeft, overlayPageRight, false);
+    let collectedText = "";
+    console.log("Candidates found:", candidates.length);
+    for (let i = 0; i < candidates.length; i++) {
+      const {
+        textNode
+      } = candidates[i];
+      if (i === 0 && i === candidates.length - 1) {
+        collectedText += textNode.textContent.substring(firstOffset, lastOffset);
+      } else if (i === 0) {
+        collectedText += textNode.textContent.substring(firstOffset);
+      } else if (i === candidates.length - 1) {
+        collectedText += textNode.textContent.substring(0, lastOffset);
+      } else {
+        collectedText += textNode.textContent;
+      }
+    }
     return {
-      anchorNode: firstNode,
+      anchorNode: first.textNode,
       anchorOffset: firstOffset,
-      focusNode: lastNode,
+      focusNode: last.textNode,
       focusOffset: lastOffset,
       text: collectedText.trim()
     };
@@ -12561,12 +12790,29 @@ class FilterHighlightOverlay {
     }
     return pdfViewer._pages[pageNumber - 1];
   }
-  clearHighlight() {
+  async clearHighlight() {
     if (this.#currentOverlay) {
-      if (typeof this.#currentOverlay.remove === 'function') {
-        this.#currentOverlay.remove();
+      console.log("DEBUG - Clearing previous highlights");
+      const uiManager = this.#uiManager || window.PDFViewerApplication?.pdfViewer?.annotationEditorUIManager;
+      if (uiManager) {
+        const editors = uiManager.getEditors();
+        console.log("DEBUG - Editors:", editors, "Type:", typeof editors);
+        if (editors) {
+          const editorList = editors instanceof Map ? Array.from(editors.values()) : Array.isArray(editors) ? editors : Object.values(editors);
+          for (const editor of editorList) {
+            if (editor && typeof editor.remove === 'function') {
+              try {
+                console.log("DEBUG - Removing editor:", editor);
+                editor.remove();
+              } catch (e) {
+                console.warn("Error removing editor:", e);
+              }
+            }
+          }
+        }
       }
       this.#currentOverlay = null;
+      await new Promise(resolve => setTimeout(resolve, 100));
     }
   }
 }
@@ -18188,7 +18434,7 @@ class PDFViewer {
   #textLayerMode = TextLayerMode.ENABLE;
   #viewerAlert = null;
   constructor(options) {
-    const viewerVersion = "5.4.457";
+    const viewerVersion = "5.4.460";
     if (version !== viewerVersion) {
       throw new Error(`The API version "${version}" does not match the Viewer version "${viewerVersion}".`);
     }
@@ -22216,7 +22462,76 @@ const PDFViewerApplication = {
     await (this.pdfDocument?.annotationStorage.size > 0 ? this.save() : this.download());
     classList.remove("wait");
   },
-  async saveSelectionAsJson() {
+  async saveSelectionAsJson(params = null) {
+    console.log("params:", params);
+    if (params?.methodOfCreation === "editor_save_button" && params?.editorInfo) {
+      const {
+        editorInfo
+      } = params;
+      const pageView = this.pdfViewer.getPageView(editorInfo.pageIndex);
+      if (!pageView) {
+        console.warn("Could not find page view for editor");
+        return;
+      }
+      const pageElement = this.pdfViewer.viewer.querySelector(`.page[data-page-number="${editorInfo.pageNumber}"]`);
+      if (!pageElement) {
+        console.warn("Could not find page element for editor");
+        return;
+      }
+      const textLayer = pageElement.querySelector(".textLayer");
+      if (!textLayer) {
+        console.warn("Could not find text layer for editor");
+        return;
+      }
+      const textLayerRect = textLayer.getBoundingClientRect();
+      const x = editorInfo.screenRect.left - textLayerRect.left;
+      const y = editorInfo.screenRect.top - textLayerRect.top;
+      const width = editorInfo.screenRect.width;
+      const height = editorInfo.screenRect.height;
+      const pdfCoords = pageView.getPagePoint(x, y);
+      const pdfCoordsEnd = pageView.getPagePoint(x + width, y + height);
+      const location = [Math.round(pdfCoords[0]), Math.round(pdfCoords[1]), Math.round(pdfCoordsEnd[0]), Math.round(pdfCoordsEnd[1])];
+      const data = {
+        page: editorInfo.pageNumber,
+        text: editorInfo.textContent,
+        location,
+        timestamp: Date.now(),
+        documentUrl: this.url || window.location.href
+      };
+      console.log("Selection data sent to parent window within Editor:", data);
+      if (this.isViewerEmbedded && window.parent !== window) {
+        try {
+          window.parent.postMessage({
+            type: "pdfjs-selection",
+            source: "pdf.js",
+            data
+          }, "*");
+          console.log("Selection data sent to parent window:", data);
+        } catch (postError) {
+          console.error("Error posting message to parent:", postError);
+        }
+      }
+      try {
+        const customEvent = new CustomEvent("pdfselectioncaptured", {
+          bubbles: true,
+          cancelable: false,
+          detail: data
+        });
+        if (this.isViewerEmbedded) {
+          try {
+            parent.document.dispatchEvent(customEvent);
+          } catch {
+            document.dispatchEvent(customEvent);
+          }
+        } else {
+          document.dispatchEvent(customEvent);
+        }
+      } catch (eventError) {
+        console.error("Error dispatching custom event:", eventError);
+      }
+      console.log("Selection saved and transferred (from editor):", data);
+      return;
+    }
     try {
       const selection = window.getSelection();
       if (!selection || selection.rangeCount === 0) {