pdfmerger/distribution/lib/PDFMerger.js

Uses the Pdfbox library to merge PDF files into a single PDF file.

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var path = require('path');

var _require = require('stream'),
    Readable = _require.Readable;

var spawn = require('child_process').spawn;

var ChildStream = function (_Readable) {
  _inherits(ChildStream, _Readable);

  function ChildStream(childProcess) {
    _classCallCheck(this, ChildStream);

    var _this = _possibleConstructorReturn(this, (ChildStream.__proto__ || Object.getPrototypeOf(ChildStream)).call(this));

    var self = _this;

    childProcess.stdout.on('data', function (data) {
      self.emit('data', data);
    });

    childProcess.stderr.on('data', function (data) {
      self.emit('error', data.toString('utf8'));
    });

    childProcess.on('close', function (code) {
      self.emit('close', code);
    });

    _this.child = childProcess;
    return _this;
  }

  _createClass(ChildStream, [{
    key: '_read',
    value: function _read(size) {
      return this.child.stdout.read(size);
    }
  }, {
    key: 'pipe',
    value: function pipe(stream) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      return this.child.stdout.pipe(stream, options);
    }
  }]);

  return ChildStream;
}(Readable);

module.exports = function (src, dest, options, callback) {

  if (!(Array.isArray(src) || typeof src === 'string')) {
    throw new Error('First argument should be either a path to a directory or an array of paths to pdf source files');
  }

  if (Array.isArray(src) && src.length < 2) {
    throw new Error('There must be at least 2 paths in the source array');
  }

  var opts = options || {};

  var maxHeap = opts.maxHeap;
  var minHeap = opts.minHeap;

  var dirPathArr = __dirname.split(path.sep);

  dirPathArr.pop();
  dirPathArr.pop();
  dirPathArr.push('jar');
  dirPathArr.push('pdfmerger.jar');

  var jarPath = dirPathArr.join(path.sep);

  var childArgs = ['-jar', jarPath];

  if (maxHeap) {
    childArgs.unshift('-Xmx' + maxHeap + 'm');
  }

  if (minHeap) {
    childArgs.unshift('-Xms' + minHeap + 'm');
  }

  var sources = Array.isArray(src) ? src : [src];

  // set all sources
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = sources[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var source = _step.value;

      childArgs.push('-s');
      childArgs.push(source);
    }

    // set output file path
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  if (dest) {
    childArgs.push('-o');
    childArgs.push(dest);
  }

  var child = spawn('java', childArgs);

  var e = 0;

  if (dest) {

    child.stderr.on('data', function (data) {
      e++;
      child.kill('SIGINT');
      // TODO: better error handling/messages
      callback && callback(new Error(data.toString('utf8')));
    });

    child.on('close', function (code) {
      if (e === 0 && code === 1) {
        return callback && callback(new Error('PDFBox shut down because of a problem.'));
      }

      callback && e === 0 && callback(null);
    });

    return this;
  }

  return new ChildStream(child);
};