pdf-creator-node 2.2.1 → 2.3.4

package/example/node_modules/pdf-creator-node/example/node_modules/phantomjs-prebuilt/lib/util.js

@@ -0,0 +1,161 @@
+/**
+ * @fileoverview Package-private helpers for the installer.
+ */
+
+'use strict'
+
+var cp = require('child_process')
+var fs = require('fs-extra')
+var hasha = require('hasha')
+var helper = require('./phantomjs')
+var kew = require('kew')
+var path = require('path')
+
+var DEFAULT_CDN = 'https://github.com/Medium/phantomjs/releases/download/v2.1.1'
+var libPath = __dirname
+
+/**
+ * Given a lib/location file of a PhantomJS previously installed with NPM,
+ * is there a valid PhantomJS binary at this lib/location.
+ * @return {Promise<string>} resolved location of phantomjs binary on success
+ */
+function findValidPhantomJsBinary(libPath) {
+  return kew.fcall(function () {
+    var libModule = require(libPath)
+    if (libModule.location &&
+        getTargetPlatform() == libModule.platform &&
+        getTargetArch() == libModule.arch) {
+      var resolvedLocation = path.resolve(path.dirname(libPath), libModule.location)
+      if (fs.statSync(resolvedLocation)) {
+        return checkPhantomjsVersion(resolvedLocation).then(function (matches) {
+          if (matches) {
+            return kew.resolve(resolvedLocation)
+          }
+        })
+      }
+    }
+    return false
+  }).fail(function () {
+    return false
+  })
+}
+
+/**
+ * Check to make sure a given binary is the right version.
+ * @return {kew.Promise.<boolean>}
+ */
+function checkPhantomjsVersion(phantomPath) {
+  console.log('Found PhantomJS at', phantomPath, '...verifying')
+  return kew.nfcall(cp.execFile, phantomPath, ['--version']).then(function (stdout) {
+    var version = stdout.trim()
+    if (helper.version == version) {
+      return true
+    } else {
+      console.log('PhantomJS detected, but wrong version', stdout.trim(), '@', phantomPath + '.')
+      return false
+    }
+  }).fail(function (err) {
+    console.error('Error verifying phantomjs, continuing', err)
+    return false
+  })
+}
+
+/**
+ * Writes the location file with location and platform/arch metadata about the
+ * binary.
+ */
+function writeLocationFile(location) {
+  console.log('Writing location.js file')
+  if (getTargetPlatform() === 'win32') {
+    location = location.replace(/\\/g, '\\\\')
+  }
+
+  var platform = getTargetPlatform()
+  var arch = getTargetArch()
+
+  var contents = 'module.exports.location = "' + location + '"\n'
+
+  if (/^[a-zA-Z0-9]*$/.test(platform) && /^[a-zA-Z0-9]*$/.test(arch)) {
+    contents +=
+        'module.exports.platform = "' + getTargetPlatform() + '"\n' +
+        'module.exports.arch = "' + getTargetArch() + '"\n'
+  }
+
+  fs.writeFileSync(path.join(libPath, 'location.js'), contents)
+}
+
+/**
+ * @return {?{url: string, checksum: string}} Get the download URL and expected
+ *     SHA-256 checksum for phantomjs.  May return null if no download url exists.
+ */
+function getDownloadSpec() {
+  var cdnUrl = process.env.npm_config_phantomjs_cdnurl ||
+      process.env.PHANTOMJS_CDNURL ||
+      DEFAULT_CDN
+  var downloadUrl = cdnUrl + '/phantomjs-' + helper.version + '-'
+  var checksum = ''
+
+  var platform = getTargetPlatform()
+  var arch = getTargetArch()
+  if (platform === 'linux' && arch === 'x64') {
+    downloadUrl += 'linux-x86_64.tar.bz2'
+    checksum = '86dd9a4bf4aee45f1a84c9f61cf1947c1d6dce9b9e8d2a907105da7852460d2f'
+  } else if (platform === 'linux' && arch == 'ia32') {
+    downloadUrl += 'linux-i686.tar.bz2'
+    checksum = '80e03cfeb22cc4dfe4e73b68ab81c9fdd7c78968cfd5358e6af33960464f15e3'
+  } else if (platform === 'darwin') {
+    downloadUrl += 'macosx.zip'
+    checksum = '538cf488219ab27e309eafc629e2bcee9976990fe90b1ec334f541779150f8c1'
+  } else if (platform === 'win32') {
+    downloadUrl += 'windows.zip'
+    checksum = 'd9fb05623d6b26d3654d008eab3adafd1f6350433dfd16138c46161f42c7dcc8'
+  } else {
+    return null
+  }
+  return {url: downloadUrl, checksum: checksum}
+}
+
+/**
+ * Check to make sure that the file matches the checksum.
+ * @param {string} fileName
+ * @param {string} checksum
+ * @return {Promise.<boolean>}
+ */
+function verifyChecksum(fileName, checksum) {
+  return kew.resolve(hasha.fromFile(fileName, {algorithm: 'sha256'})).then(function (hash) {
+    var result = checksum == hash
+    if (result) {
+      console.log('Verified checksum of previously downloaded file')
+    } else {
+      console.log('Checksum did not match')
+    }
+    return result
+  }).fail(function (err) {
+    console.error('Failed to verify checksum: ', err)
+    return false
+  })
+}
+
+/**
+ * @return {string}
+ */
+function getTargetPlatform() {
+  return process.env.PHANTOMJS_PLATFORM || process.platform
+}
+
+/**
+ * @return {string}
+ */
+function getTargetArch() {
+  return process.env.PHANTOMJS_ARCH || process.arch
+}
+
+module.exports = {
+  checkPhantomjsVersion: checkPhantomjsVersion,
+  getDownloadSpec: getDownloadSpec,
+  getTargetPlatform: getTargetPlatform,
+  getTargetArch: getTargetArch,
+  findValidPhantomJsBinary: findValidPhantomJsBinary,
+  verifyChecksum: verifyChecksum,
+  writeLocationFile: writeLocationFile
+}

package/example/node_modules/pdf-creator-node/example/node_modules/phantomjs-prebuilt/package.json

@@ -0,0 +1,85 @@
+{
+  "_from": "phantomjs-prebuilt@^2.1.4",
+  "_id": "phantomjs-prebuilt@2.1.16",
+  "_inBundle": false,
+  "_integrity": "sha1-79ISpKOWbTZHaE6ouniFSb4q7+8=",
+  "_location": "/phantomjs-prebuilt",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "phantomjs-prebuilt@^2.1.4",
+    "name": "phantomjs-prebuilt",
+    "escapedName": "phantomjs-prebuilt",
+    "rawSpec": "^2.1.4",
+    "saveSpec": null,
+    "fetchSpec": "^2.1.4"
+  },
+  "_requiredBy": [
+    "/html-pdf"
+  ],
+  "_resolved": "https://registry.npmjs.org/phantomjs-prebuilt/-/phantomjs-prebuilt-2.1.16.tgz",
+  "_shasum": "efd212a4a3966d3647684ea8ba788549be2aefef",
+  "_spec": "phantomjs-prebuilt@^2.1.4",
+  "_where": "/Users/hajareshyam/Work/NodeJs/pdf-creator-node/example/node_modules/html-pdf",
+  "author": {
+    "name": "Dan Pupius",
+    "email": "dan@obvious.com",
+    "url": "http://pupius.co.uk"
+  },
+  "bin": {
+    "phantomjs": "bin/phantomjs"
+  },
+  "bugs": {
+    "url": "https://github.com/Medium/phantomjs/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "es6-promise": "^4.0.3",
+    "extract-zip": "^1.6.5",
+    "fs-extra": "^1.0.0",
+    "hasha": "^2.2.0",
+    "kew": "^0.7.0",
+    "progress": "^1.1.8",
+    "request": "^2.81.0",
+    "request-progress": "^2.0.1",
+    "which": "^1.2.10"
+  },
+  "deprecated": "this package is now deprecated",
+  "description": "Headless WebKit with JS API",
+  "devDependencies": {
+    "eslint": "2.7.0",
+    "nodeunit": "0.9.1",
+    "webdriverio": "~4.2.3"
+  },
+  "homepage": "https://github.com/Medium/phantomjs",
+  "keywords": [
+    "phantomjs",
+    "headless",
+    "webkit"
+  ],
+  "license": "Apache-2.0",
+  "main": "lib/phantomjs",
+  "maintainers": [
+    {
+      "name": "Dan Pupius",
+      "email": "dan@medium.com",
+      "url": "http://pupius.co.uk/"
+    },
+    {
+      "name": "Nick Santos",
+      "email": "nick@medium.com",
+      "url": "http://nick-santos.com/"
+    }
+  ],
+  "name": "phantomjs-prebuilt",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Medium/phantomjs.git"
+  },
+  "scripts": {
+    "install": "node install.js",
+    "test": "nodeunit --reporter=minimal test/tests.js && eslint ."
+  },
+  "version": "2.1.16"
+}

package/example/node_modules/pdf-creator-node/example/node_modules/phantomjs-prebuilt/test/exit.js

@@ -0,0 +1 @@
+phantom.exit(123)

package/example/node_modules/pdf-creator-node/example/node_modules/phantomjs-prebuilt/test/loadspeed.js

@@ -0,0 +1,25 @@
+// phantomjs test script
+// opens url and reports time to load
+// requires an active internet connection
+var page = require('webpage').create()
+var system = require('system')
+var t
+var address
+
+if (system.args.length === 1) {
+  console.log('Usage: loadspeed.js <some URL>')
+  phantom.exit()
+}
+
+t = Date.now()
+address = system.args[1]
+page.open(address, function (status) {
+  if (status !== 'success') {
+    console.log('FAIL to load the address')
+  } else {
+    t = Date.now() - t
+    console.log('Loading time ' + t + ' msec')
+  }
+
+  phantom.exit()
+})

package/example/node_modules/pdf-creator-node/example/node_modules/phantomjs-prebuilt/test/tests.js

@@ -0,0 +1,136 @@
+/**
+ * Nodeunit functional tests.  Requires internet connection to validate phantom
+ * functions correctly.
+ */
+
+var childProcess = require('child_process')
+var fs = require('fs')
+var path = require('path')
+var webdriverio = require('webdriverio')
+var phantomjs = require('../lib/phantomjs')
+var util = require('../lib/util')
+
+exports.testDownload = function (test) {
+  test.expect(1)
+  test.ok(fs.existsSync(phantomjs.path), 'Binary file should have been downloaded')
+  test.done()
+}
+
+
+exports.testPhantomExecutesTestScript = function (test) {
+  test.expect(1)
+
+  var childArgs = [
+    path.join(__dirname, 'loadspeed.js'),
+    'http://www.google.com/'
+  ]
+
+  childProcess.execFile(phantomjs.path, childArgs, function (err, stdout) {
+    var value = (stdout.indexOf('msec') !== -1)
+    test.ok(value, 'Test script should have executed and returned run time')
+    test.done()
+  })
+}
+
+
+exports.testPhantomExitCode = function (test) {
+  test.expect(1)
+  childProcess.execFile(phantomjs.path, [path.join(__dirname, 'exit.js')], function (err) {
+    test.equals(err.code, 123, 'Exit code should be returned from phantom script')
+    test.done()
+  })
+}
+
+
+exports.testBinFile = function (test) {
+  test.expect(1)
+
+  var binPath = process.platform === 'win32' ?
+      path.join(__dirname, '..', 'lib', 'phantom', 'phantomjs.exe') :
+      path.join(__dirname, '..', 'bin', 'phantomjs')
+
+  childProcess.execFile(binPath, ['--version'], function (err, stdout) {
+    test.equal(phantomjs.version, stdout.trim(), 'Version should be match')
+    test.done()
+  })
+}
+
+
+exports.testCleanPath = function (test) {
+  test.expect(5)
+  test.equal('/Users/dan/bin', phantomjs.cleanPath('/Users/dan/bin:./bin'))
+  test.equal('/Users/dan/bin:/usr/bin', phantomjs.cleanPath('/Users/dan/bin:./bin:/usr/bin'))
+  test.equal('/usr/bin', phantomjs.cleanPath('./bin:/usr/bin'))
+  test.equal('', phantomjs.cleanPath('./bin'))
+  test.equal('/Work/bin:/usr/bin', phantomjs.cleanPath('/Work/bin:/Work/phantomjs/node_modules/.bin:/usr/bin'))
+  test.done()
+}
+
+exports.testBogusReinstallLocation = function (test) {
+  util.findValidPhantomJsBinary('./blargh')
+  .then(function (binaryLocation) {
+    test.ok(!binaryLocation, 'Expected link to fail')
+    test.done()
+  })
+}
+
+exports.testSuccessfulReinstallLocation = function (test) {
+  util.findValidPhantomJsBinary(path.resolve(__dirname, '../lib/location'))
+  .then(function (binaryLocation) {
+    test.ok(binaryLocation, 'Expected link to succeed')
+    test.done()
+  })
+}
+
+exports.testBogusVerifyChecksum = function (test) {
+  util.verifyChecksum(path.resolve(__dirname, './exit.js'), 'blargh')
+  .then(function (success) {
+    test.ok(!success, 'Expected checksum to fail')
+    test.done()
+  })
+}
+
+exports.testSuccessfulVerifyChecksum = function (test) {
+  util.verifyChecksum(path.resolve(__dirname, './exit.js'),
+                      '217b7bccebefe5f5e267162060660b03de577867b6123ecfd3b26b5c6af2e92b')
+  .then(function (success) {
+    test.ok(success, 'Expected checksum to succeed')
+    test.done()
+  })
+}
+
+exports.testPhantomExec = function (test) {
+  test.expect(1)
+  var p = phantomjs.exec(path.join(__dirname, 'exit.js'))
+  p.on('exit', function (code) {
+    test.equals(code, 123, 'Exit code should be returned from phantom script')
+    test.done()
+  })
+}
+
+exports.testPhantomRun = function (test) {
+  test.expect(1)
+  var wdOpts = { desiredCapabilities: { browserName: 'phantomjs' } }
+  phantomjs.run('--webdriver=4444').then(function (p) {
+    webdriverio.remote(wdOpts).init()
+      .url('https://developer.mozilla.org/en-US/')
+      .getTitle().then(function (title) {
+        test.equals(title, 'Mozilla Developer Network', 'Page title')
+      })
+      .then(function () {
+        p.kill()
+        test.done()
+      })
+  })
+}
+
+exports.testPhantomRunError = function (test) {
+  test.expect(1)
+  phantomjs.run('--bogus').then(function () {
+    test.ok(false, 'Expected not to start')
+    test.done()
+  }, function (err) {
+    test.equal('Error: Unknown option: bogus\n', err.message)
+    test.done()
+  })
+}

package/example/node_modules/pdf-creator-node/example/node_modules/pinkie/index.js

@@ -0,0 +1,292 @@
+'use strict';
+
+var PENDING = 'pending';
+var SETTLED = 'settled';
+var FULFILLED = 'fulfilled';
+var REJECTED = 'rejected';
+var NOOP = function () {};
+var isNode = typeof global !== 'undefined' && typeof global.process !== 'undefined' && typeof global.process.emit === 'function';
+
+var asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate;
+var asyncQueue = [];
+var asyncTimer;
+
+function asyncFlush() {
+	// run promise callbacks
+	for (var i = 0; i < asyncQueue.length; i++) {
+		asyncQueue[i][0](asyncQueue[i][1]);
+	}
+
+	// reset async asyncQueue
+	asyncQueue = [];
+	asyncTimer = false;
+}
+
+function asyncCall(callback, arg) {
+	asyncQueue.push([callback, arg]);
+
+	if (!asyncTimer) {
+		asyncTimer = true;
+		asyncSetTimer(asyncFlush, 0);
+	}
+}
+
+function invokeResolver(resolver, promise) {
+	function resolvePromise(value) {
+		resolve(promise, value);
+	}
+
+	function rejectPromise(reason) {
+		reject(promise, reason);
+	}
+
+	try {
+		resolver(resolvePromise, rejectPromise);
+	} catch (e) {
+		rejectPromise(e);
+	}
+}
+
+function invokeCallback(subscriber) {
+	var owner = subscriber.owner;
+	var settled = owner._state;
+	var value = owner._data;
+	var callback = subscriber[settled];
+	var promise = subscriber.then;
+
+	if (typeof callback === 'function') {
+		settled = FULFILLED;
+		try {
+			value = callback(value);
+		} catch (e) {
+			reject(promise, e);
+		}
+	}
+
+	if (!handleThenable(promise, value)) {
+		if (settled === FULFILLED) {
+			resolve(promise, value);
+		}
+
+		if (settled === REJECTED) {
+			reject(promise, value);
+		}
+	}
+}
+
+function handleThenable(promise, value) {
+	var resolved;
+
+	try {
+		if (promise === value) {
+			throw new TypeError('A promises callback cannot return that same promise.');
+		}
+
+		if (value && (typeof value === 'function' || typeof value === 'object')) {
+			// then should be retrieved only once
+			var then = value.then;
+
+			if (typeof then === 'function') {
+				then.call(value, function (val) {
+					if (!resolved) {
+						resolved = true;
+
+						if (value === val) {
+							fulfill(promise, val);
+						} else {
+							resolve(promise, val);
+						}
+					}
+				}, function (reason) {
+					if (!resolved) {
+						resolved = true;
+
+						reject(promise, reason);
+					}
+				});
+
+				return true;
+			}
+		}
+	} catch (e) {
+		if (!resolved) {
+			reject(promise, e);
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+function resolve(promise, value) {
+	if (promise === value || !handleThenable(promise, value)) {
+		fulfill(promise, value);
+	}
+}
+
+function fulfill(promise, value) {
+	if (promise._state === PENDING) {
+		promise._state = SETTLED;
+		promise._data = value;
+
+		asyncCall(publishFulfillment, promise);
+	}
+}
+
+function reject(promise, reason) {
+	if (promise._state === PENDING) {
+		promise._state = SETTLED;
+		promise._data = reason;
+
+		asyncCall(publishRejection, promise);
+	}
+}
+
+function publish(promise) {
+	promise._then = promise._then.forEach(invokeCallback);
+}
+
+function publishFulfillment(promise) {
+	promise._state = FULFILLED;
+	publish(promise);
+}
+
+function publishRejection(promise) {
+	promise._state = REJECTED;
+	publish(promise);
+	if (!promise._handled && isNode) {
+		global.process.emit('unhandledRejection', promise._data, promise);
+	}
+}
+
+function notifyRejectionHandled(promise) {
+	global.process.emit('rejectionHandled', promise);
+}
+
+/**
+ * @class
+ */
+function Promise(resolver) {
+	if (typeof resolver !== 'function') {
+		throw new TypeError('Promise resolver ' + resolver + ' is not a function');
+	}
+
+	if (this instanceof Promise === false) {
+		throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.');
+	}
+
+	this._then = [];
+
+	invokeResolver(resolver, this);
+}
+
+Promise.prototype = {
+	constructor: Promise,
+
+	_state: PENDING,
+	_then: null,
+	_data: undefined,
+	_handled: false,
+
+	then: function (onFulfillment, onRejection) {
+		var subscriber = {
+			owner: this,
+			then: new this.constructor(NOOP),
+			fulfilled: onFulfillment,
+			rejected: onRejection
+		};
+
+		if ((onRejection || onFulfillment) && !this._handled) {
+			this._handled = true;
+			if (this._state === REJECTED && isNode) {
+				asyncCall(notifyRejectionHandled, this);
+			}
+		}
+
+		if (this._state === FULFILLED || this._state === REJECTED) {
+			// already resolved, call callback async
+			asyncCall(invokeCallback, subscriber);
+		} else {
+			// subscribe
+			this._then.push(subscriber);
+		}
+
+		return subscriber.then;
+	},
+
+	catch: function (onRejection) {
+		return this.then(null, onRejection);
+	}
+};
+
+Promise.all = function (promises) {
+	if (!Array.isArray(promises)) {
+		throw new TypeError('You must pass an array to Promise.all().');
+	}
+
+	return new Promise(function (resolve, reject) {
+		var results = [];
+		var remaining = 0;
+
+		function resolver(index) {
+			remaining++;
+			return function (value) {
+				results[index] = value;
+				if (!--remaining) {
+					resolve(results);
+				}
+			};
+		}
+
+		for (var i = 0, promise; i < promises.length; i++) {
+			promise = promises[i];
+
+			if (promise && typeof promise.then === 'function') {
+				promise.then(resolver(i), reject);
+			} else {
+				results[i] = promise;
+			}
+		}
+
+		if (!remaining) {
+			resolve(results);
+		}
+	});
+};
+
+Promise.race = function (promises) {
+	if (!Array.isArray(promises)) {
+		throw new TypeError('You must pass an array to Promise.race().');
+	}
+
+	return new Promise(function (resolve, reject) {
+		for (var i = 0, promise; i < promises.length; i++) {
+			promise = promises[i];
+
+			if (promise && typeof promise.then === 'function') {
+				promise.then(resolve, reject);
+			} else {
+				resolve(promise);
+			}
+		}
+	});
+};
+
+Promise.resolve = function (value) {
+	if (value && typeof value === 'object' && value.constructor === Promise) {
+		return value;
+	}
+
+	return new Promise(function (resolve) {
+		resolve(value);
+	});
+};
+
+Promise.reject = function (reason) {
+	return new Promise(function (resolve, reject) {
+		reject(reason);
+	});
+};
+
+module.exports = Promise;