pdf-creator-node 1.4.0 → 1.4.1

package/example/node_modules/kew/kew.js

@@ -1,860 +0,0 @@
-
-/**
- * An object representing a "promise" for a future value
- *
- * @param {?function(T, ?)=} onSuccess a function to handle successful
- *     resolution of this promise
- * @param {?function(!Error, ?)=} onFail a function to handle failed
- *     resolution of this promise
- * @constructor
- * @template T
- */
-function Promise(onSuccess, onFail) {
-  this.promise = this
-  this._isPromise = true
-  this._successFn = onSuccess
-  this._failFn = onFail
-  this._scope = this
-  this._boundArgs = null
-  this._hasContext = false
-  this._nextContext = undefined
-  this._currentContext = undefined
-}
-
-/**
- * @param {function()} callback
- */
-function nextTick (callback) {
-  callback()
-}
-
-if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {
-  nextTick = process.nextTick
-}
-
-/**
- * All callback execution should go through this function.  While the
- * implementation below is simple, it can be replaced with more sophisticated
- * implementations that enforce QoS on the event loop.
- *
- * @param {Promise} defer
- * @param {Function} callback
- * @param {Object|undefined} scope
- * @param {Array} args
- */
-function nextTickCallback (defer, callback, scope, args) {
-  try {
-    defer.resolve(callback.apply(scope, args))
-  } catch (thrown) {
-    defer.reject(thrown)
-  }
-}
-
-/**
- * Used for accessing the nextTick function from outside the kew module.
- *
- * @return {Function}
- */
-function getNextTickFunction () {
-  return nextTick
-}
-
-/**
- * Used for overriding the nextTick function from outside the kew module so that
- * the user can plug and play lower level schedulers
- * @param {!Function} fn
- */
-function setNextTickFunction (fn) {
-  nextTick = fn
-}
-
-/**
- * Keep track of the number of promises that are rejected along side
- * the number of rejected promises we call _failFn on so we can look
- * for leaked rejections.
- * @constructor
- */
-function PromiseStats() {
-  /** @type {number} */
-  this.errorsEmitted = 0
-
-  /** @type {number} */
-  this.errorsHandled = 0
-}
-
-var stats = new PromiseStats()
-
-Promise.prototype._handleError = function () {
-  if (!this._errorHandled) {
-    stats.errorsHandled++
-    this._errorHandled = true
-  }
-}
-
-/**
- * Specify that the current promise should have a specified context
- * @param  {*} context context
- * @private
- */
-Promise.prototype._useContext = function (context) {
-  this._nextContext = this._currentContext = context
-  this._hasContext = true
-  return this
-}
-
-Promise.prototype.clearContext = function () {
-  this._hasContext = false
-  this._nextContext = undefined
-  return this
-}
-
-/**
- * Set the context for all promise handlers to follow
- *
- * NOTE(dpup): This should be considered deprecated.  It does not do what most
- * people would expect.  The context will be passed as a second argument to all
- * subsequent callbacks.
- *
- * @param {*} context An arbitrary context
- */
-Promise.prototype.setContext = function (context) {
-  this._nextContext = context
-  this._hasContext = true
-  return this
-}
-
-/**
- * Get the context for a promise
- * @return {*} the context set by setContext
- */
-Promise.prototype.getContext = function () {
-  return this._nextContext
-}
-
-/**
- * Resolve this promise with a specified value
- *
- * @param {*=} data
- */
-Promise.prototype.resolve = function (data) {
-  if (this._error || this._hasData) throw new Error("Unable to resolve or reject the same promise twice")
-
-  var i
-  if (data && isPromise(data)) {
-    this._child = data
-    if (this._promises) {
-      for (i = 0; i < this._promises.length; i += 1) {
-        data._chainPromise(this._promises[i])
-      }
-      delete this._promises
-    }
-
-    if (this._onComplete) {
-      for (i = 0; i < this._onComplete.length; i+= 1) {
-        data.fin(this._onComplete[i])
-      }
-      delete this._onComplete
-    }
-  } else if (data && isPromiseLike(data)) {
-    data.then(
-      function(data) { this.resolve(data) }.bind(this),
-      function(err) { this.reject(err) }.bind(this)
-    )
-  } else {
-    this._hasData = true
-    this._data = data
-
-    if (this._onComplete) {
-      for (i = 0; i < this._onComplete.length; i++) {
-        this._onComplete[i]()
-      }
-    }
-
-    if (this._promises) {
-      for (i = 0; i < this._promises.length; i += 1) {
-        this._promises[i]._useContext(this._nextContext)
-        this._promises[i]._withInput(data)
-      }
-      delete this._promises
-    }
-  }
-}
-
-/**
- * Reject this promise with an error
- *
- * @param {!Error} e
- */
-Promise.prototype.reject = function (e) {
-  if (this._error || this._hasData) throw new Error("Unable to resolve or reject the same promise twice")
-
-  var i
-  this._error = e
-  stats.errorsEmitted++
-
-  if (this._ended) {
-    this._handleError()
-    process.nextTick(function onPromiseThrow() {
-      throw e
-    })
-  }
-
-  if (this._onComplete) {
-    for (i = 0; i < this._onComplete.length; i++) {
-      this._onComplete[i]()
-    }
-  }
-
-  if (this._promises) {
-    this._handleError()
-    for (i = 0; i < this._promises.length; i += 1) {
-      this._promises[i]._useContext(this._nextContext)
-      this._promises[i]._withError(e)
-    }
-    delete this._promises
-  }
-}
-
-/**
- * Provide a callback to be called whenever this promise successfully
- * resolves. Allows for an optional second callback to handle the failure
- * case.
- *
- * @param {?function(this:void, T, ?): RESULT|undefined} onSuccess
- * @param {?function(this:void, !Error, ?): RESULT=} onFail
- * @return {!Promise.<RESULT>} returns a new promise with the output of the onSuccess or
- *     onFail handler
- * @template RESULT
- */
-Promise.prototype.then = function (onSuccess, onFail) {
-  var promise = new Promise(onSuccess, onFail)
-  if (this._nextContext) promise._useContext(this._nextContext)
-
-  if (this._child) this._child._chainPromise(promise)
-  else this._chainPromise(promise)
-
-  return promise
-}
-
-/**
- * Provide a callback to be called whenever this promise successfully
- * resolves. The callback will be executed in the context of the provided scope.
- *
- * @param {function(this:SCOPE, ...): RESULT} onSuccess
- * @param {SCOPE} scope Object whose context callback will be executed in.
- * @param {...*} var_args Additional arguments to be passed to the promise callback.
- * @return {!Promise.<RESULT>} returns a new promise with the output of the onSuccess
- * @template SCOPE, RESULT
- */
-Promise.prototype.thenBound = function (onSuccess, scope, var_args) {
-  var promise = new Promise(onSuccess)
-  if (this._nextContext) promise._useContext(this._nextContext)
-
-  promise._scope = scope
-  if (arguments.length > 2) {
-    promise._boundArgs = Array.prototype.slice.call(arguments, 2)
-  }
-
-  // Chaining must happen after setting args and scope since it may fire callback.
-  if (this._child) this._child._chainPromise(promise)
-  else this._chainPromise(promise)
-
-  return promise
-}
-
-/**
- * Provide a callback to be called whenever this promise is rejected
- *
- * @param {function(this:void, !Error, ?)} onFail
- * @return {!Promise.<T>} returns a new promise with the output of the onFail handler
- */
-Promise.prototype.fail = function (onFail) {
-  return this.then(null, onFail)
-}
-
-/**
- * Provide a callback to be called whenever this promise is rejected.
- * The callback will be executed in the context of the provided scope.
- *
- * @param {function(this:SCOPE, ...)} onFail
- * @param {SCOPE} scope Object whose context callback will be executed in.
- * @param {...?} var_args
- * @return {!Promise.<T>} returns a new promise with the output of the onSuccess
- * @template SCOPE
- */
-Promise.prototype.failBound = function (onFail, scope, var_args) {
-  var promise = new Promise(null, onFail)
-  if (this._nextContext) promise._useContext(this._nextContext)
-
-  promise._scope = scope
-  if (arguments.length > 2) {
-    promise._boundArgs = Array.prototype.slice.call(arguments, 2)
-  }
-
-  // Chaining must happen after setting args and scope since it may fire callback.
-  if (this._child) this._child._chainPromise(promise)
-  else this._chainPromise(promise)
-
-  return promise
-}
-
-/**
- * Spread a promises outputs to the functions arguments.
- * @param {?function(this:void, ...): RESULT|undefined} onSuccess
- * @return {!Promise.<RESULT>} returns a new promise with the output of the onSuccess or
- *     onFail handler
- * @template RESULT
- */
-Promise.prototype.spread = function (onSuccess) {
-  return this.then(allInternal)
-  .then(function (array) {
-    return onSuccess.apply(null, array)
-  })
-}
-
-/**
- * Spread a promises outputs to the functions arguments.
- * @param {function(this:SCOPE, ...): RESULT} onSuccess
- * @param {SCOPE} scope Object whose context callback will be executed in.
- * @param {...*} var_args Additional arguments to be passed to the promise callback.
- * @return {!Promise.<RESULT>} returns a new promise with the output of the onSuccess
- * @template SCOPE, RESULT
- */
-Promise.prototype.spreadBound = function (onSuccess, scope, var_args) {
-  var args = Array.prototype.slice.call(arguments, 2)
-  return this.then(allInternal)
-  .then(function (array) {
-    return onSuccess.apply(scope, args.concat(array))
-  })
-}
-
-/**
- * Provide a callback to be called whenever this promise is either resolved
- * or rejected.
- *
- * @param {function()} onComplete
- * @return {!Promise.<T>} returns the current promise
- */
-Promise.prototype.fin = function (onComplete) {
-  if (this._hasData || this._error) {
-    onComplete()
-    return this
-  }
-
-  if (this._child) {
-    this._child.fin(onComplete)
-  } else {
-    if (!this._onComplete) this._onComplete = [onComplete]
-    else this._onComplete.push(onComplete)
-  }
-
-  return this
-}
-
-/**
- * Mark this promise as "ended". If the promise is rejected, this will throw an
- * error in whatever scope it happens to be in
- *
- * @return {!Promise.<T>} returns the current promise
- * @deprecated Prefer done(), because it's consistent with Q.
- */
-Promise.prototype.end = function () {
-  this._end()
-  return this
-}
-
-
-/**
- * Mark this promise as "ended".
- * @private
- */
-Promise.prototype._end = function () {
-  if (this._error) {
-    this._handleError()
-    throw this._error
-  }
-  this._ended = true
-  return this
-}
-
-/**
- * Close the promise. Any errors after this completes will be thrown to the global handler.
- *
- * @param {?function(this:void, T, ?)=} onSuccess a function to handle successful
- *     resolution of this promise
- * @param {?function(this:void, !Error, ?)=} onFailure a function to handle failed
- *     resolution of this promise
- * @return {void}
- */
-Promise.prototype.done = function (onSuccess, onFailure) {
-  var self = this
-  if (onSuccess || onFailure) {
-    self = self.then(onSuccess, onFailure)
-  }
-  self._end()
-}
-
-/**
- * Return a new promise that behaves the same as the current promise except
- * that it will be rejected if the current promise does not get fulfilled
- * after a certain amount of time.
- *
- * @param {number} timeoutMs The timeout threshold in msec
- * @param {string=} timeoutMsg error message
- * @return {!Promise.<T>} a new promise with timeout
- */
- Promise.prototype.timeout = function (timeoutMs, timeoutMsg) {
-  var deferred = new Promise()
-  var isTimeout = false
-
-  var timeout = setTimeout(function() {
-    deferred.reject(new Error(timeoutMsg || 'Promise timeout after ' + timeoutMs + ' ms.'))
-    isTimeout = true
-  }, timeoutMs)
-
-  this.then(function (data) {
-    if (!isTimeout) {
-      clearTimeout(timeout)
-      deferred.resolve(data)
-    }
-  },
-  function (err) {
-    if (!isTimeout) {
-      clearTimeout(timeout)
-      deferred.reject(err)
-    }
-  })
-
-  return deferred.promise
-}
-
-/**
- * Attempt to resolve this promise with the specified input
- *
- * @param {*} data the input
- */
-Promise.prototype._withInput = function (data) {
-  if (this._successFn) {
-    this._nextTick(this._successFn, [data, this._currentContext])
-  } else {
-    this.resolve(data)
-  }
-
-  // context is no longer needed
-  delete this._currentContext
-}
-
-/**
- * Attempt to reject this promise with the specified error
- *
- * @param {!Error} e
- * @private
- */
-Promise.prototype._withError = function (e) {
-  if (this._failFn) {
-    this._nextTick(this._failFn, [e, this._currentContext])
-  } else {
-    this.reject(e)
-  }
-
-  // context is no longer needed
-  delete this._currentContext
-}
-
-/**
- * Calls a function in the correct scope, and includes bound arguments.
- * @param {Function} fn
- * @param {Array} args
- * @private
- */
-Promise.prototype._nextTick = function (fn, args) {
-  if (this._boundArgs) {
-    args = this._boundArgs.concat(args)
-  }
-  nextTick(nextTickCallback.bind(null, this, fn, this._scope, args))
-}
-
-/**
- * Chain a promise to the current promise
- *
- * @param {!Promise} promise the promise to chain
- * @private
- */
-Promise.prototype._chainPromise = function (promise) {
-  var i
-  if (this._hasContext) promise._useContext(this._nextContext)
-
-  if (this._child) {
-    this._child._chainPromise(promise)
-  } else if (this._hasData) {
-    promise._withInput(this._data)
-  } else if (this._error) {
-    // We can't rely on _withError() because it's called on the chained promises
-    // and we need to use the source's _errorHandled state
-    this._handleError()
-    promise._withError(this._error)
-  } else if (!this._promises) {
-    this._promises = [promise]
-  } else {
-    this._promises.push(promise)
-  }
-}
-
-/**
- * Utility function used for creating a node-style resolver
- * for deferreds
- *
- * @param {!Promise} deferred a promise that looks like a deferred
- * @param {Error=} err an optional error
- * @param {*=} data optional data
- */
-function resolver(deferred, err, data) {
-  if (err) deferred.reject(err)
-  else deferred.resolve(data)
-}
-
-/**
- * Creates a node-style resolver for a deferred by wrapping
- * resolver()
- *
- * @return {function(?Error, *)} node-style callback
- */
-Promise.prototype.makeNodeResolver = function () {
-  return resolver.bind(null, this)
-}
-
-/**
- * Return true iff the given object is a promise of this library.
- *
- * Because kew's API is slightly different than other promise libraries,
- * it's important that we have a test for its promise type. If you want
- * to test for a more general A+ promise, you should do a cap test for
- * the features you want.
- *
- * @param {*} obj The object to test
- * @return {boolean} Whether the object is a promise
- */
-function isPromise(obj) {
-  return !!obj._isPromise
-}
-
-/**
- * Return true iff the given object is a promise-like object, e.g. appears to
- * implement Promises/A+ specification
- *
- * @param {*} obj The object to test
- * @return {boolean} Whether the object is a promise-like object
- */
-function isPromiseLike(obj) {
-  return (typeof obj === 'object' || typeof obj === 'function') &&
-    typeof obj.then === 'function'
-}
-
-/**
- * Static function which creates and resolves a promise immediately
- *
- * @param {T} data data to resolve the promise with
- * @return {!Promise.<T>}
- * @template T
- */
-function resolve(data) {
-  var promise = new Promise()
-  promise.resolve(data)
-  return promise
-}
-
-/**
- * Static function which creates and rejects a promise immediately
- *
- * @param {!Error} e error to reject the promise with
- * @return {!Promise}
- */
-function reject(e) {
-  var promise = new Promise()
-  promise.reject(e)
-  return promise
-}
-
-/**
- * Replace an element in an array with a new value. Used by .all() to
- * call from .then()
- *
- * @param {!Array} arr
- * @param {number} idx
- * @param {*} val
- * @return {*} the val that's being injected into the array
- */
-function replaceEl(arr, idx, val) {
-  arr[idx] = val
-  return val
-}
-
-/**
- * Replace an element in an array as it is resolved with its value.
- * Used by .allSettled().
- *
- * @param {!Array} arr
- * @param {number} idx
- * @param {*} value The value from a resolved promise.
- * @return {*} the data that's being passed in
- */
-function replaceElFulfilled(arr, idx, value) {
-  arr[idx] = {
-    state: 'fulfilled',
-    value: value
-  }
-  return value
-}
-
-/**
- * Replace an element in an array as it is rejected with the reason.
- * Used by .allSettled().
- *
- * @param {!Array} arr
- * @param {number} idx
- * @param {*} reason The reason why the original promise is rejected
- * @return {*} the data that's being passed in
- */
-function replaceElRejected(arr, idx, reason) {
-  arr[idx] = {
-    state: 'rejected',
-    reason: reason
-  }
-  return reason
-}
-
-/**
- * Takes in an array of promises or literals and returns a promise which returns
- * an array of values when all have resolved. If any fail, the promise fails.
- *
- * @param {!Array.<!Promise>} promises
- * @return {!Promise.<!Array>}
- */
-function all(promises) {
-  if (arguments.length != 1 || !Array.isArray(promises)) {
-    promises = Array.prototype.slice.call(arguments, 0)
-  }
-  return allInternal(promises)
-}
-
-/**
- * A version of all() that does not accept var_args
- *
- * @param {!Array.<!Promise>} promises
- * @return {!Promise.<!Array>}
- */
-function allInternal(promises) {
-  if (!promises.length) return resolve([])
-
-  var outputs = []
-  var finished = false
-  var promise = new Promise()
-  var counter = promises.length
-
-  for (var i = 0; i < promises.length; i += 1) {
-    if (!promises[i] || !isPromiseLike(promises[i])) {
-      outputs[i] = promises[i]
-      counter -= 1
-    } else {
-      promises[i].then(replaceEl.bind(null, outputs, i))
-      .then(function decrementAllCounter() {
-        counter--
-        if (!finished && counter === 0) {
-          finished = true
-          promise.resolve(outputs)
-        }
-      }, function onAllError(e) {
-        if (!finished) {
-          finished = true
-          promise.reject(e)
-        }
-      })
-    }
-  }
-
-  if (counter === 0 && !finished) {
-    finished = true
-    promise.resolve(outputs)
-  }
-
-  return promise
-}
-
-/**
- * Takes in an array of promises or values and returns a promise that is
- * fulfilled with an array of state objects when all have resolved or
- * rejected. If a promise is resolved, its corresponding state object is
- * {state: 'fulfilled', value: Object}; whereas if a promise is rejected, its
- * corresponding state object is {state: 'rejected', reason: Object}.
- *
- * @param {!Array} promises or values
- * @return {!Promise.<!Array>} Promise fulfilled with state objects for each input
- */
-function allSettled(promises) {
-  if (!Array.isArray(promises)) {
-    throw Error('The input to "allSettled()" should be an array of Promise or values')
-  }
-  if (!promises.length) return resolve([])
-
-  var outputs = []
-  var promise = new Promise()
-  var counter = promises.length
-
-  for (var i = 0; i < promises.length; i += 1) {
-    if (!promises[i] || !isPromiseLike(promises[i])) {
-      replaceElFulfilled(outputs, i, promises[i])
-      if ((--counter) === 0) promise.resolve(outputs)
-    } else {
-      promises[i]
-        .then(replaceElFulfilled.bind(null, outputs, i), replaceElRejected.bind(null, outputs, i))
-        .then(function () {
-          if ((--counter) === 0) promise.resolve(outputs)
-        })
-    }
-  }
-
-  return promise
-}
-
-/**
- * Takes an array of results and spreads them to the arguments of a function.
- * @param {!Array} array
- * @param {!Function} fn
- */
-function spread(array, fn) {
-  resolve(array).spread(fn)
-}
-
-/**
- * Create a new Promise which looks like a deferred
- *
- * @return {!Promise}
- */
-function defer() {
-  return new Promise()
-}
-
-/**
- * Return a promise which will wait a specified number of ms to resolve
- *
- * @param {*} delayMsOrVal A delay (in ms) if this takes one argument, or ther
- *     return value if it takes two.
- * @param {number=} opt_delayMs
- * @return {!Promise}
- */
-function delay(delayMsOrVal, opt_delayMs) {
-  var returnVal = undefined
-  var delayMs = delayMsOrVal
-  if (typeof opt_delayMs != 'undefined') {
-    delayMs = opt_delayMs
-    returnVal = delayMsOrVal
-  }
-
-  if (typeof delayMs != 'number') {
-    throw new Error('Bad delay value ' + delayMs)
-  }
-
-  var defer = new Promise()
-  setTimeout(function onDelay() {
-    defer.resolve(returnVal)
-  }, delayMs)
-  return defer
-}
-
-/**
- * Returns a promise that has the same result as `this`, but fulfilled
- * after at least ms milliseconds
- * @param {number} ms
- */
-Promise.prototype.delay = function (ms) {
-  return this.then(function (val) {
-    return delay(val, ms)
-  })
-}
-
-/**
- * Return a promise which will evaluate the function fn in a future turn with
- * the provided args
- *
- * @param {function(...)} fn
- * @param {...*} var_args a variable number of arguments
- * @return {!Promise}
- */
-function fcall(fn, var_args) {
-  var rootArgs = Array.prototype.slice.call(arguments, 1)
-  var defer = new Promise()
-  nextTick(nextTickCallback.bind(null, defer, fn, undefined, rootArgs))
-  return defer
-}
-
-
-/**
- * Returns a promise that will be invoked with the result of a node style
- * callback. All args to fn should be given except for the final callback arg
- *
- * @param {function(...)} fn
- * @param {...*} var_args a variable number of arguments
- * @return {!Promise}
- */
-function nfcall(fn, var_args) {
-  // Insert an undefined argument for scope and let bindPromise() do the work.
-  var args = Array.prototype.slice.call(arguments, 0)
-  args.splice(1, 0, undefined)
-  return ncall.apply(undefined, args)
-}
-
-
-/**
- * Like `nfcall`, but permits passing a `this` context for the call.
- *
- * @param {function(...)} fn
- * @param {Object} scope
- * @param {...*} var_args
- * @return {!Promise}
- */
-function ncall(fn, scope, var_args) {
-  return bindPromise.apply(null, arguments)()
-}
-
-
-/**
- * Binds a function to a scope with an optional number of curried arguments. Attaches
- * a node style callback as the last argument and returns a promise
- *
- * @param {function(...)} fn
- * @param {Object} scope
- * @param {...*} var_args a variable number of arguments
- * @return {function(...)}: !Promise}
- */
-function bindPromise(fn, scope, var_args) {
-  var rootArgs = Array.prototype.slice.call(arguments, 2)
-  return function onBoundPromise(var_args) {
-    var defer = new Promise()
-    try {
-      fn.apply(scope, rootArgs.concat(Array.prototype.slice.call(arguments, 0), defer.makeNodeResolver()))
-    } catch (e) {
-      defer.reject(e)
-    }
-    return defer
-  }
-}
-
-module.exports = {
-  all: all,
-  bindPromise: bindPromise,
-  defer: defer,
-  delay: delay,
-  fcall: fcall,
-  isPromise: isPromise,
-  isPromiseLike: isPromiseLike,
-  ncall: ncall,
-  nfcall: nfcall,
-  resolve: resolve,
-  reject: reject,
-  spread: spread,
-  stats: stats,
-  allSettled: allSettled,
-  Promise: Promise,
-  getNextTickFunction: getNextTickFunction,
-  setNextTickFunction: setNextTickFunction,
-}