@tstdl/base 0.87.1 → 0.87.3

package/browser/browser-context-controller.d.ts

@@ -1,8 +1,8 @@
-import type { BrowserContext } from 'playwright';
+import type { BrowserContext, Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
 import type { Resolvable } from '../injector/interfaces.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
+import { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
 import type { Logger } from '../logger/logger.js';
 import type { Record } from '../types.js';
 import type { Tagged } from 'type-fest';
@@ -19,12 +19,22 @@ export type NewPageOptions = {
 export type BrowserContextState = Tagged<Record<string | number, unknown>, 'BrowserContextState'>;
 export type BrowserContextControllerArgument = NewBrowserContextOptions;
 export declare class BrowserContextController implements AsyncDisposable, Resolvable<BrowserContextControllerArgument> {
+    #private;
     /** @deprecated should be avoided */
     readonly context: BrowserContext;
     readonly options: BrowserContextControllerOptions;
     readonly [resolveArgumentType]: BrowserContextControllerArgument;
     constructor(context: BrowserContext, options?: BrowserContextControllerOptions);
+    [afterResolve](): void;
+    initialize(): void;
     [disposeAsync](): Promise<void>;
+    pages(): PageController[];
+    /**
+     * Get a controller for the page.
+     * @param page page to get controller for
+     * @param options options to use for the page controller *if* it is new. Ignored if there is already a controller associated.
+     */
+    getControllerByPage(page: Page, options?: PageControllerOptions): PageController;
     close(): Promise<void>;
     getState(): Promise<BrowserContextState>;
     setExtraHttpHeaders(headers: Record<string, string | undefined>): Promise<void>;

package/browser/browser-context-controller.js

@@ -44,6 +44,7 @@ var __metadata = function(k, v) {
     return Reflect.metadata(k, v);
 };
 let BrowserContextController = class BrowserContextController2 {
+  #pageControllers = /* @__PURE__ */ new WeakMap();
   /** @deprecated should be avoided */
   context;
   options;
@@ -51,9 +52,38 @@ let BrowserContextController = class BrowserContextController2 {
     this.context = context;
     this.options = options;
   }
+  [import_interfaces.afterResolve]() {
+    this.initialize();
+  }
+  initialize() {
+    this.context.on("page", (page) => {
+      page.once("close", () => this.#pageControllers.delete(page));
+    });
+  }
   async [import_disposable.disposeAsync]() {
     await this.close();
   }
+  pages() {
+    const pages = this.context.pages();
+    return pages.map((page) => this.getControllerByPage(page));
+  }
+  /**
+   * Get a controller for the page.
+   * @param page page to get controller for
+   * @param options options to use for the page controller *if* it is new. Ignored if there is already a controller associated.
+   */
+  getControllerByPage(page, options) {
+    if (page.context() != this.context) {
+      throw new Error("Page is not from this context.");
+    }
+    const existingController = this.#pageControllers.get(page);
+    if ((0, import_type_guards.isDefined)(existingController)) {
+      return existingController;
+    }
+    const newController = new import_page_controller.PageController(page, this, { ...this.options.defaultNewPageOptions?.controllerOptions, ...options });
+    this.#pageControllers.set(page, newController);
+    return newController;
+  }
   async close() {
     await this.context.close();
   }
@@ -68,7 +98,8 @@ let BrowserContextController = class BrowserContextController2 {
   async newPage(options) {
     const page = await this.context.newPage();
     const mergedOptions = { ...this.options.defaultNewPageOptions, ...options };
-    const controller = new import_page_controller.PageController(page, mergedOptions.controllerOptions);
+    const controller = new import_page_controller.PageController(page, this, mergedOptions.controllerOptions);
+    this.#pageControllers.set(page, controller);
     if ((0, import_type_guards.isDefined)(mergedOptions.extraHttpHeaders)) {
       await controller.setExtraHttpHeaders(mergedOptions.extraHttpHeaders);
     }

package/browser/document-controller.d.ts

@@ -1,27 +1,33 @@
 import type { ElementHandle, Frame, FrameLocator, Page } from 'playwright';
-import type { Delay } from './element-controller.js';
+import type { BrowserContextController } from './browser-context-controller.js';
 import { ElementController } from './element-controller.js';
 import type { FrameController, FrameControllerOptions } from './frame-controller.js';
 import { LocatorController } from './locator-controller.js';
-import type { PageControllerOptions } from './page-controller.js';
+import type { Delay } from './types.js';
 export type DocumentControllerOptions = {
     defaultActionDelay?: Delay;
     defaultTypeDelay?: Delay;
 };
-export type DocumentControllerForwardOptions = {
-    pageControllerOptions: PageControllerOptions;
-    frameControllerOptions: FrameControllerOptions;
-};
+export declare function setFrameControllerConstructor(constructor: typeof FrameController): void;
 export declare class DocumentController<T extends Page | Frame = Page | Frame> extends LocatorController<T> {
-    protected readonly forwardOptions: DocumentControllerForwardOptions;
+    #private;
     /** @deprecated should be avoided */
     readonly document: T;
-    constructor(document: T, options: DocumentControllerOptions, forwardOptions: DocumentControllerForwardOptions);
+    readonly context: BrowserContextController;
+    readonly options: DocumentControllerOptions;
+    constructor(document: T, context: BrowserContextController, options: DocumentControllerOptions);
+    frames(): FrameController[];
+    /**
+     * Get a controller for the frame.
+     * @param frame frame to get controller for
+     * @param options options to use for the frame controller *if* it is new. Ignored if there is already a controller associated.
+     */
+    getControllerByFrame(frame: Frame, options?: FrameControllerOptions): FrameController;
     setContent(...args: Parameters<Page['setContent']>): Promise<void>;
     navigate(...args: Parameters<Page['goto']>): Promise<void>;
     waitForLoadState(...args: Parameters<Page['waitForLoadState']>): Promise<void>;
     waitForUrl(...args: Parameters<Page['waitForURL']>): Promise<void>;
     waitForElement(selector: string, options?: Parameters<Page['waitForSelector']>[1]): Promise<ElementController<ElementHandle<SVGElement | HTMLElement>>>;
     locateInFrame(frameSelector: string): LocatorController<FrameLocator>;
-    waitForFrame(selector: string, options?: Parameters<Page['waitForSelector']>[1]): Promise<FrameController>;
+    waitForFrame(selector: string, options?: Parameters<Page['waitForSelector']>[1], controllerOptions?: FrameControllerOptions): Promise<FrameController>;
 }

package/browser/document-controller.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,31 +15,54 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var document_controller_exports = {};
 __export(document_controller_exports, {
-  DocumentController: () => DocumentController
+  DocumentController: () => DocumentController,
+  setFrameControllerConstructor: () => setFrameControllerConstructor
 });
 module.exports = __toCommonJS(document_controller_exports);
 var import_type_guards = require("../utils/type-guards.js");
 var import_element_controller = require("./element-controller.js");
 var import_locator_controller = require("./locator-controller.js");
+var import_utils = require("./utils.js");
+let frameControllerConstructor;
+function setFrameControllerConstructor(constructor) {
+  frameControllerConstructor = constructor;
+}
 class DocumentController extends import_locator_controller.LocatorController {
-  forwardOptions;
+  #frameControllers = /* @__PURE__ */ new WeakMap();
   /** @deprecated should be avoided */
   document;
-  constructor(document, options, forwardOptions) {
+  context;
+  options;
+  constructor(document, context, options) {
     super(document, { actionDelay: options.defaultActionDelay, typeDelay: options.defaultTypeDelay });
     this.document = document;
-    this.forwardOptions = forwardOptions;
+    this.context = context;
+    this.options = options;
+  }
+  frames() {
+    const frames = (0, import_utils.isPage)(this.document) ? this.document.frames() : this.document.childFrames();
+    return frames.map((page) => this.getControllerByFrame(page));
+  }
+  /**
+   * Get a controller for the frame.
+   * @param frame frame to get controller for
+   * @param options options to use for the frame controller *if* it is new. Ignored if there is already a controller associated.
+   */
+  getControllerByFrame(frame, options) {
+    const documentPage = (0, import_utils.isPage)(this.document) ? this.document : this.document.page();
+    if (frame.page() != documentPage) {
+      throw new Error("Frame is not from this page.");
+    }
+    const existingController = this.#frameControllers.get(frame);
+    if ((0, import_type_guards.isDefined)(existingController)) {
+      return existingController;
+    }
+    const newController = new frameControllerConstructor(frame, this.context, { ...this.options, ...options });
+    this.#frameControllers.set(frame, newController);
+    return newController;
   }
   async setContent(...args) {
     await this.document.setContent(...args);
@@ -66,24 +87,12 @@ class DocumentController extends import_locator_controller.LocatorController {
     const locator = this.document.frameLocator(frameSelector);
     return new import_locator_controller.LocatorController(locator, this.elementControllerOptions);
   }
-  async waitForFrame(selector, options) {
+  async waitForFrame(selector, options, controllerOptions) {
     const element = await this.waitForElement(selector, options);
     const frame = await element.locatorOrHandle.contentFrame();
     if ((0, import_type_guards.isNull)(frame)) {
       throw new Error("Element is not a frame.");
     }
-    return newFrameController(frame, this.forwardOptions.frameControllerOptions, { pageControllerOptions: this.forwardOptions.pageControllerOptions });
+    return this.getControllerByFrame(frame, controllerOptions);
   }
 }
-let frameControllerConstructor;
-async function newFrameController(...args) {
-  if ((0, import_type_guards.isUndefined)(frameControllerConstructor)) {
-    frameControllerConstructor = importFrameController();
-    void frameControllerConstructor.then((constructor) => frameControllerConstructor = constructor);
-  }
-  return new (await frameControllerConstructor)(...args);
-}
-async function importFrameController() {
-  const module2 = await import("./frame-controller.js");
-  return module2.FrameController;
-}

package/browser/element-controller.d.ts

@@ -1,10 +1,6 @@
 import type { ElementHandle, Locator } from 'playwright';
 import type { Merge, NonUndefinable, TypedOmit } from '../types.js';
-import type { ValueOrProvider } from '../utils/value-or-provider.js';
-export type Delay = ValueOrProvider<number>;
-export type ActionDelayOptions = {
-    actionDelay?: Delay;
-};
+import type { ActionDelayOptions, Delay, TimeoutOptions } from './types.js';
 export type TypeDelayOptions = {
     typeDelay?: Delay;
 };
@@ -23,6 +19,12 @@ export type Filter = {
     hasText?: string | RegExp;
     hasNotText?: string | RegExp;
 };
+export type BoundingBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
 export declare class ElementController<T extends Locator | ElementHandle = Locator | ElementHandle> implements Pick<Locator, Methods> {
     readonly locatorOrHandle: T;
     readonly options: ElementControllerOptions;
@@ -35,6 +37,12 @@ export declare class ElementController<T extends Locator | ElementHandle = Locat
      * @param elementController
      */
     and(elementController: ElementController): ElementController<Locator>;
+    /**
+     * Get an controller with elements contained in this and the provided controller.
+     * Requires locator based controller
+     * @param elementController
+     */
+    or(elementController: ElementController): ElementController<Locator>;
     /**
      * Filter out elements with by provided filter.
      * Requires locator based controller.
@@ -45,12 +53,23 @@ export declare class ElementController<T extends Locator | ElementHandle = Locat
      * Requires locator based controller.
      */
     locate(selectorOrController: string | ElementController, filter?: Filter): ElementController<Locator>;
+    first(): ElementController<Locator>;
+    last(): ElementController<Locator>;
+    nth(index: number): ElementController<Locator>;
+    evaluate<R, A>(fn: string | ((element: SVGElement | HTMLElement, argument: A) => R | Promise<R>), argument: A): Promise<R>;
+    evaluate<R, A>(fn: string | ((element: SVGElement | HTMLElement, argument?: A) => R | Promise<R>), argument?: A): Promise<R>;
     /**
      * Wait for element state
      * @param state some states may only be usable for either locator or handle
      * @param options options
      */
     waitFor(state?: Parameters<ElementHandle['waitForElementState']>[0] | NonNullable<LocatorOptions<'waitFor', '0'>['state']>, options?: Parameters<ElementHandle['waitForElementState']>[1]): Promise<void>;
+    boundingBox(options?: TimeoutOptions): Promise<BoundingBox | null>;
+    scrollIntoViewIfNeeded(options?: TimeoutOptions): Promise<void>;
+    /**
+     * Counts matching elements for locator based or returns 1 for handle based.
+     */
+    count(): Promise<number>;
     /**
      * Check if element exists
      * @param options.state which state is required in order to be deemed existing
@@ -58,14 +77,14 @@ export declare class ElementController<T extends Locator | ElementHandle = Locat
      */
     exists(options?: {
         state?: 'visible' | 'attached';
-        timeout?: number;
-    }): Promise<boolean>;
+    } & TimeoutOptions): Promise<boolean>;
     isVisible(): Promise<boolean>;
     isHidden(): Promise<boolean>;
     isEnabled(): Promise<boolean>;
     isDisabled(): Promise<boolean>;
     isChecked(): Promise<boolean>;
     isEditable(): Promise<boolean>;
+    clear(options?: Merge<LocatorOptions<'clear', 1>, ActionDelayOptions>): Promise<void>;
     fill(text: string, options?: Merge<LocatorOptions<'fill', 1>, ActionDelayOptions>): Promise<void>;
     type(text: string, options?: Merge<TypedOmit<LocatorOptions<'type', 1>, 'delay'>, ActionDelayOptions & TypeDelayOptions>): Promise<void>;
     press(key: string, options?: Merge<LocatorOptions<'press', 1>, ActionDelayOptions>): Promise<void>;
@@ -81,6 +100,5 @@ export declare class ElementController<T extends Locator | ElementHandle = Locat
     tap(options?: Merge<LocatorOptions<'tap', 1>, ActionDelayOptions>): Promise<void>;
     selectText(options?: Merge<LocatorOptions<'selectText', 1>, ActionDelayOptions>): Promise<void>;
     inputValue(options?: LocatorOptions<'inputValue', 0>): Promise<string>;
-    private prepareAction;
 }
 export {};

package/browser/element-controller.js

@@ -21,11 +21,10 @@ __export(element_controller_exports, {
   ElementController: () => ElementController
 });
 module.exports = __toCommonJS(element_controller_exports);
-var import_timing = require("../utils/timing.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_value_or_provider = require("../utils/value-or-provider.js");
 var import_utils = require("./utils.js");
-const filterNonLocatorErrorMessage = "Requires a locator basesd controller";
+const requiresLocatorBasedController = "Requires a locator based controller";
 class ElementController {
   locatorOrHandle;
   options;
@@ -53,17 +52,28 @@ class ElementController {
    * @param elementController
    */
   and(elementController) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, filterNonLocatorErrorMessage);
-    (0, import_utils.assertLocator)(elementController.locatorOrHandle, filterNonLocatorErrorMessage);
+    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
+    (0, import_utils.assertLocator)(elementController.locatorOrHandle, requiresLocatorBasedController);
     const locator = this.locatorOrHandle.and(elementController.locatorOrHandle);
     return new ElementController(locator, this.options);
   }
+  /**
+   * Get an controller with elements contained in this and the provided controller.
+   * Requires locator based controller
+   * @param elementController
+   */
+  or(elementController) {
+    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
+    (0, import_utils.assertLocator)(elementController.locatorOrHandle, requiresLocatorBasedController);
+    const locator = this.locatorOrHandle.or(elementController.locatorOrHandle);
+    return new ElementController(locator, this.options);
+  }
   /**
    * Filter out elements with by provided filter.
    * Requires locator based controller.
    */
   filter(filter) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, filterNonLocatorErrorMessage);
+    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
     const locator = this.locatorOrHandle.filter(convertFilter(filter));
     return new ElementController(locator, this.options);
   }
@@ -72,12 +82,33 @@ class ElementController {
    * Requires locator based controller.
    */
   locate(selectorOrController, filter) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, filterNonLocatorErrorMessage);
-    const selector = (0, import_type_guards.isString)(selectorOrController) ? selectorOrController : (0, import_utils.assertLocatorPass)(selectorOrController.locatorOrHandle, filterNonLocatorErrorMessage);
+    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
+    const selector = (0, import_type_guards.isString)(selectorOrController) ? selectorOrController : (0, import_utils.assertLocatorPass)(selectorOrController.locatorOrHandle, requiresLocatorBasedController);
     const convertedFilter = (0, import_type_guards.isDefined)(filter) ? convertFilter(filter) : void 0;
     const locator = this.locatorOrHandle.locator(selector, convertedFilter);
     return new ElementController(locator, this.options);
   }
+  first() {
+    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
+    const locator = this.locatorOrHandle.first();
+    return new ElementController(locator, this.options);
+  }
+  last() {
+    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
+    const locator = this.locatorOrHandle.last();
+    return new ElementController(locator, this.options);
+  }
+  nth(index) {
+    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
+    const locator = this.locatorOrHandle.nth(index);
+    return new ElementController(locator, this.options);
+  }
+  async evaluate(fn, argument) {
+    if ((0, import_utils.isLocator)(this.locatorOrHandle)) {
+      return this.locatorOrHandle.evaluate(fn, argument);
+    }
+    return this.locatorOrHandle.evaluate(fn, argument);
+  }
   /**
    * Wait for element state
    * @param state some states may only be usable for either locator or handle
@@ -89,6 +120,18 @@ class ElementController {
     }
     return this.locatorOrHandle.waitForElementState(state, options);
   }
+  async boundingBox(options) {
+    return this.locatorOrHandle.boundingBox({ timeout: options?.timeout ?? 1e3 });
+  }
+  async scrollIntoViewIfNeeded(options) {
+    await this.locatorOrHandle.scrollIntoViewIfNeeded({ timeout: options?.timeout ?? 1e3 });
+  }
+  /**
+   * Counts matching elements for locator based or returns 1 for handle based.
+   */
+  async count() {
+    return (0, import_utils.isLocator)(this.locatorOrHandle) ? this.locatorOrHandle.count() : 1;
+  }
   /**
    * Check if element exists
    * @param options.state which state is required in order to be deemed existing
@@ -96,7 +139,7 @@ class ElementController {
    */
   async exists(options) {
     try {
-      await this.waitFor(options?.state ?? "visible", { timeout: options?.timeout ?? 250 });
+      await this.waitFor(options?.state ?? "visible", { timeout: options?.timeout ?? 1e3 });
       return true;
     } catch (error) {
       if (error instanceof Error && error.message.includes("violation")) {
@@ -123,97 +166,89 @@ class ElementController {
   async isEditable() {
     return this.locatorOrHandle.isEditable();
   }
+  async clear(options) {
+    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
+    await (0, import_utils.prepareAction)(options);
+    await this.locatorOrHandle.clear(options);
+  }
   async fill(text, options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.fill(text, options);
   }
   async type(text, options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     if ((0, import_type_guards.isUndefined)(this.options.typeDelay)) {
       await this.locatorOrHandle.type(text, options);
     } else {
       for (const char of text) {
         await this.locatorOrHandle.type(char, options);
-        await delay(options?.typeDelay ?? this.options.typeDelay);
+        await (0, import_utils.delay)(options?.typeDelay ?? this.options.typeDelay);
       }
     }
   }
   async press(key, options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.press(key, options);
   }
   async check(options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.check(options);
   }
   async uncheck(options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.uncheck(options);
   }
   async setChecked(checked, options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.setChecked(checked, options);
   }
   async selectOption(option, options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     const selectedOptions = await this.locatorOrHandle.selectOption(option, options);
     return selectedOptions;
   }
   async setInputFiles(files, options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.setInputFiles(files, options);
   }
   async click(options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.click({
       ...options,
       delay: (0, import_value_or_provider.resolveValueOrProvider)(options?.clickDelay)
     });
   }
   async dblclick(options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.dblclick({
       ...options,
       delay: (0, import_value_or_provider.resolveValueOrProvider)(options?.clickDelay)
     });
   }
   async hover(options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.hover(options);
   }
   async focus(options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.focus(options);
   }
   async tap(options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.tap(options);
   }
   async selectText(options) {
-    await this.prepareAction(options);
+    await (0, import_utils.prepareAction)(options);
     await this.locatorOrHandle.selectText(options);
   }
   async inputValue(options) {
     return this.locatorOrHandle.inputValue(options);
   }
-  async prepareAction(options) {
-    const actionDelay = options?.actionDelay ?? this.options.actionDelay;
-    if ((0, import_type_guards.isDefined)(actionDelay)) {
-      await this.waitFor("visible", { timeout: (0, import_value_or_provider.resolveValueOrProvider)(options?.timeout) });
-      await delay(actionDelay);
-    }
-  }
-}
-async function delay(milliseconds) {
-  if ((0, import_type_guards.isUndefined)(milliseconds)) {
-    return;
-  }
-  await (0, import_timing.timeout)((0, import_value_or_provider.resolveValueOrProvider)(milliseconds));
 }
 function convertFilter(filter) {
   return {
-    has: (0, import_type_guards.isDefined)(filter.has) ? (0, import_utils.assertLocatorPass)(filter.has.locatorOrHandle, filterNonLocatorErrorMessage) : void 0,
-    hasNot: (0, import_type_guards.isDefined)(filter.hasNot) ? (0, import_utils.assertLocatorPass)(filter.hasNot.locatorOrHandle, filterNonLocatorErrorMessage) : void 0,
+    has: (0, import_type_guards.isDefined)(filter.has) ? (0, import_utils.assertLocatorPass)(filter.has.locatorOrHandle, requiresLocatorBasedController) : void 0,
+    hasNot: (0, import_type_guards.isDefined)(filter.hasNot) ? (0, import_utils.assertLocatorPass)(filter.hasNot.locatorOrHandle, requiresLocatorBasedController) : void 0,
     hasText: filter.hasText,
     hasNotText: filter.hasNotText
   };

package/browser/frame-controller.d.ts

@@ -1,23 +1,19 @@
 import type { Frame, Page } from 'playwright';
+import type { BrowserContextController } from './browser-context-controller.js';
 import type { DocumentControllerOptions } from './document-controller.js';
 import { DocumentController } from './document-controller.js';
-import type { PageControllerOptions } from './page-controller.js';
-import { PageController } from './page-controller.js';
+import type { PageController, PageControllerOptions } from './page-controller.js';
 export type FrameControllerOptions = DocumentControllerOptions;
-export type FrameControllerForwardOptions = {
-    pageControllerOptions: PageControllerOptions;
-};
 export declare class FrameController extends DocumentController<Frame> {
-    private readonly frameControllerForwardOptions;
     /** @deprecated should be avoided */
     readonly frame: Frame;
     readonly options: FrameControllerOptions;
-    constructor(frame: Frame, options: FrameControllerOptions, forwardOptions: FrameControllerForwardOptions);
+    constructor(frame: Frame, context: BrowserContextController, options: FrameControllerOptions);
     /** Get the page containing this frame */
-    getPage(): PageController;
+    getPage(options?: PageControllerOptions): PageController;
     /**
      * @param frameSelector frame name, url or url predicate
      * @returns
      */
-    getFrame(frameSelector: Parameters<Page['frame']>[0]): FrameController;
+    getFrame(frameSelector: Parameters<Page['frame']>[0], options?: FrameControllerOptions): FrameController;
 }

package/browser/frame-controller.js

@@ -23,30 +23,27 @@ __export(frame_controller_exports, {
 module.exports = __toCommonJS(frame_controller_exports);
 var import_type_guards = require("../utils/type-guards.js");
 var import_document_controller = require("./document-controller.js");
-var import_page_controller = require("./page-controller.js");
 class FrameController extends import_document_controller.DocumentController {
-  frameControllerForwardOptions;
   /** @deprecated should be avoided */
   frame;
   options;
-  constructor(frame, options, forwardOptions) {
-    super(frame, options, { frameControllerOptions: options, pageControllerOptions: forwardOptions.pageControllerOptions });
+  constructor(frame, context, options) {
+    super(frame, context, options);
     this.options = options;
-    this.frameControllerForwardOptions = forwardOptions;
   }
   /** Get the page containing this frame */
-  getPage() {
-    return new import_page_controller.PageController(this.frame.page(), this.frameControllerForwardOptions.pageControllerOptions);
+  getPage(options) {
+    return this.context.getControllerByPage(this.frame.page(), options);
   }
   /**
    * @param frameSelector frame name, url or url predicate
    * @returns
    */
-  getFrame(frameSelector) {
+  getFrame(frameSelector, options) {
     const frame = this.frame.page().frame(frameSelector);
     if ((0, import_type_guards.isNull)(frame)) {
       throw new Error("Frame not found.");
     }
-    return new FrameController(frame, this.options, this.frameControllerForwardOptions);
+    return this.getControllerByFrame(frame, { ...this.options, ...options });
   }
 }

package/browser/module.js

@@ -28,6 +28,8 @@ var import_injector = require("../injector/injector.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_browser_service = require("./browser.service.js");
+var import_document_controller = require("./document-controller.js");
+var import_frame_controller = require("./frame-controller.js");
 const browserTypes = {
   chromium: import_playwright.chromium,
   firefox: import_playwright.firefox,
@@ -49,3 +51,4 @@ function getBrowserType(type) {
   }
   return browserType;
 }
+(0, import_document_controller.setFrameControllerConstructor)(import_frame_controller.FrameController);

package/browser/page-controller.d.ts

@@ -2,22 +2,28 @@ import type { Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
 import type { Logger } from '../logger/logger.js';
+import type { BrowserContextController } from './browser-context-controller.js';
 import type { DocumentControllerOptions } from './document-controller.js';
 import { DocumentController } from './document-controller.js';
-import type { FrameControllerOptions } from './frame-controller.js';
-import { FrameController } from './frame-controller.js';
+import { ElementController } from './element-controller.js';
+import type { FrameController, FrameControllerOptions } from './frame-controller.js';
 import type { PdfRenderOptions } from './pdf-options.js';
 import type { Abortable } from './types.js';
-export type PageControllerOptions = DocumentControllerOptions & {
-    defaultFrameControllerOptions?: FrameControllerOptions;
+export type PageControllerOptions = DocumentControllerOptions;
+export type ScrollToCoordinates = {
+    x?: number;
+    y?: number;
 };
 export declare class PageController extends DocumentController<Page> implements AsyncDisposable {
     /** @deprecated should be avoided */
     readonly page: Page;
     readonly options: PageControllerOptions;
-    constructor(page: Page, options?: PageControllerOptions);
+    constructor(page: Page, context: BrowserContextController, options?: PageControllerOptions);
     [disposeAsync](): Promise<void>;
     close(): Promise<void>;
+    /** finds pages opened by this page (having opener set to this page) */
+    opened(): Promise<PageController[]>;
+    opener(): Promise<PageController | null>;
     setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
     waitForClose(): Promise<void>;
     url(): string;
@@ -25,8 +31,10 @@ export declare class PageController extends DocumentController<Page> implements
      * @param frameSelector frame name, url or url predicate
      * @returns
      */
-    frame(frameSelector: Parameters<Page['frame']>[0]): FrameController;
+    frame(frameSelector: Parameters<Page['frame']>[0], options?: FrameControllerOptions): FrameController;
     renderPdf(options?: PdfRenderOptions & Abortable): Promise<Uint8Array>;
+    scroll(deltaX: number, deltaY: number): Promise<void>;
+    scrollTo(coordinatesOrController: ScrollToCoordinates | ElementController): Promise<void>;
     renderPdfStream(options?: PdfRenderOptions & Abortable): ReadableStream<Uint8Array>;
     attachLogger(logger: Logger): void;
 }

package/browser/page-controller.js

@@ -28,14 +28,14 @@ var import_timing = require("../utils/timing.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_units = require("../utils/units.js");
 var import_document_controller = require("./document-controller.js");
-var import_frame_controller = require("./frame-controller.js");
+var import_element_controller = require("./element-controller.js");
 var import_utils = require("./utils.js");
 class PageController extends import_document_controller.DocumentController {
   /** @deprecated should be avoided */
   page;
   options;
-  constructor(page, options = {}) {
-    super(page, options, { pageControllerOptions: options, frameControllerOptions: options.defaultFrameControllerOptions ?? options });
+  constructor(page, context, options = {}) {
+    super(page, context, options);
     this.page = page;
     this.options = options;
   }
@@ -45,6 +45,23 @@ class PageController extends import_document_controller.DocumentController {
   async close() {
     await this.page.close();
   }
+  /** finds pages opened by this page (having opener set to this page) */
+  async opened() {
+    const openedPages = [];
+    for (const page of this.context.pages()) {
+      if (await page.opener() == this) {
+        openedPages.push(page);
+      }
+    }
+    return openedPages;
+  }
+  async opener() {
+    const opener = await this.page.opener();
+    if ((0, import_type_guards.isNull)(opener)) {
+      return null;
+    }
+    return this.context.getControllerByPage(opener);
+  }
   async setExtraHttpHeaders(headers) {
     const filtered = (0, import_object.filterUndefinedFromRecord)(headers);
     await this.page.setExtraHTTPHeaders(filtered);
@@ -65,17 +82,63 @@ class PageController extends import_document_controller.DocumentController {
    * @param frameSelector frame name, url or url predicate
    * @returns
    */
-  frame(frameSelector) {
+  frame(frameSelector, options) {
     const frame = this.page.frame(frameSelector);
     if ((0, import_type_guards.isNull)(frame)) {
       throw new Error("Frame not found.");
     }
-    return new import_frame_controller.FrameController(frame, this.options, this.forwardOptions);
+    return this.getControllerByFrame(frame, { ...this.options, ...options });
   }
   async renderPdf(options = {}) {
     const createPdfOptions = convertPdfOptions(options);
     return (0, import_timing.withTimeout)(options.timeout ?? 30 * import_units.millisecondsPerSecond, this.page.pdf(createPdfOptions), { errorMessage: "Rendering pdf timed out." });
   }
+  async scroll(deltaX, deltaY) {
+    await this.page.mouse.wheel(deltaX, deltaY);
+  }
+  async scrollTo(coordinatesOrController) {
+    const viewportSize = this.page.viewportSize();
+    if ((0, import_type_guards.isNull)(viewportSize)) {
+      throw new Error("Could not get page viewport size.");
+    }
+    const targetLeft = viewportSize.width / 3;
+    const targetRight = viewportSize.width / 3 * 2;
+    const targetTop = viewportSize.height / 3;
+    const targetBottom = viewportSize.height / 3 * 2;
+    const offsetX = viewportSize.width / 10;
+    const offsetY = viewportSize.height / 10;
+    const isElement = coordinatesOrController instanceof import_element_controller.ElementController;
+    while (true) {
+      const { scrollWidth, scrollHeight, scrollLeft, scrollTop, clientWidth, clientHeight } = await this.page.evaluate(async () => {
+        const { scrollWidth: scrollWidth2, scrollHeight: scrollHeight2, scrollLeft: scrollLeft2, scrollTop: scrollTop2, clientWidth: clientWidth2, clientHeight: clientHeight2 } = document.documentElement;
+        return { scrollWidth: scrollWidth2, scrollHeight: scrollHeight2, scrollLeft: scrollLeft2, scrollTop: scrollTop2, clientWidth: clientWidth2, clientHeight: clientHeight2 };
+      });
+      let targetX;
+      let targetY;
+      if (isElement) {
+        const boundingBox = await coordinatesOrController.boundingBox();
+        if ((0, import_type_guards.isNull)(boundingBox)) {
+          throw new Error("Could not get element bounding box.");
+        }
+        targetX = boundingBox.x + boundingBox.width / 2;
+        targetY = boundingBox.y + boundingBox.height / 2;
+      } else {
+        targetX = (0, import_type_guards.isDefined)(coordinatesOrController.x) ? coordinatesOrController.x - scrollLeft : void 0;
+        targetY = (0, import_type_guards.isDefined)(coordinatesOrController.y) ? coordinatesOrController.y - scrollTop : void 0;
+      }
+      const deltaX = (0, import_type_guards.isUndefined)(targetX) ? void 0 : targetX < targetLeft && scrollLeft > 0 ? -offsetX : targetX > targetRight && scrollLeft + clientWidth < scrollWidth ? offsetX : void 0;
+      const deltaY = (0, import_type_guards.isUndefined)(targetY) ? void 0 : targetY < targetTop && scrollTop > 0 ? -offsetY : targetY > targetBottom && scrollTop + clientHeight < scrollHeight ? offsetY : void 0;
+      if ((0, import_type_guards.isDefined)(deltaY)) {
+        await this.page.mouse.wheel(0, deltaY);
+        await (0, import_utils.delay)(Math.max(10, 150 - Math.abs(targetY - targetTop) / 10));
+      } else if ((0, import_type_guards.isDefined)(deltaX)) {
+        await this.page.mouse.wheel(deltaX, 0);
+        await (0, import_utils.delay)(Math.max(10, 150 - Math.abs(targetX - targetLeft) / 10));
+      } else {
+        break;
+      }
+    }
+  }
   renderPdfStream(options = {}) {
     return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
       const buffer = await this.renderPdf(options);

package/browser/types.d.ts

@@ -1,3 +1,4 @@
+import type { ValueOrProvider } from '../utils/value-or-provider.js';
 export type TimeoutOptions = {
     timeout?: number;
 };
@@ -8,3 +9,7 @@ export type WaitForStateOptions = {
 export type Abortable = {
     abort?: AbortSignal;
 };
+export type Delay = ValueOrProvider<number>;
+export type ActionDelayOptions = {
+    actionDelay?: Delay;
+};

package/browser/utils.d.ts

@@ -2,6 +2,7 @@ import type { Logger } from '../logger/logger.js';
 import type { BrowserContext, ElementHandle, Frame, LaunchOptions, Locator, Page } from 'playwright';
 import type { NewBrowserContextOptions } from './browser-controller.js';
 import type { NewBrowserOptions } from './browser.service.js';
+import type { ActionDelayOptions, Delay, TimeoutOptions } from './types.js';
 export declare function getLaunchOptions(options: NewBrowserOptions): LaunchOptions;
 export declare function mergeNewBrowserContextOptions(a: NewBrowserContextOptions | undefined, b?: NewBrowserContextOptions, c?: NewBrowserContextOptions): NewBrowserContextOptions;
 export declare function attachLogger(loggable: Page | BrowserContext, logger: Logger): void;
@@ -12,3 +13,5 @@ export declare function isElementHandle(locatorOrHandle: Locator | ElementHandle
 export declare function isPage(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is Page;
 export declare function isFrame(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is Frame;
 export declare function isBrowserContext(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is BrowserContext;
+export declare function prepareAction(options?: ActionDelayOptions & TimeoutOptions): Promise<void>;
+export declare function delay(milliseconds: Delay | undefined): Promise<void>;

package/browser/utils.js

@@ -21,17 +21,21 @@ __export(utils_exports, {
   assertLocator: () => assertLocator,
   assertLocatorPass: () => assertLocatorPass,
   attachLogger: () => attachLogger,
+  delay: () => delay,
   getLaunchOptions: () => getLaunchOptions,
   isBrowserContext: () => isBrowserContext,
   isElementHandle: () => isElementHandle,
   isFrame: () => isFrame,
   isLocator: () => isLocator,
   isPage: () => isPage,
-  mergeNewBrowserContextOptions: () => mergeNewBrowserContextOptions
+  mergeNewBrowserContextOptions: () => mergeNewBrowserContextOptions,
+  prepareAction: () => prepareAction
 });
 module.exports = __toCommonJS(utils_exports);
 var import_object = require("../utils/object/object.js");
+var import_timing = require("../utils/timing.js");
 var import_type_guards = require("../utils/type-guards.js");
+var import_value_or_provider = require("../utils/value-or-provider.js");
 const pageLoggerMap = /* @__PURE__ */ new WeakMap();
 function getLaunchOptions(options) {
   const { windowSize, browserArguments, headless } = options;
@@ -125,3 +129,15 @@ function isFrame(pageOrFrameOrContext) {
 function isBrowserContext(pageOrFrameOrContext) {
   return pageOrFrameOrContext.constructor.name == "BrowserContext";
 }
+async function prepareAction(options) {
+  const actionDelay = options?.actionDelay;
+  if ((0, import_type_guards.isDefined)(actionDelay)) {
+    await (0, import_timing.timeout)((0, import_value_or_provider.resolveValueOrProvider)(actionDelay));
+  }
+}
+async function delay(milliseconds) {
+  if ((0, import_type_guards.isUndefined)(milliseconds)) {
+    return;
+  }
+  await (0, import_timing.timeout)((0, import_value_or_provider.resolveValueOrProvider)(milliseconds));
+}

package/examples/browser/basic.d.ts

@@ -1 +1 @@
-export {};
+import '../../polyfills.js';

package/examples/browser/basic.js

@@ -1,4 +1,5 @@
 "use strict";
+var import_polyfills = require("../../polyfills.js");
 var import_promises = require("node:fs/promises");
 var import_application = require("../../application/index.js");
 var import_browser_service = require("../../browser/browser.service.js");

package/function/log.d.ts

@@ -3,4 +3,4 @@ export type WrapLogOptions = {
     fnName?: string;
     logger?: Logger;
 };
-export declare function wrapLog(fn: Function, options?: WrapLogOptions): Function;
+export declare function wrapLog(fn: Function, { fnName, logger }?: WrapLogOptions): Function;

package/function/log.js

@@ -23,15 +23,21 @@ __export(log_exports, {
 module.exports = __toCommonJS(log_exports);
 var import_type_guards = require("../utils/type-guards.js");
 var import_type_of = require("../utils/type-of.js");
-function wrapLog(fn, options) {
-  const fnName = options?.fnName ?? fn.name;
-  const log = options?.logger?.trace.bind(options.logger) ?? console.log.bind(console);
+function wrapLog(fn, { fnName = fn.name, logger } = {}) {
+  const log = logger?.trace.bind(logger) ?? console.log.bind(console);
   const wrapped = {
     [fnName](...args) {
-      const argString = args.map((arg) => (0, import_type_guards.isPrimitive)(arg) ? (0, import_type_guards.isString)(arg) ? `"${arg}"` : String(arg) : (0, import_type_of.typeOf)(arg)).join(", ");
+      const argString = args.map((arg) => stringifyArg(arg)).join(", ");
       log(`[call: ${fnName}(${argString})]`);
       return Reflect.apply(fn, this, args);
     }
   };
   return wrapped[fnName];
 }
+function stringifyArg(arg, depth = 1) {
+  if ((0, import_type_guards.isArray)(arg) && depth > 0) {
+    const argString = arg.map((innerArg) => stringifyArg(innerArg, depth - 1)).join(", ");
+    return `[${argString}]`;
+  }
+  return (0, import_type_guards.isPrimitive)(arg) ? (0, import_type_guards.isString)(arg) ? `"${arg}"` : String(arg) : (0, import_type_of.typeOf)(arg);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.87.1",
+  "version": "0.87.3",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"