dragonfly_chrome_headless 0.2.0

data/node_modules/html-pdf-chrome/src/ChromePrintOptions.ts

@@ -0,0 +1,99 @@
+'use strict';
+
+/**
+ * Chrome Page.printToPDF options.
+ * Note: these require Chrome >= 60.
+ *
+ * @export
+ * @interface ChromePrintOptions
+ */
+export interface ChromePrintOptions {
+  /**
+   * Paper orientation. Defaults to false.
+   *
+   * @type {boolean}
+   * @memberof ChromePrintOptions
+   */
+  landscape?: boolean;
+
+  /**
+   * Display header and footer. Defaults to false.
+   *
+   * @type {boolean}
+   * @memberof ChromePrintOptions
+   */
+  displayHeaderFooter?: boolean;
+
+  /**
+   * Print background graphics. Defaults to false.
+   *
+   * @type {boolean}
+   * @memberof ChromePrintOptions
+   */
+  printBackground?: boolean;
+
+  /**
+   * Scale of the webpage rendering. Defaults to 1.
+   *
+   * @type {number}
+   * @memberof ChromePrintOptions
+   */
+  scale?: number;
+
+  /**
+   * Paper width in inches. Defaults to 8.5 inches.
+   *
+   * @type {number}
+   * @memberof ChromePrintOptions
+   */
+  paperWidth?: number;
+
+  /**
+   * Paper height in inches. Defaults to 11 inches.
+   *
+   * @type {number}
+   * @memberof ChromePrintOptions
+   */
+  paperHeight?: number;
+
+  /**
+   * Top margin in inches. Defaults to 1cm (~0.4 inches).
+   *
+   * @type {number}
+   * @memberof ChromePrintOptions
+   */
+  marginTop?: number;
+
+  /**
+   * Bottom margin in inches. Defaults to 1cm (~0.4 inches).
+   *
+   * @type {number}
+   * @memberof ChromePrintOptions
+   */
+  marginBottom?: number;
+
+  /**
+   * Left margin in inches. Defaults to 1cm (~0.4 inches).
+   *
+   * @type {number}
+   * @memberof ChromePrintOptions
+   */
+  marginLeft?: number;
+
+  /**
+   * Right margin in inches. Defaults to 1cm (~0.4 inches).
+   *
+   * @type {number}
+   * @memberof ChromePrintOptions
+   */
+  marginRight?: number;
+
+  /**
+   * Paper ranges to print, e.g., '1-5, 8, 11-13'.
+   * Defaults to the empty string, which means print all pages.
+   *
+   * @type {string}
+   * @memberof ChromePrintOptions
+   */
+  pageRanges?: string;
+}

data/node_modules/html-pdf-chrome/src/CompletionTrigger.ts

@@ -0,0 +1,201 @@
+'use strict';
+
+/**
+ * Defines a trigger that signifies page render completion.
+ *
+ * @export
+ * @abstract
+ * @class CompletionTrigger
+ */
+export abstract class CompletionTrigger {
+
+  /**
+   * Creates an instance of CompletionTrigger.
+   * @param {number} [timeout=1000] milliseconds until timing out.
+   * @param {string} [timeoutMessage='CompletionTrigger timed out.'] The timeout message.
+   * @memberof CompletionTrigger
+   */
+  constructor(
+    protected timeout = 1000,
+    protected timeoutMessage = 'CompletionTrigger timed out.',
+  ) {}
+
+  /**
+   * Abstracts away the trigger logic.
+   *
+   * @abstract
+   * @param {*} client the Chrome connection information.
+   * @returns {Promise<any>} resolves if triggered, rejects on error or timeout.
+   * @memberof CompletionTrigger
+   */
+  public abstract async wait(client: any): Promise<any>;
+}
+
+/**
+ * Waits for a specified amount of time.
+ *
+ * @export
+ * @class Timer
+ * @extends {CompletionTrigger}
+ */
+export class Timer extends CompletionTrigger {
+
+  /**
+   * Creates an instance of the Timer CompletionTrigger.
+   * @param {number} timeout ms to wait until timing out.
+   * @memberof Timer
+   */
+  constructor(timeout: number) {
+    super(timeout);
+  }
+
+  public async wait(client: any): Promise<any> {
+    return new Promise((resolve) => {
+      setTimeout(resolve, this.timeout);
+    });
+  }
+}
+
+/**
+ * Waits for an Event to fire.
+ *
+ * @export
+ * @class Event
+ * @extends {CompletionTrigger}
+ */
+export class Event extends CompletionTrigger {
+
+  /**
+   * Creates an instance of the Event CompletionTrigger.
+   * @param {string} event the name of the event to listen for.
+   * @param {string} [cssSelector] the CSS selector of the element to listen on.
+   *  Defaults to body.
+   * @param {number} [timeout] ms to wait until timing out.
+   * @memberof Event
+   */
+  constructor(protected event: string, protected cssSelector?: string, timeout?: number) {
+    super(timeout);
+  }
+
+  public async wait(client: any): Promise<any> {
+    const {Runtime} = client;
+    const selector = this.cssSelector ? `querySelector('${this.cssSelector}')` : 'body';
+    return Runtime.evaluate({
+      awaitPromise: true,
+      expression: `
+        new Promise((resolve, reject) => {
+          document.${selector}.addEventListener('${this.event}', resolve, { once: true });
+          setTimeout(() => reject('${this.timeoutMessage}'), ${this.timeout});
+        })`,
+    });
+  }
+}
+
+/**
+ * Waits for a callback to be called.
+ *
+ * @export
+ * @class Callback
+ * @extends {CompletionTrigger}
+ */
+export class Callback extends CompletionTrigger {
+
+  /**
+   * Creates an instance of the Callback CompletionTrigger.
+   * @param {string} [callbackName] the name of the callback to listen for.
+   *  Defaults to htmlPdfCb.
+   * @param {number} [timeout] ms to wait until timing out.
+   * @memberof Callback
+   */
+  constructor(protected callbackName?: string, timeout?: number) {
+    super(timeout);
+  }
+
+  public async wait(client: any): Promise<any> {
+    const {Runtime} = client;
+    const cbName = this.callbackName || 'htmlPdfCb';
+    return Runtime.evaluate({
+      awaitPromise: true,
+      expression: `
+        new Promise((resolve, reject) => {
+          ${cbName} = resolve;
+          setTimeout(() => reject('${this.timeoutMessage}'), ${this.timeout});
+        })`,
+    });
+  }
+}
+
+/**
+ * Waits for a DOM element to appear.
+ *
+ * @export
+ * @class Element
+ * @extends {CompletionTrigger}
+ */
+export class Element extends CompletionTrigger {
+
+  /**
+   * Creates an instance of the Element CompletionTrigger.
+   * @param {string} cssSelector the element to listen for.
+   * @param {number} [timeout] ms to wait until timing out.
+   * @memberof Element
+   */
+  constructor(protected cssSelector: string, timeout?: number) {
+    super(timeout);
+  }
+
+  public async wait(client: any): Promise<any> {
+    const {Runtime} = client;
+    return Runtime.evaluate({
+      awaitPromise: true,
+      expression: `
+        new Promise((resolve, reject) => {
+          new MutationObserver((mutations, observer) => {
+            mutations.forEach((mutation) => {
+              if ([...mutation.addedNodes].find((node) => node.matches('${this.cssSelector}'))) {
+                observer.disconnect();
+                resolve();
+              }
+            });
+          }).observe(document.body, { childList: true });
+          setTimeout(() => reject('${this.timeoutMessage}'), ${this.timeout});
+        })`,
+    });
+  }
+}
+
+/**
+ * Waits for a variable to be true.
+ *
+ * @export
+ * @class Variable
+ * @extends {CompletionTrigger}
+ */
+export class Variable extends CompletionTrigger {
+
+  /**
+   * Creates an instance of the Variable CompletionTrigger.
+   * @param {string} [variableName] the variable to listen on.
+   *  Defaults to htmlPdfDone.
+   * @param {number} [timeout] ms to wait until timing out.
+   * @memberof Variable
+   */
+  constructor(protected variableName?: string, timeout?: number) {
+    super(timeout);
+  }
+
+  public async wait(client: any): Promise<any> {
+    const {Runtime} = client;
+    const varName = this.variableName || 'htmlPdfDone';
+    return Runtime.evaluate({
+      awaitPromise: true,
+      expression: `
+        new Promise((resolve, reject) => {
+          Object.defineProperty(window, '${varName}', {
+            set: (val) => { if (val === true) resolve(); }
+          });
+          setTimeout(() => reject('${this.timeoutMessage}'), ${this.timeout});
+        })`,
+    });
+  }
+}

data/node_modules/html-pdf-chrome/src/CreateResult.ts

@@ -0,0 +1,100 @@
+'use strict';
+
+import * as fs from 'fs';
+import { Readable, Stream } from 'stream';
+
+/**
+ * Allows exporting of PDF data to multiple formats.
+ *
+ * @export
+ * @class CreateResult
+ */
+export class CreateResult {
+
+  /**
+   * Writes the given data Buffer to the specified file location.
+   *
+   * @private
+   * @static
+   * @param {string} filename the file name to write to.
+   * @param {Buffer} data the data to write.
+   * @returns {Promise<void>}
+   *
+   * @memberof CreateResult
+   */
+  private static async writeFile(filename: string, data: Buffer): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      fs.writeFile(filename, data, (err) => {
+        err ? reject(err) : resolve();
+      });
+    });
+  }
+
+  /**
+   * Base64-encoded PDF data.
+   *
+   * @private
+   * @type {string}
+   * @memberof CreateResult
+   */
+  private data: string;
+
+  /**
+   * Creates an instance of CreateResult.
+   * @param {string} data base64 PDF data
+   *
+   * @memberof CreateResult
+   */
+  public constructor(data: string) {
+    this.data = data;
+  }
+
+  /**
+   * Get the base64 PDF data.
+   *
+   * @returns {string} base64 PDF data.
+   *
+   * @memberof CreateResult
+   */
+  public toBase64(): string {
+    return this.data;
+  }
+
+  /**
+   * Get a Buffer of the PDF data.
+   *
+   * @returns {Buffer} PDF data.
+   *
+   * @memberof CreateResult
+   */
+  public toBuffer(): Buffer {
+    return Buffer.from(this.data, 'base64');
+  }
+
+  /**
+   * Get a Stream of the PDF data.
+   *
+   * @returns {Stream} Stream of PDF data.
+   *
+   * @memberof CreateResult
+   */
+  public toStream(): Stream {
+    const stream = new Readable();
+    stream.push(this.data, 'base64');
+    stream.push(null);
+    return stream;
+  }
+
+  /**
+   * Saves the PDF to a file.
+   *
+   * @param {string} filename the filename.
+   * @returns {Promise<void>} resolves upon successful create.
+   *
+   * @memberof CreateResult
+   */
+  public async toFile(filename: string): Promise<void> {
+    await CreateResult.writeFile(filename, this.toBuffer());
+  }
+
+}

data/node_modules/html-pdf-chrome/src/index.ts

@@ -0,0 +1,179 @@
+'use strict';
+
+import { launch, LaunchedChrome } from 'chrome-launcher';
+import * as CDP from 'chrome-remote-interface';
+import * as fs from 'fs';
+import { Readable, Stream } from 'stream';
+
+import { ChromePrintOptions } from './ChromePrintOptions';
+import * as CompletionTrigger from './CompletionTrigger';
+import { CreateResult } from './CreateResult';
+
+export { CompletionTrigger, CreateResult };
+
+/**
+ * PDF generation options.
+ *
+ * @export
+ * @interface CreateOptions
+ */
+export interface CreateOptions {
+  /**
+   * The host to connect to Chrome at.
+   * If set, it attempts to connect to Chrome.
+   * If this and port are not set, it spawns
+   * Chrome for the duration of the PDF generation.
+   *
+   * @type {string}
+   * @memberof CreateOptions
+   */
+  host?: string;
+
+  /**
+   * The port to connect to Chrome with.
+   * If set, it attempts to connect to Chrome.
+   * If this and host are not set, it spawns
+   * Chrome for the duration of the PDF generation.
+   *
+   * @type {number}
+   * @memberof CreateOptions
+   */
+  port?: number;
+
+  /**
+   * The explicit path of the intended Chrome binary.
+   *
+   * @type {string}
+   * @memberof CreateOptions
+   */
+  chromePath?: string;
+
+  /**
+   * The options to pass to Chrome's Page.printToPDF.
+   * Note: these require Chrome >= 60.
+   *
+   * @type {ChromePrintOptions}
+   * @memberof CreateOptions
+   */
+  printOptions?: ChromePrintOptions;
+
+  /**
+   * An optional CompletionTrigger to wait for before
+   * printing the rendered page to a PDF.
+   *
+   * @type {CompletionTrigger.CompletionTrigger}
+   * @memberof CreateOptions
+   */
+  completionTrigger?: CompletionTrigger.CompletionTrigger;
+
+  /**
+   * The time in milliseconds to wait until timing out.
+   */
+  timeout?: number;
+
+  /**
+   * A private flag to signify the operation has been canceled.
+   */
+  _canceled?: boolean;
+}
+
+/**
+ * Generates a PDF from the given HTML string, launching Chrome as necessary.
+ *
+ * @export
+ * @param {string} html the HTML string.
+ * @param {Options} [options] the generation options.
+ * @returns {Promise<CreateResult>} the generated PDF data.
+ */
+export async function create(html: string, options?: CreateOptions): Promise<CreateResult> {
+  const myOptions = Object.assign({}, options);
+  let chrome: LaunchedChrome;
+
+  myOptions._canceled = false;
+  if (myOptions.timeout >= 0) {
+    setTimeout(() => {
+      myOptions._canceled = true;
+    }, myOptions.timeout);
+  }
+
+  await throwIfCanceled(myOptions);
+  if (!myOptions.host && !myOptions.port) {
+    await throwIfCanceled(myOptions);
+    chrome = await launchChrome(myOptions);
+  }
+
+  try {
+    return await generate(html, myOptions);
+  } finally {
+    if (chrome) {
+      await chrome.kill();
+    }
+  }
+}
+
+/**
+ * Connects to Chrome and generates a PDF from HTML or a URL.
+ *
+ * @param {string} html the HTML string or URL.
+ * @param {CreateOptions} options the generation options.
+ * @returns {Promise<CreateResult>} the generated PDF data.
+ */
+async function generate(html: string, options: CreateOptions): Promise<CreateResult>  {
+  await throwIfCanceled(options);
+  const client = await CDP(options);
+  try {
+    const {Page} = client;
+    await Page.enable(); // Enable Page events
+    const url = /^(https?|file|data):/i.test(html) ? html : `data:text/html,${html}`;
+    await throwIfCanceled(options);
+    await Page.navigate({url});
+    await throwIfCanceled(options);
+    await Page.loadEventFired();
+    if (options.completionTrigger) {
+      await throwIfCanceled(options);
+      const waitResult = await options.completionTrigger.wait(client);
+      if (waitResult && waitResult.exceptionDetails) {
+        await throwIfCanceled(options);
+        throw new Error(waitResult.result.value);
+      }
+    }
+    await throwIfCanceled(options);
+    // https://chromedevtools.github.io/debugger-protocol-viewer/tot/Page/#method-printToPDF
+    const pdf = await Page.printToPDF(options.printOptions);
+    await throwIfCanceled(options);
+    return new CreateResult(pdf.data);
+  } finally {
+    client.close();
+  }
+}
+
+/**
+ * Throws an exception if the operation has been canceled.
+ *
+ * @param {CreateOptions} options the options which track cancellation.
+ * @returns {Promise<void>} reject if cancelled, resolve if not.
+ */
+async function throwIfCanceled(options: CreateOptions): Promise<void> {
+  if (options._canceled) {
+    throw new Error('HtmlPdf.create() timed out.');
+  }
+}
+
+/**
+ * Launches Chrome with the specified options.
+ *
+ * @param {CreateOptions} options the options for Chrome.
+ * @returns {Promise<LaunchedChrome>} The launched Chrome instance.
+ */
+async function launchChrome(options: CreateOptions): Promise<LaunchedChrome> {
+  const chrome = await launch({
+    port: options.port,
+    chromePath: options.chromePath,
+    chromeFlags: [
+      '--disable-gpu',
+      '--headless',
+    ],
+  });
+  options.port = chrome.port;
+  return chrome;
+}