@tstdl/base 0.83.27 → 0.83.28

package/application/application.js

@@ -24,8 +24,8 @@ module.exports = __toCommonJS(application_exports);
 var import_container = require("../container/index.js");
 var import_core = require("../core.js");
 var import_logger = require("../logger/index.js");
-var import_module = require("../module/module.js");
 var import_module_base = require("../module/module-base.js");
+var import_module = require("../module/module.js");
 var import_function_module = require("../module/modules/function.module.js");
 var import_process_shutdown = require("../process-shutdown.js");
 var import_deferred_promise = require("../promise/deferred-promise.js");

package/browser/browser-controller.d.ts

@@ -0,0 +1,26 @@
+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 * as puppeteer from 'puppeteer';
+import type { NewBrowserOptions } from './browser.service.js';
+import type { PageControllerOptions } from './page-controller.js';
+import { PageController } from './page-controller.js';
+export type BrowserControllerOptions = {
+    defaultNewPageOptions?: NewPageOptions;
+};
+export type NewPageOptions = {
+    extraHttpHeaders?: Record<string, string>;
+    controllerOptions?: PageControllerOptions;
+};
+export declare class BrowserController implements AsyncDisposable, Injectable<NewBrowserOptions> {
+    /** @deprecated should be avoided */
+    readonly browser: puppeteer.Browser;
+    readonly options: BrowserControllerOptions | undefined;
+    readonly [resolveArgumentType]: NewBrowserOptions;
+    constructor(browser: puppeteer.Browser, options?: BrowserControllerOptions);
+    [disposeAsync](): Promise<void>;
+    close(): Promise<void>;
+    newPage(options?: NewPageOptions): Promise<PageController>;
+    waitForClose(): Promise<void>;
+}

package/browser/browser-controller.js

@@ -0,0 +1,99 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __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 browser_controller_exports = {};
+__export(browser_controller_exports, {
+  BrowserController: () => BrowserController
+});
+module.exports = __toCommonJS(browser_controller_exports);
+var import_decorators = require("../container/decorators.js");
+var import_interfaces = require("../container/interfaces.js");
+var import_disposable = require("../disposable/disposable.js");
+var import_object = require("../utils/object/object.js");
+var import_type_guards = require("../utils/type-guards.js");
+var puppeteer = __toESM(require("puppeteer"), 1);
+var import_browser_service = require("./browser.service.js");
+var import_page_controller = require("./page-controller.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+let BrowserController = class BrowserController2 {
+  /** @deprecated should be avoided */
+  browser;
+  options;
+  constructor(browser, options) {
+    this.browser = browser;
+    this.options = options;
+  }
+  async [import_disposable.disposeAsync]() {
+    return this.close();
+  }
+  async close() {
+    if (this.browser.isConnected()) {
+      await this.browser.close();
+    }
+  }
+  async newPage(options) {
+    const mergedExtraHttpHeaderEntries = [...(0, import_object.objectEntries)(options?.extraHttpHeaders ?? {}), ...(0, import_object.objectEntries)(this.options?.defaultNewPageOptions?.extraHttpHeaders ?? {})];
+    const newPageOptions = {
+      controllerOptions: options?.controllerOptions ?? this.options?.defaultNewPageOptions?.controllerOptions,
+      extraHttpHeaders: mergedExtraHttpHeaderEntries.length > 0 ? (0, import_object.fromEntries)(mergedExtraHttpHeaderEntries) : void 0
+    };
+    const page = await this.browser.newPage();
+    const controller = new import_page_controller.PageController(page, newPageOptions.controllerOptions);
+    if ((0, import_type_guards.isDefined)(newPageOptions.extraHttpHeaders)) {
+      await controller.setExtraHttpHeaders(newPageOptions.extraHttpHeaders);
+    }
+    return controller;
+  }
+  async waitForClose() {
+    return new Promise((resolve) => this.browser.once("disconnected", resolve));
+  }
+};
+BrowserController = __decorate([
+  (0, import_decorators.injectable)({
+    provider: {
+      useFactory: async (argument, context) => {
+        const browserService = await context.resolveAsync(import_browser_service.BrowserService);
+        return browserService.newBrowser(argument);
+      }
+    }
+  }),
+  __metadata("design:paramtypes", [puppeteer.Browser, Object])
+], BrowserController);

package/browser/browser.service.d.ts

@@ -0,0 +1,32 @@
+import type { Injectable } from '../container/interfaces.js';
+import { afterResolve, resolveArgumentType } from '../container/interfaces.js';
+import type { AsyncDisposable } from '../disposable/disposable.js';
+import { disposeAsync } from '../disposable/disposable.js';
+import type { BrowserControllerOptions } from './browser-controller.js';
+import { BrowserController } from './browser-controller.js';
+export declare class BrowserServiceOptions {
+    defaultNewBrowserOptions?: NewBrowserOptions;
+}
+export type BrowserServiceArgument = BrowserServiceOptions;
+export type NewBrowserOptions = {
+    headless?: boolean;
+    width?: number;
+    height?: number;
+    language?: string;
+    proxy?: string;
+    /** @deprecated should be avoided */
+    browserArguments?: string[];
+    /** @deprecated should be avoided */
+    browserEnvironment?: Record<string, string | undefined>;
+    controllerOptions?: BrowserControllerOptions;
+};
+export declare class BrowserService implements AsyncDisposable, Injectable<BrowserServiceArgument> {
+    private readonly browsers;
+    readonly options: BrowserServiceOptions | undefined;
+    readonly [resolveArgumentType]: BrowserServiceArgument;
+    constructor(options?: BrowserServiceOptions);
+    [afterResolve](): void;
+    [disposeAsync](): Promise<void>;
+    newBrowser(options?: NewBrowserOptions): Promise<BrowserController>;
+    dispose(): Promise<void>;
+}

package/browser/browser.service.js

@@ -0,0 +1,110 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __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 browser_service_exports = {};
+__export(browser_service_exports, {
+  BrowserService: () => BrowserService,
+  BrowserServiceOptions: () => BrowserServiceOptions
+});
+module.exports = __toCommonJS(browser_service_exports);
+var import_decorators = require("../container/decorators.js");
+var import_interfaces = require("../container/interfaces.js");
+var import_core = require("../core.js");
+var import_disposable = require("../disposable/disposable.js");
+var import_type_guards = require("../utils/type-guards.js");
+var puppeteer = __toESM(require("puppeteer"), 1);
+var import_browser_controller = require("./browser-controller.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+class BrowserServiceOptions {
+  defaultNewBrowserOptions;
+}
+let BrowserService = class BrowserService2 {
+  browsers;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.browsers = [];
+  }
+  [import_interfaces.afterResolve]() {
+    import_core.disposer.add(this);
+  }
+  async [import_disposable.disposeAsync]() {
+    return this.dispose();
+  }
+  async newBrowser(options) {
+    const { width = 1e3, height = 1e3, browserArguments, browserEnvironment, proxy, language, headless, controllerOptions } = { ...this.options?.defaultNewBrowserOptions, ...options };
+    const args = [`--window-size=${width},${height}`, ...browserArguments ?? []];
+    const env = { ...process.env, ...browserEnvironment };
+    if ((0, import_type_guards.isDefined)(proxy)) {
+      args.push(`--proxy-server=${proxy}`);
+    }
+    if ((0, import_type_guards.isDefined)(language)) {
+      args.push(`--lang=${language}`);
+      env["LANGUAGE"] = language;
+    }
+    const browser = await puppeteer.launch({
+      headless: headless == true ? "new" : false,
+      args,
+      env,
+      defaultViewport: { width, height }
+    });
+    this.browsers.push(new WeakRef(browser));
+    return new import_browser_controller.BrowserController(browser, controllerOptions);
+  }
+  async dispose() {
+    for (const browserRef of this.browsers) {
+      const browser = browserRef.deref();
+      if ((0, import_type_guards.isDefined)(browser) && browser.isConnected()) {
+        await browser.close();
+      }
+    }
+  }
+};
+BrowserService = __decorate([
+  (0, import_decorators.singleton)(),
+  __param(0, (0, import_decorators.injectArg)()),
+  __metadata("design:paramtypes", [BrowserServiceOptions])
+], BrowserService);

package/browser/index.d.ts

@@ -0,0 +1,4 @@
+export * from './browser-controller.js';
+export * from './browser.service.js';
+export * from './page-controller.js';
+export * from './types.js';

package/browser/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_exports = {};
+module.exports = __toCommonJS(browser_exports);
+__reExport(browser_exports, require("./browser-controller.js"), module.exports);
+__reExport(browser_exports, require("./browser.service.js"), module.exports);
+__reExport(browser_exports, require("./page-controller.js"), module.exports);
+__reExport(browser_exports, require("./types.js"), module.exports);

package/browser/page-controller.d.ts

@@ -0,0 +1,56 @@
+import * as puppeteer from 'puppeteer';
+import type { AsyncDisposable } from '../disposable/disposable.js';
+import { disposeAsync } from '../disposable/disposable.js';
+import type { WritableOneOrMany } from '../types.js';
+import type { PdfRenderOptions } from './pdf-options.js';
+export type Delay = number | DelayProvider;
+export type DelayProvider = () => number;
+export type PageControllerOptions = {
+    actionDelay?: Delay;
+    typeDelay?: Delay;
+};
+export type SelectorOptions = {
+    xpath?: boolean;
+};
+export type WaitForElementOptions = {
+    timeout?: number;
+};
+export type PageLifecycleEvent = puppeteer.PuppeteerLifeCycleEvent;
+export type WaitForOptions = {
+    timeout?: number;
+    waitUntil?: WritableOneOrMany<PageLifecycleEvent>;
+};
+export declare class PageController implements AsyncDisposable {
+    /** @deprecated should be avoided */
+    readonly page: puppeteer.Page;
+    readonly options: PageControllerOptions;
+    constructor(pageOrFrame: puppeteer.Page | puppeteer.Frame, options?: PageControllerOptions);
+    [disposeAsync](): Promise<void>;
+    close(): Promise<void>;
+    setContent(html: string, options?: WaitForOptions): Promise<void>;
+    setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
+    authenticate(username: string, password: string): Promise<void>;
+    navigate(url: string, options?: WaitForOptions): Promise<void>;
+    waitForClose(): Promise<void>;
+    waitForIdle(options?: {
+        idleTime?: number;
+        timeout?: number;
+    }): Promise<void>;
+    waitForUrl(urlOrPredicate: string | ((url: string) => boolean | Promise<boolean>), options?: {
+        timeout?: number;
+    }): Promise<void>;
+    waitForFrame(selector: string, options?: SelectorOptions): Promise<PageController>;
+    waitForFrameByUrl(urlOrPredicate: string | ((frame: puppeteer.Frame) => boolean | Promise<boolean>), options?: {
+        timeout?: number;
+    }): Promise<PageController>;
+    getDeepestFrame(): PageController;
+    type(handleOrSelector: puppeteer.ElementHandle | string, text: string, options?: SelectorOptions): Promise<void>;
+    select(handleOrSelector: puppeteer.ElementHandle | string, value: string, options?: SelectorOptions): Promise<void>;
+    click(handleOrSelector: puppeteer.ElementHandle | string, options?: SelectorOptions): Promise<void>;
+    getValue(handleOrSelector: puppeteer.ElementHandle | string, options?: SelectorOptions): Promise<string>;
+    waitForElement(selector: string, options?: WaitForElementOptions & SelectorOptions): Promise<void>;
+    renderPdf(options?: PdfRenderOptions): Promise<Uint8Array>;
+    renderPdfStream(options?: PdfRenderOptions): ReadableStream<Uint8Array>;
+    private waitForElementHandle;
+    private prepareAction;
+}

package/browser/page-controller.js

@@ -0,0 +1,189 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __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 page_controller_exports = {};
+__export(page_controller_exports, {
+  PageController: () => PageController
+});
+module.exports = __toCommonJS(page_controller_exports);
+var import_node_stream = require("node:stream");
+var puppeteer = __toESM(require("puppeteer"), 1);
+var import_disposable = require("../disposable/disposable.js");
+var import_readable_stream_from_promise = require("../utils/stream/readable-stream-from-promise.js");
+var import_timing = require("../utils/timing.js");
+var import_type_guards = require("../utils/type-guards.js");
+class PageController {
+  /** @deprecated should be avoided */
+  page;
+  options;
+  constructor(pageOrFrame, options = {}) {
+    this.page = pageOrFrame instanceof puppeteer.Page ? pageOrFrame : pageOrFrame.page();
+    this.options = options;
+  }
+  async [import_disposable.disposeAsync]() {
+    return this.close();
+  }
+  async close() {
+    return this.page.close();
+  }
+  async setContent(html, options) {
+    await this.page.setContent(html, options);
+  }
+  async setExtraHttpHeaders(headers) {
+    await this.page.setExtraHTTPHeaders(headers);
+  }
+  async authenticate(username, password) {
+    await this.page.authenticate({ username, password });
+  }
+  async navigate(url, options) {
+    await this.page.goto(url, options);
+  }
+  async waitForClose() {
+    return new Promise((resolve) => this.page.once("close", resolve));
+  }
+  async waitForIdle(options) {
+    await this.page.waitForNetworkIdle(options);
+  }
+  async waitForUrl(urlOrPredicate, options) {
+    const pageFrame = this.page.mainFrame();
+    await this.page.waitForFrame(async (frame) => {
+      if (frame != pageFrame) {
+        return false;
+      }
+      if ((0, import_type_guards.isString)(urlOrPredicate)) {
+        return frame.url().includes(urlOrPredicate);
+      }
+      return urlOrPredicate(frame.url());
+    }, { timeout: options?.timeout });
+  }
+  async waitForFrame(selector, options) {
+    const frame = await this.waitForElementHandle(selector, options);
+    return new PageController(frame.frame.page());
+  }
+  async waitForFrameByUrl(urlOrPredicate, options) {
+    const frame = await this.page.waitForFrame(urlOrPredicate, options);
+    return new PageController(frame.page());
+  }
+  getDeepestFrame() {
+    let frame = this.page.mainFrame();
+    while (true) {
+      const children = frame.childFrames();
+      if (children.length > 1) {
+        throw new Error("Multiple frames found. Only works with single frame.");
+      }
+      if (children.length == 0) {
+        break;
+      }
+      frame = children[0];
+    }
+    return new PageController(frame);
+  }
+  async type(handleOrSelector, text, options) {
+    await this.prepareAction();
+    const handle = (0, import_type_guards.isString)(handleOrSelector) ? await this.waitForElementHandle(handleOrSelector, options) : handleOrSelector;
+    await handle.evaluate((element) => element.select());
+    if ((0, import_type_guards.isUndefined)(this.options.typeDelay)) {
+      await handle.type(text);
+    } else {
+      for (const char of text) {
+        await handle.type(char);
+        await delay(this.options.typeDelay);
+      }
+    }
+  }
+  async select(handleOrSelector, value, options) {
+    await this.prepareAction();
+    const handle = (0, import_type_guards.isString)(handleOrSelector) ? await this.waitForElementHandle(handleOrSelector, options) : handleOrSelector;
+    await handle.select(value);
+  }
+  async click(handleOrSelector, options) {
+    await this.prepareAction();
+    const handle = (0, import_type_guards.isString)(handleOrSelector) ? await this.waitForElementHandle(handleOrSelector, options) : handleOrSelector;
+    await handle.click();
+  }
+  async getValue(handleOrSelector, options) {
+    const handle = (0, import_type_guards.isString)(handleOrSelector) ? await this.waitForElementHandle(handleOrSelector, options) : handleOrSelector;
+    return handle.evaluate((element) => element.value);
+  }
+  async waitForElement(selector, options) {
+    await this.waitForElementHandle(selector, options);
+  }
+  async renderPdf(options = {}) {
+    const createPdfOptions = convertPdfOptions(options);
+    return this.page.pdf(createPdfOptions);
+  }
+  renderPdfStream(options = {}) {
+    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
+      const createPdfOptions = convertPdfOptions(options);
+      const pdfStream = await this.page.createPDFStream(createPdfOptions);
+      return import_node_stream.Readable.toWeb(pdfStream);
+    });
+  }
+  async waitForElementHandle(selector, { timeout: waitTimeout = 5e3, xpath = false } = {}) {
+    const handle = xpath ? await this.page.waitForXPath(selector, { timeout: waitTimeout }) : await this.page.waitForSelector(selector, { timeout: waitTimeout });
+    if ((0, import_type_guards.isNull)(handle)) {
+      throw new Error("Element not found");
+    }
+    return handle;
+  }
+  async prepareAction() {
+    await delay(this.options.actionDelay);
+    await this.waitForIdle();
+  }
+}
+async function delay(milliseconds) {
+  if ((0, import_type_guards.isUndefined)(milliseconds)) {
+    return;
+  }
+  if ((0, import_type_guards.isNumber)(milliseconds)) {
+    await (0, import_timing.timeout)(milliseconds);
+  } else {
+    await (0, import_timing.timeout)(milliseconds());
+  }
+}
+function convertPdfOptions(options) {
+  const margin = (0, import_type_guards.isUndefined)(options.margin) ? void 0 : (0, import_type_guards.isObject)(options.margin) ? options.margin : {
+    top: options.margin,
+    bottom: options.margin,
+    right: options.margin,
+    left: options.margin
+  };
+  return {
+    format: options.format ?? "a4",
+    scale: options.scale,
+    landscape: options.landscape,
+    width: options.width,
+    height: options.height,
+    omitBackground: options.omitDefaultBackground,
+    printBackground: options.renderBackground,
+    margin,
+    displayHeaderFooter: options.displayHeaderFooter ?? ((0, import_type_guards.isDefined)(options.headerTemplate) || (0, import_type_guards.isDefined)(options.footerTemplate)),
+    headerTemplate: options.headerTemplate,
+    footerTemplate: options.footerTemplate
+  };
+}

package/browser/pdf-options.d.ts

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