@tstdl/base 0.84.0 → 0.84.2

package/browser/browser-controller.d.ts

@@ -3,10 +3,9 @@ import type { Injectable } from '../container/interfaces.js';
 import { resolveArgumentType } from '../container/interfaces.js';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
-import type { BrowserContextControllerOptions, BrowserContextState, NewPageOptions } from './browser-context-controller.js';
+import type { BrowserContextState, NewPageOptions } from './browser-context-controller.js';
 import { BrowserContextController } from './browser-context-controller.js';
 import type { NewBrowserOptions } from './browser.service.js';
-import type { PageController } from './page-controller.js';
 export type BrowserControllerOptions = {
     defaultNewContextOptions?: NewBrowserContextOptions;
 };
@@ -14,7 +13,7 @@ export type NewBrowserContextOptions = {
     state?: BrowserContextState;
     locale?: string;
     extraHttpHeaders?: Record<string, string>;
-    controllerOptions?: BrowserContextControllerOptions;
+    defaultNewPageOptions?: NewPageOptions;
     viewport?: {
         width: number;
         height: number;
@@ -35,11 +34,6 @@ export declare class BrowserController implements AsyncDisposable, Injectable<Br
     constructor(browser: Browser, options?: BrowserControllerOptions);
     [disposeAsync](): Promise<void>;
     newContext(options?: NewBrowserContextOptions): Promise<BrowserContextController>;
-    /**
-     * Creates a new context and a new page. Context is automatically closed on page close.
-     * Only use for isolated or "use once" scenarios, otherwise all the contexts are more expensive than using a single context.
-     */
-    newPage(options?: NewBrowserContextOptions & NewPageOptions): Promise<PageController>;
     close(): Promise<void>;
     waitForClose(): Promise<void>;
 }

package/browser/browser-controller.js

@@ -61,22 +61,7 @@ let BrowserController = class BrowserController2 {
       proxy: mergedOptions.proxy,
       extraHTTPHeaders: mergedOptions.extraHttpHeaders
     });
-    return new import_browser_context_controller.BrowserContextController(context, mergedOptions.controllerOptions);
-  }
-  /**
-   * Creates a new context and a new page. Context is automatically closed on page close.
-   * Only use for isolated or "use once" scenarios, otherwise all the contexts are more expensive than using a single context.
-   */
-  async newPage(options) {
-    const context = await this.newContext(options);
-    try {
-      const page = await context.newPage(options);
-      page.ownedContext = context;
-      return page;
-    } catch (error) {
-      await context.close();
-      throw error;
-    }
+    return new import_browser_context_controller.BrowserContextController(context, mergedOptions);
   }
   async close() {
     if (this.browser.isConnected()) {

package/browser/browser.service.d.ts

@@ -3,7 +3,7 @@ import { afterResolve, resolveArgumentType } from '../container/interfaces.js';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
 import { BrowserContextController } from './browser-context-controller.js';
-import type { BrowserControllerOptions, NewBrowserContextOptions } from './browser-controller.js';
+import type { NewBrowserContextOptions } from './browser-controller.js';
 import { BrowserController } from './browser-controller.js';
 export declare class BrowserServiceOptions {
     defaultNewBrowserOptions?: NewBrowserOptions;
@@ -18,7 +18,7 @@ export type NewBrowserOptions = {
     };
     /** @deprecated should be avoided */
     browserArguments?: string[];
-    controllerOptions?: BrowserControllerOptions;
+    defaultNewContextOptions?: NewBrowserContextOptions;
 };
 export declare class BrowserService implements AsyncDisposable, Injectable<BrowserServiceArgument> {
     private readonly browsers;

package/browser/browser.service.js

@@ -72,11 +72,11 @@ let BrowserService = class BrowserService2 {
     const browser = await (0, import_utils.getBrowserType)(mergedOptions.browser).launch(launchOptions);
     this.browsers.add(browser);
     browser.once("disconnected", () => this.browsers.delete(browser));
-    return new import_browser_controller.BrowserController(browser, mergedOptions.controllerOptions);
+    return new import_browser_controller.BrowserController(browser, { defaultNewContextOptions: mergedOptions.defaultNewContextOptions });
   }
   async newPersistentContext(dataDirectory, browserOptions = {}, contextOptions = {}) {
     const mergedBrowserOptions = { ...this.options?.defaultNewBrowserOptions, ...browserOptions };
-    const mergedContextOptions = (0, import_utils.mergeNewBrowserContextOptions)(this.options?.defaultNewBrowserOptions?.controllerOptions?.defaultNewContextOptions, browserOptions.controllerOptions?.defaultNewContextOptions, contextOptions);
+    const mergedContextOptions = (0, import_utils.mergeNewBrowserContextOptions)(this.options?.defaultNewBrowserOptions?.defaultNewContextOptions, browserOptions.defaultNewContextOptions, contextOptions);
     const launchOptions = (0, import_utils.getLaunchOptions)(mergedBrowserOptions);
     const context = await (0, import_utils.getBrowserType)(mergedBrowserOptions.browser).launchPersistentContext(dataDirectory, {
       ...launchOptions,
@@ -87,7 +87,7 @@ let BrowserService = class BrowserService2 {
     });
     this.persistentBrowserContexts.add(context);
     context.once("close", () => this.persistentBrowserContexts.delete(context));
-    return new import_browser_context_controller.BrowserContextController(context, mergedBrowserOptions.controllerOptions?.defaultNewContextOptions?.controllerOptions);
+    return new import_browser_context_controller.BrowserContextController(context, mergedBrowserOptions.defaultNewContextOptions);
   }
   async dispose() {
     for (const browser of this.browsers) {

package/browser/element-controller.d.ts

@@ -0,0 +1,37 @@
+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;
+};
+export type TypeDelayOptions = {
+    typeDelay?: Delay;
+};
+export type ClickDelayOptions = {
+    clickDelay?: Delay;
+};
+export type ElementControllerOptions = {
+    actionDelay?: Delay;
+    typeDelay?: Delay;
+};
+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);
+    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

@@ -0,0 +1,91 @@
+"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 element_controller_exports = {};
+__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_page_controller = require("./page-controller.js");
+var import_utils = require("./utils.js");
+class ElementController {
+  locatorOrHandle;
+  pageController;
+  options;
+  constructor(locatorOrHandle, pageController, options = {}) {
+    this.locatorOrHandle = locatorOrHandle;
+    this.pageController = pageController;
+    this.options = options;
+  }
+  async waitFor(options) {
+    return this.locatorOrHandle.waitFor(options);
+  }
+  async fill(text, options) {
+    await this.prepareAction(options);
+    await this.locatorOrHandle.fill(text, options);
+  }
+  async type(text, options) {
+    await this.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);
+      }
+    }
+  }
+  async selectOption(value, options) {
+    await this.prepareAction(options);
+    await this.locatorOrHandle.selectOption(value, options);
+  }
+  async click(options) {
+    await this.prepareAction(options);
+    await this.locatorOrHandle.click({
+      ...options,
+      delay: (0, import_value_or_provider.resolveValueOrProvider)(options?.clickDelay)
+    });
+  }
+  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);
+  }
+}
+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/browser/index.d.ts

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

package/browser/index.js

@@ -18,4 +18,6 @@ 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("./element-controller.js"), module.exports);
 __reExport(browser_exports, require("./page-controller.js"), module.exports);
+__reExport(browser_exports, require("./types.js"), module.exports);

package/browser/page-controller.d.ts

@@ -1,54 +1,36 @@
 import type { Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
-import type { BrowserContextController } from './browser-context-controller.js';
+import type { NonUndefinable, SimplifyObject } from '../types.js';
+import type { Delay } from './element-controller.js';
+import { ElementController } from './element-controller.js';
 import type { PdfRenderOptions } from './pdf-options.js';
-export type Delay = number | DelayProvider;
-export type DelayProvider = () => number;
+import type { Abortable } from './types.js';
 export type PageControllerOptions = {
-    actionDelay?: Delay;
-    typeDelay?: Delay;
-};
-export type WaitOptions = {
-    timeout?: number;
-};
-export type LoadState = 'load' | 'domcontentloaded' | 'networkidle';
-export type WaitForStateOptions = {
-    waitUntil: LoadState;
-};
-export type DelayOptions = {
-    delay?: Delay;
-};
-export type Abortable = {
-    abort?: AbortSignal;
-};
-/** @deprecated for internal use only */
-export type PageControllerInternal = {
-    ownedContext?: BrowserContextController;
+    defaultActionDelay?: Delay;
+    defaultTypeDelay?: Delay;
 };
 export declare class PageController implements AsyncDisposable {
-    private readonly ownedContext?;
+    private readonly elementControllerOptions;
     /** @deprecated should be avoided */
     readonly page: Page;
     readonly options: PageControllerOptions;
     constructor(page: Page, options?: PageControllerOptions);
     [disposeAsync](): Promise<void>;
     close(): Promise<void>;
-    setContent(html: string, options?: WaitOptions & WaitForStateOptions): Promise<void>;
+    setContent(...args: Parameters<Page['setContent']>): Promise<void>;
     setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
-    navigate(url: string, options?: WaitOptions & WaitForStateOptions): Promise<void>;
+    navigate(...args: Parameters<Page['goto']>): Promise<void>;
     waitForClose(): Promise<void>;
-    waitForState(state: LoadState, options?: WaitOptions): Promise<void>;
-    waitForNetworkIdle(options?: WaitOptions): Promise<void>;
-    waitForUrl(urlOrPredicate: string | RegExp | ((url: URL) => boolean), options?: WaitOptions): Promise<void>;
-    waitForFrame(selector: string, options?: WaitOptions): Promise<PageController>;
-    fill(selector: string, text: string, options?: DelayOptions & WaitOptions): Promise<void>;
-    type(selector: string, text: string, options?: DelayOptions & WaitOptions): Promise<void>;
-    selectOption(selector: string, value: string | string[], options?: WaitOptions): Promise<void>;
-    click(selector: string, options?: WaitOptions): Promise<void>;
-    getValue(selector: string, options?: WaitOptions): Promise<string>;
-    waitForElement(selector: string, options?: WaitOptions): Promise<void>;
+    waitForLoadState(...args: Parameters<Page['waitForLoadState']>): Promise<void>;
+    waitForUrl(...args: Parameters<Page['waitForURL']>): Promise<void>;
+    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;
     renderPdf(options?: PdfRenderOptions & Abortable): Promise<Uint8Array>;
     renderPdfStream(options?: PdfRenderOptions & Abortable): ReadableStream<Uint8Array>;
-    private prepareAction;
 }

package/browser/page-controller.js

@@ -26,33 +26,31 @@ 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 {
-  ownedContext;
+  elementControllerOptions;
   /** @deprecated should be avoided */
   page;
   options;
   constructor(page, options = {}) {
     this.page = page;
     this.options = options;
+    this.elementControllerOptions = { actionDelay: this.options.defaultActionDelay, typeDelay: this.options.defaultTypeDelay };
   }
   async [import_disposable.disposeAsync]() {
     await this.close();
   }
   async close() {
-    if ((0, import_type_guards.isDefined)(this.ownedContext)) {
-      await this.ownedContext.close();
-    } else {
-      await this.page.close();
-    }
+    await this.page.close();
   }
-  async setContent(html, options) {
-    await this.page.setContent(html, { timeout: options?.timeout, waitUntil: options?.waitUntil });
+  async setContent(...args) {
+    await this.page.setContent(...args);
   }
   async setExtraHttpHeaders(headers) {
     await this.page.setExtraHTTPHeaders(headers);
   }
-  async navigate(url, options) {
-    await this.page.goto(url, { timeout: options?.timeout, waitUntil: options?.waitUntil });
+  async navigate(...args) {
+    await this.page.goto(...args);
   }
   async waitForClose() {
     return new Promise((resolve) => {
@@ -63,56 +61,39 @@ class PageController {
       this.page.once("close", () => resolve());
     });
   }
-  async waitForState(state, options) {
-    await this.page.waitForLoadState(state, { timeout: options?.timeout });
-  }
-  async waitForNetworkIdle(options) {
-    await this.page.waitForLoadState("networkidle", { timeout: options?.timeout });
-  }
-  async waitForUrl(urlOrPredicate, options) {
-    await this.page.waitForURL(urlOrPredicate, { timeout: options?.timeout });
-  }
-  async waitForFrame(selector, options) {
-    const handle = await this.page.waitForSelector(selector, { timeout: options?.timeout });
-    const frame = await handle.contentFrame();
-    (0, import_type_guards.assertNotNull)(frame, "Could not get frame for specified selector.");
-    return new PageController(frame.page());
-  }
-  async fill(selector, text, options) {
-    await this.prepareAction();
-    const locator = this.page.locator(selector);
-    await locator.fill(text, { timeout: options?.timeout });
-  }
-  async type(selector, text, options) {
-    await this.prepareAction();
-    const locator = this.page.locator(selector);
-    await locator.focus({ timeout: options?.timeout });
-    if ((0, import_type_guards.isUndefined)(this.options.typeDelay)) {
-      await locator.type(text, { timeout: options?.timeout });
-    } else {
-      for (const char of text) {
-        await locator.type(char, { timeout: options?.timeout });
-        await delay(options?.delay ?? this.options.typeDelay);
-      }
-    }
+  async waitForLoadState(...args) {
+    await this.page.waitForLoadState(...args);
+  }
+  async waitForUrl(...args) {
+    await this.page.waitForURL(...args);
+  }
+  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);
   }
-  async selectOption(selector, value, options) {
-    await this.prepareAction();
-    const locator = this.page.locator(selector);
-    await locator.selectOption(value, { timeout: options?.timeout });
+  getByLabel(text, options) {
+    const locator = this.page.getByLabel(text, options);
+    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
   }
-  async click(selector, options) {
-    await this.prepareAction();
-    const locator = this.page.locator(selector);
-    await locator.click({ delay: 50, timeout: options?.timeout });
+  getByAltText(text, options) {
+    const locator = this.page.getByAltText(text, options);
+    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
   }
-  async getValue(selector, options) {
-    const locator = this.page.locator(selector);
-    return locator.inputValue({ timeout: options?.timeout });
+  getByPlaceholder(text, options) {
+    const locator = this.page.getByPlaceholder(text, options);
+    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
   }
-  async waitForElement(selector, options) {
-    const locator = this.page.locator(selector);
-    return locator.waitFor({ timeout: options?.timeout });
+  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);
   }
   async renderPdf(options = {}) {
     const createPdfOptions = convertPdfOptions(options);
@@ -129,20 +110,6 @@ class PageController {
       });
     });
   }
-  async prepareAction() {
-    await delay(this.options.actionDelay);
-    await this.waitForNetworkIdle();
-  }
-}
-async function delay(milliseconds) {
-  if ((0, import_type_guards.isUndefined)(milliseconds)) {
-    return;
-  }
-  if ((0, import_type_guards.isNumber)(milliseconds)) {
-    await (0, import_timing.timeout)(milliseconds);
-  } else {
-    await (0, import_timing.timeout)(milliseconds());
-  }
 }
 function convertPdfOptions(options) {
   const margin = (0, import_type_guards.isUndefined)(options.margin) ? void 0 : (0, import_type_guards.isObject)(options.margin) ? options.margin : {

package/browser/types.d.ts

@@ -0,0 +1,10 @@
+export type TimeoutOptions = {
+    timeout?: number;
+};
+export type LoadState = 'load' | 'domcontentloaded' | 'networkidle';
+export type WaitForStateOptions = {
+    waitUntil: LoadState;
+};
+export type Abortable = {
+    abort?: AbortSignal;
+};

package/browser/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/browser/utils.d.ts

@@ -1,6 +1,8 @@
-import type { BrowserType, LaunchOptions } from 'playwright';
+import type { BrowserType, ElementHandle, LaunchOptions, Locator } from 'playwright';
 import type { NewBrowserContextOptions } from './browser-controller.js';
 import type { NewBrowserOptions } from './browser.service.js';
 export declare function getLaunchOptions(options: NewBrowserOptions): LaunchOptions;
 export declare function mergeNewBrowserContextOptions(a: NewBrowserContextOptions | undefined, b?: NewBrowserContextOptions, c?: NewBrowserContextOptions): NewBrowserContextOptions;
 export declare function getBrowserType(type: string | undefined): BrowserType;
+export declare function isLocator(value: Locator | ElementHandle): value is Locator;
+export declare function isElementHandle(value: Locator | ElementHandle): value is ElementHandle;

package/browser/utils.js

@@ -20,11 +20,14 @@ var utils_exports = {};
 __export(utils_exports, {
   getBrowserType: () => getBrowserType,
   getLaunchOptions: () => getLaunchOptions,
+  isElementHandle: () => isElementHandle,
+  isLocator: () => isLocator,
   mergeNewBrowserContextOptions: () => mergeNewBrowserContextOptions
 });
 module.exports = __toCommonJS(utils_exports);
 var import_not_supported_error = require("../error/not-supported.error.js");
 var import_object = require("../utils/object/object.js");
+var import_type_guards = require("../utils/type-guards.js");
 var import_playwright = require("playwright");
 function getLaunchOptions(options) {
   const { windowSize, browserArguments, headless } = options;
@@ -58,3 +61,11 @@ function getBrowserType(type) {
   }
   return browserType;
 }
+const exclusiveLocatorKey = "locator";
+function isLocator(value) {
+  return (0, import_type_guards.isFunction)(value[exclusiveLocatorKey]);
+}
+const exclusiveElementHandleKey = "$";
+function isElementHandle(value) {
+  return (0, import_type_guards.isFunction)(value[exclusiveElementHandleKey]);
+}

package/examples/browser/basic.js

@@ -7,13 +7,14 @@ var import_timing = require("../../utils/timing.js");
 async function main() {
   const browserService = await import_container.container.resolveAsync(import_browser_service.BrowserService);
   const browser = await browserService.newBrowser({ headless: false });
-  const page = await browser.newPage();
+  const context = await browser.newContext();
+  const page = await context.newPage();
   await page.navigate("https://google.com");
-  await page.click("//div[text() = 'Alle ablehnen']");
+  await page.getBySelector("//div[text() = 'Alle ablehnen']").click();
   await (0, import_timing.timeout)(1e3);
   const pdf = await page.renderPdf();
   (0, import_node_fs.writeFileSync)("/tmp/pdf.pdf", pdf);
   await page.navigate("file:///tmp/pdf.pdf");
-  await browser.waitForClose();
+  await page.waitForClose();
 }
 import_application.Application.run(main);

package/http/client/adapters/undici-http-client.adapter.js

@@ -82,7 +82,7 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter2 extends import_http
     try {
       const response = await (0, import_undici.request)(httpClientRequest.url, {
         method: httpClientRequest.method,
-        signal: httpClientRequest.abortToken.asAbortSignal,
+        signal: httpClientRequest.abortToken.asAbortSignal(),
         headers: httpClientRequest.headers.asNormalizedObject(),
         body,
         headersTimeout: httpClientRequest.timeout,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.0",
+  "version": "0.84.2",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -8,14 +8,16 @@
   "type": "commonjs",
   "scripts": {
     "build": "tsc && tsc-alias",
-    "build:watch": "tsc && (concurrently --raw 'tsc --watch' 'tsc-alias --watch')",
+    "build:watch": "concurrently --raw --kill-others npm:tsc:watch npm:tsc-alias:watch",
     "build:production": "rm -rf dist && npm run build && npm run build:production:cjs && npm run build:production:copy-files",
     "build:production:cjs": "esbuild `find dist \\( -name '*.js' -o -name '*.jsx' \\)` --outdir=dist --allow-overwrite --format=cjs",
     "build:production:copy-files": "cp package.json .eslintrc.json tsconfig.server.json dist/ && cp tsconfig.base.json dist/tsconfig.json && sed -i 's/\"type\": \"module\",/\"type\": \"commonjs\",/g' dist/package.json",
     "build:docs": "typedoc",
     "build:docs-watch": "typedoc --watch",
     "lint": "eslint -c .eslintrc.json --ext .ts .",
-    "pub": "npm run build:production && rm -vf dist/test* && npm publish dist/"
+    "pub": "npm run build:production && rm -vf dist/test* && npm publish dist/",
+    "tsc:watch": "tsc --watch",
+    "tsc-alias:watch": "tsc-alias --watch"
   },
   "dependencies": {
     "luxon": "^3.3",

package/pdf/pdf.service.js

@@ -153,10 +153,17 @@ let PdfService = class PdfService2 {
   }
   renderStream(handler, options = {}) {
     return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const page = (0, import_type_guards.isDefined)(options.browserContext) ? await options.browserContext.newPage() : await this.browserController.newPage({ locale: options.locale ?? this.defaultLocale });
+      const context = options.browserContext ?? await this.browserController.newContext({ locale: options.locale ?? this.defaultLocale });
+      const page = await context.newPage();
       const optionsFromHandler = await handler(page);
       const pdfStream = page.renderPdfStream({ ...optionsFromHandler, ...options });
-      const close = async () => page.close();
+      const close = async () => {
+        if ((0, import_type_guards.isDefined)(options.browserContext)) {
+          await page.close();
+        } else {
+          await context.close();
+        }
+      };
       return (0, import_finalize_stream.finalizeStream)(pdfStream, {
         beforeDone: close,
         beforeCancel: close,