@tstdl/base 0.84.1 → 0.84.3

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,39 @@
-import type { Page } from 'playwright';
+import type { ElementHandle, 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>;
+    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;
     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,61 @@ class PageController {
       this.page.once("close", () => resolve());
     });
   }
-  async waitForState(state, options) {
-    await this.page.waitForLoadState(state, { timeout: options?.timeout });
+  async waitForLoadState(...args) {
+    await this.page.waitForLoadState(...args);
   }
-  async waitForNetworkIdle(options) {
-    await this.page.waitForLoadState("networkidle", { timeout: options?.timeout });
+  async waitForUrl(...args) {
+    await this.page.waitForURL(...args);
   }
-  async waitForUrl(urlOrPredicate, options) {
-    await this.page.waitForURL(urlOrPredicate, { timeout: options?.timeout });
+  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 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);
-      }
+    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);
   }
-  async selectOption(selector, value, options) {
-    await this.prepareAction();
-    const locator = this.page.locator(selector);
-    await locator.selectOption(value, { timeout: options?.timeout });
+  getFrame(selector) {
+    const frame = this.page.frame(selector);
+    if ((0, import_type_guards.isNull)(frame)) {
+      throw new Error("Frame not found.");
+    }
+    return new PageController(frame.page(), this.options);
   }
-  async click(selector, options) {
-    await this.prepareAction();
-    const locator = this.page.locator(selector);
-    await locator.click({ delay: 50, timeout: options?.timeout });
+  getBySelector(selector, options) {
+    const locator = this.page.locator(selector, 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 });
+  getByRole(role, options) {
+    const locator = this.page.getByRole(role, 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 });
+  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);
   }
   async renderPdf(options = {}) {
     const createPdfOptions = convertPdfOptions(options);
@@ -129,20 +132,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/core.d.ts

@@ -4,9 +4,12 @@ import type { LoggerArgument } from './logger/index.js';
 import { LogLevel, Logger } from './logger/index.js';
 export declare const CORE_LOGGER: InjectionToken<Logger, any>;
 export declare const disposer: AsyncDisposer;
+export declare function isDevMode(): boolean;
+export declare function enableProductionMode(): void;
 export declare function connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, maxTries?: number): Promise<void>;
 export declare function disposeInstances(): Promise<void>;
 export type CoreConfiguration = {
+    production?: boolean;
     logger?: InjectionToken<Logger, LoggerArgument>;
     logLevel?: LogLevel;
     coreLogPrefix?: string;

package/core.js

@@ -22,7 +22,9 @@ __export(core_exports, {
   configureTstdl: () => configureTstdl,
   connect: () => connect,
   disposeInstances: () => disposeInstances,
-  disposer: () => disposer
+  disposer: () => disposer,
+  enableProductionMode: () => enableProductionMode,
+  isDevMode: () => isDevMode
 });
 module.exports = __toCommonJS(core_exports);
 var import_container = require("./container/index.js");
@@ -33,6 +35,13 @@ var import_timing = require("./utils/timing.js");
 var import_type_guards = require("./utils/type-guards.js");
 const CORE_LOGGER = (0, import_container.injectionToken)("core logger");
 const disposer = new import_async_disposer.AsyncDisposer();
+let _isDevMode = true;
+function isDevMode() {
+  return _isDevMode;
+}
+function enableProductionMode() {
+  _isDevMode = false;
+}
 async function connect(name, connectFunction, logger, maxTries = 5) {
   let triesLeft = maxTries;
   let success = false;
@@ -57,6 +66,9 @@ async function disposeInstances() {
 }
 let coreLogPrefix;
 function configureTstdl(config = {}) {
+  if (config.production == true) {
+    enableProductionMode();
+  }
   import_container.container.register(import_logger2.Logger, { useToken: config.logger ?? import_logger.ConsoleLogger });
   import_container.container.registerSingleton(import_logger2.LogLevel, { useFactory: (level) => (0, import_type_guards.assertDefinedPass)(level, "LogLevel argument not provided") }, { defaultArgumentProvider: () => config.logLevel ?? import_logger2.LogLevel.Trace });
   if ((0, import_type_guards.isDefined)(config.coreLogPrefix)) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.1",
+  "version": "0.84.3",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -23,7 +23,7 @@
     "luxon": "^3.3",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
-    "type-fest": "^3.9"
+    "type-fest": "^3.10"
   },
   "devDependencies": {
     "@types/chroma-js": "2.4",
@@ -31,13 +31,13 @@
     "@types/luxon": "3.3",
     "@types/minio": "7.0",
     "@types/mjml": "4.7",
-    "@types/node": "18",
+    "@types/node": "20",
     "@types/nodemailer": "6.4",
     "@typescript-eslint/eslint-plugin": "5.59",
     "@typescript-eslint/parser": "5.59",
     "concurrently": "8.0",
     "esbuild": "0.17",
-    "eslint": "8.39",
+    "eslint": "8.40",
     "eslint-import-resolver-typescript": "3.5",
     "eslint-plugin-import": "2.27",
     "tsc-alias": "1.8",
@@ -58,7 +58,7 @@
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",
-    "mongodb": "^5.3",
+    "mongodb": "^5.4",
     "nodemailer": "^6.9",
     "playwright": "^1.33",
     "preact": "^10.13",

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,

package/schema/coercers/uint8-array.coercer.js

@@ -32,7 +32,7 @@ class Uint8ArrayCoercer extends import_types.SchemaValueCoercer {
   sourceType = Array;
   targetType = Uint8Array;
   coerce(value, path, { options }) {
-    const testResult = (0, import_schema.testWithFastError)(byteNumberArraySchema, value, options, path);
+    const testResult = (0, import_schema.testSchema)(byteNumberArraySchema, value, options, path);
     if (!testResult.valid) {
       return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(Uint8Array, Array, path, { inner: testResult.error, fast: options.fastErrors }) };
     }

package/schema/schema.d.ts

@@ -11,4 +11,5 @@ export declare const Schema: {
     function<T_3 extends readonly SchemaTestable<any>[], R extends SchemaTestable<any>, F extends (...args: TupleSchemaOutput<T_3>) => SchemaOutput<R>>(argumentSchemas: T_3, returnSchema: R, handler: F): F;
     asyncFunction<T_4 extends readonly SchemaTestable<any>[], R_1 extends SchemaTestable<any>, F_1 extends (...args: TupleSchemaOutput<T_4>) => Promise<SchemaOutput<R_1>>>(argumentSchemas: T_4, returnSchema: R_1, handler: F_1): F_1;
 };
-export declare function testWithFastError<T>(schema: Schema<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
+export declare function testSchema<T>(schema: Schema<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
+export declare function getExpectString(schema: SchemaTestable): string;

package/schema/schema.error.js

@@ -24,6 +24,7 @@ module.exports = __toCommonJS(schema_error_exports);
 var import_custom_error = require("../error/custom.error.js");
 var import_array = require("../utils/array/array.js");
 var import_type_guards = require("../utils/type-guards.js");
+var import_schema = require("./schema.js");
 var import_utils = require("./utils/index.js");
 class SchemaError extends import_custom_error.CustomError {
   static errorName = "SchemaError";
@@ -42,9 +43,9 @@ class SchemaError extends import_custom_error.CustomError {
   }
   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
   static expectedButGot(expected, got, path, options) {
-    const expectedNames = (0, import_array.toArray)(expected).map((exp) => (0, import_type_guards.isString)(exp) ? exp : (0, import_utils.getValueTypeName)(exp));
+    const expectedNames = (0, import_array.toArray)(expected).map((exp) => (0, import_type_guards.isString)(exp) ? exp : (0, import_schema.getExpectString)(exp));
     const gotName = (0, import_type_guards.isString)(got) ? got : (0, import_utils.getValueTypeName)(got);
-    const expectedString = expectedNames.length == 1 ? expectedNames[0] : `[${expectedNames.join(", ")}]`;
+    const expectedString = expectedNames.length == 1 ? expectedNames[0] : `(${expectedNames.join(" | ")})`;
     const customMessage = (0, import_type_guards.isDefined)(options.customMessage) ? `: ${options.customMessage}` : ".";
     const message = `Expected ${expectedString} but got ${gotName}${customMessage}`;
     return new SchemaError(message, { path, ...options });

package/schema/schema.js

@@ -19,7 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var schema_exports = {};
 __export(schema_exports, {
   Schema: () => Schema,
-  testWithFastError: () => testWithFastError
+  getExpectString: () => getExpectString,
+  testSchema: () => testSchema
 });
 module.exports = __toCommonJS(schema_exports);
 var import_json_path = require("../json-path/index.js");
@@ -54,14 +55,14 @@ const Schema = {
   test(schemaOrValueType, value, options, path = import_json_path.JsonPath.ROOT) {
     const normalizedOptions = { fastErrors: true, ...options };
     const schema = (0, import_types.schemaTestableToSchema)(schemaOrValueType);
-    const result = testWithFastError(schema, value, normalizedOptions, path);
+    const result = testSchema(schema, value, normalizedOptions, path);
     if (result.valid) {
       return result;
     }
-    if (options?.fastErrors == false) {
-      return result;
+    if ((0, import_type_guards.isUndefined)(result.error.stack)) {
+      result.error.stack = new Error().stack;
     }
-    return { valid: false, error: new import_schema_error.SchemaError(result.error.message, { ...result.error }) };
+    return result;
   },
   validate(schemaOrValueType, value, options) {
     const schema = (0, import_types.schemaTestableToSchema)(schemaOrValueType);
@@ -107,7 +108,7 @@ function getFunctionParametersSchema(argumentSchemas) {
   argumentSchemas.forEach((arg, index) => schema.properties[index] = arg);
   return schema;
 }
-function testWithFastError(schema, value, options, path = import_json_path.JsonPath.ROOT) {
+function testSchema(schema, value, options, path = import_json_path.JsonPath.ROOT) {
   initialize();
   if ((0, import_types.isValueSchema)(schema)) {
     return testValue(schema, value, options, path);
@@ -122,9 +123,7 @@ function testWithFastError(schema, value, options, path = import_json_path.JsonP
 }
 function testType(schema, value, options = {}, path = import_json_path.JsonPath.ROOT) {
   const resolvedValueType = (0, import_types.resolveValueType)(schema.type);
-  if (resolvedValueType == "any") {
-    return { valid: true, value };
-  } else if ((0, import_type_guards.isFunction)(resolvedValueType)) {
+  if ((0, import_type_guards.isFunction)(resolvedValueType)) {
     if (value instanceof resolvedValueType || (0, import_utils.getValueType)(value) == resolvedValueType) {
       return { valid: true, value };
     }
@@ -132,7 +131,7 @@ function testType(schema, value, options = {}, path = import_json_path.JsonPath.
     if ((0, import_type_guards.isNotNull)(objectSchema)) {
       return testObject(objectSchema, value, options, path);
     }
-  } else if (resolvedValueType == "null" && (0, import_type_guards.isNull)(value) || resolvedValueType == "undefined" && (0, import_type_guards.isUndefined)(value) || resolvedValueType == "any") {
+  } else if (resolvedValueType == "any" || resolvedValueType == "null" && (0, import_type_guards.isNull)(value) || resolvedValueType == "undefined" && (0, import_type_guards.isUndefined)(value)) {
     return { valid: true, value };
   }
   return { valid: false, error: import_schema_error.SchemaError.expectedButGot(resolvedValueType, (0, import_utils.getValueType)(value), path, { fast: options.fastErrors }) };
@@ -151,7 +150,7 @@ function testObject(objectSchema, value, options = {}, path = import_json_path.J
     return { valid: false, error: new import_schema_error.SchemaError("Unknown property", { path: path.add(unknownValuePropertyKeys[0]), fast: options.fastErrors }) };
   }
   for (const key of schemaPropertyKeys) {
-    const propertyResult = testWithFastError(schema.properties[key], value[key], options, path.add(key));
+    const propertyResult = testSchema(schema.properties[key], value[key], options, path.add(key));
     if (!propertyResult.valid) {
       return propertyResult;
     }
@@ -161,12 +160,12 @@ function testObject(objectSchema, value, options = {}, path = import_json_path.J
     for (const key of unknownValuePropertyKeys) {
       const propertyPath = path.add(key);
       if ((0, import_type_guards.isDefined)(schema.unknownPropertiesKey)) {
-        const keyResult = testWithFastError(schema.unknownPropertiesKey, key, options);
+        const keyResult = testSchema(schema.unknownPropertiesKey, key, options);
         if (!keyResult.valid && !mask) {
           return { valid: false, error: new import_schema_error.SchemaError("Invalid property key.", { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
         }
       }
-      const propertyResult = testWithFastError(schema.unknownProperties, value[key], options, path.add(key));
+      const propertyResult = testSchema(schema.unknownProperties, value[key], options, path.add(key));
       if (!propertyResult.valid && !mask) {
         return propertyResult;
       }
@@ -275,7 +274,7 @@ function testValue(schema, value, options = {}, path = import_json_path.JsonPath
 function isValidValue(validSchemas, value, options, path) {
   const errorResults = [];
   for (const schema of validSchemas) {
-    const result = testWithFastError(schema, value, options, path);
+    const result = testSchema(schema, value, options, path);
     if (result.valid) {
       return result;
     }
@@ -287,15 +286,16 @@ function isValidValue(validSchemas, value, options, path) {
   const errors = errorResults.map((result) => result.error);
   const expectStrings = [];
   for (const schema of validSchemas) {
-    getExpectString(schema);
+    expectStrings.push(getExpectString(schema));
   }
-  const expectString = expectStrings.join("\n");
+  const expectString = expectStrings.length > 1 ? `(${expectStrings.join(" | ")})` : expectStrings[0];
   return { valid: false, error: import_schema_error.SchemaError.expectedButGot(expectString, (0, import_utils.getValueType)(value), path, { inner: errors, fast: options.fastErrors }) };
 }
 function getExpectString(schema) {
   const expectedNames = (0, import_utils.getSchemaTypeNames)(schema);
-  const expectedTypeString = expectedNames.length == 1 ? expectedNames[0] : `[${expectedNames.join(", ")}]`;
+  const arraySuffix = (0, import_types.isValueSchema)(schema) && schema.array == true ? "[]" : "";
+  const expectedTypeString = expectedNames.length == 1 ? `${expectedNames[0]}${arraySuffix}` : `(${expectedNames.join(" | ")})${arraySuffix}`;
   const expects = (0, import_types.isValueSchema)(schema) ? (0, import_array.toArray)(schema.valueConstraints ?? []).map((constraint) => constraint.expects) : [];
-  const expectsString = expects.length > 0 ? ` (${expects.join(", ")})` : "";
+  const expectsString = expects.length > 0 ? `[${expects.join(", ")}]` : "";
   return `${expectedTypeString}${expectsString}`;
 }

package/schema/utils/value-type.js

@@ -28,6 +28,7 @@ module.exports = __toCommonJS(value_type_exports);
 var import_array = require("../../utils/array/array.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_types = require("../types/types.js");
+const lowercaseTypesSet = /* @__PURE__ */ new Set([...import_types.primitiveConstructorSet, Object, Array]);
 function getValueType(value) {
   if ((0, import_type_guards.isUndefined)(value)) {
     return "undefined";
@@ -47,10 +48,10 @@ function includesValueType(valueType, valueTypes) {
 }
 function getValueTypeName(valueType) {
   const resolvedValueType = (0, import_types.resolveValueType)(valueType);
-  return (0, import_type_guards.isString)(resolvedValueType) ? resolvedValueType : resolvedValueType.name;
+  return (0, import_type_guards.isString)(resolvedValueType) ? resolvedValueType : lowercaseTypesSet.has(resolvedValueType) ? resolvedValueType.name.toLowerCase() : resolvedValueType.name;
 }
 function getSchemaTypeNames(schema) {
-  return getSchemaValueTypes(schema).map((valueType) => (0, import_type_guards.isString)(valueType) ? valueType : valueType.name);
+  return getSchemaValueTypes(schema).map(getValueTypeName);
 }
 function getSchemaValueTypes(schema) {
   if ((0, import_types.isTypeSchema)(schema)) {