@grabbit-labs/dynafetch 0.2.4 → 0.2.5

package/dist/index.js

@@ -764,8 +764,19 @@ var TELEMETRY_INLINE_PATTERNS = [
   /\bhj\s*\(/i,
   /\bnewrelic\b/i,
   /\bdatadog\b/i,
-  /\bSentry\b/i,
-  /\bLogRocket\b/i
+  /\bSentry\.(?:init|capture|captureException|configureScope|withScope)\b/i,
+  /\bLogRocket\.(?:init|identify|track)\b/i
+];
+var INLINE_APPLICATION_PATTERNS = [
+  /\bwebpackChunk\w*/i,
+  /\b__webpack_require__\b/i,
+  /\b__SCRIPTS_LOADED__\b/i,
+  /\b__LOADABLE_LOADED_CHUNKS__\b/i,
+  /\bparcelRequire\b/i,
+  /\bwindow\.__[A-Z0-9_]{3,}\s*=/i,
+  /\bglobalThis\.__[A-Z0-9_]{3,}\s*=/i,
+  /\bself\.__[A-Z0-9_]{3,}\s*=/i,
+  /\bperformance\.mark\s*\(/i
 ];
 function siteKey(hostname) {
   const parts = hostname.split(".").filter(Boolean);
@@ -799,6 +810,7 @@ function classifyScriptAsset(script, pageUrl) {
     if (script.scriptKind === "module") return "application";
     return "unknown";
   }
+  if (matchesAny(content, INLINE_APPLICATION_PATTERNS)) return "application";
   if (matchesAny(content, TELEMETRY_INLINE_PATTERNS)) return "telemetry";
   return "application";
 }
@@ -996,6 +1008,59 @@ var Executor = class {
     }
     this.activeTimerHandles.clear();
   }
+  async performAutoScroll(window) {
+    const steps = this.clampMs(Number(process.env.PHANTOM_AUTO_SCROLL_STEPS ?? 3), 0, 12);
+    if (steps === 0) return false;
+    const stepPx = this.clampMs(
+      Number(process.env.PHANTOM_AUTO_SCROLL_STEP_PX ?? Math.max(Number(window.innerHeight) || 0, 900)),
+      100,
+      1e4
+    );
+    const delayMs = this.clampMs(Number(process.env.PHANTOM_AUTO_SCROLL_DELAY_MS ?? 150), 0, 5e3);
+    const dispatchScroll = () => {
+      try {
+        window.dispatchEvent(new window.Event("scroll"));
+      } catch {
+      }
+      try {
+        window.document?.dispatchEvent?.(new window.Event("scroll"));
+      } catch {
+      }
+      try {
+        window.document?.documentElement?.dispatchEvent?.(new window.Event("scroll"));
+      } catch {
+      }
+    };
+    let didScroll = false;
+    for (let step = 0; step < steps && !this.windowClosed; step++) {
+      const nextY = (Number(window.scrollY) || 0) + stepPx;
+      try {
+        window.scrollTo(0, nextY);
+      } catch {
+        try {
+          window.scrollY = nextY;
+        } catch {
+        }
+      }
+      dispatchScroll();
+      didScroll = true;
+      if (delayMs > 0) {
+        await new Promise((resolve) => window.setTimeout(resolve, delayMs));
+      }
+    }
+    if (didScroll) {
+      try {
+        window.scrollTo(0, 0);
+      } catch {
+        try {
+          window.scrollY = 0;
+        } catch {
+        }
+      }
+      dispatchScroll();
+    }
+    return didScroll;
+  }
   applyDefaults(quiescence, moduleWaitMsOverride) {
     const hardMaxCap = this.clampMs(Number(process.env.PHANTOM_QUIESCENCE_MAX_CAP_MS ?? 8e3), 500, 6e4);
     const minWaitMs = this.clampMs(quiescence?.minWaitMs ?? 75, 0, 1e4);
@@ -1539,9 +1604,10 @@ var Executor = class {
       };
     }
     if (!window.crypto) window.crypto = {};
+    const nodeWebCrypto = g.crypto || nodeCrypto.webcrypto;
     if (!window.crypto.getRandomValues) {
-      if (g.crypto && typeof g.crypto.getRandomValues === "function") {
-        window.crypto.getRandomValues = g.crypto.getRandomValues.bind(g.crypto);
+      if (nodeWebCrypto && typeof nodeWebCrypto.getRandomValues === "function") {
+        window.crypto.getRandomValues = nodeWebCrypto.getRandomValues.bind(nodeWebCrypto);
       } else {
         window.crypto.getRandomValues = (arr) => {
           const buf = nodeCrypto.randomBytes(arr.length);
@@ -1550,6 +1616,22 @@ var Executor = class {
         };
       }
     }
+    if (!window.crypto.subtle && nodeWebCrypto?.subtle) {
+      window.crypto.subtle = nodeWebCrypto.subtle;
+    }
+    if (!window.crypto.randomUUID) {
+      if (typeof nodeWebCrypto?.randomUUID === "function") {
+        window.crypto.randomUUID = nodeWebCrypto.randomUUID.bind(nodeWebCrypto);
+      } else {
+        window.crypto.randomUUID = () => nodeCrypto.randomUUID();
+      }
+    }
+    if (!window.CryptoKey && g.CryptoKey) {
+      window.CryptoKey = g.CryptoKey;
+    }
+    if (!window.SubtleCrypto && g.SubtleCrypto) {
+      window.SubtleCrypto = g.SubtleCrypto;
+    }
     {
       const _g = globalThis;
       if (_g.MessageChannel) {
@@ -1629,6 +1711,81 @@ var Executor = class {
         availHeight: 900
       };
     }
+    const parsePx = (value) => {
+      if (typeof value === "number" && Number.isFinite(value)) return value;
+      if (typeof value === "string") {
+        const parsed = Number.parseFloat(value.replace(/px$/i, ""));
+        if (Number.isFinite(parsed)) return parsed;
+      }
+      return 0;
+    };
+    const fallbackViewportHeight = Math.max(Number(window.innerHeight) || 0, 900);
+    const fallbackViewportWidth = Math.max(Number(window.innerWidth) || 0, 1440);
+    const fallbackDocumentHeight = Math.max(fallbackViewportHeight * 6, 5400);
+    const makeRect = (width, height) => ({
+      x: 0,
+      y: 0,
+      top: 0,
+      left: 0,
+      bottom: height,
+      right: width,
+      width,
+      height,
+      toJSON() {
+        return { x: 0, y: 0, top: 0, left: 0, bottom: height, right: width, width, height };
+      }
+    });
+    const computeElementBox = (el) => {
+      const tag = String(el?.tagName || "").toLowerCase();
+      if (tag === "html" || tag === "body") {
+        return {
+          width: fallbackViewportWidth,
+          height: fallbackDocumentHeight
+        };
+      }
+      const width = parsePx(el?.style?.width) || parsePx(el?.getAttribute?.("width")) || fallbackViewportWidth;
+      const height = parsePx(el?.style?.height) || parsePx(el?.getAttribute?.("height")) || 240;
+      return { width, height };
+    };
+    try {
+      const elementProto = window.Element?.prototype;
+      if (elementProto) {
+        const originalGetBoundingClientRect = elementProto.getBoundingClientRect;
+        elementProto.getBoundingClientRect = function() {
+          try {
+            const rect = originalGetBoundingClientRect?.call(this);
+            if (rect && (rect.width > 0 || rect.height > 0)) return rect;
+          } catch {
+          }
+          const { width, height } = computeElementBox(this);
+          return makeRect(width, height);
+        };
+      }
+      const htmlEl = window.document?.documentElement;
+      const bodyEl = window.document?.body;
+      const defineSize = (target, name, value) => {
+        try {
+          Object.defineProperty(target, name, {
+            configurable: true,
+            get: () => value
+          });
+        } catch {
+        }
+      };
+      if (htmlEl) {
+        defineSize(htmlEl, "clientWidth", fallbackViewportWidth);
+        defineSize(htmlEl, "clientHeight", fallbackViewportHeight);
+        defineSize(htmlEl, "scrollWidth", fallbackViewportWidth);
+        defineSize(htmlEl, "scrollHeight", fallbackDocumentHeight);
+      }
+      if (bodyEl) {
+        defineSize(bodyEl, "clientWidth", fallbackViewportWidth);
+        defineSize(bodyEl, "clientHeight", fallbackViewportHeight);
+        defineSize(bodyEl, "scrollWidth", fallbackViewportWidth);
+        defineSize(bodyEl, "scrollHeight", fallbackDocumentHeight);
+      }
+    } catch {
+    }
     if (!window.visualViewport) {
       window.visualViewport = {
         width: window.innerWidth,
@@ -2241,6 +2398,22 @@ var Executor = class {
       this.timings.quiescence_ms = Date.now() - quiescenceStart;
       const reason = this.matchFound && !this.findAll ? "(early exit on match)" : "";
       log(`[Executor] Quiescence reached in ${Date.now() - quiescenceStart}ms ${reason}`);
+      if (!this.matchFound || this.findAll) {
+        const didScroll = await this.performAutoScroll(window);
+        if (didScroll) {
+          if (this.moduleInFlight.size > 0) {
+            await this.waitForModuleWork(this.moduleWaitMs);
+          }
+          log("[Executor] Waiting for post-scroll quiescence...");
+          const postScrollStart = Date.now();
+          try {
+            await this.waitForQuiescence();
+          } catch (e) {
+            warn("[Executor] Post-scroll quiescence wait failed:", e);
+          }
+          this.timings.quiescence_ms += Date.now() - postScrollStart;
+        }
+      }
       const renderedHtml = this.serializeDocument(window);
       this.windowClosed = true;
       const result = {