Skip to content

Write HTML. Render video. Built for agents.

3.9 KB
Raw Blame
import { isDegradableEvaluateTimeoutError, withRemainingBudget } from "./captureTimeout.js";

const LAZY_SCROLL_STEP_DELAY_MS = 400;
const LAZY_SCROLL_MAX_IMAGE_WAIT_MS = 5_000;
const LAZY_SCROLL_BOTTOM_SETTLE_MS = 800;
const LAZY_SCROLL_IMAGE_POLL_MS = 250;

export interface LazyScrollPage {
  evaluate(pageFunction: string): Promise<unknown>;
}

export interface LazyScrollResult {
  steps: number;
  timedOut: boolean;
  degraded: boolean;
}

async function evaluateWithinBudget(
  page: LazyScrollPage,
  expression: string,
  deadline: number,
  label: string,
): Promise<unknown> {
  return withRemainingBudget(page.evaluate(expression), deadline - Date.now(), label);
}

async function settleAfterScroll(
  page: LazyScrollPage,
  deadline: number,
  sleep: (ms: number) => Promise<void>,
): Promise<void> {
  const bottomSettleMs = Math.min(LAZY_SCROLL_BOTTOM_SETTLE_MS, Math.max(0, deadline - Date.now()));
  if (bottomSettleMs > 0) {
    await evaluateWithinBudget(
      page,
      `window.scrollTo(0, document.body.scrollHeight)`,
      deadline,
      "lazy-scroll-bottom",
    );
    await sleep(bottomSettleMs);
  }

  const imageDeadline = Math.min(deadline, Date.now() + LAZY_SCROLL_MAX_IMAGE_WAIT_MS);
  while (Date.now() < imageDeadline) {
    const pending = (await evaluateWithinBudget(
      page,
      `Array.from(document.images).filter(function(img) { return !img.complete; }).length`,
      imageDeadline,
      "lazy-scroll-image-pending",
    )) as number;
    if (!(pending > 0)) {
      break;
    }
    const waitMs = Math.min(LAZY_SCROLL_IMAGE_POLL_MS, imageDeadline - Date.now());
    if (waitMs <= 0) {
      break;
    }
    await sleep(waitMs);
  }

  if (deadline - Date.now() > 0) {
    await evaluateWithinBudget(page, `window.scrollTo(0, 0)`, deadline, "lazy-scroll-reset");
  }
}

// fallow-ignore-next-line complexity
export async function lazyScrollForCapture(
  page: LazyScrollPage,
  budgetMs: number,
  opts: {
    stepDelayMs?: number;
    onWarning?: (message: string) => void;
    sleep?: (ms: number) => Promise<void>;
  } = {},
): Promise<LazyScrollResult> {
  if (budgetMs <= 0) {
    return { steps: 0, timedOut: false, degraded: false };
  }

  const stepDelayMs = opts.stepDelayMs ?? LAZY_SCROLL_STEP_DELAY_MS;
  const sleep = opts.sleep ?? ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)));
  const deadline = Date.now() + budgetMs;
  let steps = 0;
  let timedOut = false;
  let degraded = false;

  try {
    while (Date.now() < deadline) {
      const state = (await evaluateWithinBudget(
        page,
        `(() => {
        var y = window.scrollY || window.pageYOffset || 0;
        var view = window.innerHeight || 0;
        var height = document.body ? document.body.scrollHeight : 0;
        var next = Math.min(y + view * 0.7, Math.max(0, height - view));
        var atBottom = height <= view + 2 || next <= y + 1;
        window.scrollTo(0, atBottom ? height : next);
        return { atBottom: atBottom };
      })()`,
        deadline,
        "lazy-scroll-step",
      )) as { atBottom: boolean };

      steps += 1;
      if (state.atBottom) {
        break;
      }

      const remaining = deadline - Date.now();
      if (remaining <= 0) {
        timedOut = true;
        break;
      }
      await sleep(Math.min(stepDelayMs, remaining));
    }

    if (Date.now() >= deadline) {
      timedOut = true;
    }

    if (deadline - Date.now() > 0) {
      await settleAfterScroll(page, deadline, sleep);
    }
  } catch (err) {
    if (!isDegradableEvaluateTimeoutError(err)) {
      throw err;
    }
    degraded = true;
    timedOut = true;
    opts.onWarning?.("lazy-scroll evaluate timed out; continuing with current page state");
    if (deadline - Date.now() > 0) {
      try {
        await evaluateWithinBudget(page, `window.scrollTo(0, 0)`, deadline, "lazy-scroll-recovery");
      } catch {
        /* page may be wedged; do not spend another unbounded protocol wait */
      }
    }
  }

  return { steps, timedOut, degraded };
}