@tstdl/base 0.83.28 → 0.84.1

package/pdf/pdf.service.d.ts

@@ -1,20 +1,15 @@
-import { BrowserService } from '../browser/browser.service.js';
+import { BrowserContextController } from '../browser/browser-context-controller.js';
+import type { BrowserControllerArgument } from '../browser/browser-controller.js';
+import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
-import type { AfterResolve, Injectable } from '../container/index.js';
-import { afterResolve, type resolveArgumentType } from '../container/index.js';
-import type { AsyncDisposable } from '../disposable/disposable.js';
-import { disposeAsync } from '../disposable/disposable.js';
-import { Logger } from '../logger/index.js';
+import type { Injectable } from '../container/index.js';
+import { resolveArgumentType } from '../container/index.js';
 import type { TemplateField } from '../templates/index.js';
 import { Template, TemplateService } from '../templates/index.js';
 export declare class PdfServiceRenderOptions extends PdfRenderOptions {
-    language?: string;
+    browserContext?: BrowserContextController;
+    locale?: string;
     waitForNetworkIdle?: boolean;
-    /**
-     * Timeout for closing render context in case something went wrong.
-     * @default 60000 (1 minute)
-     */
-    timeout?: number;
 }
 export type PdfTemplateOptions = PdfRenderOptions;
 export declare class PdfTemplate<Context extends object = any> extends Template<{
@@ -25,18 +20,17 @@ export declare class PdfTemplate<Context extends object = any> extends Template<
     options?: PdfTemplateOptions;
 }
 export type PdfServiceOptions = {
-    language?: string;
+    locale?: string;
+};
+export type PdfServiceArgument = PdfServiceOptions & {
+    browserControllerArgument: BrowserControllerArgument;
 };
-export type PdfServiceArgument = PdfServiceOptions;
-export declare class PdfService implements AsyncDisposable, AfterResolve, Injectable<PdfServiceArgument> {
+export declare class PdfService implements Injectable<PdfServiceArgument> {
     private readonly templateService;
-    private readonly logger;
-    private readonly pool;
+    private readonly browserController;
+    private readonly defaultLocale;
     readonly [resolveArgumentType]: PdfServiceArgument;
-    constructor(templateService: TemplateService, browserService: BrowserService, logger: Logger, options?: PdfServiceOptions);
-    [afterResolve](): void;
-    [disposeAsync](): Promise<void>;
-    dispose(): Promise<void>;
+    constructor(templateService: TemplateService, browserController: BrowserController, options?: PdfServiceOptions);
     /**
      * Renders HTML to pdf stream
      * @param html html to render

package/pdf/pdf.service.js

@@ -24,20 +24,16 @@ __export(pdf_service_exports, {
   pdfTemplate: () => pdfTemplate
 });
 module.exports = __toCommonJS(pdf_service_exports);
-var import_browser_service = require("../browser/browser.service.js");
+var import_browser_context_controller = require("../browser/browser-context-controller.js");
+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_core = require("../core.js");
-var import_disposable = require("../disposable/disposable.js");
-var import_logger = require("../logger/index.js");
-var import_pool = require("../pool/pool.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");
 var import_readable_stream_from_promise = require("../utils/stream/readable-stream-from-promise.js");
 var import_stream_reader = require("../utils/stream/stream-reader.js");
 var import_type_guards = require("../utils/type-guards.js");
-var import_units = require("../utils/units.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")
@@ -58,26 +54,22 @@ var __param = function(paramIndex, decorator) {
   };
 };
 class PdfServiceRenderOptions extends import_pdf_options.PdfRenderOptions {
-  language;
+  browserContext;
+  locale;
   waitForNetworkIdle;
-  /**
-   * Timeout for closing render context in case something went wrong.
-   * @default 60000 (1 minute)
-   */
-  timeout;
 }
+__decorate([
+  (0, import_schema.Optional)(),
+  __metadata("design:type", import_browser_context_controller.BrowserContextController)
+], PdfServiceRenderOptions.prototype, "browserContext", void 0);
 __decorate([
   (0, import_schema.Optional)(),
   __metadata("design:type", String)
-], PdfServiceRenderOptions.prototype, "language", void 0);
+], PdfServiceRenderOptions.prototype, "locale", void 0);
 __decorate([
   (0, import_schema.Optional)(),
   __metadata("design:type", Boolean)
 ], PdfServiceRenderOptions.prototype, "waitForNetworkIdle", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  __metadata("design:type", Number)
-], PdfServiceRenderOptions.prototype, "timeout", void 0);
 class PdfTemplate extends import_templates.Template {
 }
 __decorate([
@@ -87,21 +79,12 @@ __decorate([
 const browserArguments = ["--font-render-hinting=none", "--disable-web-security", "--disable-features=IsolateOrigins", "--disable-site-isolation-trials"];
 let PdfService = class PdfService2 {
   templateService;
-  logger;
-  pool;
-  constructor(templateService, browserService, logger, options = {}) {
+  browserController;
+  defaultLocale;
+  constructor(templateService, browserController, options = {}) {
     this.templateService = templateService;
-    this.logger = logger;
-    this.pool = new import_pool.Pool(async () => browserService.newBrowser({ headless: true, language: options.language, browserArguments }), async (controller) => controller.close(), logger);
-  }
-  [import_container.afterResolve]() {
-    import_core.disposer.add(this);
-  }
-  async [import_disposable.disposeAsync]() {
-    return this.dispose();
-  }
-  async dispose() {
-    return this.pool.dispose();
+    this.browserController = browserController;
+    this.defaultLocale = options.locale;
   }
   /**
    * Renders HTML to pdf stream
@@ -110,7 +93,7 @@ let PdfService = class PdfService2 {
    * @returns pdf stream
    */
   renderHtmlStream(html, options) {
-    return this.renderStream(async (page) => page.setContent(html, { waitUntil: options?.waitForNetworkIdle == true ? "networkidle2" : "load" }), options);
+    return this.renderStream(async (page) => page.setContent(html, { waitUntil: options?.waitForNetworkIdle == true ? "networkidle" : "load" }), options);
   }
   /**
    * Renders HTML to pdf
@@ -130,7 +113,7 @@ let PdfService = class PdfService2 {
    */
   renderUrlStream(url, options) {
     return this.renderStream(async (controller) => {
-      await controller.navigate(url, { waitUntil: options?.waitForNetworkIdle == true ? "networkidle2" : "load" });
+      await controller.navigate(url, { waitUntil: options?.waitForNetworkIdle == true ? "networkidle" : "load" });
     }, options);
   }
   /**
@@ -153,7 +136,7 @@ let PdfService = class PdfService2 {
   renderTemplateStream(keyOrTemplate, templateContext, options) {
     return this.renderStream(async (page) => {
       const { fields: { header, body, footer }, options: optionsFromTemplate } = await this.templateService.render(keyOrTemplate, templateContext);
-      await page.setContent(body, { timeout: options?.timeout, waitUntil: options?.waitForNetworkIdle == true ? "networkidle2" : "load" });
+      await page.setContent(body, { timeout: options?.timeout, waitUntil: options?.waitForNetworkIdle == true ? "networkidle" : "load" });
       return { ...optionsFromTemplate, headerTemplate: header, footerTemplate: footer };
     }, options);
   }
@@ -170,45 +153,23 @@ let PdfService = class PdfService2 {
   }
   renderStream(handler, options = {}) {
     return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const browserController = await this.pool.get();
-      let page;
-      try {
-        page = await browserController.newPage();
-      } catch (error) {
-        await this.pool.disposeInstance(browserController);
-        throw error;
-      }
-      if ((0, import_type_guards.isDefined)(options.language)) {
-        await page.setExtraHttpHeaders({ "Accept-Language": options.language });
-      }
+      const page = (0, import_type_guards.isDefined)(options.browserContext) ? await options.browserContext.newPage() : await this.browserController.newPage({ locale: options.locale ?? this.defaultLocale });
       const optionsFromHandler = await handler(page);
       const pdfStream = page.renderPdfStream({ ...optionsFromHandler, ...options });
-      const timeoutRef = setTimeout(() => void pdfStream.cancel(new Error("Pdf render timed out.")), options.timeout ?? import_units.millisecondsPerMinute);
-      const close = async () => {
-        try {
-          clearTimeout(timeoutRef);
-          await page.close();
-        } catch (error) {
-          await this.pool.disposeInstance(browserController);
-          this.logger.error(error);
-        }
-      };
+      const close = async () => page.close();
       return (0, import_finalize_stream.finalizeStream)(pdfStream, {
         beforeDone: close,
         beforeCancel: close,
-        error: async () => {
-          clearTimeout(timeoutRef);
-          await this.pool.disposeInstance(browserController);
-        }
+        error: close
       });
     });
   }
 };
 PdfService = __decorate([
   (0, import_container.singleton)(),
-  __param(2, (0, import_container.resolveArg)("PdfService")),
-  __param(3, (0, import_container.injectArg)()),
-  __metadata("design:paramtypes", [import_templates.TemplateService, import_browser_service.BrowserService, import_logger.Logger, Object])
+  __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])
 ], PdfService);
 function pdfTemplate(name, fields, options) {
   return {

package/pool/pool.d.ts

@@ -34,6 +34,7 @@ export declare class Pool<T extends object> implements AsyncDisposable {
     private disposed;
     get length(): number;
     constructor(factory: PoolInstanceFactory<T>, disposer: PoolInstanceDisposer<T>, logger: Logger, options?: PoolOptions);
+    owns(instance: T): boolean;
     get(): Promise<T>;
     release(instance: T): Promise<void>;
     /**

package/pool/pool.js

@@ -50,6 +50,9 @@ class Pool {
     this.placeholderInstances = 0;
     this.disposed = false;
   }
+  owns(instance) {
+    return this.usedInstances.includes(instance) || this.freeInstances.includes(instance);
+  }
   async get() {
     if (this.disposed) {
       throw new Error("Pool was disposed.");

package/queue/mongo/queue.js

@@ -216,7 +216,7 @@ let MongoQueue = class MongoQueue2 extends import_queue.Queue {
     return this.cancelMany(jobIds);
   }
   async *getConsumer(cancellationToken) {
-    const continueToken = import_cancellation_token.CancellationToken.fromObservable(this.messageBus.allMessages$);
+    const continueToken = import_cancellation_token.CancellationToken.from(this.messageBus.allMessages$);
     for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationToken)) {
       const job = await this.dequeue();
       if (job != void 0) {
@@ -228,7 +228,7 @@ let MongoQueue = class MongoQueue2 extends import_queue.Queue {
     continueToken.complete();
   }
   async *getBatchConsumer(size, cancellationToken) {
-    const continueToken = import_cancellation_token.CancellationToken.fromObservable(this.messageBus.allMessages$);
+    const continueToken = import_cancellation_token.CancellationToken.from(this.messageBus.allMessages$);
     for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationToken)) {
       const jobs = await this.dequeueMany(size);
       if (jobs.length > 0) {

package/types.d.ts

@@ -1,4 +1,4 @@
-import type { Except, OptionalKeysOf, UnionToIntersection } from 'type-fest';
+import type { Except, UnionToIntersection } from 'type-fest';
 export type ObjectLiteral = {};
 export type PrimitiveTypeMap = {
     'string': string;
@@ -113,7 +113,7 @@ export type OmitBy<T, V> = Omit<T, {
  */
 export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
 export type Unoptionalize<T extends object> = Simplify<OmitBy<T, undefined> & {
-    [P in OptionalKeysOf<T>]: T[P] | undefined;
+    [P in PropertiesOfType<T, undefined>]: T[P] | undefined;
 }>;
 export type SimplifiedOptionalize<T extends object> = Simplify<Optionalize<T>>;
 export type Merge<T1, T2> = SimplifyObject<Except<T1, Extract<keyof T1, keyof T2>> & T2>;

package/utils/cancellation-token.d.ts

@@ -67,7 +67,7 @@ export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribab
     /**
      * Returns an AbortSignal.
      */
-    asAbortSignal: AbortSignal;
+    asAbortSignal(): AbortSignal;
     /**
      * Create a new token and connect it to this instance.
      * @see {@link connect}
@@ -81,7 +81,6 @@ export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribab
 }
 export declare class CancellationToken implements ReadonlyCancellationToken {
     private readonly stateSubject;
-    private abortController;
     readonly state$: Observable<boolean>;
     readonly set$: Observable<void>;
     readonly unset$: Observable<void>;
@@ -90,8 +89,6 @@ export declare class CancellationToken implements ReadonlyCancellationToken {
     get $set(): Promise<void>;
     get $unset(): Promise<void>;
     get $state(): Promise<boolean>;
-    get asReadonly(): ReadonlyCancellationToken;
-    get asAbortSignal(): AbortSignal;
     /**
      * @param initialState which state to initialze this token to
      * - `false`: unset
@@ -100,23 +97,21 @@ export declare class CancellationToken implements ReadonlyCancellationToken {
      */
     constructor(initialState?: boolean);
     /**
-     * Creates a token and sets it whenever the abort signal is aborted.
-     * @param signal abort signal to listen to
-     * @param complete complete token after resolve
+     * Creates a token and sets it whenever the source signals
+     * @param source source to listen to
+     * @param complete complete token after signal
      */
-    static fromAbortSignal(signal: AbortSignal, complete?: boolean): CancellationToken;
+    static from(source: AbortSignal | PromiseLike<any> | Observable<void>, options?: {
+        complete?: boolean;
+    }): CancellationToken;
     /**
-     * Creates a token and sets it whenever the promise is resolved.
-     * @param promise promise to await
-     * @param complete complete token after resolve
-     */
-    static fromPromise(promise: PromiseLike<any>, complete?: boolean): CancellationToken;
-    /**
-     * Creates a token and connets its next, error and complete.
+     * Creates a token and connects the source to its next, error and complete.
      * @param observable observable to subscribe. Takes emitted value as state if type is boolean otherwise sets state to true.
      */
-    static fromObservable(observable: Observable<void | boolean>, config?: ConnectConfig): CancellationToken;
+    static from(source: Observable<boolean>, config?: ConnectConfig): CancellationToken;
     private static connect;
+    asAbortSignal(): AbortSignal;
+    asReadonly(): ReadonlyCancellationToken;
     createChild(config?: ConnectConfig): CancellationToken;
     connect(child: CancellationToken, config?: ConnectConfig): void;
     /**

package/utils/cancellation-token.js

@@ -27,7 +27,6 @@ var import_noop2 = require("./noop.js");
 var import_type_guards = require("./type-guards.js");
 class CancellationToken {
   stateSubject;
-  abortController;
   state$;
   set$;
   unset$;
@@ -46,20 +45,6 @@ class CancellationToken {
   get $state() {
     return (0, import_rxjs.firstValueFrom)(this.state$.pipe((0, import_rxjs.skip)(1)));
   }
-  get asReadonly() {
-    return this;
-  }
-  get asAbortSignal() {
-    if ((0, import_type_guards.isUndefined)(this.abortController)) {
-      const abortController = new AbortController();
-      this.abortController = abortController;
-      this.set$.pipe((0, import_rxjs.first)()).subscribe(() => {
-        abortController.abort();
-        this.unset$.pipe((0, import_rxjs.first)()).subscribe(() => this.abortController = void 0);
-      });
-    }
-    return this.abortController.signal;
-  }
   /**
    * @param initialState which state to initialze this token to
    * - `false`: unset
@@ -72,31 +57,9 @@ class CancellationToken {
     this.set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
     this.unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
   }
-  /**
-   * Creates a token and sets it whenever the abort signal is aborted.
-   * @param signal abort signal to listen to
-   * @param complete complete token after resolve
-   */
-  static fromAbortSignal(signal, complete = true) {
-    const signal$ = (0, import_rxjs.fromEvent)(signal, "abort", () => true);
-    return CancellationToken.fromObservable(signal$, { complete });
-  }
-  /**
-   * Creates a token and sets it whenever the promise is resolved.
-   * @param promise promise to await
-   * @param complete complete token after resolve
-   */
-  static fromPromise(promise, complete = true) {
-    const signal$ = (0, import_rxjs.from)(promise).pipe((0, import_rxjs.map)(() => true));
-    return CancellationToken.fromObservable(signal$, { complete });
-  }
-  /**
-   * Creates a token and connets its next, error and complete.
-   * @param observable observable to subscribe. Takes emitted value as state if type is boolean otherwise sets state to true.
-   */
-  static fromObservable(observable, config) {
+  static from(source, config) {
+    const source$ = source instanceof AbortSignal ? (0, import_rxjs.fromEvent)(source, "abort", () => true) : (0, import_rxjs.isObservable)(source) ? source.pipe((0, import_rxjs.map)((state) => (0, import_type_guards.isBoolean)(state) ? state : true)) : (0, import_rxjs.from)(source).pipe((0, import_rxjs.map)(() => true));
     const token = new CancellationToken();
-    const source$ = observable.pipe((0, import_rxjs.map)((state) => (0, import_type_guards.isBoolean)(state) ? state : true));
     CancellationToken.connect(source$, token, config);
     return token;
   }
@@ -113,6 +76,14 @@ class CancellationToken {
       complete: () => subscription.unsubscribe()
     });
   }
+  asAbortSignal() {
+    const abortController = new AbortController();
+    this.set$.pipe((0, import_rxjs.first)()).subscribe(() => abortController.abort());
+    return abortController.signal;
+  }
+  asReadonly() {
+    return this;
+  }
   createChild(config) {
     const child = new CancellationToken();
     this.connect(child, config);

package/utils/timing.d.ts

@@ -1,12 +1,18 @@
 import type { ReadonlyCancellationToken } from './cancellation-token.js';
+import type { ValueOrProvider } from './value-or-provider.js';
 /** timeout for specified duration */
-export declare function timeout(milliseconds?: number): Promise<void>;
+export declare function timeout(milliseconds?: number, options?: {
+    abortSignal?: AbortSignal;
+}): Promise<void>;
 /** timeout until specified time */
 export declare function timeoutUntil(timestamp: number | Date): Promise<void>;
 /** timeout for specified duration */
 export declare function cancelableTimeout(milliseconds: number, cancelToken: ReadonlyCancellationToken): Promise<boolean>;
 /** timeout until specified time */
 export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelToken: ReadonlyCancellationToken): Promise<boolean>;
+export declare function withTimeout<T>(milliseconds: number, promiseOrProvider: ValueOrProvider<Promise<T>>, options?: {
+    errorMessage?: string;
+}): Promise<T>;
 export declare function immediate(): Promise<void>;
 export declare function nextTick(): Promise<void>;
 export declare function animationFrame(): Promise<number>;

package/utils/timing.js

@@ -25,12 +25,23 @@ __export(timing_exports, {
   immediate: () => immediate,
   nextTick: () => nextTick,
   timeout: () => timeout,
-  timeoutUntil: () => timeoutUntil
+  timeoutUntil: () => timeoutUntil,
+  withTimeout: () => withTimeout
 });
 module.exports = __toCommonJS(timing_exports);
+var import_timeout_error = require("../error/timeout.error.js");
 var import_rxjs = require("rxjs");
-async function timeout(milliseconds = 0) {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+var import_throw = require("./throw.js");
+var import_value_or_provider = require("./value-or-provider.js");
+async function timeout(milliseconds = 0, options) {
+  return new Promise((resolve) => {
+    const abortListener = () => clearTimeout(timeoutRef);
+    const timeoutRef = setTimeout(() => {
+      options?.abortSignal?.removeEventListener("abort", abortListener);
+      resolve();
+    }, milliseconds);
+    options?.abortSignal?.addEventListener("abort", abortListener);
+  });
 }
 async function timeoutUntil(timestamp) {
   const left = timestamp.valueOf() - Date.now();
@@ -47,6 +58,15 @@ async function cancelableTimeoutUntil(timestamp, cancelToken) {
   const left = timestamp.valueOf() - Date.now();
   return cancelableTimeout(left, cancelToken);
 }
+async function withTimeout(milliseconds, promiseOrProvider, options) {
+  const abortController = new AbortController();
+  const promise = (0, import_value_or_provider.resolveValueOrProvider)(promiseOrProvider);
+  void promise.then(() => abortController.abort());
+  return Promise.race([
+    promise,
+    timeout(milliseconds, { abortSignal: abortController.signal }).then(() => (0, import_throw._throw)(new import_timeout_error.TimeoutError(options?.errorMessage)))
+  ]);
+}
 async function immediate() {
   return new Promise(setImmediate);
 }

package/browser/types.d.ts

@@ -1,3 +0,0 @@
-import type * as puppeteer from 'puppeteer';
-export type Browser = puppeteer.Browser;
-export type Page = puppeteer.Page;