@tstdl/base 0.92.167 → 0.92.168

package/application/application.d.ts

@@ -1,30 +1,24 @@
-import type { CancellationSignal } from '../cancellation/token.js';
+import { CancellationSignal } from '../cancellation/token.js';
+import { type ProvidersItem } from '../injector/injector.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import type { LoggerArgument } from '../logger/index.js';
-import type { Module } from '../module/module.js';
-import type { FunctionModuleFunction } from '../module/modules/function.module.js';
+import { Module } from '../module/index.js';
 import type { OneOrMany, Type } from '../types/index.js';
-export type BootstrapFn = () => void | Promise<void>;
-export type RunOptions = {
-    bootstrap?: OneOrMany<BootstrapFn>;
-};
+export type InitializerFn = () => void | Promise<void>;
+export type DestructorFn = () => void | Promise<void>;
+export declare const APPLICATION_MODULE: import("../injector/token.js").InjectionToken<Module, never>;
+export declare const APPLICATION_INITIALIZER: import("../injector/token.js").InjectionToken<InitializerFn, never>;
+export declare const APPLICATION_DESTRUCTOR: import("../injector/token.js").InjectionToken<DestructorFn, never>;
 export type ApplicationArgument = LoggerArgument;
 export declare class Application implements Resolvable<ApplicationArgument> {
     #private;
-    static _instance: Application | undefined;
-    private static get instance();
     readonly [resolveArgumentType]: string;
+    static create(name: string, providers?: OneOrMany<ProvidersItem>[]): Application;
+    static run(name: string, providers?: OneOrMany<ProvidersItem>[]): Application;
     get shutdownSignal(): CancellationSignal;
-    static get shutdownSignal(): CancellationSignal;
-    static registerModule(moduleType: Type<Module>): void;
-    static registerModuleFunction(fn: FunctionModuleFunction): void;
-    static run(...functionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;
-    static waitForShutdown(): Promise<void>;
-    static shutdown(): Promise<void>;
-    static requestShutdown(): void;
     registerModule(moduleType: Module | Type<Module>): void;
-    registerModuleFunction(fn: FunctionModuleFunction): void;
-    run(...optionsFunctionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;
+    run(): void;
+    runAndWait(): Promise<void>;
     shutdown(): Promise<void>;
     requestShutdown(): void;
     waitForShutdown(): Promise<void>;

package/application/application.js

@@ -5,75 +5,54 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 var Application_1;
-import { getGlobalInjector } from '../core.js';
+import { CancellationSignal, CancellationToken } from '../cancellation/token.js';
 import { Singleton } from '../injector/decorators.js';
-import { inject, injectArgument, runInInjectionContext } from '../injector/inject.js';
+import { inject, injectAll, injectArgument, runInInjectionContext } from '../injector/inject.js';
 import { Injector } from '../injector/injector.js';
+import { injectionToken } from '../injector/token.js';
 import { Logger } from '../logger/index.js';
-import { ModuleBase } from '../module/module-base.js';
-import { ModuleState } from '../module/module.js';
-import { FunctionModule } from '../module/modules/function.module.js';
-import { getShutdownSignal, getShutdownToken } from '../process-shutdown.js';
+import { Module, ModuleState } from '../module/index.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
-import { toArray } from '../utils/array/array.js';
 import { mapAsync } from '../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
-import { isDefined, isFunction, isObject, isUndefined } from '../utils/type-guards.js';
-let Application = class Application {
-    static { Application_1 = this; }
-    static _instance;
-    static get instance() {
-        if (isUndefined(this._instance)) {
-            this._instance = getGlobalInjector().resolve(Application_1, 'App');
-            // @ts-expect-error readonly
-            this._instance.#shutdownToken = getShutdownToken();
-        }
-        return this._instance;
-    }
+import { isDefined, isFunction } from '../utils/type-guards.js';
+export const APPLICATION_MODULE = injectionToken('ApplicationModule');
+export const APPLICATION_INITIALIZER = injectionToken('ApplicationInitializer');
+export const APPLICATION_DESTRUCTOR = injectionToken('ApplicationDestructor');
+let Application = Application_1 = class Application {
     #name = injectArgument(this);
-    #injector = inject(Injector).fork(`${this.#name}Injector`);
-    #logger = this.#injector.resolve(Logger, this.#name);
-    #moduleTypesAndInstances = new Set();
+    #injector = inject(Injector);
+    #logger = inject(Logger, this.#name);
+    #moduleTypesAndInstances = new Set(injectAll(APPLICATION_MODULE, undefined, { optional: true }));
     #shutdownPromise = new DeferredPromise();
-    #shutdownToken = getShutdownSignal().createChild();
-    get shutdownSignal() {
-        return this.#shutdownToken.signal;
-    }
-    static get shutdownSignal() {
-        return Application_1.instance.shutdownSignal;
-    }
-    static registerModule(moduleType) {
-        Application_1.instance.registerModule(moduleType);
-    }
-    static registerModuleFunction(fn) {
-        Application_1.instance.registerModuleFunction(fn);
-    }
-    static run(...functionsAndModules) {
-        Application_1.instance.run(...functionsAndModules);
-    }
-    static async waitForShutdown() {
-        return Application_1.instance.waitForShutdown();
+    #shutdownToken = inject(CancellationSignal, undefined, { optional: true })?.createChild() ?? new CancellationToken();
+    static create(name, providers = []) {
+        const injector = new Injector(`${name}Injector`);
+        for (const providersItem of providers.flat()) {
+            injector.register(providersItem.provide, providersItem, { multi: providersItem.multi });
+        }
+        return injector.resolve(Application_1, name);
     }
-    static async shutdown() {
-        await Application_1.instance.shutdown();
+    static run(name, providers = []) {
+        const app = Application_1.create(name, providers);
+        app.run();
+        return app;
     }
-    static requestShutdown() {
-        Application_1.instance.requestShutdown();
+    get shutdownSignal() {
+        return this.#shutdownToken.signal;
     }
     registerModule(moduleType) {
         this.#moduleTypesAndInstances.add(moduleType);
     }
-    registerModuleFunction(fn) {
-        const module = new FunctionModule(fn);
-        this.registerModule(module);
-    }
-    run(...optionsFunctionsAndModules) {
+    run() {
         if (this.#shutdownToken.isSet) {
             throw new Error('Application was shut down.');
         }
-        const options = ((optionsFunctionsAndModules.length > 0) && isObject(optionsFunctionsAndModules[0])) ? optionsFunctionsAndModules[0] : undefined;
-        const functionsAndModules = (isUndefined(options) ? optionsFunctionsAndModules : optionsFunctionsAndModules.slice(1));
-        void this._run(functionsAndModules, options);
+        void this._run();
+    }
+    async runAndWait() {
+        this.run();
+        await this.waitForShutdown();
     }
     async shutdown() {
         this.requestShutdown();
@@ -86,28 +65,19 @@ let Application = class Application {
         this.#shutdownToken.set();
     }
     async waitForShutdown() {
-        return this.#shutdownPromise;
+        await this.#shutdownPromise;
     }
-    async _run(functionsAndModules, options = {}) {
+    async _run() {
         let modules;
         try {
-            for (const fnOrModule of functionsAndModules.flatMap((fns) => fns)) {
-                if (fnOrModule.prototype instanceof ModuleBase) {
-                    this.registerModule(fnOrModule);
-                }
-                else {
-                    this.registerModuleFunction(fnOrModule);
-                }
+            const initializers = await this.#injector.resolveAllAsync(APPLICATION_INITIALIZER, undefined, { optional: true });
+            for (const initializer of initializers) {
+                await runInInjectionContext(this.#injector, initializer);
             }
-            if (isDefined(options.bootstrap)) {
-                for (const fn of toArray(options.bootstrap)) {
-                    await runInInjectionContext(this.#injector, fn);
-                }
-            }
-            modules = await toArrayAsync(mapAsync(this.#moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? this.#injector.resolveAsync(instanceOrType) : instanceOrType)));
+            modules = await toArrayAsync(mapAsync(this.#moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? await this.#injector.resolveAsync(instanceOrType) : instanceOrType)));
             await Promise.race([
                 this.runModules(modules),
-                this.shutdownSignal
+                this.shutdownSignal,
             ]);
         }
         catch (error) {
@@ -119,6 +89,15 @@ let Application = class Application {
             if (isDefined(modules)) {
                 await this.stopModules(modules);
             }
+            const destructors = await this.#injector.resolveAllAsync(APPLICATION_DESTRUCTOR, undefined, { optional: true });
+            for (const destructor of destructors) {
+                try {
+                    await runInInjectionContext(this.#injector, destructor);
+                }
+                catch (error) {
+                    this.#logger.error(error, { message: 'An error occurred during application destruction.' });
+                }
+            }
             await this.#injector.dispose();
             this.#logger.info('Bye');
         }
@@ -128,7 +107,7 @@ let Application = class Application {
         const promises = modules.map(async (module) => {
             try {
                 this.#logger.info(`Starting module ${module.name}`);
-                await runInInjectionContext(this.#injector, async () => module.run());
+                await runInInjectionContext(this.#injector, async () => await module.run());
                 this.#logger.info(`Module ${module.name} stopped.`);
             }
             catch (error) {

package/application/index.d.ts

@@ -1,6 +1,2 @@
-/**
- * Start application modules and shutting down the app
- *
- * @module Application
- */
 export * from './application.js';
+export * from './providers.js';

package/application/index.js

@@ -1,6 +1,2 @@
-/**
- * Start application modules and shutting down the app
- *
- * @module Application
- */
 export * from './application.js';
+export * from './providers.js';

package/application/providers.d.ts

@@ -0,0 +1,10 @@
+import { CancellationSignal } from '../cancellation/index.js';
+import { type ProvidersItem } from '../injector/index.js';
+import { Module, type FunctionModuleFunction } from '../module/index.js';
+import type { OneOrMany, Type } from '../types/index.js';
+import { type DestructorFn, type InitializerFn } from './application.js';
+export declare function provideModules(...functionsAndModules: OneOrMany<FunctionModuleFunction | Type<Module>>[]): ProvidersItem[];
+export declare function provideInitializer(fn: InitializerFn): ProvidersItem;
+export declare function provideDestructor(fn: DestructorFn): ProvidersItem;
+export declare function provideShutdownSignal(signal: CancellationSignal): ProvidersItem;
+export declare function provideSignalHandler(): ProvidersItem;

package/application/providers.js

@@ -0,0 +1,54 @@
+import { CancellationSignal } from '../cancellation/index.js';
+import { inject } from '../injector/index.js';
+import { Logger } from '../logger/index.js';
+import { FunctionModule, Module } from '../module/index.js';
+import { isFunction } from '../utils/type-guards.js';
+import { typeExtends } from '../utils/type/index.js';
+import { Application, APPLICATION_DESTRUCTOR, APPLICATION_INITIALIZER, APPLICATION_MODULE } from './application.js';
+const quitSignals = ['SIGTERM', 'SIGINT', 'SIGHUP', 'SIGBREAK'];
+const quitEvents = ['uncaughtException', 'unhandledRejection', 'rejectionHandled'];
+export function provideModules(...functionsAndModules) {
+    return functionsAndModules.flat().map((fnOrModule) => {
+        if (typeExtends(fnOrModule, Module)) {
+            return { provide: APPLICATION_MODULE, useValue: fnOrModule, multi: true };
+        }
+        else if (isFunction(fnOrModule)) {
+            return { provide: APPLICATION_MODULE, useToken: FunctionModule, defaultArgument: fnOrModule, multi: true };
+        }
+        else {
+            throw new TypeError('Invalid module or function provided to provideModules');
+        }
+    });
+}
+export function provideInitializer(fn) {
+    return { provide: APPLICATION_INITIALIZER, useValue: fn, multi: true };
+}
+export function provideDestructor(fn) {
+    return { provide: APPLICATION_DESTRUCTOR, useValue: fn, multi: true };
+}
+export function provideShutdownSignal(signal) {
+    return { provide: CancellationSignal, useValue: signal };
+}
+export function provideSignalHandler() {
+    let signalCounter = 0;
+    return provideInitializer(() => {
+        const application = inject(Application);
+        const logger = inject(Logger);
+        for (const event of quitEvents) {
+            process.on(event, (...args) => {
+                logger.error(`QuitEvent occurred: ${event}`, { details: args });
+                application.requestShutdown();
+            });
+        }
+        for (const quitSignal of quitSignals) {
+            process.on(quitSignal, (signal) => {
+                logger.info(`${signal} received, quitting.`);
+                application.requestShutdown();
+                if (++signalCounter > 1) {
+                    logger.warn('Forcefully quitting due to multiple signals...');
+                    setTimeout(() => process.exit(1), 1);
+                }
+            });
+        }
+    });
+}

package/authentication/client/authentication.service.d.ts

@@ -1,5 +1,3 @@
-import type { AsyncDisposable } from '../../disposable/index.js';
-import { disposeAsync } from '../../disposable/index.js';
 import type { AfterResolve } from '../../injector/index.js';
 import { afterResolve } from '../../injector/index.js';
 import type { Record } from '../../types/index.js';
@@ -95,7 +93,7 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
      */
     initialize(): void;
     /** @internal */
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
     /**
      * Disposes the service.
      * Stops refresh loop and completes subjects.

package/authentication/client/authentication.service.js

@@ -9,7 +9,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Subject, filter, firstValueFrom, race, timer } from 'rxjs';
 import { CancellationToken } from '../../cancellation/token.js';
-import { disposeAsync } from '../../disposable/index.js';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { ForbiddenError } from '../../errors/forbidden.error.js';
 import { InvalidTokenError } from '../../errors/invalid-token.error.js';
@@ -162,7 +161,7 @@ let AuthenticationClientService = class AuthenticationClientService {
         void this.refreshLoop();
     }
     /** @internal */
-    async [disposeAsync]() {
+    async [Symbol.asyncDispose]() {
         await this.dispose();
     }
     /**
@@ -254,7 +253,7 @@ let AuthenticationClientService = class AuthenticationClientService {
         if (this.impersonated()) {
             throw new Error('Already impersonating. Please unimpersonate first.');
         }
-        await this.lock.use(lockTimeout, true, async () => {
+        await this.lock.use(lockTimeout, async () => {
             this.impersonatorAuthenticationData = this.authenticationData;
             this.authenticationData = data;
             try {
@@ -275,7 +274,7 @@ let AuthenticationClientService = class AuthenticationClientService {
      * @param data Additional authentication data. If not provided, the data from before impersonation is used.
      */
     async unimpersonate(data) {
-        await this.lock.use(lockTimeout, true, async () => {
+        await this.lock.use(lockTimeout, async () => {
             const newData = data ?? this.impersonatorAuthenticationData;
             try {
                 const token = await this.client.unimpersonate({ data: newData });
@@ -334,7 +333,7 @@ let AuthenticationClientService = class AuthenticationClientService {
         while (this.disposeToken.isUnset) {
             try {
                 // Use a non-blocking lock to ensure only one tab/instance runs the refresh logic at a time.
-                await this.lock.use(0, false, async () => await this.refreshLoopIteration());
+                await this.lock.tryUse(undefined, async () => await this.refreshLoopIteration());
                 // Calculate delay until the next refresh check.
                 // The buffer ensures we refresh *before* the token actually expires.
                 const delay = ((this.token()?.exp ?? 0) - this.estimatedServerTimestampSeconds() - refreshBufferSeconds) * millisecondsPerSecond;

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

@@ -1,6 +1,4 @@
 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 { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
 import type { Logger } from '../logger/logger.js';
@@ -20,14 +18,14 @@ export type BrowserContextState = Tagged<Record<string | number, unknown>, 'Brow
 export type BrowserContextControllerArgument = NewBrowserContextOptions;
 export declare class BrowserContextController implements AsyncDisposable, Resolvable<BrowserContextControllerArgument> {
     #private;
-    /** @deprecated should be avoided */
+    /** @deprecated direct usage of underlying page object should be avoided */
     readonly context: BrowserContext;
     readonly options: BrowserContextControllerOptions;
     readonly [resolveArgumentType]: BrowserContextControllerArgument;
     constructor(context: BrowserContext, options?: BrowserContextControllerOptions);
     [afterResolve](): void;
     initialize(): void;
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
     pages(): PageController[];
     /**
      * Get a controller for the page.

package/browser/browser-context-controller.js

@@ -7,7 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { disposeAsync } from '../disposable/disposable.js';
 import { Injectable } from '../injector/decorators.js';
 import { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
 import { filterUndefinedFromRecord } from '../utils/object/object.js';
@@ -17,7 +16,7 @@ import { PageController } from './page-controller.js';
 import { attachLogger } from './utils.js';
 let BrowserContextController = class BrowserContextController {
     #pageControllers = new WeakMap();
-    /** @deprecated should be avoided */
+    /** @deprecated direct usage of underlying page object should be avoided */
     context;
     options;
     constructor(context, options = {}) {
@@ -32,7 +31,7 @@ let BrowserContextController = class BrowserContextController {
             page.once('close', () => this.#pageControllers.delete(page));
         });
     }
-    async [disposeAsync]() {
+    async [Symbol.asyncDispose]() {
         await this.close();
     }
     pages() {
@@ -91,7 +90,7 @@ let BrowserContextController = class BrowserContextController {
         }
     }
     async waitForClose() {
-        return new Promise((resolve) => this.context.once('close', () => resolve()));
+        await new Promise((resolve) => this.context.once('close', () => resolve()));
     }
     attachLogger(logger) {
         attachLogger(this.context, logger);
@@ -108,8 +107,8 @@ BrowserContextController = __decorate([
                 const { context: browserContext, controllerOptions } = await browserController.newRawContext(argument);
                 value.context = browserContext;
                 value.options = controllerOptions;
-            }
-        }
+            },
+        },
     }),
     __metadata("design:paramtypes", [Object, Object])
 ], BrowserContextController);

package/browser/browser-controller.d.ts

@@ -1,6 +1,4 @@
 import type { Browser, BrowserContext } from 'playwright';
-import type { AsyncDisposable } from '../disposable/disposable.js';
-import { disposeAsync } from '../disposable/disposable.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import type { Record } from '../types/index.js';
 import type { BrowserContextControllerOptions, BrowserContextState, NewPageOptions } from './browser-context-controller.js';
@@ -29,12 +27,12 @@ export type NewBrowserContextOptions = {
 };
 export type BrowserControllerArgument = NewBrowserOptions;
 export declare class BrowserController implements AsyncDisposable, Resolvable<BrowserControllerArgument> {
-    /** @deprecated should be avoided */
+    /** @deprecated direct usage of underlying browser object should be avoided */
     readonly browser: Browser;
     readonly options: BrowserControllerOptions | undefined;
     readonly [resolveArgumentType]: BrowserControllerArgument;
     constructor(browser: Browser, options?: BrowserControllerOptions);
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
     /**
      * @deprecated for internal use
      */

package/browser/browser-controller.js

@@ -7,7 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { disposeAsync } from '../disposable/disposable.js';
 import { Injectable } from '../injector/decorators.js';
 import { inject } from '../injector/inject.js';
 import { filterUndefinedFromRecord } from '../utils/object/object.js';
@@ -16,14 +15,14 @@ import { BrowserContextController } from './browser-context-controller.js';
 import { BrowserService } from './browser.service.js';
 import { mergeNewBrowserContextOptions } from './utils.js';
 let BrowserController = class BrowserController {
-    /** @deprecated should be avoided */
+    /** @deprecated direct usage of underlying browser object should be avoided */
     browser;
     options;
     constructor(browser, options) {
         this.browser = browser;
         this.options = options;
     }
-    async [disposeAsync]() {
+    async [Symbol.asyncDispose]() {
         await this.close();
     }
     /**
@@ -64,7 +63,7 @@ let BrowserController = class BrowserController {
         }
     }
     async waitForClose() {
-        return await new Promise((resolve) => {
+        await new Promise((resolve) => {
             if (!this.browser.isConnected()) {
                 resolve();
             }

package/browser/browser.service.d.ts

@@ -1,6 +1,4 @@
 import type { Browser, LaunchOptions } from 'playwright';
-import type { AsyncDisposable } from '../disposable/disposable.js';
-import { disposeAsync } from '../disposable/disposable.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import { BrowserContextController } from './browser-context-controller.js';
 import type { BrowserControllerOptions, NewBrowserContextOptions } from './browser-controller.js';
@@ -26,7 +24,7 @@ export declare class BrowserService implements AsyncDisposable, Resolvable<Brows
     private readonly persistentBrowserContexts;
     readonly options: BrowserServiceOptions | undefined;
     readonly [resolveArgumentType]: BrowserServiceArgument;
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
     /**
      * @deprecated internal use only
      */

package/browser/browser.service.js

@@ -4,7 +4,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
 };
-import { disposeAsync } from '../disposable/disposable.js';
 import { Singleton } from '../injector/decorators.js';
 import { injectArgument } from '../injector/inject.js';
 import { filterUndefinedFromRecord } from '../utils/object/object.js';
@@ -20,7 +19,7 @@ let BrowserService = class BrowserService {
     browsers = new Set();
     persistentBrowserContexts = new Set();
     options = injectArgument(this, { optional: true });
-    async [disposeAsync]() {
+    async [Symbol.asyncDispose]() {
         await this.dispose();
     }
     /**

package/browser/page-controller.d.ts

@@ -1,6 +1,4 @@
 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';
@@ -15,11 +13,11 @@ export type ScrollToCoordinates = {
     y?: number;
 };
 export declare class PageController extends DocumentController<Page> implements AsyncDisposable {
-    /** @deprecated should be avoided */
+    /** @deprecated direct usage of underlying page object should be avoided */
     readonly page: Page;
     readonly options: PageControllerOptions;
     constructor(page: Page, context: BrowserContextController, options?: PageControllerOptions);
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
     close(): Promise<void>;
     /** finds pages opened by this page (having opener set to this page) */
     opened(): Promise<PageController[]>;

package/browser/page-controller.js

@@ -1,4 +1,3 @@
-import { disposeAsync } from '../disposable/disposable.js';
 import { filterUndefinedFromRecord } from '../utils/object/object.js';
 import { readableStreamFromPromise } from '../utils/stream/from-promise.js';
 import { toReadableStream } from '../utils/stream/to-readable-stream.js';
@@ -9,7 +8,7 @@ import { DocumentController } from './document-controller.js';
 import { ElementController } from './element-controller.js';
 import { attachLogger, delay } from './utils.js';
 export class PageController extends DocumentController {
-    /** @deprecated should be avoided */
+    /** @deprecated direct usage of underlying page object should be avoided */
     page;
     options;
     constructor(page, context, options = {}) {
@@ -17,7 +16,7 @@ export class PageController extends DocumentController {
         this.page = page;
         this.options = options;
     }
-    async [disposeAsync]() {
+    async [Symbol.asyncDispose]() {
         await this.close();
     }
     async close() {
@@ -45,7 +44,7 @@ export class PageController extends DocumentController {
         await this.page.setExtraHTTPHeaders(filtered);
     }
     async waitForClose() {
-        return new Promise((resolve) => {
+        await new Promise((resolve) => {
             if (this.page.isClosed()) {
                 resolve();
                 return;
@@ -69,7 +68,7 @@ export class PageController extends DocumentController {
     }
     async renderPdf(options = {}) {
         const createPdfOptions = convertPdfOptions(options);
-        return withTimeout(options.timeout ?? 30 * millisecondsPerSecond, this.page.pdf(createPdfOptions), { errorMessage: 'Rendering pdf timed out.' });
+        return await withTimeout(options.timeout ?? 30 * millisecondsPerSecond, this.page.pdf(createPdfOptions), { errorMessage: 'Rendering pdf timed out.' });
     }
     async scroll(deltaX, deltaY) {
         await this.page.mouse.wheel(deltaX, deltaY);
@@ -87,7 +86,7 @@ export class PageController extends DocumentController {
         const offsetY = viewportSize.height / 10;
         const isElement = coordinatesOrController instanceof ElementController;
         while (true) {
-            const { scrollWidth, scrollHeight, scrollLeft, scrollTop, clientWidth, clientHeight } = await this.page.evaluate(async () => {
+            const { scrollWidth, scrollHeight, scrollLeft, scrollTop, clientWidth, clientHeight } = await this.page.evaluate(() => {
                 const { scrollWidth, scrollHeight, scrollLeft, scrollTop, clientWidth, clientHeight } = document.documentElement;
                 return { scrollWidth, scrollHeight, scrollLeft, scrollTop, clientWidth, clientHeight };
             });
@@ -139,7 +138,7 @@ function convertPdfOptions(options) {
                 top: options.margin,
                 bottom: options.margin,
                 right: options.margin,
-                left: options.margin
+                left: options.margin,
             };
     return {
         format: options.format ?? 'a4',
@@ -151,6 +150,6 @@ function convertPdfOptions(options) {
         margin,
         displayHeaderFooter: options.displayHeaderFooter ?? (isDefined(options.headerTemplate) || isDefined(options.footerTemplate)),
         headerTemplate: options.headerTemplate,
-        footerTemplate: options.footerTemplate
+        footerTemplate: options.footerTemplate,
     };
 }

package/browser/utils.js

@@ -13,7 +13,7 @@ export function getLaunchOptions(options) {
         ignoreDefaultArgs: (options.headless == 'new') ? ['--headless'] : undefined,
         headless: headless != false,
         args,
-        proxy: options.proxy
+        proxy: options.proxy,
     };
 }
 export function mergeNewBrowserContextOptions(a, b, c) {
@@ -22,13 +22,13 @@ export function mergeNewBrowserContextOptions(a, b, c) {
         ...a,
         ...b,
         ...c,
-        extraHttpHeaders: (objectKeys(mergedExtraHttpHeaders).length > 0) ? mergedExtraHttpHeaders : undefined
+        extraHttpHeaders: (objectKeys(mergedExtraHttpHeaders).length > 0) ? mergedExtraHttpHeaders : undefined,
     };
 }
 function getPageLogger(page, baseLogger) {
     let pageLogger = pageLoggerMap.get(page);
     if (isUndefined(pageLogger)) {
-        pageLogger = baseLogger.subModule(crypto.randomUUID().slice(-12));
+        pageLogger = baseLogger.with({ pageSession: crypto.randomUUID().slice(-12) });
         pageLoggerMap.set(page, pageLogger);
     }
     return pageLogger;