@tstdl/base 0.83.27 → 0.84.0

package/browser/page-controller.js

@@ -0,0 +1,166 @@
+"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 page_controller_exports = {};
+__export(page_controller_exports, {
+  PageController: () => PageController
+});
+module.exports = __toCommonJS(page_controller_exports);
+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(page, options = {}) {
+    this.page = page;
+    this.options = options;
+  }
+  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();
+    }
+  }
+  async setContent(html, options) {
+    await this.page.setContent(html, { timeout: options?.timeout, waitUntil: options?.waitUntil });
+  }
+  async setExtraHttpHeaders(headers) {
+    await this.page.setExtraHTTPHeaders(headers);
+  }
+  async navigate(url, options) {
+    await this.page.goto(url, { timeout: options?.timeout, waitUntil: options?.waitUntil });
+  }
+  async waitForClose() {
+    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 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 selectOption(selector, value, options) {
+    await this.prepareAction();
+    const locator = this.page.locator(selector);
+    await locator.selectOption(value, { timeout: options?.timeout });
+  }
+  async click(selector, options) {
+    await this.prepareAction();
+    const locator = this.page.locator(selector);
+    await locator.click({ delay: 50, timeout: options?.timeout });
+  }
+  async getValue(selector, options) {
+    const locator = this.page.locator(selector);
+    return locator.inputValue({ timeout: options?.timeout });
+  }
+  async waitForElement(selector, options) {
+    const locator = this.page.locator(selector);
+    return locator.waitFor({ timeout: options?.timeout });
+  }
+  async renderPdf(options = {}) {
+    const createPdfOptions = convertPdfOptions(options);
+    return (0, import_timing.withTimeout)(options.timeout ?? 30 * import_units.millisecondsPerSecond, this.page.pdf(createPdfOptions), { errorMessage: "Rendering pdf timed out." });
+  }
+  renderPdfStream(options = {}) {
+    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
+      const buffer = await this.renderPdf(options);
+      return new ReadableStream({
+        pull(controller) {
+          controller.enqueue(buffer);
+          controller.close();
+        }
+      });
+    });
+  }
+  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 : {
+    top: options.margin,
+    bottom: options.margin,
+    right: options.margin,
+    left: options.margin
+  };
+  return {
+    format: options.format ?? "a4",
+    scale: options.scale,
+    landscape: options.landscape,
+    width: options.width,
+    height: options.height,
+    printBackground: options.renderBackground,
+    margin,
+    displayHeaderFooter: options.displayHeaderFooter ?? ((0, import_type_guards.isDefined)(options.headerTemplate) || (0, import_type_guards.isDefined)(options.footerTemplate)),
+    headerTemplate: options.headerTemplate,
+    footerTemplate: options.footerTemplate
+  };
+}

package/browser/pdf-options.d.ts

@@ -0,0 +1,36 @@
+export declare enum PdfFormat {
+    Letter = "letter",
+    Legal = "legal",
+    Tabloid = "tabloid",
+    Ledger = "ledger",
+    A0 = "a0",
+    A1 = "a1",
+    A2 = "a2",
+    A3 = "a3",
+    A4 = "a4",
+    A5 = "a5",
+    A6 = "a6"
+}
+export declare class PdfMarginObject {
+    top?: number | string;
+    bottom?: number | string;
+    right?: number | string;
+    left?: number | string;
+}
+export declare class PdfRenderOptions {
+    renderBackground?: boolean;
+    landscape?: boolean;
+    format?: PdfFormat;
+    width?: string | number;
+    height?: string | number;
+    scale?: number;
+    margin?: string | number | PdfMarginObject;
+    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

@@ -0,0 +1,138 @@
+"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 pdf_options_exports = {};
+__export(pdf_options_exports, {
+  PdfFormat: () => PdfFormat,
+  PdfMarginObject: () => PdfMarginObject,
+  PdfRenderOptions: () => PdfRenderOptions
+});
+module.exports = __toCommonJS(pdf_options_exports);
+var import_enumeration = require("../schema/schemas/enumeration.js");
+var import_optional = require("../schema/schemas/optional.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var PdfFormat;
+(function(PdfFormat2) {
+  PdfFormat2["Letter"] = "letter";
+  PdfFormat2["Legal"] = "legal";
+  PdfFormat2["Tabloid"] = "tabloid";
+  PdfFormat2["Ledger"] = "ledger";
+  PdfFormat2["A0"] = "a0";
+  PdfFormat2["A1"] = "a1";
+  PdfFormat2["A2"] = "a2";
+  PdfFormat2["A3"] = "a3";
+  PdfFormat2["A4"] = "a4";
+  PdfFormat2["A5"] = "a5";
+  PdfFormat2["A6"] = "a6";
+})(PdfFormat || (PdfFormat = {}));
+class PdfMarginObject {
+  top;
+  bottom;
+  right;
+  left;
+}
+__decorate([
+  (0, import_optional.Optional)([Number, String]),
+  __metadata("design:type", Object)
+], PdfMarginObject.prototype, "top", void 0);
+__decorate([
+  (0, import_optional.Optional)([Number, String]),
+  __metadata("design:type", Object)
+], PdfMarginObject.prototype, "bottom", void 0);
+__decorate([
+  (0, import_optional.Optional)([Number, String]),
+  __metadata("design:type", Object)
+], PdfMarginObject.prototype, "right", void 0);
+__decorate([
+  (0, import_optional.Optional)([Number, String]),
+  __metadata("design:type", Object)
+], PdfMarginObject.prototype, "left", void 0);
+class PdfRenderOptions {
+  renderBackground;
+  landscape;
+  format;
+  width;
+  height;
+  scale;
+  margin;
+  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, "renderBackground", void 0);
+__decorate([
+  (0, import_optional.Optional)(),
+  __metadata("design:type", Boolean)
+], PdfRenderOptions.prototype, "landscape", void 0);
+__decorate([
+  (0, import_enumeration.Enumeration)(PdfFormat, { optional: true }),
+  __metadata("design:type", String)
+], PdfRenderOptions.prototype, "format", void 0);
+__decorate([
+  (0, import_optional.Optional)([String, Number]),
+  __metadata("design:type", Object)
+], PdfRenderOptions.prototype, "width", void 0);
+__decorate([
+  (0, import_optional.Optional)([String, Number]),
+  __metadata("design:type", Object)
+], PdfRenderOptions.prototype, "height", void 0);
+__decorate([
+  (0, import_optional.Optional)(),
+  __metadata("design:type", Number)
+], PdfRenderOptions.prototype, "scale", void 0);
+__decorate([
+  (0, import_optional.Optional)([String, Number, PdfMarginObject]),
+  __metadata("design:type", Object)
+], PdfRenderOptions.prototype, "margin", void 0);
+__decorate([
+  (0, import_optional.Optional)(),
+  __metadata("design:type", Boolean)
+], PdfRenderOptions.prototype, "displayHeaderFooter", void 0);
+__decorate([
+  (0, import_optional.Optional)(),
+  __metadata("design:type", String)
+], PdfRenderOptions.prototype, "headerTemplate", void 0);
+__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/core.d.ts

@@ -1,7 +1,7 @@
 import type { InjectionToken } from './container/index.js';
 import { AsyncDisposer } from './disposable/async-disposer.js';
 import type { LoggerArgument } from './logger/index.js';
-import { Logger, LogLevel } 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 connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, maxTries?: number): Promise<void>;

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/error/timeout.error.js

@@ -0,0 +1,30 @@
+"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 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.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/browser/basic.js

@@ -0,0 +1,19 @@
+"use strict";
+var import_node_fs = require("node:fs");
+var import_application = require("../../application/index.js");
+var import_browser_service = require("../../browser/browser.service.js");
+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({ headless: false });
+  const page = await browser.newPage();
+  await page.navigate("https://google.com");
+  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);
+  await page.navigate("file:///tmp/pdf.pdf");
+  await browser.waitForClose();
+}
+import_application.Application.run(main);

package/examples/mail/basic.js

@@ -1,4 +1,6 @@
 "use strict";
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
 var import_container = require("../../container/index.js");
 var import_nodemailer_mail_client = require("../../mail/clients/nodemailer.mail-client.js");
 var import_mail = require("../../mail/index.js");
@@ -8,8 +10,14 @@ var import_handlebars_template_renderer = require("../../templates/renderers/han
 var import_mjml_template_renderer = require("../../templates/renderers/mjml.template-renderer.js");
 var import_file_template_resolver = require("../../templates/resolvers/file.template-resolver.js");
 var import_config_parser = require("../../utils/config-parser.js");
-var import_node_path = require("node:path");
 var import_core = require("../../core.js");
+const import_meta = {};
+let dirname;
+try {
+  dirname = (0, import_node_url.fileURLToPath)(new URL(".", import_meta.url));
+} catch {
+  dirname = __dirname;
+}
 (0, import_core.configureTstdl)();
 (0, import_mail.configureMail)({
   clientConfig: {
@@ -26,8 +34,8 @@ var import_core = require("../../core.js");
   templateProvider: import_file_template_provider.FileTemplateProvider,
   templateRenderers: [import_mjml_template_renderer.MjmlTemplateRenderer, import_handlebars_template_renderer.HandlebarsTemplateRenderer]
 });
-(0, import_file_template_provider.configureFileTemplateProvider)({ basePath: (0, import_node_path.resolve)(__dirname, "templates") });
-(0, import_file_template_resolver.configureFileTemplateResolver)({ basePath: (0, import_node_path.resolve)(__dirname.replace("/dist", "/source"), "templates") });
+(0, import_file_template_provider.configureFileTemplateProvider)({ basePath: (0, import_node_path.resolve)(dirname, "templates") });
+(0, import_file_template_resolver.configureFileTemplateResolver)({ basePath: (0, import_node_path.resolve)(dirname.replace("/dist", "/source"), "templates") });
 async function test() {
   const service = await import_container.container.resolveAsync(import_mail.MailService);
   const result = await service.sendTemplate("hello-name", { from: (0, import_config_parser.string)("FROM", (0, import_config_parser.string)("USER", "user@example.com")), to: (0, import_config_parser.string)("TO", "user@example.com") }, { name: "Max Mustermann" });