@fogg/bug-reporter 1.0.2 → 1.0.3

package/dist/index.js

@@ -1538,6 +1538,87 @@ function createSelectionOverlay() {
     document.body.appendChild(overlay);
   });
 }
+function rectsIntersect(a, b) {
+  return !(a.left + a.width <= b.left || b.left + b.width <= a.left || a.top + a.height <= b.top || b.top + b.height <= a.top);
+}
+function intersectsCrossOriginIframe(selection) {
+  const iframes = Array.from(document.querySelectorAll("iframe"));
+  for (const iframe of iframes) {
+    const rect = iframe.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) {
+      continue;
+    }
+    if (!rectsIntersect(selection, {
+      left: rect.left,
+      top: rect.top,
+      width: rect.width,
+      height: rect.height
+    })) {
+      continue;
+    }
+    try {
+      if (!iframe.contentWindow || !iframe.contentDocument) {
+        return true;
+      }
+      void iframe.contentDocument.location.href;
+    } catch (e) {
+      return true;
+    }
+  }
+  return false;
+}
+async function captureWithDisplayMedia(selection) {
+  var _a;
+  if (!((_a = navigator.mediaDevices) == null ? void 0 : _a.getDisplayMedia)) {
+    throw new BugReporterError("CAPTURE_ERROR", "This page contains iframe content that needs screen-capture permission.");
+  }
+  let stream = null;
+  const video = document.createElement("video");
+  video.muted = true;
+  video.playsInline = true;
+  try {
+    stream = await navigator.mediaDevices.getDisplayMedia({
+      video: true,
+      audio: false
+    });
+    video.srcObject = stream;
+    await video.play();
+    if (!video.videoWidth || !video.videoHeight) {
+      await new Promise((resolve) => {
+        video.onloadedmetadata = () => resolve();
+      });
+    }
+    if (!video.videoWidth || !video.videoHeight) {
+      throw new BugReporterError("CAPTURE_ERROR", "Could not read screen-capture frame.");
+    }
+    const scaleX = video.videoWidth / window.innerWidth;
+    const scaleY = video.videoHeight / window.innerHeight;
+    const sx = Math.max(0, Math.round(selection.left * scaleX));
+    const sy = Math.max(0, Math.round(selection.top * scaleY));
+    const sw = Math.max(1, Math.round(selection.width * scaleX));
+    const sh = Math.max(1, Math.round(selection.height * scaleY));
+    const canvas = document.createElement("canvas");
+    canvas.width = sw;
+    canvas.height = sh;
+    const context = canvas.getContext("2d");
+    if (!context) {
+      throw new BugReporterError("CAPTURE_ERROR", "Canvas 2D context unavailable.");
+    }
+    context.drawImage(video, sx, sy, sw, sh, 0, 0, sw, sh);
+    return await canvasToBlob(canvas);
+  } catch (error) {
+    if (error instanceof BugReporterError) {
+      throw error;
+    }
+    if (error instanceof DOMException && error.name === "NotAllowedError") {
+      throw new BugReporterError("PERMISSION_DENIED", "Permission denied for screen capture.", error);
+    }
+    throw new BugReporterError("CAPTURE_ERROR", "Fallback screen capture failed.", error);
+  } finally {
+    stream == null ? void 0 : stream.getTracks().forEach((track) => track.stop());
+    video.srcObject = null;
+  }
+}
 function canvasToBlob(canvas) {
   return new Promise((resolve, reject) => {
     canvas.toBlob((blob) => {
@@ -1554,6 +1635,9 @@ async function captureScreenshotArea(options) {
   const masked = applyMasking(options.maskSelectors);
   const textChanges = scrubText(document.body, options.redactTextPatterns);
   try {
+    if (intersectsCrossOriginIframe(selection)) {
+      return await captureWithDisplayMedia(selection);
+    }
     const baseCanvas = await html2canvas(document.documentElement, {
       useCORS: true,
       scrollX: -window.scrollX,
@@ -1579,6 +1663,15 @@ async function captureScreenshotArea(options) {
     context.drawImage(baseCanvas, sx, sy, sw, sh, 0, 0, sw, sh);
     return await canvasToBlob(cropped);
   } catch (error) {
+    if (!intersectsCrossOriginIframe(selection)) {
+      try {
+        return await captureWithDisplayMedia(selection);
+      } catch (fallbackError) {
+        if (fallbackError instanceof BugReporterError) {
+          throw fallbackError;
+        }
+      }
+    }
     if (error instanceof BugReporterError) {
       throw error;
     }