@accordproject/markdown-pdf/lib/PdfTransformer.js

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
'use strict';

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

const parsePdf = require('easy-pdf-parser').parsePdf;

const extractPlainText = require('easy-pdf-parser').extractPlainText;

const CiceroMarkTransformer = require('@accordproject/markdown-cicero').CiceroMarkTransformer;

const PdfPrinter = require('pdfmake');

const ToPdfMakeVisitor = require('./ToPdfMakeVisitor');

const fonts = {
  Courier: {
    normal: 'Courier',
    bold: 'Courier-Bold',
    italics: 'Courier-Oblique',
    bolditalics: 'Courier-BoldOblique'
  },
  Helvetica: {
    normal: 'Helvetica',
    bold: 'Helvetica-Bold',
    italics: 'Helvetica-Oblique',
    bolditalics: 'Helvetica-BoldOblique'
  },
  Times: {
    normal: 'Times-Roman',
    bold: 'Times-Bold',
    italics: 'Times-Italic',
    bolditalics: 'Times-BoldItalic'
  },
  Symbol: {
    normal: 'Symbol'
  },
  ZapfDingbats: {
    normal: 'ZapfDingbats'
  },
  LiberationSerif: {
    normal: "".concat(__dirname, "/fonts/LiberationSerif-Regular.ttf"),
    bold: "".concat(__dirname, "/fonts/LiberationSerif-Bold.ttf"),
    italics: "".concat(__dirname, "/fonts/LiberationSerif-Italic.ttf"),
    bolditalics: "".concat(__dirname, "/fonts/LiberationSerif-BoldItalic.ttf")
  },
  LiberationSans: {
    normal: "".concat(__dirname, "/fonts/LiberationSans-Regular.ttf"),
    bold: "".concat(__dirname, "/fonts/LiberationSans-Bold.ttf"),
    italics: "".concat(__dirname, "/fonts/LiberationSans-Italic.ttf"),
    bolditalics: "".concat(__dirname, "/fonts/LiberationSans-BoldItalic.ttf")
  },
  LiberationMono: {
    normal: "".concat(__dirname, "/fonts/LiberationMono-Regular.ttf"),
    bold: "".concat(__dirname, "/fonts/LiberationMono-Bold.ttf"),
    italics: "".concat(__dirname, "/fonts/LiberationMono-Italic.ttf"),
    bolditalics: "".concat(__dirname, "/fonts/LiberationMono-BoldItalic.ttf")
  }
};
/**
 * Converts a PDF to CiceroMark DOM
 */

class PdfTransformer {
  /**
   * Construct the parser.
   * @param {object} [options] configuration options
   */
  constructor() {
    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    this.options = options;
    this.ciceroMarkTransformer = new CiceroMarkTransformer();
  }
  /**
   * Converts an pdf buffer to a CiceroMark DOM
   * @param {Buffer} input - pdf buffer
   * @param {string} [format] result format, defaults to 'concerto'. Pass
   * 'json' to return the JSON data.
   * @returns {promise} a Promise to the CiceroMark DOM
   */


  toCiceroMark(input) {
    var _arguments = arguments,
        _this = this;

    return _asyncToGenerator(function* () {
      let format = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : 'concerto';
      const plainText = yield parsePdf(input).then(extractPlainText);
      return _this.ciceroMarkTransformer.fromMarkdown(plainText, format);
    })();
  }
  /**
   * Converts a CiceroMark DOM to a PDF Buffer
   * @param {*} input - CiceroMark DOM
   * @param {*} options - the PDF generation options
   * @param {*} outputStream - the output stream
   */


  toPdf(input, options, outputStream) {
    var _this2 = this;

    return _asyncToGenerator(function* () {
      const printer = new PdfPrinter(fonts);

      if (!input.getType) {
        input = _this2.ciceroMarkTransformer.getSerializer().fromJSON(input);
      }

      const parameters = {};
      parameters.result = '';
      parameters.first = true;
      parameters.indent = 0;
      const visitor = new ToPdfMakeVisitor(_this2.options);
      input.accept(visitor, parameters);
      const dd = parameters.result; // console.log(JSON.stringify(dd, null, 2));

      dd.defaultStyle = {
        fontSize: 12,
        font: 'LiberationSerif',
        lineHeight: 1.5
      };
      dd.pageSize = 'LETTER';
      dd.pageOrientation = 'portrait', dd.pageMargins = [80, 80, 80, 80]; // allow overrding top-level options

      Object.assign(dd, options);

      if (options.tocHeading) {
        dd.content = [{
          toc: {
            title: {
              text: options.tocHeading,
              style: 'toc'
            }
          }
        }].concat([{
          text: '',
          pageBreak: 'after'
        }].concat(dd.content));
      }

      if (options.headerText) {
        dd.header = {
          text: options.headerText,
          style: 'Header'
        };
      }

      if (options.footerText || options.footerPageNumber) {
        dd.footer = function (currentPage, pageCount) {
          const footer = [{
            text: options.footerText ? options.footerText : '',
            style: 'Footer'
          }];

          if (options.footerPageNumber) {
            footer.push({
              text: currentPage.toString() + ' / ' + pageCount,
              style: 'PageNumber'
            });
          }

          return footer;
        };
      }

      const defaultStyles = {
        Footer: {
          alignment: 'left',
          margin: [10, 10, 0, 0]
        },
        PageNumber: {
          alignment: 'center',
          margin: [0, 0, 0, 0]
        },
        Header: {
          alignment: 'right',
          margin: [0, 10, 10, 0]
        },
        heading_one: {
          fontSize: 30,
          bold: true,
          alignment: 'center'
        },
        heading_two: {
          fontSize: 28,
          bold: true
        },
        heading_three: {
          fontSize: 26,
          bold: true
        },
        heading_four: {
          fontSize: 24,
          bold: true
        },
        heading_five: {
          fontSize: 22,
          bold: true
        },
        heading_six: {
          fontSize: 20,
          bold: true
        },
        Code: {
          font: 'LiberationMono'
        },
        CodeBlock: {
          font: 'LiberationMono'
        },
        HtmlInline: {
          font: 'LiberationMono'
        },
        HtmlBlock: {
          font: 'LiberationMono'
        },
        Paragraph: {
          alignment: 'justify'
        },
        toc: {
          fontSize: 30,
          bold: true,
          alignment: 'center'
        },
        Link: {
          color: 'blue'
        },
        BlockQuote: {
          margin: [20, 0]
        }
      }; // allow the caller to override default styles

      dd.styles = defaultStyles;

      if (options.styles) {
        Object.assign(dd.styles, options.styles);
      }

      const pdfDoc = printer.createPdfKitDocument(dd);
      pdfDoc.pipe(outputStream);
      pdfDoc.end();
    })();
  }

}

module.exports = PdfTransformer;