@tstdl/base 0.84.32 → 0.84.33

package/browser/browser-context-controller.d.ts

@@ -3,6 +3,7 @@ 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 { Logger } from '../logger/logger.js';
 import type { Record } from '../types.js';
 import type { Opaque } from 'type-fest';
 import type { NewBrowserContextOptions } from './browser-controller.js';
@@ -30,4 +31,5 @@ export declare class BrowserContextController implements AsyncDisposable, Inject
     newPage(options?: NewPageOptions): Promise<PageController>;
     waitForNoPages(): Promise<void>;
     waitForClose(): Promise<void>;
+    attachLogger(logger: Logger): void;
 }

package/browser/browser-context-controller.js

@@ -28,6 +28,7 @@ var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_browser_controller = require("./browser-controller.js");
 var import_page_controller = require("./page-controller.js");
+var import_utils = require("./utils.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")
@@ -89,6 +90,9 @@ let BrowserContextController = class BrowserContextController2 {
   async waitForClose() {
     return new Promise((resolve) => this.context.once("close", () => resolve()));
   }
+  attachLogger(logger) {
+    (0, import_utils.attachLogger)(this.context, logger);
+  }
 };
 BrowserContextController = __decorate([
   (0, import_decorators.injectable)({

package/browser/page-controller.d.ts

@@ -1,6 +1,7 @@
 import type { Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
+import type { Logger } from '../logger/logger.js';
 import type { DocumentControllerOptions } from './document-controller.js';
 import { DocumentController } from './document-controller.js';
 import type { FrameControllerOptions } from './frame-controller.js';
@@ -27,4 +28,5 @@ export declare class PageController extends DocumentController<Page> implements
     frame(frameSelector: Parameters<Page['frame']>[0]): FrameController;
     renderPdf(options?: PdfRenderOptions & Abortable): Promise<Uint8Array>;
     renderPdfStream(options?: PdfRenderOptions & Abortable): ReadableStream<Uint8Array>;
+    attachLogger(logger: Logger): void;
 }

package/browser/page-controller.js

@@ -29,6 +29,7 @@ var import_type_guards = require("../utils/type-guards.js");
 var import_units = require("../utils/units.js");
 var import_document_controller = require("./document-controller.js");
 var import_frame_controller = require("./frame-controller.js");
+var import_utils = require("./utils.js");
 class PageController extends import_document_controller.DocumentController {
   /** @deprecated should be avoided */
   page;
@@ -86,6 +87,9 @@ class PageController extends import_document_controller.DocumentController {
       });
     });
   }
+  attachLogger(logger) {
+    (0, import_utils.attachLogger)(this.page, logger);
+  }
 }
 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/utils.d.ts

@@ -1,7 +1,12 @@
-import type { ElementHandle, LaunchOptions, Locator } from 'playwright';
+import type { Logger } from '../logger/logger.js';
+import type { BrowserContext, ElementHandle, Frame, LaunchOptions, Locator, Page } 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 attachLogger(loggable: Page | BrowserContext, logger: Logger): void;
 export declare function isLocator(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is Locator;
-export declare function isElementHandle(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is Locator;
+export declare function isElementHandle(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is ElementHandle;
+export declare function isPage(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is Page;
+export declare function isFrame(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is Frame;
+export declare function isBrowserContext(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is BrowserContext;

package/browser/utils.js

@@ -18,14 +18,19 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  attachLogger: () => attachLogger,
   getLaunchOptions: () => getLaunchOptions,
+  isBrowserContext: () => isBrowserContext,
   isElementHandle: () => isElementHandle,
+  isFrame: () => isFrame,
   isLocator: () => isLocator,
+  isPage: () => isPage,
   mergeNewBrowserContextOptions: () => mergeNewBrowserContextOptions
 });
 module.exports = __toCommonJS(utils_exports);
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
+const pageLoggerMap = /* @__PURE__ */ new WeakMap();
 function getLaunchOptions(options) {
   const { windowSize, browserArguments, headless } = options;
   const args = [`--window-size=${windowSize?.width ?? 1e3},${windowSize?.height ?? 1e3}`, ...browserArguments ?? []];
@@ -48,9 +53,64 @@ function mergeNewBrowserContextOptions(a, b, c) {
     extraHttpHeaders: (0, import_object.objectKeys)(mergedExtraHttpHeaders).length > 0 ? mergedExtraHttpHeaders : void 0
   };
 }
+function getPageLogger(page, baseLogger) {
+  let pageLogger = pageLoggerMap.get(page);
+  if ((0, import_type_guards.isUndefined)(pageLogger)) {
+    pageLogger = baseLogger.subModule(crypto.randomUUID().slice(-12));
+    pageLoggerMap.set(page, pageLogger);
+  }
+  return pageLogger;
+}
+function attachLogger(loggable, logger) {
+  if (isPage(loggable)) {
+    loggable.on("close", () => pageLoggerMap.delete(loggable));
+    loggable.on("pageerror", (error) => logger.error(error));
+  }
+  loggable.on("console", (consoleMessage) => {
+    const page = consoleMessage.page();
+    const pageLogger = (0, import_type_guards.isNull)(page) ? logger : getPageLogger(page, logger);
+    const rawUrl = consoleMessage.page()?.url();
+    const parsedUrl = (0, import_type_guards.isString)(rawUrl) && rawUrl.length > 0 ? new URL(rawUrl) : rawUrl;
+    const url = (0, import_type_guards.isString)(parsedUrl) ? parsedUrl : `${parsedUrl?.protocol.startsWith("http") == true ? "" : parsedUrl?.protocol}${parsedUrl?.host}${parsedUrl?.pathname}`;
+    const location = consoleMessage.location();
+    const rawLocationText = location.lineNumber == 0 ? location.url : `${location.url}:${location.lineNumber}:${location.columnNumber}`;
+    const locationText = rawLocationText.length == 0 ? void 0 : rawLocationText;
+    const additions = Object.entries({ location: locationText }).filter(([_, value]) => (0, import_type_guards.isDefined)(value)).map(([key, value]) => `${key}: ${value}`).join(", ");
+    const message = `${url}: ${consoleMessage.text()}${additions.length > 0 ? ` (${additions})` : ""}`;
+    switch (consoleMessage.type()) {
+      case "debug":
+        pageLogger.debug(message);
+        break;
+      case "error":
+        pageLogger.error(message);
+        break;
+      case "warning":
+        pageLogger.warn(message);
+        break;
+      case "trace":
+        pageLogger.trace(message);
+        break;
+      case "clear":
+        break;
+      case "info":
+      default:
+        pageLogger.info(message);
+        break;
+    }
+  });
+}
 function isLocator(locatorOrHandle) {
-  return (0, import_type_guards.isFunction)(locatorOrHandle.count);
+  return locatorOrHandle.constructor.name == "Locator";
 }
 function isElementHandle(locatorOrHandle) {
-  return (0, import_type_guards.isFunction)(locatorOrHandle.asElement);
+  return locatorOrHandle.constructor.name == "ElementHandle";
+}
+function isPage(pageOrFrameOrContext) {
+  return pageOrFrameOrContext.constructor.name == "Page";
+}
+function isFrame(pageOrFrameOrContext) {
+  return pageOrFrameOrContext.constructor.name == "Frame";
+}
+function isBrowserContext(pageOrFrameOrContext) {
+  return pageOrFrameOrContext.constructor.name == "BrowserContext";
 }

package/examples/browser/basic.js

@@ -3,12 +3,15 @@ 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_logger = require("../../logger/logger.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 context = await browser.newContext();
   const page = await context.newPage();
+  const logger = import_container.container.resolve(import_logger.Logger).subModule("BROWSER");
+  page.attachLogger(logger);
   await page.navigate("https://google.com");
   await page.getBySelector("//div[text() = 'Alle ablehnen']").click();
   await (0, import_timing.timeout)(1e3);

package/logger/console/logger.d.ts

@@ -1,10 +1,11 @@
 import { LogLevel } from '../level.js';
-import type { LogErrorOptions } from '../logger.js';
+import type { LogErrorOptions, LoggerForkOptions } from '../logger.js';
 import { Logger } from '../logger.js';
 export declare class ConsoleLogger extends Logger {
     private readonly entryPrefix;
     constructor(level: LogLevel, module?: string | string[], prefix?: string);
-    fork(subModule: string): ConsoleLogger;
+    fork(options: LoggerForkOptions): ConsoleLogger;
+    subModule(subModule: string): ConsoleLogger;
     prefix(prefix: string): ConsoleLogger;
     protected log(level: LogLevel, entryOrError: string | Error, errorOptions?: LogErrorOptions): void;
 }

package/logger/console/logger.js

@@ -57,7 +57,12 @@ let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger2 extends import_logger
     const modulePrefix = (0, import_type_guards.isDefined)(this.module) ? this.module.map((m) => `[${m}]`).join(" ") : "";
     this.entryPrefix = `${modulePrefix}${modulePrefix.length > 0 ? " " : ""}${this.logPrefix}`;
   }
-  fork(subModule) {
+  fork(options) {
+    const level = options.level ?? this.level;
+    const module2 = (0, import_type_guards.isDefined)(options.subModule) ? [...this.module ?? [], options.subModule] : this.module;
+    return new ConsoleLogger_1(level, module2, options.prefix);
+  }
+  subModule(subModule) {
     return new ConsoleLogger_1(this.level, [...this.module ?? [], subModule]);
   }
   prefix(prefix) {

package/logger/logger.d.ts

@@ -1,5 +1,4 @@
-import type { Injectable } from '../container/index.js';
-import type { resolveArgumentType } from '../container/index.js';
+import type { Injectable, resolveArgumentType } from '../container/index.js';
 import { LogLevel } from './level.js';
 export type LogEntry = string;
 export type LogEntryProvider = () => LogEntry;
@@ -15,6 +14,11 @@ export type LoggerArgument = string | undefined | {
     module?: string | string[];
     prefix?: string;
 };
+export type LoggerForkOptions = {
+    subModule?: string;
+    prefix?: string;
+    level?: LogLevel;
+};
 export declare abstract class Logger implements Injectable<LoggerArgument> {
     readonly level: LogLevel;
     readonly module?: string[];
@@ -29,7 +33,8 @@ export declare abstract class Logger implements Injectable<LoggerArgument> {
     debug(entry: LogEntryOrProvider): void;
     trace(entry: LogEntryOrProvider): void;
     private _log;
-    abstract fork(subModule: string): Logger;
+    abstract fork(options: LoggerForkOptions): Logger;
+    abstract subModule(subModule: string): Logger;
     abstract prefix(prefix: string): Logger;
     protected abstract log(level: LogLevel, entry: LogEntry | Error, errorOptions?: LogErrorOptions): void;
 }

package/logger/noop/logger.d.ts

@@ -2,6 +2,7 @@ import { Logger } from '../logger.js';
 export declare class NoopLogger extends Logger {
     constructor();
     fork(): Logger;
+    subModule(): Logger;
     prefix(): Logger;
     protected log(): void;
 }

package/logger/noop/logger.js

@@ -31,6 +31,9 @@ class NoopLogger extends import_logger.Logger {
   fork() {
     return this;
   }
+  subModule() {
+    return this;
+  }
   prefix() {
     return this;
   }

package/package.json

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

package/pdf/pdf.service.d.ts

@@ -4,12 +4,15 @@ import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
 import type { Injectable } from '../container/index.js';
 import { resolveArgumentType } from '../container/index.js';
+import { LogLevel } from '../logger/level.js';
+import { Logger } from '../logger/logger.js';
 import type { TemplateField } from '../templates/index.js';
 import { Template, TemplateService } from '../templates/index.js';
 export declare class PdfServiceRenderOptions extends PdfRenderOptions {
     browserContext?: BrowserContextController;
     locale?: string;
     waitForNetworkIdle?: boolean;
+    log?: boolean | LogLevel;
 }
 export type PdfTemplateOptions = PdfRenderOptions;
 export declare class PdfTemplate<Context extends object = any> extends Template<{
@@ -28,9 +31,10 @@ export type PdfServiceArgument = PdfServiceOptions & {
 export declare class PdfService implements Injectable<PdfServiceArgument> {
     private readonly templateService;
     private readonly browserController;
+    private readonly logger;
     private readonly defaultLocale;
     readonly [resolveArgumentType]: PdfServiceArgument;
-    constructor(templateService: TemplateService, browserController: BrowserController, options?: PdfServiceOptions);
+    constructor(templateService: TemplateService, browserController: BrowserController, logger: Logger, options?: PdfServiceOptions);
     /**
      * Renders HTML to pdf stream
      * @param html html to render

package/pdf/pdf.service.js

@@ -28,6 +28,8 @@ var import_browser_context_controller = require("../browser/browser-context-cont
 var import_browser_controller = require("../browser/browser-controller.js");
 var import_pdf_options = require("../browser/pdf-options.js");
 var import_container = require("../container/index.js");
+var import_level = require("../logger/level.js");
+var import_logger = require("../logger/logger.js");
 var import_schema = require("../schema/index.js");
 var import_templates = require("../templates/index.js");
 var import_finalize_stream = require("../utils/stream/finalize-stream.js");
@@ -57,6 +59,7 @@ class PdfServiceRenderOptions extends import_pdf_options.PdfRenderOptions {
   browserContext;
   locale;
   waitForNetworkIdle;
+  log;
 }
 __decorate([
   (0, import_schema.Optional)(),
@@ -70,6 +73,10 @@ __decorate([
   (0, import_schema.Optional)(),
   __metadata("design:type", Boolean)
 ], PdfServiceRenderOptions.prototype, "waitForNetworkIdle", void 0);
+__decorate([
+  (0, import_schema.Optional)(),
+  __metadata("design:type", Object)
+], PdfServiceRenderOptions.prototype, "log", void 0);
 class PdfTemplate extends import_templates.Template {
 }
 __decorate([
@@ -80,10 +87,12 @@ const browserArguments = ["--font-render-hinting=none", "--disable-web-security"
 let PdfService = class PdfService2 {
   templateService;
   browserController;
+  logger;
   defaultLocale;
-  constructor(templateService, browserController, options = {}) {
+  constructor(templateService, browserController, logger, options = {}) {
     this.templateService = templateService;
     this.browserController = browserController;
+    this.logger = logger;
     this.defaultLocale = options.locale;
   }
   /**
@@ -155,6 +164,11 @@ let PdfService = class PdfService2 {
     return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
       const context = options.browserContext ?? await this.browserController.newContext({ locale: options.locale ?? this.defaultLocale });
       const page = await context.newPage();
+      if ((0, import_type_guards.isDefined)(options.log) && options.log != false) {
+        const level = options.log == true ? import_level.LogLevel.Info : options.log;
+        const logger = this.logger.fork({ level, subModule: "PAGE" });
+        page.attachLogger(logger);
+      }
       const optionsFromHandler = await handler(page);
       const pdfStream = page.renderPdfStream({ ...optionsFromHandler, ...options });
       const close = async () => {
@@ -175,8 +189,14 @@ let PdfService = class PdfService2 {
 PdfService = __decorate([
   (0, import_container.singleton)(),
   __param(1, (0, import_container.forwardArg)((argument) => argument?.browserControllerArgument ?? { browserArguments })),
-  __param(2, (0, import_container.injectArg)()),
-  __metadata("design:paramtypes", [import_templates.TemplateService, import_browser_controller.BrowserController, Object])
+  __param(2, (0, import_container.resolveArg)("PdfService")),
+  __param(3, (0, import_container.injectArg)()),
+  __metadata("design:paramtypes", [
+    import_templates.TemplateService,
+    import_browser_controller.BrowserController,
+    import_logger.Logger,
+    Object
+  ])
 ], PdfService);
 function pdfTemplate(name, fields, options) {
   return {

package/utils/repl.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
-import * as repl from 'node:repl';
+import type { ReplOptions } from 'node:repl';
 import type { Record } from '../types.js';
 /**
  * Starts an interactive (repl) session (node only)
  * @param context context to set the repl context to
  */
-export declare function startRepl(options?: repl.ReplOptions & {
+export declare function repl(options?: ReplOptions & {
     context?: Record<string>;
 }): Promise<void>;

package/utils/repl.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,25 +15,17 @@ 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 repl_exports = {};
 __export(repl_exports, {
-  startRepl: () => startRepl
+  repl: () => repl
 });
 module.exports = __toCommonJS(repl_exports);
-var repl = __toESM(require("node:repl"), 1);
+var import_node_repl = require("node:repl");
 var import_object = require("./object/object.js");
 var import_type_guards = require("./type-guards.js");
-async function startRepl(options) {
-  const replServer = repl.start(options);
+async function repl(options) {
+  const replServer = (0, import_node_repl.start)(options);
   if ((0, import_type_guards.isDefined)(options?.context)) {
     for (const [key, value] of (0, import_object.objectEntries)(options.context)) {
       replServer.context[key] = value;

package/utils/value-or-provider.d.ts

@@ -1,2 +1,3 @@
 export type ValueOrProvider<T> = T extends () => any ? never : T | (() => T);
+export type ResolvedValueOrProvider<T extends ValueOrProvider<any>> = T extends ValueOrProvider<infer U> ? U : never;
 export declare function resolveValueOrProvider<T>(valueOrProvider: ValueOrProvider<T>): T;