@opensteer/browser-core 0.7.0 → 0.7.2

package/dist/index.cjs

@@ -2843,7 +2843,287 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/post-load-tracker.ts
+var DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS = 400;
+var DEFAULT_ACTION_BOUNDARY_POLL_INTERVAL_MS = 100;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readNonNegativeNumber(value) {
+  const parsed = readFiniteNumber(value);
+  return parsed === void 0 || parsed < 0 ? 0 : parsed;
+}
+function normalizePostLoadTrackerState(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const installedAt = readFiniteNumber(value.installedAt);
+  const lastMutationAt = readFiniteNumber(value.lastMutationAt);
+  const lastNetworkActivityAt = readFiniteNumber(value.lastNetworkActivityAt);
+  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) {
+    return void 0;
+  }
+  return {
+    installedAt,
+    lastMutationAt,
+    lastNetworkActivityAt,
+    now,
+    pendingFetches: readNonNegativeNumber(value.pendingFetches),
+    pendingTimeouts: readNonNegativeNumber(value.pendingTimeouts),
+    pendingXhrs: readNonNegativeNumber(value.pendingXhrs),
+    readyState
+  };
+}
+function buildPostLoadTrackerInstallScript() {
+  return `(() => {
+    const globalObject = globalThis;
+    if (globalObject.__opensteerActionBoundaryTrackerInstalled) {
+      return true;
+    }
+
+    const tracker = {
+      installedAt: performance.now(),
+      lastMutationAt: performance.now(),
+      lastNetworkActivityAt: performance.now(),
+      pendingFetches: 0,
+      pendingTimeouts: 0,
+      pendingXhrs: 0,
+      readyState: document.readyState,
+      timeoutIds: new Set(),
+    };
+    globalObject.__opensteerActionBoundaryTrackerInstalled = true;
+    globalObject.__opensteerActionBoundaryTracker = tracker;
+
+    const markMutation = () => {
+      tracker.lastMutationAt = performance.now();
+      tracker.readyState = document.readyState;
+    };
+    const markNetwork = () => {
+      tracker.lastNetworkActivityAt = performance.now();
+      tracker.readyState = document.readyState;
+    };
+
+    const startObserver = () => {
+      const target = document.documentElement ?? document;
+      if (!(target instanceof Node)) {
+        return;
+      }
+      const observer = new MutationObserver(markMutation);
+      observer.observe(target, {
+        subtree: true,
+        childList: true,
+        characterData: true,
+        attributes: true,
+      });
+      markMutation();
+    };
+
+    if (document.documentElement) {
+      startObserver();
+    } else {
+      document.addEventListener("DOMContentLoaded", startObserver, { once: true });
+    }
+
+    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) => {
+        tracker.pendingFetches += 1;
+        markNetwork();
+        return nativeFetch(...args)
+          .finally(() => {
+            tracker.pendingFetches = Math.max(0, tracker.pendingFetches - 1);
+            markNetwork();
+          });
+      };
+    }
+
+    if (typeof globalObject.XMLHttpRequest === "function") {
+      const NativeXMLHttpRequest = globalObject.XMLHttpRequest;
+      const nativeSend = NativeXMLHttpRequest.prototype.send;
+      NativeXMLHttpRequest.prototype.send = function(...args) {
+        tracker.pendingXhrs += 1;
+        markNetwork();
+        const finalize = () => {
+          this.removeEventListener("loadend", finalize);
+          tracker.pendingXhrs = Math.max(0, tracker.pendingXhrs - 1);
+          markNetwork();
+        };
+        this.addEventListener("loadend", finalize, { once: true });
+        return nativeSend.apply(this, args);
+      };
+    }
+
+    return true;
+  })()`;
+}
+function buildPostLoadTrackerReadExpression() {
+  return `(() => {
+    const tracker = globalThis.__opensteerActionBoundaryTracker;
+    if (!tracker) {
+      return null;
+    }
+
+    return {
+      installedAt: Number(tracker.installedAt ?? 0),
+      lastMutationAt: Number(tracker.lastMutationAt ?? 0),
+      lastNetworkActivityAt: Number(tracker.lastNetworkActivityAt ?? 0),
+      now: Number(performance.now()),
+      pendingFetches: Number(tracker.pendingFetches ?? 0),
+      pendingTimeouts: Number(tracker.pendingTimeouts ?? 0),
+      pendingXhrs: Number(tracker.pendingXhrs ?? 0),
+      readyState: String(document.readyState),
+    };
+  })()`;
+}
+function postLoadTrackerIsSettled(tracker, quietWindowMs = DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS) {
+  if (!tracker) {
+    return false;
+  }
+  if (tracker.readyState !== "complete") {
+    return false;
+  }
+  if (tracker.pendingFetches > 0 || tracker.pendingTimeouts > 0 || tracker.pendingXhrs > 0) {
+    return false;
+  }
+  const lastActivityAt = Math.max(
+    tracker.installedAt,
+    tracker.lastMutationAt,
+    tracker.lastNetworkActivityAt
+  );
+  return tracker.now - lastActivityAt >= quietWindowMs;
+}
+
+// src/action-boundary.ts
+var CROSS_DOCUMENT_INTERACTION_TIMEOUT_MS = 3e4;
+var CROSS_DOCUMENT_DETECTION_WINDOW_MS = 500;
+async function waitForActionBoundary(input) {
+  if (input.timeoutMs <= 0) {
+    return {
+      trigger: "dom-action",
+      crossDocument: false,
+      bootstrapSettled: false,
+      timedOutPhase: "bootstrap"
+    };
+  }
+  const deadline = Date.now() + input.timeoutMs;
+  const crossDocumentDetectionDeadline = input.snapshot === void 0 ? void 0 : Math.min(deadline, Date.now() + CROSS_DOCUMENT_DETECTION_WINDOW_MS);
+  const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_ACTION_BOUNDARY_POLL_INTERVAL_MS;
+  let trigger = "dom-action";
+  let crossDocument = false;
+  let waitedForNavigationContentLoaded = false;
+  while (Date.now() < deadline) {
+    input.throwBackgroundError();
+    if (input.isPageClosed()) {
+      return {
+        trigger,
+        crossDocument,
+        bootstrapSettled: true
+      };
+    }
+    if (input.signal?.aborted) {
+      if (isTimeoutAbort(input.signal.reason) && Date.now() >= deadline) {
+        return {
+          trigger,
+          crossDocument,
+          bootstrapSettled: false,
+          timedOutPhase: "bootstrap"
+        };
+      }
+      throw abortError(input.signal);
+    }
+    const currentDocumentRef = input.getCurrentMainFrameDocumentRef();
+    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 && crossDocumentDetectionDeadline !== void 0 && Date.now() >= crossDocumentDetectionDeadline) {
+      return {
+        trigger,
+        crossDocument,
+        bootstrapSettled: true
+      };
+    }
+    if (crossDocument && postLoadTrackerIsSettled(await input.readTrackerState())) {
+      return {
+        trigger,
+        crossDocument,
+        bootstrapSettled: true
+      };
+    }
+    await delay(Math.min(pollIntervalMs, Math.max(0, deadline - Date.now())));
+  }
+  return {
+    trigger,
+    crossDocument,
+    bootstrapSettled: false,
+    timedOutPhase: "bootstrap"
+  };
+}
+function abortError(signal) {
+  return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+async function delay(ms) {
+  if (ms <= 0) {
+    return;
+  }
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function isTimeoutAbort(reason) {
+  return typeof reason === "object" && reason !== null && "code" in reason && reason.code === "timeout";
+}
+
 exports.BrowserCoreError = BrowserCoreError;
+exports.CROSS_DOCUMENT_DETECTION_WINDOW_MS = CROSS_DOCUMENT_DETECTION_WINDOW_MS;
+exports.CROSS_DOCUMENT_INTERACTION_TIMEOUT_MS = CROSS_DOCUMENT_INTERACTION_TIMEOUT_MS;
+exports.DEFAULT_ACTION_BOUNDARY_POLL_INTERVAL_MS = DEFAULT_ACTION_BOUNDARY_POLL_INTERVAL_MS;
+exports.DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS = DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS;
 exports.DEFAULT_VISUAL_STABILITY_SETTLE_MS = DEFAULT_VISUAL_STABILITY_SETTLE_MS;
 exports.DEFAULT_VISUAL_STABILITY_TIMEOUT_MS = DEFAULT_VISUAL_STABILITY_TIMEOUT_MS;
 exports.DOM_SNAPSHOT_COMPUTED_STYLE_NAMES = DOM_SNAPSHOT_COMPUTED_STYLE_NAMES;
@@ -2853,6 +3133,8 @@ exports.bodyPayloadFromUtf8 = bodyPayloadFromUtf8;
 exports.brand = brand;
 exports.buildCdpShadowBoundaryIndex = buildCdpShadowBoundaryIndex;
 exports.buildDomSnapshotFromCdpCapture = buildDomSnapshotFromCdpCapture;
+exports.buildPostLoadTrackerInstallScript = buildPostLoadTrackerInstallScript;
+exports.buildPostLoadTrackerReadExpression = buildPostLoadTrackerReadExpression;
 exports.closedPageError = closedPageError;
 exports.closedSessionError = closedSessionError;
 exports.createBodyPayload = createBodyPayload;
@@ -2899,7 +3181,9 @@ exports.mergeBrowserCapabilities = mergeBrowserCapabilities;
 exports.nextDocumentEpoch = nextDocumentEpoch;
 exports.noBrowserCapabilities = noBrowserCapabilities;
 exports.normalizeCdpShadowRootType = normalizeCdpShadowRootType;
+exports.normalizePostLoadTrackerState = normalizePostLoadTrackerState;
 exports.parseCdpStringTable = parseCdpStringTable;
+exports.postLoadTrackerIsSettled = postLoadTrackerIsSettled;
 exports.quadBounds = quadBounds;
 exports.rareCdpIntegerValue = rareCdpIntegerValue;
 exports.rareCdpStringValue = rareCdpStringValue;
@@ -2909,6 +3193,7 @@ exports.serializeDocumentEpoch = serializeDocumentEpoch;
 exports.serializeRef = serializeRef;
 exports.staleNodeRefError = staleNodeRefError;
 exports.unsupportedCapabilityError = unsupportedCapabilityError;
+exports.waitForActionBoundary = waitForActionBoundary;
 exports.waitForCdpVisualStability = waitForCdpVisualStability;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map