@opensteer/engine-abp 0.8.3 → 0.8.4

package/dist/index.cjs

@@ -1279,19 +1279,24 @@ function normalizePostLoadTrackerState(value) {
   const installedAt = readFiniteNumber(value.installedAt);
   const lastMutationAt = readFiniteNumber(value.lastMutationAt);
   const lastNetworkActivityAt = readFiniteNumber(value.lastNetworkActivityAt);
+  const lastTrackedNetworkActivityAt = readFiniteNumber(value.lastTrackedNetworkActivityAt);
   const now = readFiniteNumber(value.now);
   const readyState = typeof value.readyState === "string" ? value.readyState : void 0;
-  if (installedAt === void 0 || lastMutationAt === void 0 || lastNetworkActivityAt === void 0 || now === void 0 || readyState === void 0) {
+  if (installedAt === void 0 || lastMutationAt === void 0 || lastNetworkActivityAt === void 0 || lastTrackedNetworkActivityAt === void 0 || now === void 0 || readyState === void 0) {
     return void 0;
   }
   return {
     installedAt,
     lastMutationAt,
     lastNetworkActivityAt,
+    lastTrackedNetworkActivityAt,
     now,
     pendingFetches: readNonNegativeNumber(value.pendingFetches),
     pendingTimeouts: readNonNegativeNumber(value.pendingTimeouts),
     pendingXhrs: readNonNegativeNumber(value.pendingXhrs),
+    trackedPendingFetches: readNonNegativeNumber(value.trackedPendingFetches),
+    trackedPendingXhrs: readNonNegativeNumber(value.trackedPendingXhrs),
+    collecting: value.collecting === true,
     readyState
   };
 }
@@ -1306,11 +1311,14 @@ function buildPostLoadTrackerInstallScript() {
       installedAt: performance.now(),
       lastMutationAt: performance.now(),
       lastNetworkActivityAt: performance.now(),
+      lastTrackedNetworkActivityAt: performance.now(),
       pendingFetches: 0,
       pendingTimeouts: 0,
       pendingXhrs: 0,
+      trackedPendingFetches: 0,
+      trackedPendingXhrs: 0,
+      collecting: true,
       readyState: document.readyState,
-      timeoutIds: new Set(),
     };
     globalObject.__opensteerActionBoundaryTrackerInstalled = true;
     globalObject.__opensteerActionBoundaryTracker = tracker;
@@ -1323,6 +1331,18 @@ function buildPostLoadTrackerInstallScript() {
       tracker.lastNetworkActivityAt = performance.now();
       tracker.readyState = document.readyState;
     };
+    const markTrackedNetwork = () => {
+      tracker.lastTrackedNetworkActivityAt = performance.now();
+      markNetwork();
+    };
+    const resetTracking = () => {
+      const now = performance.now();
+      tracker.lastTrackedNetworkActivityAt = now;
+      tracker.trackedPendingFetches = 0;
+      tracker.trackedPendingXhrs = 0;
+      tracker.collecting = true;
+      tracker.readyState = document.readyState;
+    };
 
     const startObserver = () => {
       const target = document.documentElement ?? document;
@@ -1348,45 +1368,26 @@ function buildPostLoadTrackerInstallScript() {
     document.addEventListener("readystatechange", markMutation);
     addEventListener("load", markMutation, { once: true });
 
-    const nativeSetTimeout = globalObject.setTimeout.bind(globalObject);
-    const nativeClearTimeout = globalObject.clearTimeout.bind(globalObject);
-    globalObject.setTimeout = function(callback, delay, ...args) {
-      tracker.pendingTimeouts += 1;
-      markNetwork();
-      let handle;
-      const wrapped =
-        typeof callback === "function"
-          ? (...callbackArgs) => {
-              if (tracker.timeoutIds.delete(handle)) {
-                tracker.pendingTimeouts = Math.max(0, tracker.pendingTimeouts - 1);
-              }
-              try {
-                return callback(...callbackArgs);
-              } finally {
-                markMutation();
-              }
-            }
-          : callback;
-      handle = nativeSetTimeout(wrapped, delay, ...args);
-      tracker.timeoutIds.add(handle);
-      return handle;
-    };
-    globalObject.clearTimeout = function(handle) {
-      if (tracker.timeoutIds.delete(handle)) {
-        tracker.pendingTimeouts = Math.max(0, tracker.pendingTimeouts - 1);
-      }
-      return nativeClearTimeout(handle);
-    };
-
     if (typeof globalObject.fetch === "function") {
       const nativeFetch = globalObject.fetch.bind(globalObject);
       globalObject.fetch = (...args) => {
+        const tracked = tracker.collecting === true;
         tracker.pendingFetches += 1;
-        markNetwork();
+        if (tracked) {
+          tracker.trackedPendingFetches += 1;
+          markTrackedNetwork();
+        } else {
+          markNetwork();
+        }
         return nativeFetch(...args)
           .finally(() => {
             tracker.pendingFetches = Math.max(0, tracker.pendingFetches - 1);
-            markNetwork();
+            if (tracked) {
+              tracker.trackedPendingFetches = Math.max(0, tracker.trackedPendingFetches - 1);
+              markTrackedNetwork();
+            } else {
+              markNetwork();
+            }
           });
       };
     }
@@ -1395,21 +1396,60 @@ function buildPostLoadTrackerInstallScript() {
       const NativeXMLHttpRequest = globalObject.XMLHttpRequest;
       const nativeSend = NativeXMLHttpRequest.prototype.send;
       NativeXMLHttpRequest.prototype.send = function(...args) {
+        const tracked = tracker.collecting === true;
         tracker.pendingXhrs += 1;
-        markNetwork();
+        if (tracked) {
+          tracker.trackedPendingXhrs += 1;
+          markTrackedNetwork();
+        } else {
+          markNetwork();
+        }
         const finalize = () => {
           this.removeEventListener("loadend", finalize);
           tracker.pendingXhrs = Math.max(0, tracker.pendingXhrs - 1);
-          markNetwork();
+          if (tracked) {
+            tracker.trackedPendingXhrs = Math.max(0, tracker.trackedPendingXhrs - 1);
+            markTrackedNetwork();
+          } else {
+            markNetwork();
+          }
         };
         this.addEventListener("loadend", finalize, { once: true });
         return nativeSend.apply(this, args);
       };
     }
 
+    tracker.beginObservation = () => {
+      resetTracking();
+      return true;
+    };
+    tracker.freezeObservation = () => {
+      tracker.collecting = false;
+      tracker.readyState = document.readyState;
+      return true;
+    };
+
     return true;
   })()`;
 }
+function buildPostLoadTrackerBeginExpression() {
+  return `(() => {
+    const tracker = globalThis.__opensteerActionBoundaryTracker;
+    if (!tracker || typeof tracker.beginObservation !== "function") {
+      return false;
+    }
+    return tracker.beginObservation();
+  })()`;
+}
+function buildPostLoadTrackerFreezeExpression() {
+  return `(() => {
+    const tracker = globalThis.__opensteerActionBoundaryTracker;
+    if (!tracker || typeof tracker.freezeObservation !== "function") {
+      return false;
+    }
+    return tracker.freezeObservation();
+  })()`;
+}
 function buildPostLoadTrackerReadExpression() {
   return `(() => {
     const tracker = globalThis.__opensteerActionBoundaryTracker;
@@ -1421,14 +1461,31 @@ function buildPostLoadTrackerReadExpression() {
       installedAt: Number(tracker.installedAt ?? 0),
       lastMutationAt: Number(tracker.lastMutationAt ?? 0),
       lastNetworkActivityAt: Number(tracker.lastNetworkActivityAt ?? 0),
+      lastTrackedNetworkActivityAt: Number(tracker.lastTrackedNetworkActivityAt ?? 0),
       now: Number(performance.now()),
       pendingFetches: Number(tracker.pendingFetches ?? 0),
       pendingTimeouts: Number(tracker.pendingTimeouts ?? 0),
       pendingXhrs: Number(tracker.pendingXhrs ?? 0),
+      trackedPendingFetches: Number(tracker.trackedPendingFetches ?? 0),
+      trackedPendingXhrs: Number(tracker.trackedPendingXhrs ?? 0),
+      collecting: tracker.collecting === true,
       readyState: String(document.readyState),
     };
   })()`;
 }
+function capturePostLoadTrackerSnapshot(tracker) {
+  return {
+    lastTrackedNetworkActivityAt: tracker.lastTrackedNetworkActivityAt,
+    trackedPendingFetches: tracker.trackedPendingFetches,
+    trackedPendingXhrs: tracker.trackedPendingXhrs
+  };
+}
+function postLoadTrackerHasTrackedNetworkActivitySince(snapshot, tracker) {
+  if (!tracker) {
+    return false;
+  }
+  return tracker.trackedPendingFetches > snapshot.trackedPendingFetches || tracker.trackedPendingXhrs > snapshot.trackedPendingXhrs || tracker.lastTrackedNetworkActivityAt > snapshot.lastTrackedNetworkActivityAt;
+}
 function postLoadTrackerIsSettled(tracker, quietWindowMs = DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS) {
   if (!tracker) {
     return false;
@@ -1436,13 +1493,13 @@ function postLoadTrackerIsSettled(tracker, quietWindowMs = DEFAULT_POST_LOAD_TRA
   if (tracker.readyState !== "complete") {
     return false;
   }
-  if (tracker.pendingFetches > 0 || tracker.pendingTimeouts > 0 || tracker.pendingXhrs > 0) {
+  if (tracker.trackedPendingFetches > 0 || tracker.trackedPendingXhrs > 0) {
     return false;
   }
   const lastActivityAt = Math.max(
     tracker.installedAt,
     tracker.lastMutationAt,
-    tracker.lastNetworkActivityAt
+    tracker.lastTrackedNetworkActivityAt
   );
   return tracker.now - lastActivityAt >= quietWindowMs;
 }
@@ -1464,7 +1521,7 @@ async function waitForActionBoundary(input) {
   const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_ACTION_BOUNDARY_POLL_INTERVAL_MS;
   let trigger = "dom-action";
   let crossDocument = false;
-  let waitedForNavigationContentLoaded = false;
+  let sameDocumentAsyncActivity = false;
   while (Date.now() < deadline) {
     input.throwBackgroundError();
     if (input.isPageClosed()) {
@@ -1486,16 +1543,21 @@ async function waitForActionBoundary(input) {
       throw abortError(input.signal);
     }
     const currentDocumentRef = input.getCurrentMainFrameDocumentRef();
+    const currentPageUrl = input.getCurrentPageUrl?.();
     if (input.snapshot !== void 0 && currentDocumentRef !== void 0 && currentDocumentRef !== input.snapshot.documentRef) {
       trigger = "navigation";
       crossDocument = true;
-      if (!waitedForNavigationContentLoaded) {
-        waitedForNavigationContentLoaded = true;
-        const remaining = Math.max(0, deadline - Date.now());
-        if (remaining > 0) {
-          await input.waitForNavigationContentLoaded(remaining);
-        }
-      }
+    }
+    if (!crossDocument && !sameDocumentAsyncActivity && input.snapshot?.tracker !== void 0 && postLoadTrackerHasTrackedNetworkActivitySince(
+      input.snapshot.tracker,
+      await input.readTrackerState()
+    )) {
+      trigger = "navigation";
+      sameDocumentAsyncActivity = true;
+    }
+    if (!crossDocument && input.snapshot?.url !== void 0 && currentPageUrl !== void 0 && currentPageUrl !== input.snapshot.url && input.isCurrentMainFrameBootstrapSettled !== void 0 && !input.isCurrentMainFrameBootstrapSettled()) {
+      trigger = "navigation";
+      crossDocument = true;
     }
     if (!crossDocument && crossDocumentDetectionDeadline !== void 0 && Date.now() >= crossDocumentDetectionDeadline) {
       return {
@@ -1504,7 +1566,18 @@ async function waitForActionBoundary(input) {
         bootstrapSettled: true
       };
     }
-    if (crossDocument && postLoadTrackerIsSettled(await input.readTrackerState())) {
+    if (sameDocumentAsyncActivity) {
+      return {
+        trigger,
+        crossDocument,
+        bootstrapSettled: true
+      };
+    }
+    if (crossDocument && input.isCurrentMainFrameBootstrapSettled !== void 0 && !input.isCurrentMainFrameBootstrapSettled()) {
+      await delay(Math.min(pollIntervalMs, Math.max(0, deadline - Date.now())));
+      continue;
+    }
+    if (crossDocument) {
       return {
         trigger,
         crossDocument,
@@ -2271,6 +2344,7 @@ function normalizeSelectChooserEventData(data) {
 
 // src/action-settle.ts
 var DEFAULT_ABP_ACTION_SETTLE_TIMEOUT_MS = CROSS_DOCUMENT_INTERACTION_TIMEOUT_MS;
+var DEFAULT_ABP_POST_LOAD_CAPTURE_WINDOW_MS = 1e3;
 function clampAbpActionSettleTimeout(timeoutMs) {
   if (timeoutMs === void 0) {
     return DEFAULT_ABP_ACTION_SETTLE_TIMEOUT_MS;
@@ -2282,6 +2356,8 @@ function abortError2(signal) {
 }
 function createAbpActionSettler(context) {
   const installScript = buildPostLoadTrackerInstallScript();
+  const beginExpression = buildPostLoadTrackerBeginExpression();
+  const freezeExpression = buildPostLoadTrackerFreezeExpression();
   const readExpression = buildPostLoadTrackerReadExpression();
   async function installTracker(controller) {
     if (!controller.settleTrackerRegistered) {
@@ -2311,6 +2387,67 @@ function createAbpActionSettler(context) {
       throw error;
     }
   }
+  async function beginTrackerObservation(controller) {
+    await installTracker(controller);
+    await controller.cdp.send("Runtime.evaluate", {
+      expression: beginExpression,
+      returnByValue: true,
+      awaitPromise: true
+    });
+  }
+  async function freezeTrackerObservation(controller) {
+    await controller.cdp.send("Runtime.evaluate", {
+      expression: freezeExpression,
+      returnByValue: true,
+      awaitPromise: true
+    });
+  }
+  async function captureSnapshot(controller) {
+    const documentRef = context.getMainFrameDocumentRef(controller);
+    if (documentRef === void 0) {
+      throw new Error(`page ${controller.pageRef} does not expose a main frame`);
+    }
+    await beginTrackerObservation(controller);
+    const tracker = await readTrackerState(controller);
+    return {
+      pageRef: controller.pageRef,
+      documentRef,
+      ...controller.mainFrameRef === void 0 ? {} : {
+        url: controller.framesByCdpId.get(controller.mainFrameRef)?.currentDocument.url
+      },
+      ...tracker === void 0 ? {} : { tracker: capturePostLoadTrackerSnapshot(tracker) }
+    };
+  }
+  async function waitForPostLoadQuiet(input) {
+    const { controller, timeoutMs, signal } = input;
+    if (timeoutMs <= 0) {
+      return;
+    }
+    const quietMs = input.quietMs ?? DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS;
+    const captureWindowMs = Math.max(
+      0,
+      Math.min(input.captureWindowMs ?? DEFAULT_ABP_POST_LOAD_CAPTURE_WINDOW_MS, timeoutMs)
+    );
+    const deadline = Date.now() + timeoutMs;
+    await installTracker(controller);
+    if (captureWindowMs > 0) {
+      await delayWithSignal(captureWindowMs, signal, deadline);
+    }
+    await freezeTrackerObservation(controller);
+    while (Date.now() < deadline) {
+      if (signal?.aborted) {
+        throw abortError2(signal);
+      }
+      context.throwBackgroundError(controller);
+      if (controller.lifecycleState === "closed") {
+        return;
+      }
+      if (postLoadTrackerIsSettled(await readTrackerState(controller), quietMs)) {
+        return;
+      }
+      await delayWithSignal(100, signal, deadline);
+    }
+  }
   async function settle(options) {
     const { controller, timeoutMs, signal, snapshot, policySettle } = options;
     if (timeoutMs <= 0) {
@@ -2351,7 +2488,8 @@ function createAbpActionSettler(context) {
           ...signal === void 0 ? {} : { signal },
           snapshot,
           getCurrentMainFrameDocumentRef: () => context.getMainFrameDocumentRef(controller),
-          waitForNavigationContentLoaded: (remainingMs) => context.waitForNavigationContentLoaded(controller, remainingMs),
+          getCurrentPageUrl: () => controller.mainFrameRef === void 0 ? void 0 : controller.framesByCdpId.get(controller.mainFrameRef)?.currentDocument.url,
+          isCurrentMainFrameBootstrapSettled: () => context.isCurrentMainFrameBootstrapSettled(controller),
           readTrackerState: () => readTrackerState(controller),
           throwBackgroundError: () => context.throwBackgroundError(controller),
           isPageClosed: () => controller.lifecycleState === "closed"
@@ -2383,10 +2521,33 @@ function createAbpActionSettler(context) {
     return boundary;
   }
   return {
+    captureSnapshot,
     installTracker,
+    waitForPostLoadQuiet,
     settle
   };
 }
+async function delayWithSignal(delayMs, signal, deadline) {
+  const effectiveDelay = Math.max(0, Math.min(delayMs, Math.max(0, deadline - Date.now())));
+  if (effectiveDelay <= 0) {
+    return;
+  }
+  if (signal?.aborted) {
+    throw abortError2(signal);
+  }
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, effectiveDelay);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(abortError2(signal));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 
 // src/rest-client.ts
 function isRecord3(value) {
@@ -4301,7 +4462,7 @@ var AbpBrowserCoreEngine = class _AbpBrowserCoreEngine {
     setExecutionPaused: (controller, paused) => this.setControllerExecutionPaused(controller, paused),
     flushDomUpdateTask: (controller) => this.flushDomUpdateTask(controller),
     getMainFrameDocumentRef: (controller) => controller.mainFrameRef === void 0 ? void 0 : this.frames.get(controller.mainFrameRef)?.currentDocument.documentRef,
-    waitForNavigationContentLoaded: async () => void 0,
+    isCurrentMainFrameBootstrapSettled: () => true,
     throwBackgroundError: (controller) => this.throwBackgroundError(controller),
     isPageClosedError: isAbpPageClosedError
   });
@@ -5064,6 +5225,9 @@ var AbpBrowserCoreEngine = class _AbpBrowserCoreEngine {
       )
     );
   }
+  async drainEvents(input) {
+    return this.drainQueuedEvents(input.pageRef);
+  }
   async listFrames(input) {
     const controller = this.requirePage(input.pageRef);
     await this.flushDomUpdateTask(controller);
@@ -5115,6 +5279,11 @@ var AbpBrowserCoreEngine = class _AbpBrowserCoreEngine {
       (contentDocumentIndex) => resolveCapturedContentDocumentRef(controller.framesByCdpId, captured, contentDocumentIndex)
     );
   }
+  async getActionBoundarySnapshot(input) {
+    const controller = this.requirePage(input.pageRef);
+    await this.flushDomUpdateTask(controller);
+    return this.actionSettler.captureSnapshot(controller);
+  }
   async waitForVisualStability(input) {
     const controller = this.requirePage(input.pageRef);
     await this.flushDomUpdateTask(controller);
@@ -5125,6 +5294,20 @@ var AbpBrowserCoreEngine = class _AbpBrowserCoreEngine {
     });
     await this.flushDomUpdateTask(controller);
   }
+  async waitForPostLoadQuiet(input) {
+    const controller = this.requirePage(input.pageRef);
+    await this.flushDomUpdateTask(controller);
+    await this.actionSettler.waitForPostLoadQuiet({
+      controller,
+      timeoutMs: clampAbpActionSettleTimeout(input.timeoutMs),
+      ...input.quietMs === void 0 ? {} : { quietMs: input.quietMs },
+      ...input.captureWindowMs === void 0 ? {} : { captureWindowMs: input.captureWindowMs },
+      ...input.signal === void 0 ? {} : { signal: input.signal }
+    });
+    if (controller.lifecycleState !== "closed") {
+      await this.flushDomUpdateTask(controller);
+    }
+  }
   async readText(input) {
     const document = this.requireDocument(input.documentRef);
     const controller = this.requirePage(document.pageRef);