@tstdl/base 0.83.28 → 0.84.1

package/browser/page-controller.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,143 +15,123 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var page_controller_exports = {};
 __export(page_controller_exports, {
   PageController: () => PageController
 });
 module.exports = __toCommonJS(page_controller_exports);
-var import_node_stream = require("node:stream");
-var puppeteer = __toESM(require("puppeteer"), 1);
 var import_disposable = require("../disposable/disposable.js");
 var import_readable_stream_from_promise = require("../utils/stream/readable-stream-from-promise.js");
 var import_timing = require("../utils/timing.js");
 var import_type_guards = require("../utils/type-guards.js");
+var import_units = require("../utils/units.js");
 class PageController {
+  ownedContext;
   /** @deprecated should be avoided */
   page;
   options;
-  constructor(pageOrFrame, options = {}) {
-    this.page = pageOrFrame instanceof puppeteer.Page ? pageOrFrame : pageOrFrame.page();
+  constructor(page, options = {}) {
+    this.page = page;
     this.options = options;
   }
   async [import_disposable.disposeAsync]() {
-    return this.close();
+    await this.close();
   }
   async close() {
-    return this.page.close();
+    if ((0, import_type_guards.isDefined)(this.ownedContext)) {
+      await this.ownedContext.close();
+    } else {
+      await this.page.close();
+    }
   }
   async setContent(html, options) {
-    await this.page.setContent(html, options);
+    await this.page.setContent(html, { timeout: options?.timeout, waitUntil: options?.waitUntil });
   }
   async setExtraHttpHeaders(headers) {
     await this.page.setExtraHTTPHeaders(headers);
   }
-  async authenticate(username, password) {
-    await this.page.authenticate({ username, password });
-  }
   async navigate(url, options) {
-    await this.page.goto(url, options);
+    await this.page.goto(url, { timeout: options?.timeout, waitUntil: options?.waitUntil });
   }
   async waitForClose() {
-    return new Promise((resolve) => this.page.once("close", resolve));
+    return new Promise((resolve) => {
+      if (this.page.isClosed()) {
+        resolve();
+        return;
+      }
+      this.page.once("close", () => resolve());
+    });
+  }
+  async waitForState(state, options) {
+    await this.page.waitForLoadState(state, { timeout: options?.timeout });
   }
-  async waitForIdle(options) {
-    await this.page.waitForNetworkIdle(options);
+  async waitForNetworkIdle(options) {
+    await this.page.waitForLoadState("networkidle", { timeout: options?.timeout });
   }
   async waitForUrl(urlOrPredicate, options) {
-    const pageFrame = this.page.mainFrame();
-    await this.page.waitForFrame(async (frame) => {
-      if (frame != pageFrame) {
-        return false;
-      }
-      if ((0, import_type_guards.isString)(urlOrPredicate)) {
-        return frame.url().includes(urlOrPredicate);
-      }
-      return urlOrPredicate(frame.url());
-    }, { timeout: options?.timeout });
+    await this.page.waitForURL(urlOrPredicate, { timeout: options?.timeout });
   }
   async waitForFrame(selector, options) {
-    const frame = await this.waitForElementHandle(selector, options);
-    return new PageController(frame.frame.page());
-  }
-  async waitForFrameByUrl(urlOrPredicate, options) {
-    const frame = await this.page.waitForFrame(urlOrPredicate, 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());
   }
-  getDeepestFrame() {
-    let frame = this.page.mainFrame();
-    while (true) {
-      const children = frame.childFrames();
-      if (children.length > 1) {
-        throw new Error("Multiple frames found. Only works with single frame.");
-      }
-      if (children.length == 0) {
-        break;
-      }
-      frame = children[0];
-    }
-    return new PageController(frame);
+  async fill(selector, text, options) {
+    await this.prepareAction();
+    const locator = this.page.locator(selector);
+    await locator.fill(text, { timeout: options?.timeout });
   }
-  async type(handleOrSelector, text, options) {
+  async type(selector, text, options) {
     await this.prepareAction();
-    const handle = (0, import_type_guards.isString)(handleOrSelector) ? await this.waitForElementHandle(handleOrSelector, options) : handleOrSelector;
-    await handle.evaluate((element) => element.select());
+    const locator = this.page.locator(selector);
+    await locator.focus({ timeout: options?.timeout });
     if ((0, import_type_guards.isUndefined)(this.options.typeDelay)) {
-      await handle.type(text);
+      await locator.type(text, { timeout: options?.timeout });
     } else {
       for (const char of text) {
-        await handle.type(char);
-        await delay(this.options.typeDelay);
+        await locator.type(char, { timeout: options?.timeout });
+        await delay(options?.delay ?? this.options.typeDelay);
       }
     }
   }
-  async select(handleOrSelector, value, options) {
+  async selectOption(selector, value, options) {
     await this.prepareAction();
-    const handle = (0, import_type_guards.isString)(handleOrSelector) ? await this.waitForElementHandle(handleOrSelector, options) : handleOrSelector;
-    await handle.select(value);
+    const locator = this.page.locator(selector);
+    await locator.selectOption(value, { timeout: options?.timeout });
   }
-  async click(handleOrSelector, options) {
+  async click(selector, options) {
     await this.prepareAction();
-    const handle = (0, import_type_guards.isString)(handleOrSelector) ? await this.waitForElementHandle(handleOrSelector, options) : handleOrSelector;
-    await handle.click();
+    const locator = this.page.locator(selector);
+    await locator.click({ delay: 50, timeout: options?.timeout });
   }
-  async getValue(handleOrSelector, options) {
-    const handle = (0, import_type_guards.isString)(handleOrSelector) ? await this.waitForElementHandle(handleOrSelector, options) : handleOrSelector;
-    return handle.evaluate((element) => element.value);
+  async getValue(selector, options) {
+    const locator = this.page.locator(selector);
+    return locator.inputValue({ timeout: options?.timeout });
   }
   async waitForElement(selector, options) {
-    await this.waitForElementHandle(selector, options);
+    const locator = this.page.locator(selector);
+    return locator.waitFor({ timeout: options?.timeout });
   }
   async renderPdf(options = {}) {
     const createPdfOptions = convertPdfOptions(options);
-    return this.page.pdf(createPdfOptions);
+    return (0, import_timing.withTimeout)(options.timeout ?? 30 * import_units.millisecondsPerSecond, this.page.pdf(createPdfOptions), { errorMessage: "Rendering pdf timed out." });
   }
   renderPdfStream(options = {}) {
     return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const createPdfOptions = convertPdfOptions(options);
-      const pdfStream = await this.page.createPDFStream(createPdfOptions);
-      return import_node_stream.Readable.toWeb(pdfStream);
+      const buffer = await this.renderPdf(options);
+      return new ReadableStream({
+        pull(controller) {
+          controller.enqueue(buffer);
+          controller.close();
+        }
+      });
     });
   }
-  async waitForElementHandle(selector, { timeout: waitTimeout = 5e3, xpath = false } = {}) {
-    const handle = xpath ? await this.page.waitForXPath(selector, { timeout: waitTimeout }) : await this.page.waitForSelector(selector, { timeout: waitTimeout });
-    if ((0, import_type_guards.isNull)(handle)) {
-      throw new Error("Element not found");
-    }
-    return handle;
-  }
   async prepareAction() {
     await delay(this.options.actionDelay);
-    await this.waitForIdle();
+    await this.waitForNetworkIdle();
   }
 }
 async function delay(milliseconds) {
@@ -179,7 +157,6 @@ function convertPdfOptions(options) {
     landscape: options.landscape,
     width: options.width,
     height: options.height,
-    omitBackground: options.omitDefaultBackground,
     printBackground: options.renderBackground,
     margin,
     displayHeaderFooter: options.displayHeaderFooter ?? ((0, import_type_guards.isDefined)(options.headerTemplate) || (0, import_type_guards.isDefined)(options.footerTemplate)),

package/browser/pdf-options.d.ts

@@ -18,7 +18,6 @@ export declare class PdfMarginObject {
     left?: number | string;
 }
 export declare class PdfRenderOptions {
-    omitDefaultBackground?: boolean;
     renderBackground?: boolean;
     landscape?: boolean;
     format?: PdfFormat;
@@ -29,4 +28,9 @@ export declare class PdfRenderOptions {
     displayHeaderFooter?: boolean;
     headerTemplate?: string;
     footerTemplate?: string;
+    /**
+     * Timeout for closing render context in case something went wrong.
+     * @default 60000 (1 minute)
+     */
+    timeout?: number;
 }

package/browser/pdf-options.js

@@ -76,7 +76,6 @@ __decorate([
   __metadata("design:type", Object)
 ], PdfMarginObject.prototype, "left", void 0);
 class PdfRenderOptions {
-  omitDefaultBackground;
   renderBackground;
   landscape;
   format;
@@ -87,11 +86,12 @@ class PdfRenderOptions {
   displayHeaderFooter;
   headerTemplate;
   footerTemplate;
+  /**
+   * Timeout for closing render context in case something went wrong.
+   * @default 60000 (1 minute)
+   */
+  timeout;
 }
-__decorate([
-  (0, import_optional.Optional)(),
-  __metadata("design:type", Boolean)
-], PdfRenderOptions.prototype, "omitDefaultBackground", void 0);
 __decorate([
   (0, import_optional.Optional)(),
   __metadata("design:type", Boolean)
@@ -132,3 +132,7 @@ __decorate([
   (0, import_optional.Optional)(),
   __metadata("design:type", String)
 ], PdfRenderOptions.prototype, "footerTemplate", void 0);
+__decorate([
+  (0, import_optional.Optional)(),
+  __metadata("design:type", Number)
+], PdfRenderOptions.prototype, "timeout", void 0);

package/browser/utils.d.ts

@@ -0,0 +1,6 @@
+import type { BrowserType, LaunchOptions } 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;

package/browser/utils.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 utils_exports = {};
+__export(utils_exports, {
+  getBrowserType: () => getBrowserType,
+  getLaunchOptions: () => getLaunchOptions,
+  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_playwright = require("playwright");
+function getLaunchOptions(options) {
+  const { windowSize, browserArguments, headless } = options;
+  const args = [`--window-size=${windowSize?.width ?? 1e3},${windowSize?.height ?? 1e3}`, ...browserArguments ?? []];
+  return { headless, args };
+}
+function mergeNewBrowserContextOptions(a, b, c) {
+  const mergedExtraHttpHeaders = { ...a?.extraHttpHeaders, ...b?.extraHttpHeaders, ...c?.extraHttpHeaders };
+  return {
+    ...a,
+    ...b,
+    ...c,
+    extraHttpHeaders: (0, import_object.objectKeys)(mergedExtraHttpHeaders).length > 0 ? mergedExtraHttpHeaders : void 0
+  };
+}
+function getBrowserType(type) {
+  let browserType;
+  switch (type) {
+    case "chromium":
+    case void 0:
+      browserType = import_playwright.chromium;
+      break;
+    case "firefox":
+      browserType = import_playwright.firefox;
+      break;
+    case "webkit":
+      browserType = import_playwright.webkit;
+      break;
+    default:
+      throw new import_not_supported_error.NotSupportedError(`Browser type ${type} is not supported.`);
+  }
+  return browserType;
+}

package/data-structures/cache.d.ts

@@ -0,0 +1,11 @@
+export declare class Cache<K, V> {
+    private readonly cache;
+    private _capacity;
+    get capacity(): number;
+    set capacity(capacity: number);
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): void;
+    private removeEntries;
+}

package/data-structures/cache.js

@@ -0,0 +1,69 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  Cache: () => Cache
+});
+module.exports = __toCommonJS(cache_exports);
+class Cache {
+  cache;
+  _capacity;
+  get capacity() {
+    return this._capacity;
+  }
+  set capacity(capacity) {
+    this.removeEntries(this._capacity - capacity);
+    this._capacity = capacity;
+  }
+  constructor(capacity) {
+    this._capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    const isNew = !this.cache.has(key);
+    if (isNew && this.cache.size >= this.capacity) {
+      this.removeEntries(1);
+    }
+    this.cache.set(key, value);
+  }
+  delete(key) {
+    this.delete(key);
+  }
+  removeEntries(count) {
+    if (count <= 0) {
+      return;
+    }
+    let left = count;
+    for (const key of this.cache.keys()) {
+      if (left-- <= 0) {
+        return;
+      }
+      this.cache.delete(key);
+    }
+  }
+}

package/data-structures/index.d.ts

@@ -1,5 +1,6 @@
 export * from './array-dictionary.js';
 export * from './array-list.js';
+export * from './cache.js';
 export * from './circular-buffer.js';
 export * from './collection.js';
 export * from './dictionary.js';

package/data-structures/index.js

@@ -17,6 +17,7 @@ var data_structures_exports = {};
 module.exports = __toCommonJS(data_structures_exports);
 __reExport(data_structures_exports, require("./array-dictionary.js"), module.exports);
 __reExport(data_structures_exports, require("./array-list.js"), module.exports);
+__reExport(data_structures_exports, require("./cache.js"), module.exports);
 __reExport(data_structures_exports, require("./circular-buffer.js"), module.exports);
 __reExport(data_structures_exports, require("./collection.js"), module.exports);
 __reExport(data_structures_exports, require("./dictionary.js"), module.exports);

package/disposable/async-disposer.d.ts

@@ -4,6 +4,7 @@ import type { AsyncDisposable, Disposable } from './disposable.js';
 import { disposeAsync } from './disposable.js';
 declare const deferrerToken: unique symbol;
 export type TaskFunction = () => any;
+export type AsyncDisposeHandler = TaskFunction | Disposable | AsyncDisposable;
 export type Task = {
     priority: number;
     taskFunction: TaskFunction;
@@ -29,7 +30,7 @@ export declare class AsyncDisposer implements AsyncDisposable {
      * @param fnOrDisposable
      * @param priority when it will be disposed in relation to other tasks (lower gets disposed first). When other tasks have the same priority, they will be disposed in parallel
      */
-    add(fnOrDisposable: TaskFunction | Disposable | AsyncDisposable, priority?: number): void;
+    add(fnOrDisposable: AsyncDisposeHandler, priority?: number): void;
     dispose(): Promise<void>;
     [disposeAsync](): Promise<void>;
 }

package/error/index.d.ts

@@ -11,5 +11,6 @@ export * from './multi.error.js';
 export * from './not-found.error.js';
 export * from './not-implemented.error.js';
 export * from './not-supported.error.js';
+export * from './timeout.error.js';
 export * from './unauthorized.error.js';
 export * from './unsupported-media-type.error.js';

package/error/index.js

@@ -28,5 +28,6 @@ __reExport(error_exports, require("./multi.error.js"), module.exports);
 __reExport(error_exports, require("./not-found.error.js"), module.exports);
 __reExport(error_exports, require("./not-implemented.error.js"), module.exports);
 __reExport(error_exports, require("./not-supported.error.js"), module.exports);
+__reExport(error_exports, require("./timeout.error.js"), module.exports);
 __reExport(error_exports, require("./unauthorized.error.js"), module.exports);
 __reExport(error_exports, require("./unsupported-media-type.error.js"), module.exports);

package/error/timeout.error.d.ts

@@ -0,0 +1,5 @@
+import { CustomError } from './custom.error.js';
+export declare class TimeoutError extends CustomError {
+    static readonly errorName = "TimeoutError";
+    constructor(message?: string);
+}

package/{browser/types.js → error/timeout.error.js}

@@ -3,6 +3,10 @@ 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))
@@ -12,5 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+var timeout_error_exports = {};
+__export(timeout_error_exports, {
+  TimeoutError: () => TimeoutError
+});
+module.exports = __toCommonJS(timeout_error_exports);
+var import_custom_error = require("./custom.error.js");
+class TimeoutError extends import_custom_error.CustomError {
+  static errorName = "TimeoutError";
+  constructor(message = "Operation timed out.") {
+    super({ message });
+  }
+}

package/examples/browser/basic.js

@@ -6,10 +6,10 @@ var import_container = require("../../container/container.js");
 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();
+  const browser = await browserService.newBrowser({ headless: false });
   const page = await browser.newPage();
   await page.navigate("https://google.com");
-  await page.click("//div[text() = 'Alle ablehnen']", { xpath: true });
+  await page.click("//div[text() = 'Alle ablehnen']");
   await (0, import_timing.timeout)(1e3);
   const pdf = await page.renderPdf();
   (0, import_node_fs.writeFileSync)("/tmp/pdf.pdf", pdf);

package/examples/pdf/basic.js

@@ -30,18 +30,22 @@ try {
 async function main() {
   const browserService = await import_container.container.resolveAsync(import_browser_service.BrowserService);
   const pdfService = await import_container.container.resolveAsync(import_pdf_service.PdfService);
-  const result1 = await pdfService.renderTemplate("hello-name", { name: "Max Mustermann" });
-  const result2 = await pdfService.renderUrl("https://google.de");
+  const [result1, result2] = await Promise.all([
+    pdfService.renderTemplate("hello-name", { name: "Max Mustermann" }),
+    pdfService.renderUrl("https://google.de")
+  ]);
   console.log(`Resulting PDFs have ${result1.length} and ${result2.length} bytes.`);
   (0, import_node_fs.writeFileSync)("/tmp/template.pdf", result1);
   (0, import_node_fs.writeFileSync)("/tmp/page.pdf", result2);
-  const browser = await browserService.newBrowser();
-  const page1 = await browser.newPage();
-  const page2 = await browser.newPage();
+  const browser = await browserService.newBrowser({ headless: false });
+  const context = await browser.newContext();
+  const page1 = await context.newPage();
+  const page2 = await context.newPage();
   await Promise.all([
     page1.navigate("file:///tmp/template.pdf"),
     page2.navigate("file:///tmp/page.pdf")
   ]);
-  await browser.waitForClose();
+  await page1.waitForClose();
+  await page2.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/http/client/http-client-request.js

@@ -97,7 +97,7 @@ class HttpClientRequest {
    * can be used to cancel the request. Throws HttpError
    */
   get abortToken() {
-    return this._abortToken.asReadonly;
+    return this._abortToken.asReadonly();
   }
   constructor(urlOrObject, method, options = {}) {
     if ((0, import_type_guards.isString)(urlOrObject)) {

package/http/server/node/node-http-server.js

@@ -133,7 +133,7 @@ let NodeHttpServer = class NodeHttpServer2 extends import_http_server.HttpServer
       }
       if (connections > 0) {
         this.logger.info(`Waiting for ${connections} connections to end`);
-        await (0, import_timing.cancelableTimeout)(250, import_cancellation_token.CancellationToken.fromObservable(close$));
+        await (0, import_timing.cancelableTimeout)(250, import_cancellation_token.CancellationToken.from(close$));
       }
     }
     this.untrackConnectedSockets?.();

package/lock/web/web-lock.js

@@ -55,9 +55,9 @@ let WebLock = class WebLock2 extends import_lock.Lock {
         releasePromise.resolve();
       }
     };
-    const timeoutToken = (0, import_type_guards.isDefined)(timeout) && timeout > 0 ? import_cancellation_token.CancellationToken.fromObservable((0, import_rxjs.timer)(timeout).pipe((0, import_rxjs.map)(() => true))) : void 0;
+    const timeoutToken = (0, import_type_guards.isDefined)(timeout) && timeout > 0 ? import_cancellation_token.CancellationToken.from((0, import_rxjs.timer)(timeout).pipe((0, import_rxjs.map)(() => true))) : void 0;
     void navigator.locks.request(this.resource, {
-      signal: (0, import_type_guards.isDefined)(timeoutToken) ? timeoutToken.asAbortSignal : void 0,
+      signal: (0, import_type_guards.isDefined)(timeoutToken) ? timeoutToken.asAbortSignal() : void 0,
       ifAvailable: (0, import_type_guards.isDefined)(timeout) && timeout <= 0
     }, async (lock) => {
       if ((0, import_type_guards.isNull)(lock)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.83.28",
+  "version": "0.84.1",
   "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",
@@ -45,7 +47,7 @@
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.7",
     "@koa/router": "^12.0",
-    "@tstdl/angular": "^0.83",
+    "@tstdl/angular": "^0.84",
     "@zxcvbn-ts/core": "^2.2",
     "@zxcvbn-ts/language-common": "^2.0",
     "@zxcvbn-ts/language-de": "^2.1",
@@ -54,13 +56,13 @@
     "handlebars": "^4.7",
     "knex": "^2.4",
     "koa": "^2.14",
-    "minio": "^7.0",
+    "minio": "^7.1",
     "mjml": "^4.14",
     "mongodb": "^5.3",
     "nodemailer": "^6.9",
+    "playwright": "^1.33",
     "preact": "^10.13",
     "preact-render-to-string": "^6.0",
-    "puppeteer": "^19.11",
     "undici": "^5.22",
     "urlpattern-polyfill": "^8.0"
   },