@tstdl/base 0.87.0 → 0.87.2

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

@@ -1,8 +1,8 @@
-import type { BrowserContext } from 'playwright';
+import type { BrowserContext, Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
 import type { Resolvable } from '../injector/interfaces.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
+import { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
 import type { Logger } from '../logger/logger.js';
 import type { Record } from '../types.js';
 import type { Tagged } from 'type-fest';
@@ -19,12 +19,22 @@ export type NewPageOptions = {
 export type BrowserContextState = Tagged<Record<string | number, unknown>, 'BrowserContextState'>;
 export type BrowserContextControllerArgument = NewBrowserContextOptions;
 export declare class BrowserContextController implements AsyncDisposable, Resolvable<BrowserContextControllerArgument> {
+    #private;
     /** @deprecated should be avoided */
     readonly context: BrowserContext;
     readonly options: BrowserContextControllerOptions;
     readonly [resolveArgumentType]: BrowserContextControllerArgument;
     constructor(context: BrowserContext, options?: BrowserContextControllerOptions);
+    [afterResolve](): void;
+    initialize(): void;
     [disposeAsync](): Promise<void>;
+    pages(): PageController[];
+    /**
+     * Get a controller for the page.
+     * @param page page to get controller for
+     * @param options options to use for the page controller *if* it is new. Ignored if there is already a controller associated.
+     */
+    getControllerByPage(page: Page, options?: PageControllerOptions): PageController;
     close(): Promise<void>;
     getState(): Promise<BrowserContextState>;
     setExtraHttpHeaders(headers: Record<string, string | undefined>): Promise<void>;

package/browser/browser-context-controller.js

@@ -44,6 +44,7 @@ var __metadata = function(k, v) {
     return Reflect.metadata(k, v);
 };
 let BrowserContextController = class BrowserContextController2 {
+  #pageControllers = /* @__PURE__ */ new WeakMap();
   /** @deprecated should be avoided */
   context;
   options;
@@ -51,9 +52,38 @@ let BrowserContextController = class BrowserContextController2 {
     this.context = context;
     this.options = options;
   }
+  [import_interfaces.afterResolve]() {
+    this.initialize();
+  }
+  initialize() {
+    this.context.on("page", (page) => {
+      page.once("close", () => this.#pageControllers.delete(page));
+    });
+  }
   async [import_disposable.disposeAsync]() {
     await this.close();
   }
+  pages() {
+    const pages = this.context.pages();
+    return pages.map((page) => this.getControllerByPage(page));
+  }
+  /**
+   * Get a controller for the page.
+   * @param page page to get controller for
+   * @param options options to use for the page controller *if* it is new. Ignored if there is already a controller associated.
+   */
+  getControllerByPage(page, options) {
+    if (page.context() != this.context) {
+      throw new Error("Page is not from this context.");
+    }
+    const existingController = this.#pageControllers.get(page);
+    if ((0, import_type_guards.isDefined)(existingController)) {
+      return existingController;
+    }
+    const newController = new import_page_controller.PageController(page, this, { ...this.options.defaultNewPageOptions?.controllerOptions, ...options });
+    this.#pageControllers.set(page, newController);
+    return newController;
+  }
   async close() {
     await this.context.close();
   }
@@ -68,7 +98,8 @@ let BrowserContextController = class BrowserContextController2 {
   async newPage(options) {
     const page = await this.context.newPage();
     const mergedOptions = { ...this.options.defaultNewPageOptions, ...options };
-    const controller = new import_page_controller.PageController(page, mergedOptions.controllerOptions);
+    const controller = new import_page_controller.PageController(page, this, mergedOptions.controllerOptions);
+    this.#pageControllers.set(page, controller);
     if ((0, import_type_guards.isDefined)(mergedOptions.extraHttpHeaders)) {
       await controller.setExtraHttpHeaders(mergedOptions.extraHttpHeaders);
     }

package/browser/document-controller.d.ts

@@ -1,27 +1,33 @@
 import type { ElementHandle, Frame, FrameLocator, Page } from 'playwright';
+import type { BrowserContextController } from './browser-context-controller.js';
 import type { Delay } from './element-controller.js';
 import { ElementController } from './element-controller.js';
 import type { FrameController, FrameControllerOptions } from './frame-controller.js';
 import { LocatorController } from './locator-controller.js';
-import type { PageControllerOptions } from './page-controller.js';
 export type DocumentControllerOptions = {
     defaultActionDelay?: Delay;
     defaultTypeDelay?: Delay;
 };
-export type DocumentControllerForwardOptions = {
-    pageControllerOptions: PageControllerOptions;
-    frameControllerOptions: FrameControllerOptions;
-};
+export declare function setFrameControllerConstructor(constructor: typeof FrameController): void;
 export declare class DocumentController<T extends Page | Frame = Page | Frame> extends LocatorController<T> {
-    protected readonly forwardOptions: DocumentControllerForwardOptions;
+    #private;
     /** @deprecated should be avoided */
     readonly document: T;
-    constructor(document: T, options: DocumentControllerOptions, forwardOptions: DocumentControllerForwardOptions);
+    readonly context: BrowserContextController;
+    readonly options: DocumentControllerOptions;
+    constructor(document: T, context: BrowserContextController, options: DocumentControllerOptions);
+    frames(): FrameController[];
+    /**
+     * Get a controller for the frame.
+     * @param frame frame to get controller for
+     * @param options options to use for the frame controller *if* it is new. Ignored if there is already a controller associated.
+     */
+    getControllerByFrame(frame: Frame, options?: FrameControllerOptions): FrameController;
     setContent(...args: Parameters<Page['setContent']>): Promise<void>;
     navigate(...args: Parameters<Page['goto']>): 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<ElementController<ElementHandle<SVGElement | HTMLElement>>>;
     locateInFrame(frameSelector: string): LocatorController<FrameLocator>;
-    waitForFrame(selector: string, options?: Parameters<Page['waitForSelector']>[1]): Promise<FrameController>;
+    waitForFrame(selector: string, options?: Parameters<Page['waitForSelector']>[1], controllerOptions?: FrameControllerOptions): Promise<FrameController>;
 }

package/browser/document-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,31 +15,54 @@ 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 document_controller_exports = {};
 __export(document_controller_exports, {
-  DocumentController: () => DocumentController
+  DocumentController: () => DocumentController,
+  setFrameControllerConstructor: () => setFrameControllerConstructor
 });
 module.exports = __toCommonJS(document_controller_exports);
 var import_type_guards = require("../utils/type-guards.js");
 var import_element_controller = require("./element-controller.js");
 var import_locator_controller = require("./locator-controller.js");
+var import_utils = require("./utils.js");
+let frameControllerConstructor;
+function setFrameControllerConstructor(constructor) {
+  frameControllerConstructor = constructor;
+}
 class DocumentController extends import_locator_controller.LocatorController {
-  forwardOptions;
+  #frameControllers = /* @__PURE__ */ new WeakMap();
   /** @deprecated should be avoided */
   document;
-  constructor(document, options, forwardOptions) {
+  context;
+  options;
+  constructor(document, context, options) {
     super(document, { actionDelay: options.defaultActionDelay, typeDelay: options.defaultTypeDelay });
     this.document = document;
-    this.forwardOptions = forwardOptions;
+    this.context = context;
+    this.options = options;
+  }
+  frames() {
+    const frames = (0, import_utils.isPage)(this.document) ? this.document.frames() : this.document.childFrames();
+    return frames.map((page) => this.getControllerByFrame(page));
+  }
+  /**
+   * Get a controller for the frame.
+   * @param frame frame to get controller for
+   * @param options options to use for the frame controller *if* it is new. Ignored if there is already a controller associated.
+   */
+  getControllerByFrame(frame, options) {
+    const documentPage = (0, import_utils.isPage)(this.document) ? this.document : this.document.page();
+    if (frame.page() != documentPage) {
+      throw new Error("Frame is not from this page.");
+    }
+    const existingController = this.#frameControllers.get(frame);
+    if ((0, import_type_guards.isDefined)(existingController)) {
+      return existingController;
+    }
+    const newController = new frameControllerConstructor(frame, this.context, { ...this.options, ...options });
+    this.#frameControllers.set(frame, newController);
+    return newController;
   }
   async setContent(...args) {
     await this.document.setContent(...args);
@@ -66,24 +87,12 @@ class DocumentController extends import_locator_controller.LocatorController {
     const locator = this.document.frameLocator(frameSelector);
     return new import_locator_controller.LocatorController(locator, this.elementControllerOptions);
   }
-  async waitForFrame(selector, options) {
+  async waitForFrame(selector, options, controllerOptions) {
     const element = await this.waitForElement(selector, options);
     const frame = await element.locatorOrHandle.contentFrame();
     if ((0, import_type_guards.isNull)(frame)) {
       throw new Error("Element is not a frame.");
     }
-    return newFrameController(frame, this.forwardOptions.frameControllerOptions, { pageControllerOptions: this.forwardOptions.pageControllerOptions });
+    return this.getControllerByFrame(frame, controllerOptions);
   }
 }
-let frameControllerConstructor;
-async function newFrameController(...args) {
-  if ((0, import_type_guards.isUndefined)(frameControllerConstructor)) {
-    frameControllerConstructor = importFrameController();
-    void frameControllerConstructor.then((constructor) => frameControllerConstructor = constructor);
-  }
-  return new (await frameControllerConstructor)(...args);
-}
-async function importFrameController() {
-  const module2 = await import("./frame-controller.js");
-  return module2.FrameController;
-}

package/browser/frame-controller.d.ts

@@ -1,23 +1,19 @@
 import type { Frame, Page } from 'playwright';
+import type { BrowserContextController } from './browser-context-controller.js';
 import type { DocumentControllerOptions } from './document-controller.js';
 import { DocumentController } from './document-controller.js';
-import type { PageControllerOptions } from './page-controller.js';
-import { PageController } from './page-controller.js';
+import type { PageController, PageControllerOptions } from './page-controller.js';
 export type FrameControllerOptions = DocumentControllerOptions;
-export type FrameControllerForwardOptions = {
-    pageControllerOptions: PageControllerOptions;
-};
 export declare class FrameController extends DocumentController<Frame> {
-    private readonly frameControllerForwardOptions;
     /** @deprecated should be avoided */
     readonly frame: Frame;
     readonly options: FrameControllerOptions;
-    constructor(frame: Frame, options: FrameControllerOptions, forwardOptions: FrameControllerForwardOptions);
+    constructor(frame: Frame, context: BrowserContextController, options: FrameControllerOptions);
     /** Get the page containing this frame */
-    getPage(): PageController;
+    getPage(options?: PageControllerOptions): PageController;
     /**
      * @param frameSelector frame name, url or url predicate
      * @returns
      */
-    getFrame(frameSelector: Parameters<Page['frame']>[0]): FrameController;
+    getFrame(frameSelector: Parameters<Page['frame']>[0], options?: FrameControllerOptions): FrameController;
 }

package/browser/frame-controller.js

@@ -23,30 +23,27 @@ __export(frame_controller_exports, {
 module.exports = __toCommonJS(frame_controller_exports);
 var import_type_guards = require("../utils/type-guards.js");
 var import_document_controller = require("./document-controller.js");
-var import_page_controller = require("./page-controller.js");
 class FrameController extends import_document_controller.DocumentController {
-  frameControllerForwardOptions;
   /** @deprecated should be avoided */
   frame;
   options;
-  constructor(frame, options, forwardOptions) {
-    super(frame, options, { frameControllerOptions: options, pageControllerOptions: forwardOptions.pageControllerOptions });
+  constructor(frame, context, options) {
+    super(frame, context, options);
     this.options = options;
-    this.frameControllerForwardOptions = forwardOptions;
   }
   /** Get the page containing this frame */
-  getPage() {
-    return new import_page_controller.PageController(this.frame.page(), this.frameControllerForwardOptions.pageControllerOptions);
+  getPage(options) {
+    return this.context.getControllerByPage(this.frame.page(), options);
   }
   /**
    * @param frameSelector frame name, url or url predicate
    * @returns
    */
-  getFrame(frameSelector) {
+  getFrame(frameSelector, options) {
     const frame = this.frame.page().frame(frameSelector);
     if ((0, import_type_guards.isNull)(frame)) {
       throw new Error("Frame not found.");
     }
-    return new FrameController(frame, this.options, this.frameControllerForwardOptions);
+    return this.getControllerByFrame(frame, { ...this.options, ...options });
   }
 }

package/browser/module.js

@@ -28,6 +28,8 @@ var import_injector = require("../injector/injector.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_browser_service = require("./browser.service.js");
+var import_document_controller = require("./document-controller.js");
+var import_frame_controller = require("./frame-controller.js");
 const browserTypes = {
   chromium: import_playwright.chromium,
   firefox: import_playwright.firefox,
@@ -49,3 +51,4 @@ function getBrowserType(type) {
   }
   return browserType;
 }
+(0, import_document_controller.setFrameControllerConstructor)(import_frame_controller.FrameController);

package/browser/page-controller.d.ts

@@ -2,22 +2,23 @@ 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 { BrowserContextController } from './browser-context-controller.js';
 import type { DocumentControllerOptions } from './document-controller.js';
 import { DocumentController } from './document-controller.js';
-import type { FrameControllerOptions } from './frame-controller.js';
-import { FrameController } from './frame-controller.js';
+import type { FrameController, FrameControllerOptions } from './frame-controller.js';
 import type { PdfRenderOptions } from './pdf-options.js';
 import type { Abortable } from './types.js';
-export type PageControllerOptions = DocumentControllerOptions & {
-    defaultFrameControllerOptions?: FrameControllerOptions;
-};
+export type PageControllerOptions = DocumentControllerOptions;
 export declare class PageController extends DocumentController<Page> implements AsyncDisposable {
     /** @deprecated should be avoided */
     readonly page: Page;
     readonly options: PageControllerOptions;
-    constructor(page: Page, options?: PageControllerOptions);
+    constructor(page: Page, context: BrowserContextController, options?: PageControllerOptions);
     [disposeAsync](): Promise<void>;
     close(): Promise<void>;
+    /** finds pages opened by this page (having opener set to this page) */
+    opened(): Promise<PageController[]>;
+    opener(): Promise<PageController | null>;
     setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
     waitForClose(): Promise<void>;
     url(): string;
@@ -25,7 +26,7 @@ export declare class PageController extends DocumentController<Page> implements
      * @param frameSelector frame name, url or url predicate
      * @returns
      */
-    frame(frameSelector: Parameters<Page['frame']>[0]): FrameController;
+    frame(frameSelector: Parameters<Page['frame']>[0], options?: FrameControllerOptions): FrameController;
     renderPdf(options?: PdfRenderOptions & Abortable): Promise<Uint8Array>;
     renderPdfStream(options?: PdfRenderOptions & Abortable): ReadableStream<Uint8Array>;
     attachLogger(logger: Logger): void;

package/browser/page-controller.js

@@ -28,14 +28,13 @@ 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_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;
   options;
-  constructor(page, options = {}) {
-    super(page, options, { pageControllerOptions: options, frameControllerOptions: options.defaultFrameControllerOptions ?? options });
+  constructor(page, context, options = {}) {
+    super(page, context, options);
     this.page = page;
     this.options = options;
   }
@@ -45,6 +44,23 @@ class PageController extends import_document_controller.DocumentController {
   async close() {
     await this.page.close();
   }
+  /** finds pages opened by this page (having opener set to this page) */
+  async opened() {
+    const openedPages = [];
+    for (const page of this.context.pages()) {
+      if (await page.opener() == this) {
+        openedPages.push(page);
+      }
+    }
+    return openedPages;
+  }
+  async opener() {
+    const opener = await this.page.opener();
+    if ((0, import_type_guards.isNull)(opener)) {
+      return null;
+    }
+    return this.context.getControllerByPage(opener);
+  }
   async setExtraHttpHeaders(headers) {
     const filtered = (0, import_object.filterUndefinedFromRecord)(headers);
     await this.page.setExtraHTTPHeaders(filtered);
@@ -65,12 +81,12 @@ class PageController extends import_document_controller.DocumentController {
    * @param frameSelector frame name, url or url predicate
    * @returns
    */
-  frame(frameSelector) {
+  frame(frameSelector, options) {
     const frame = this.page.frame(frameSelector);
     if ((0, import_type_guards.isNull)(frame)) {
       throw new Error("Frame not found.");
     }
-    return new import_frame_controller.FrameController(frame, this.options, this.forwardOptions);
+    return this.getControllerByFrame(frame, { ...this.options, ...options });
   }
   async renderPdf(options = {}) {
     const createPdfOptions = convertPdfOptions(options);

package/examples/browser/basic.d.ts

@@ -1 +1 @@
-export {};
+import '../../polyfills.js';

package/examples/browser/basic.js

@@ -1,4 +1,5 @@
 "use strict";
+var import_polyfills = require("../../polyfills.js");
 var import_promises = require("node:fs/promises");
 var import_application = require("../../application/index.js");
 var import_browser_service = require("../../browser/browser.service.js");

package/function/log.d.ts

@@ -3,4 +3,4 @@ export type WrapLogOptions = {
     fnName?: string;
     logger?: Logger;
 };
-export declare function wrapLog(fn: Function, options?: WrapLogOptions): Function;
+export declare function wrapLog(fn: Function, { fnName, logger }?: WrapLogOptions): Function;

package/function/log.js

@@ -23,15 +23,21 @@ __export(log_exports, {
 module.exports = __toCommonJS(log_exports);
 var import_type_guards = require("../utils/type-guards.js");
 var import_type_of = require("../utils/type-of.js");
-function wrapLog(fn, options) {
-  const fnName = options?.fnName ?? fn.name;
-  const log = options?.logger?.trace.bind(options.logger) ?? console.log.bind(console);
+function wrapLog(fn, { fnName = fn.name, logger } = {}) {
+  const log = logger?.trace.bind(logger) ?? console.log.bind(console);
   const wrapped = {
     [fnName](...args) {
-      const argString = args.map((arg) => (0, import_type_guards.isPrimitive)(arg) ? (0, import_type_guards.isString)(arg) ? `"${arg}"` : String(arg) : (0, import_type_of.typeOf)(arg)).join(", ");
+      const argString = args.map((arg) => stringifyArg(arg)).join(", ");
       log(`[call: ${fnName}(${argString})]`);
       return Reflect.apply(fn, this, args);
     }
   };
   return wrapped[fnName];
 }
+function stringifyArg(arg, depth = 1) {
+  if ((0, import_type_guards.isArray)(arg) && depth > 0) {
+    const argString = arg.map((innerArg) => stringifyArg(innerArg, depth - 1)).join(", ");
+    return `[${argString}]`;
+  }
+  return (0, import_type_guards.isPrimitive)(arg) ? (0, import_type_guards.isString)(arg) ? `"${arg}"` : String(arg) : (0, import_type_of.typeOf)(arg);
+}

package/package.json

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

package/utils/async-iterable-helpers/metadata.d.ts

@@ -1,5 +1,3 @@
 import type { AnyIterable } from '../any-iterable-iterator.js';
 import type { IterableItemMetadata } from '../iterable-helpers/types.js';
 export declare function metadataAsync<T>(iterable: AnyIterable<T>): AsyncIterableIterator<IterableItemMetadata<T>>;
-export declare function sync<T>(iterable: Iterable<T>): AsyncIterableIterator<IterableItemMetadata<T>>;
-export declare function async<T>(iterable: AnyIterable<T>): AsyncIterableIterator<IterableItemMetadata<T>>;

package/utils/async-iterable-helpers/metadata.js

@@ -18,9 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var metadata_exports = {};
 __export(metadata_exports, {
-  async: () => async,
-  metadataAsync: () => metadataAsync,
-  sync: () => sync
+  metadataAsync: () => metadataAsync
 });
 module.exports = __toCommonJS(metadata_exports);
 var import_is_async_iterable = require("./is-async-iterable.js");

package/utils/async-iterable-helpers/skip.js

@@ -21,7 +21,7 @@ __export(skip_exports, {
   skipAsync: () => skipAsync
 });
 module.exports = __toCommonJS(skip_exports);
-var import_take_while = require("./take-while.js");
+var import_filter = require("./filter.js");
 function skipAsync(iterable, count) {
-  return (0, import_take_while.takeWhileAsync)(iterable, false, (_item, index) => index >= count);
+  return (0, import_filter.filterAsync)(iterable, (_item, index) => index >= count);
 }

package/utils/async-iterable-helpers/take.js

@@ -21,7 +21,23 @@ __export(take_exports, {
   takeAsync: () => takeAsync
 });
 module.exports = __toCommonJS(take_exports);
-async function* takeAsync(iterable, count) {
+var import_is_async_iterable = require("./is-async-iterable.js");
+function takeAsync(iterable, count) {
+  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, count) : sync(iterable, count);
+}
+async function* sync(iterable, count) {
+  if (count <= 0) {
+    return;
+  }
+  let counter = 0;
+  for (const item of iterable) {
+    yield item;
+    if (++counter >= count) {
+      break;
+    }
+  }
+}
+async function* async(iterable, count) {
   if (count <= 0) {
     return;
   }