add globals

Author: emma-sg

src/autoplay.ts

@@ -53,20 +53,19 @@ export class Autoplay extends BackgroundBehavior {
     while (run) {
       for (const [, elem] of querySelectorAllDeep(
         "video, audio, picture",
-      ).entries()) {
-        interface AutoplayElement extends HTMLMediaElement {
-          __bx_autoplay_found?: boolean;
-        }
-        if (!(elem as AutoplayElement)["__bx_autoplay_found"]) {
+      ).entries() as ArrayIterator<
+        [number, HTMLVideoElement | HTMLAudioElement | HTMLPictureElement]
+      >) {
+        if (!elem["__bx_autoplay_found"]) {
           if (!this.running) {
             if (this.processFetchableUrl(elem as HTMLMediaElement)) {
-              (elem as AutoplayElement)["__bx_autoplay_found"] = true;
+              elem["__bx_autoplay_found"] = true;
             }
             continue;
           }
 
           await this.loadMedia(elem as HTMLMediaElement);
-          (elem as AutoplayElement)["__bx_autoplay_found"] = true;
+          elem["__bx_autoplay_found"] = true;
         }
       }
 

src/autoscroll.ts

@@ -11,7 +11,7 @@ import {
 import { type AutoFetcher } from "./autofetcher";
 
 // ===========================================================================
-export class AutoScroll extends Behavior {
+export class AutoScroll extends Behavior<{}, {}> {
   autoFetcher: AutoFetcher;
   showMoreQuery: string;
   state: { segments: number } = { segments: 1 };
@@ -57,7 +57,7 @@ export class AutoScroll extends Behavior {
     this.lastMsg = msg;
   }
 
-  hasScrollEL(obj) {
+  hasScrollEL(obj: HTMLElement | Document | Window) {
     try {
       return !!self["getEventListeners"](obj).scroll;
     } catch (_) {
@@ -81,12 +81,12 @@ export class AutoScroll extends Behavior {
       return true;
     }
 
-    const lastScrollHeight = self.document.scrollingElement.scrollHeight;
+    const lastScrollHeight = self.document.scrollingElement!.scrollHeight;
     const numFetching = this.autoFetcher.numFetching;
 
     // scroll to almost end of page
     const scrollEnd =
-      document.scrollingElement.scrollHeight * 0.98 - self.innerHeight;
+      document.scrollingElement!.scrollHeight * 0.98 - self.innerHeight;
 
     window.scrollTo({ top: scrollEnd, left: 0, behavior: "smooth" });
 
@@ -95,7 +95,7 @@ export class AutoScroll extends Behavior {
 
     // scroll height changed, should scroll
     if (
-      lastScrollHeight !== self.document.scrollingElement.scrollHeight ||
+      lastScrollHeight !== self.document.scrollingElement!.scrollHeight ||
       numFetching < this.autoFetcher.numFetching
     ) {
       window.scrollTo({ top: 0, left: 0, behavior: "auto" });
@@ -112,7 +112,7 @@ export class AutoScroll extends Behavior {
 
     if (
       (self.window.scrollY + self["scrollHeight"]) /
-        self.document.scrollingElement.scrollHeight <
+        self.document.scrollingElement!.scrollHeight <
       0.9
     ) {
       return false;
@@ -194,7 +194,6 @@ export class AutoScroll extends Behavior {
         showMoreElem = null;
       }
 
-      // eslint-disable-next-line
       self.scrollBy(scrollOpts as ScrollToOptions);
 
       await sleep(interval);
@@ -256,7 +255,6 @@ export class AutoScroll extends Behavior {
         lastScrollHeight = scrollHeight;
       }
 
-      // eslint-disable-next-line
       self.scrollBy(scrollOpts as ScrollToOptions);
 
       await sleep(interval);

src/lib/behavior.ts

@@ -17,7 +17,10 @@ export class BackgroundBehavior {
 }
 
 // ===========================================================================
-export class Behavior extends BackgroundBehavior {
+export class Behavior<State, Opts = EmptyObject>
+  extends BackgroundBehavior
+  implements AbstractBehavior<State, Opts>
+{
   _running: Promise<void> | null;
   paused: any;
   _unpause: any;
@@ -105,51 +108,66 @@ export class Behavior extends BackgroundBehavior {
     }
   }
 
-  async *[Symbol.asyncIterator]() {
+  async *[Symbol.asyncIterator](): AsyncGenerator<
+    State | undefined,
+    void,
+    void
+  > {
     yield;
   }
 }
 
 // WIP: BehaviorRunner class allows for arbitrary behaviors outside of the
 // library to be run through the BehaviorManager
 
-export type Context<State, Opts> = {
+export type EmptyObject = Record<string, never>;
+
+export type Context<State, Opts = EmptyObject> = {
   Lib: typeof Lib;
   state: State;
   opts: Opts;
   log: (data: any, type?: string) => Promise<void>;
 };
 
-abstract class AbstractBehaviorInst<State, Opts, RunResult> {
-  abstract run: (ctx: Context<State, Opts>) => AsyncIterable<RunResult | void>;
+export abstract class AbstractBehavior<State, Opts = EmptyObject> {
+  static id: String;
+  static isMatch: () => boolean;
+  static init: () => any;
+
+  abstract run: (ctx: Context<State, Opts>) => AsyncIterable<any>;
 
   abstract awaitPageLoad?: (ctx: Context<State, Opts>) => Promise<void>;
 }
 
-interface StaticAbstractBehavior {
-  id: string;
-  isMatch: () => boolean;
-  init: () => any;
-}
+type StaticProps<T> = {
+  [K in keyof T]: T[K];
+};
 
-export type AbstractBehavior<State, Opts, RunResult> =
-  (new () => AbstractBehaviorInst<State, Opts, RunResult>) &
-    StaticAbstractBehavior;
+type StaticBehaviorProps = StaticProps<typeof AbstractBehavior>;
 
-export class BehaviorRunner<State, Opts, RunResult> extends BackgroundBehavior {
-  inst: AbstractBehaviorInst<State, Opts, RunResult>;
-  behaviorProps: StaticAbstractBehavior;
+// Non-abstract constructor type
+type ConcreteBehaviorConstructor<State, Opts> = StaticBehaviorProps & {
+  new (): AbstractBehavior<State, Opts>;
+};
+
+export class BehaviorRunner<
+  State,
+  Opts = EmptyObject,
+> extends BackgroundBehavior {
+  inst: AbstractBehavior<State, Opts>;
+  behaviorProps: ConcreteBehaviorConstructor<State, Opts>;
   ctx: Context<State, Opts>;
-  _running: Promise<void> | null;
+  _running: any;
   paused: any;
-  _unpause: ((value?: unknown) => void) | null;
+  _unpause: any;
 
   get id() {
-    return (this.inst.constructor as any).id;
+    return (this.inst.constructor as ConcreteBehaviorConstructor<State, Opts>)
+      .id;
   }
 
   constructor(
-    behavior: AbstractBehavior<State, Opts, RunResult>,
+    behavior: ConcreteBehaviorConstructor<State, Opts>,
     mainOpts = {},
   ) {
     super();
@@ -167,7 +185,7 @@ export class BehaviorRunner<State, Opts, RunResult> extends BackgroundBehavior {
     state = state || {};
     opts = opts ? { ...opts, ...mainOpts } : mainOpts;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const log = async (data: any, type: string) => this.wrappedLog(data, type);
+    const log = async (data: any, type?: string) => this.wrappedLog(data, type);
 
     this.ctx = { Lib, state, opts, log };
 
@@ -194,7 +212,7 @@ export class BehaviorRunner<State, Opts, RunResult> extends BackgroundBehavior {
     this._running = this.run();
   }
 
-  async done() {
+  done() {
     return this._running ? this._running : Promise.resolve();
   }
 

src/lib/global.d.ts

@@ -0,0 +1,34 @@
+import { type BehaviorManager } from "..";
+
+export {}; // Ensure this is treated as a module
+
+interface BehaviorGlobals {
+  __bx_addLink?: (url: string) => Promise<void>;
+  __bx_fetch?: (url: string) => Promise<boolean>;
+  __bx_addSet?: (url: string) => Promise<boolean>;
+  __bx_netIdle?: (params: {
+    idleTime: number;
+    concurrency: number;
+  }) => Promise<void>;
+  __bx_initFlow?: (params: any) => Promise<number>;
+  __bx_nextFlowStep?: (id: number) => Promise<any>;
+  __bx_contentCheckFailed?: (reason: string) => void;
+  __bx_open?: (params: { url: string | URL }) => Promise<void>;
+  __bx_openResolve?: (window: WindowProxy | null) => void;
+  __bx_behaviors?: BehaviorManager;
+}
+
+interface AutoplayProperties {
+  __bx_autoplay_found?: boolean;
+}
+
+declare global {
+  interface WorkerGlobalScope extends BehaviorGlobals {}
+  interface Window extends BehaviorGlobals {
+    __WB_replay_top?: Window;
+  }
+
+  interface HTMLVideoElement extends AutoplayProperties {}
+  interface HTMLAudioElement extends AutoplayProperties {}
+  interface HTMLPictureElement extends AutoplayProperties {}
+}

src/lib/utils.ts

@@ -1,6 +1,7 @@
 import { type BehaviorManager } from "..";
 import { type Context } from "./behavior";
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 let _logFunc: ((...data: any[]) => void) | null = console.log;
 // @ts-expect-error TODO: what is this, and why is it declared twice, once here and once as a function?
 let _behaviorMgrClass: (cls: typeof BehaviorManager) => void | null = null;
@@ -68,6 +69,7 @@ export async function awaitLoad(iframe?: HTMLIFrameElement) {
   });
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function unsetToJson(obj: any) {
   if (obj.toJSON) {
     try {
@@ -79,6 +81,7 @@ function unsetToJson(obj: any) {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function restoreToJson(obj: any) {
   if (obj.__bx__toJSON) {
     try {
@@ -91,40 +94,44 @@ function restoreToJson(obj: any) {
 }
 
 function unsetAllJson() {
-  unsetToJson(Object as any);
-  unsetToJson(Object.prototype as any);
-  unsetToJson(Array as any);
-  unsetToJson(Array.prototype as any);
+  unsetToJson(Object);
+  unsetToJson(Object.prototype);
+  unsetToJson(Array);
+  unsetToJson(Array.prototype);
 }
 
 function restoreAllJson() {
-  restoreToJson(Object as any);
-  restoreToJson(Object.prototype as any);
-  restoreToJson(Array as any);
-  restoreToJson(Array.prototype as any);
+  restoreToJson(Object);
+  restoreToJson(Object.prototype);
+  restoreToJson(Array);
+  restoreToJson(Array.prototype);
 }
 
 let needUnsetToJson = false;
 
+type WithToJSON<T> = T & {
+  toJSON?: () => unknown;
+};
+
 export function checkToJsonOverride() {
   needUnsetToJson =
-    !!(Object as any).toJSON ||
-    !!(Object.prototype as any).toJSON ||
-    !!(Array as any).toJSON ||
-    !!(Array.prototype as any).toJSON;
+    !!(Object as WithToJSON<typeof Object>).toJSON ||
+    !!(Object.prototype as WithToJSON<typeof Object.prototype>).toJSON ||
+    !!(Array as WithToJSON<typeof Array>).toJSON ||
+    !!(Array.prototype as WithToJSON<typeof Array.prototype>).toJSON;
 }
 
-export async function callBinding(
-  binding: (obj: any) => any,
-  obj: any,
-): Promise<any> {
+export async function callBinding<P, R>(
+  binding: (obj: P) => R,
+  obj: P,
+): Promise<R> {
   try {
     if (needUnsetToJson) {
       unsetAllJson();
     }
     return binding(obj);
   } catch (_) {
-    return binding(JSON.stringify(obj));
+    return binding(JSON.stringify(obj) as P);
   } finally {
     if (needUnsetToJson) {
       restoreAllJson();
@@ -189,8 +196,8 @@ export function assertContentValid(
 ) {
   if (typeof self["__bx_contentCheckFailed"] === "function") {
     if (!assertFunc()) {
-      behaviorLog("Behavior content check failed: " + reason, "error");
-      callBinding(self["__bx_contentCheckFailed"], reason);
+      void behaviorLog("Behavior content check failed: " + reason, "error");
+      void callBinding(self["__bx_contentCheckFailed"], reason);
     }
   }
 }
@@ -231,8 +238,7 @@ export function _behaviorMgrClass(cls: typeof BehaviorManager) {
   _behaviorMgrClass = cls;
 }
 
-export function installBehaviors(obj: any) {
-  // @ts-expect-error TODO: fix types here
+export function installBehaviors(obj: Window | WorkerGlobalScope) {
   obj.__bx_behaviors = new _behaviorMgrClass();
 }