update abstract behaviour for autoscroll

Author: emma-sg

src/autoscroll.ts

@@ -1,11 +1,20 @@
-import { sleep, waitUnit, xpathNode, isInViewport, waitUntil, behaviorLog, addLink, currentlyFetching } from "./lib/utils";
+import {
+  sleep,
+  waitUnit,
+  xpathNode,
+  isInViewport,
+  waitUntil,
+  behaviorLog,
+  addLink,
+  currentlyFetching,
+} from "./lib/utils";
+import type { AbstractBehavior } from "./lib/behavior";
 //import { type AutoFetcher } from "./autofetcher";
 
-
 // ===========================================================================
-export class AutoScroll {
+export class AutoScroll implements AbstractBehavior {
   showMoreQuery: string;
-  state: { segments: number } = { segments: 1};
+  state: { segments: number } = { segments: 1 };
   lastScrollPos: number;
   samePosCount: number;
 
@@ -15,7 +24,8 @@ export class AutoScroll {
   constructor() {
     //super();
 
-    this.showMoreQuery = "//*[contains(text(), 'show more') or contains(text(), 'Show more')]";
+    this.showMoreQuery =
+      "//*[contains(text(), 'show more') or contains(text(), 'Show more')]";
 
     this.lastScrollPos = -1;
     this.samePosCount = 0;
@@ -27,7 +37,7 @@ export class AutoScroll {
 
   static init() {
     return {
-      state: {}
+      state: {},
     };
   }
 
@@ -45,7 +55,10 @@ export class AutoScroll {
 
   canScrollMore() {
     const scrollElem = self.document.scrollingElement || self.document.body;
-    return this.currScrollPos() < Math.max(scrollElem.clientHeight, scrollElem.scrollHeight);
+    return (
+      this.currScrollPos() <
+      Math.max(scrollElem.clientHeight, scrollElem.scrollHeight)
+    );
   }
 
   debug(msg: string) {
@@ -67,9 +80,11 @@ export class AutoScroll {
   }
 
   async shouldScroll() {
-    if (!this.hasScrollEL(self.window) &&
+    if (
+      !this.hasScrollEL(self.window) &&
       !this.hasScrollEL(self.document) &&
-      !this.hasScrollEL(self.document.body)) {
+      !this.hasScrollEL(self.document.body)
+    ) {
       return false;
     }
 
@@ -82,16 +97,19 @@ export class AutoScroll {
     const numFetching = currentlyFetching();
 
     // scroll to almost end of page
-    const scrollEnd = (document.scrollingElement.scrollHeight * 0.98) - self.innerHeight;
+    const scrollEnd =
+      document.scrollingElement.scrollHeight * 0.98 - self.innerHeight;
 
     window.scrollTo({ top: scrollEnd, left: 0, behavior: "smooth" });
 
     // wait for any updates
     await sleep(500);
 
     // scroll height changed, should scroll
-    if (lastScrollHeight !== self.document.scrollingElement.scrollHeight ||
-      numFetching < currentlyFetching()) {
+    if (
+      lastScrollHeight !== self.document.scrollingElement.scrollHeight ||
+      numFetching < currentlyFetching()
+    ) {
       window.scrollTo({ top: 0, left: 0, behavior: "auto" });
       return true;
     }
@@ -104,14 +122,18 @@ export class AutoScroll {
       return false;
     }
 
-    if ((self.window.scrollY + self["scrollHeight"]) / self.document.scrollingElement.scrollHeight < 0.90) {
+    if (
+      (self.window.scrollY + self["scrollHeight"]) /
+        self.document.scrollingElement.scrollHeight <
+      0.9
+    ) {
       return false;
     }
 
     return true;
   }
 
-  async* run(ctx) {
+  async *run(ctx) {
     const { getState } = ctx.Lib;
 
     if (this.shouldScrollUp()) {
@@ -124,12 +146,18 @@ export class AutoScroll {
       return;
     }
 
-    yield getState(ctx, "Skipping autoscroll, page seems to not be responsive to scrolling events");
+    yield getState(
+      ctx,
+      "Skipping autoscroll, page seems to not be responsive to scrolling events",
+    );
   }
 
-  async* scrollDown(ctx) {
+  async *scrollDown(ctx) {
     const { getState } = ctx.Lib;
-    const scrollInc = Math.min(self.document.scrollingElement.clientHeight * 0.10, 30);
+    const scrollInc = Math.min(
+      self.document.scrollingElement.clientHeight * 0.1,
+      30,
+    );
     const interval = 75;
     let elapsedWait = 0;
 
@@ -141,8 +169,11 @@ export class AutoScroll {
 
     while (this.canScrollMore()) {
       if (document.location.pathname !== this.origPath) {
-        void behaviorLog("Location Changed, stopping scroll: " +
-          `${document.location.pathname} != ${this.origPath}`, "info");
+        void behaviorLog(
+          "Location Changed, stopping scroll: " +
+            `${document.location.pathname} != ${this.origPath}`,
+          "info",
+        );
         void addLink(document.location.href);
         return;
       }
@@ -165,8 +196,11 @@ export class AutoScroll {
         await sleep(waitUnit);
 
         await Promise.race([
-          waitUntil(() => self.document.scrollingElement.scrollHeight > scrollHeight, 500),
-          sleep(30000)
+          waitUntil(
+            () => self.document.scrollingElement.scrollHeight > scrollHeight,
+            500,
+          ),
+          sleep(30000),
         ]);
 
         if (self.document.scrollingElement.scrollHeight === scrollHeight) {
@@ -182,20 +216,25 @@ export class AutoScroll {
 
       if (this.state.segments === 1) {
         // only print this the first time
-        yield getState(ctx, `Scrolling down by ${scrollOpts.top} pixels every ${interval / 1000.0} seconds`);
+        yield getState(
+          ctx,
+          `Scrolling down by ${scrollOpts.top} pixels every ${interval / 1000.0} seconds`,
+        );
         elapsedWait = 2.0;
-
       } else {
         const waitSecs = elapsedWait / (this.state.segments - 1);
         // only add extra wait if actually changed height
         // check for scrolling, but allow for more time for content to appear the longer have already scrolled
-        void behaviorLog(`Waiting up to ${waitSecs} seconds for more scroll segments`, "debug");
+        void behaviorLog(
+          `Waiting up to ${waitSecs} seconds for more scroll segments`,
+          "debug",
+        );
 
         const startTime = Date.now();
 
         await Promise.race([
           waitUntil(() => this.canScrollMore(), interval),
-          sleep(waitSecs)
+          sleep(waitSecs),
         ]);
 
         elapsedWait += (Date.now() - startTime) * 2;
@@ -215,9 +254,12 @@ export class AutoScroll {
     }
   }
 
-  async* scrollUp(ctx) {
+  async *scrollUp(ctx) {
     const { getState } = ctx.Lib;
-    const scrollInc = Math.min(self.document.scrollingElement.clientHeight * 0.10, 30);
+    const scrollInc = Math.min(
+      self.document.scrollingElement.clientHeight * 0.1,
+      30,
+    );
     const interval = 75;
 
     const scrollOpts = { top: -scrollInc, left: 0, behavior: "auto" };
@@ -238,13 +280,16 @@ export class AutoScroll {
 
       if (this.state.segments === 1) {
         // only print this the first time
-        yield getState(ctx, `Scrolling up by ${scrollOpts.top} pixels every ${interval / 1000.0} seconds`);
+        yield getState(
+          ctx,
+          `Scrolling up by ${scrollOpts.top} pixels every ${interval / 1000.0} seconds`,
+        );
       } else {
         // only add extra wait if actually changed height
         // check for scrolling, but allow for more time for content to appear the longer have already scrolled
         await Promise.race([
           waitUntil(() => self.scrollY > 0, interval),
-          sleep((this.state.segments - 1) * 2000)
+          sleep((this.state.segments - 1) * 2000),
         ]);
       }
     }