@tstdl/base 0.84.3 → 0.84.4

package/.eslintrc.json

@@ -24,10 +24,6 @@
   },
   "plugins": ["@typescript-eslint"],
   "rules": {
-    /** angular */
-    "@angular-eslint/template/eqeqeq": "off",
-    "@angular-eslint/no-host-metadata-property": ["error", { "allowStatic": true }],
-
     /** typescript */
     "@typescript-eslint/brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
     "@typescript-eslint/consistent-type-definitions": "off",

package/browser/document-controller.d.ts

@@ -0,0 +1,26 @@
+import type { ElementHandle, Frame, Page } from 'playwright';
+import type { Delay } 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';
+export type DocumentControllerOptions = {
+    defaultActionDelay?: Delay;
+    defaultTypeDelay?: Delay;
+};
+export type DocumentControllerForwardOptions = {
+    pageControllerOptions: PageControllerOptions;
+    frameControllerOptions: FrameControllerOptions;
+};
+export declare class DocumentController extends LocatorController {
+    protected readonly forwardOptions: DocumentControllerForwardOptions;
+    /** @deprecated should be avoided */
+    readonly document: Page | Frame;
+    constructor(document: Page | Frame, options: DocumentControllerOptions, forwardOptions: DocumentControllerForwardOptions);
+    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<ElementHandle>;
+    getInFrame(frameSelector: string): LocatorController;
+    waitForFrame(selector: string, options?: Parameters<Page['waitForSelector']>[1]): Promise<FrameController>;
+}

package/browser/document-controller.js

@@ -0,0 +1,88 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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
+});
+module.exports = __toCommonJS(document_controller_exports);
+var import_type_guards = require("../utils/type-guards.js");
+var import_locator_controller = require("./locator-controller.js");
+class DocumentController extends import_locator_controller.LocatorController {
+  forwardOptions;
+  /** @deprecated should be avoided */
+  document;
+  constructor(document, options, forwardOptions) {
+    super(document, { actionDelay: options.defaultActionDelay, typeDelay: options.defaultTypeDelay });
+    this.document = document;
+    this.forwardOptions = forwardOptions;
+  }
+  async setContent(...args) {
+    await this.document.setContent(...args);
+  }
+  async navigate(...args) {
+    await this.document.goto(...args);
+  }
+  async waitForLoadState(...args) {
+    await this.document.waitForLoadState(...args);
+  }
+  async waitForUrl(...args) {
+    await this.document.waitForURL(...args);
+  }
+  async waitForElement(selector, options) {
+    const element = await this.document.waitForSelector(selector, options);
+    if ((0, import_type_guards.isNull)(element)) {
+      throw new Error("Element not found.");
+    }
+    return element;
+  }
+  getInFrame(frameSelector) {
+    const locator = this.document.frameLocator(frameSelector);
+    return new import_locator_controller.LocatorController(locator, this.elementControllerOptions);
+  }
+  async waitForFrame(selector, options) {
+    const element = await this.waitForElement(selector, options);
+    const frame = await element.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 });
+  }
+}
+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,7 +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';
-import type { ElementHandle, Locator } from 'playwright';
-import { PageController } from './page-controller.js';
 export type Delay = ValueOrProvider<number>;
 export type ActionDelayOptions = {
     actionDelay?: Delay;
@@ -19,19 +18,14 @@ export type ElementControllerOptions = {
 type LocatorOptions<K extends keyof Locator, I extends keyof Parameters<Locator[K]>> = NonUndefinable<Parameters<Locator[K]>[I]>;
 export declare class ElementController {
     readonly locatorOrHandle: Locator | ElementHandle;
-    readonly pageController: PageController;
     readonly options: ElementControllerOptions;
-    constructor(locatorOrHandle: Locator | ElementHandle, pageController: PageController, options?: ElementControllerOptions);
+    constructor(locatorOrHandle: Locator | ElementHandle, options?: ElementControllerOptions);
     waitFor(options?: Parameters<Locator['waitFor']>[0]): 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>;
     selectOption(value: string | string[], options?: Merge<LocatorOptions<'selectOption', 1>, ActionDelayOptions>): Promise<void>;
     click(options?: Merge<TypedOmit<LocatorOptions<'click', 0>, 'delay'>, ActionDelayOptions & ClickDelayOptions>): Promise<void>;
     getValue(options?: LocatorOptions<'inputValue', 0>): Promise<string>;
-    /**
-     * Get PageController for element. Element must be a frame.
-     */
-    getPage(options?: LocatorOptions<'elementHandle', 0>): Promise<PageController>;
     private prepareAction;
 }
 export {};

package/browser/element-controller.js

@@ -24,15 +24,11 @@ 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_page_controller = require("./page-controller.js");
-var import_utils = require("./utils.js");
 class ElementController {
   locatorOrHandle;
-  pageController;
   options;
-  constructor(locatorOrHandle, pageController, options = {}) {
+  constructor(locatorOrHandle, options = {}) {
     this.locatorOrHandle = locatorOrHandle;
-    this.pageController = pageController;
     this.options = options;
   }
   async waitFor(options) {
@@ -67,18 +63,6 @@ class ElementController {
   async getValue(options) {
     return this.locatorOrHandle.inputValue(options);
   }
-  /**
-   * Get PageController for element. Element must be a frame.
-   */
-  async getPage(options) {
-    const handle = (0, import_utils.isLocator)(this.locatorOrHandle) ? await this.locatorOrHandle.elementHandle(options) : this.locatorOrHandle;
-    if ((0, import_type_guards.isNull)(handle)) {
-      throw new Error("Could not get element handle.");
-    }
-    const frame = await this.locatorOrHandle.contentFrame();
-    (0, import_type_guards.assertNotNull)(frame, "Could not get content frame for element handle.");
-    return new import_page_controller.PageController(frame.page(), this.pageController.options);
-  }
   async prepareAction(options) {
     await delay(options?.actionDelay ?? this.options.actionDelay);
   }

package/browser/frame-controller.d.ts

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

package/browser/frame-controller.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var frame_controller_exports = {};
+__export(frame_controller_exports, {
+  FrameController: () => FrameController
+});
+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 });
+    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);
+  }
+  /**
+   * @param frameSelector frame name, url or url predicate
+   * @returns
+   */
+  getFrame(frameSelector) {
+    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);
+  }
+}

package/browser/index.d.ts

@@ -1,6 +1,9 @@
 export * from './browser-context-controller.js';
 export * from './browser-controller.js';
 export * from './browser.service.js';
+export * from './document-controller.js';
 export * from './element-controller.js';
+export * from './frame-controller.js';
+export * from './locator-controller.js';
 export * from './page-controller.js';
 export * from './types.js';

package/browser/index.js

@@ -18,6 +18,9 @@ module.exports = __toCommonJS(browser_exports);
 __reExport(browser_exports, require("./browser-context-controller.js"), module.exports);
 __reExport(browser_exports, require("./browser-controller.js"), module.exports);
 __reExport(browser_exports, require("./browser.service.js"), module.exports);
+__reExport(browser_exports, require("./document-controller.js"), module.exports);
 __reExport(browser_exports, require("./element-controller.js"), module.exports);
+__reExport(browser_exports, require("./frame-controller.js"), module.exports);
+__reExport(browser_exports, require("./locator-controller.js"), module.exports);
 __reExport(browser_exports, require("./page-controller.js"), module.exports);
 __reExport(browser_exports, require("./types.js"), module.exports);

package/browser/locator-controller.d.ts

@@ -0,0 +1,16 @@
+import type { Frame, FrameLocator, Locator, Page } from 'playwright';
+import type { NonUndefinable, SimplifyObject } from '../types.js';
+import type { ElementControllerOptions } from './element-controller.js';
+import { ElementController } from './element-controller.js';
+export declare class LocatorController {
+    protected readonly elementControllerOptions: ElementControllerOptions;
+    readonly locatable: Page | Frame | Locator | FrameLocator;
+    constructor(locatable: Page | Frame | Locator | FrameLocator, elementControllerOptions: ElementControllerOptions);
+    getBySelector(selector: string, options?: SimplifyObject<Pick<NonUndefinable<Parameters<Page['locator']>[1]>, 'hasText' | 'hasNotText'>>): ElementController;
+    getByRole(role: Parameters<Page['getByRole']>[0], options?: Parameters<Page['getByRole']>[1]): ElementController;
+    getByLabel(text: Parameters<Page['getByLabel']>[0], options?: Parameters<Page['getByLabel']>[1]): ElementController;
+    getByAltText(text: Parameters<Page['getByAltText']>[0], options?: Parameters<Page['getByAltText']>[1]): ElementController;
+    getByPlaceholder(text: Parameters<Page['getByPlaceholder']>[0], options?: Parameters<Page['getByPlaceholder']>[1]): ElementController;
+    getByText(text: Parameters<Page['getByText']>[0], options?: Parameters<Page['getByText']>[1]): ElementController;
+    getByTitle(text: Parameters<Page['getByTitle']>[0], options?: Parameters<Page['getByTitle']>[1]): ElementController;
+}

package/browser/locator-controller.js

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var locator_controller_exports = {};
+__export(locator_controller_exports, {
+  LocatorController: () => LocatorController
+});
+module.exports = __toCommonJS(locator_controller_exports);
+var import_element_controller = require("./element-controller.js");
+class LocatorController {
+  elementControllerOptions;
+  locatable;
+  constructor(locatable, elementControllerOptions) {
+    this.locatable = locatable;
+    this.elementControllerOptions = elementControllerOptions;
+  }
+  getBySelector(selector, options) {
+    const locator = this.locatable.locator(selector, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByRole(role, options) {
+    const locator = this.locatable.getByRole(role, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByLabel(text, options) {
+    const locator = this.locatable.getByLabel(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByAltText(text, options) {
+    const locator = this.locatable.getByAltText(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByPlaceholder(text, options) {
+    const locator = this.locatable.getByPlaceholder(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByText(text, options) {
+    const locator = this.locatable.getByText(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByTitle(text, options) {
+    const locator = this.locatable.getByTitle(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+}

package/browser/page-controller.d.ts

@@ -1,39 +1,29 @@
-import type { ElementHandle, Page } from 'playwright';
+import type { Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
-import type { NonUndefinable, SimplifyObject } from '../types.js';
-import type { Delay } from './element-controller.js';
-import { ElementController } from './element-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 type { PdfRenderOptions } from './pdf-options.js';
 import type { Abortable } from './types.js';
-export type PageControllerOptions = {
-    defaultActionDelay?: Delay;
-    defaultTypeDelay?: Delay;
+export type PageControllerOptions = DocumentControllerOptions & {
+    defaultFrameControllerOptions?: FrameControllerOptions;
 };
-export declare class PageController implements AsyncDisposable {
-    private readonly elementControllerOptions;
+export declare class PageController extends DocumentController implements AsyncDisposable {
     /** @deprecated should be avoided */
     readonly page: Page;
     readonly options: PageControllerOptions;
     constructor(page: Page, options?: PageControllerOptions);
     [disposeAsync](): Promise<void>;
     close(): Promise<void>;
-    setContent(...args: Parameters<Page['setContent']>): Promise<void>;
     setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
-    navigate(...args: Parameters<Page['goto']>): Promise<void>;
     waitForClose(): 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<ElementHandle>;
-    waitForFrame(selector: string, options: Parameters<Page['waitForSelector']>[1]): Promise<PageController>;
-    getFrame(selector: Parameters<Page['frame']>[0]): PageController;
-    getBySelector(selector: string, options?: SimplifyObject<Pick<NonUndefinable<Parameters<Page['locator']>[1]>, 'hasText' | 'hasNotText'>>): ElementController;
-    getByRole(role: Parameters<Page['getByRole']>[0], options?: Parameters<Page['getByRole']>[1]): ElementController;
-    getByLabel(text: Parameters<Page['getByLabel']>[0], options?: Parameters<Page['getByLabel']>[1]): ElementController;
-    getByAltText(text: Parameters<Page['getByAltText']>[0], options?: Parameters<Page['getByAltText']>[1]): ElementController;
-    getByPlaceholder(text: Parameters<Page['getByPlaceholder']>[0], options?: Parameters<Page['getByPlaceholder']>[1]): ElementController;
-    getByText(text: Parameters<Page['getByText']>[0], options?: Parameters<Page['getByText']>[1]): ElementController;
-    getByTitle(text: Parameters<Page['getByTitle']>[0], options?: Parameters<Page['getByTitle']>[1]): ElementController;
+    /**
+     * @param frameSelector frame name, url or url predicate
+     * @returns
+     */
+    getFrame(frameSelector: Parameters<Page['frame']>[0]): FrameController;
     renderPdf(options?: PdfRenderOptions & Abortable): Promise<Uint8Array>;
     renderPdfStream(options?: PdfRenderOptions & Abortable): ReadableStream<Uint8Array>;
 }

package/browser/page-controller.js

@@ -26,16 +26,16 @@ var import_readable_stream_from_promise = require("../utils/stream/readable-stre
 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_element_controller = require("./element-controller.js");
-class PageController {
-  elementControllerOptions;
+var import_document_controller = require("./document-controller.js");
+var import_frame_controller = require("./frame-controller.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 });
     this.page = page;
     this.options = options;
-    this.elementControllerOptions = { actionDelay: this.options.defaultActionDelay, typeDelay: this.options.defaultTypeDelay };
   }
   async [import_disposable.disposeAsync]() {
     await this.close();
@@ -43,15 +43,9 @@ class PageController {
   async close() {
     await this.page.close();
   }
-  async setContent(...args) {
-    await this.page.setContent(...args);
-  }
   async setExtraHttpHeaders(headers) {
     await this.page.setExtraHTTPHeaders(headers);
   }
-  async navigate(...args) {
-    await this.page.goto(...args);
-  }
   async waitForClose() {
     return new Promise((resolve) => {
       if (this.page.isClosed()) {
@@ -61,61 +55,16 @@ class PageController {
       this.page.once("close", () => resolve());
     });
   }
-  async waitForLoadState(...args) {
-    await this.page.waitForLoadState(...args);
-  }
-  async waitForUrl(...args) {
-    await this.page.waitForURL(...args);
-  }
-  async waitForElement(selector, options) {
-    const element = await this.page.waitForSelector(selector, options);
-    if ((0, import_type_guards.isNull)(element)) {
-      throw new Error("Element not found.");
-    }
-    return element;
-  }
-  async waitForFrame(selector, options) {
-    const element = await this.waitForElement(selector, options);
-    const frame = await element.contentFrame();
-    if ((0, import_type_guards.isNull)(frame)) {
-      throw new Error("Element is not a frame.");
-    }
-    return new PageController(frame.page(), this.options);
-  }
-  getFrame(selector) {
-    const frame = this.page.frame(selector);
+  /**
+   * @param frameSelector frame name, url or url predicate
+   * @returns
+   */
+  getFrame(frameSelector) {
+    const frame = this.page.frame(frameSelector);
     if ((0, import_type_guards.isNull)(frame)) {
       throw new Error("Frame not found.");
     }
-    return new PageController(frame.page(), this.options);
-  }
-  getBySelector(selector, options) {
-    const locator = this.page.locator(selector, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByRole(role, options) {
-    const locator = this.page.getByRole(role, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByLabel(text, options) {
-    const locator = this.page.getByLabel(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByAltText(text, options) {
-    const locator = this.page.getByAltText(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByPlaceholder(text, options) {
-    const locator = this.page.getByPlaceholder(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByText(text, options) {
-    const locator = this.page.getByText(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByTitle(text, options) {
-    const locator = this.page.getByTitle(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
+    return new import_frame_controller.FrameController(frame, this.options, this.forwardOptions);
   }
   async renderPdf(options = {}) {
     const createPdfOptions = convertPdfOptions(options);

package/package.json

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