pdf-creator-node 1.4.0 → 1.4.1

package/example/node_modules/kew/package.json

@@ -1,63 +0,0 @@
-{
-  "_args": [
-    [
-      "kew@0.7.0",
-      "/Users/Shyam/Work/NPM/pdf-creator-node/example"
-    ]
-  ],
-  "_from": "kew@0.7.0",
-  "_id": "kew@0.7.0",
-  "_inBundle": false,
-  "_integrity": "sha1-edk9LTM2PW/dKXCzNdkUGtWR15s=",
-  "_location": "/kew",
-  "_optional": true,
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "kew@0.7.0",
-    "name": "kew",
-    "escapedName": "kew",
-    "rawSpec": "0.7.0",
-    "saveSpec": null,
-    "fetchSpec": "0.7.0"
-  },
-  "_requiredBy": [
-    "/phantomjs-prebuilt"
-  ],
-  "_resolved": "https://registry.npmjs.org/kew/-/kew-0.7.0.tgz",
-  "_spec": "0.7.0",
-  "_where": "/Users/Shyam/Work/NPM/pdf-creator-node/example",
-  "authors": [
-    "Jeremy Stanley <github@azulus.com> (https://github.com/azulus)",
-    "Nick Santos <nick@medium.com>",
-    "Xiao Ma <x@medium.com>"
-  ],
-  "bugs": {
-    "url": "https://github.com/Medium/kew/issues"
-  },
-  "contributors": [],
-  "dependencies": {},
-  "description": "a lightweight promise library for node",
-  "devDependencies": {
-    "closure-npc": "0.1.5",
-    "nodeunit": "0.9.0",
-    "q": "0.9.7"
-  },
-  "homepage": "https://github.com/Medium/kew",
-  "keywords": [
-    "kew",
-    "promises"
-  ],
-  "license": "Apache-2.0",
-  "main": "./kew.js",
-  "name": "kew",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Medium/kew.git"
-  },
-  "scripts": {
-    "test": "nodeunit test && closure-npc ./test/closure_test.js --jscomp_error=checkTypes"
-  },
-  "version": "0.7.0"
-}

package/example/node_modules/kew/test/chain.js

@@ -1,434 +0,0 @@
-var Q = require('../kew')
-var originalQ = require('q')
-
-// test that fin() works with a synchronous resolve
-exports.testSynchronousThenAndFin = function (test) {
-  var vals = ['a', 'b']
-  var counter = 0
-
-  var promise1 = Q.resolve(vals[0])
-  var promise2 = promise1.fin(function () {
-    counter++
-  })
-  var promise3 = promise2.then(function (data) {
-    if (data === vals[0]) return vals[1]
-  })
-  var promise4 = promise3.fin(function () {
-    counter++
-  })
-
-  Q.all([promise2, promise4])
-    .then(function (data) {
-      test.equal(counter, 2, "fin() should have been called twice")
-      test.equal(data[0], vals[0], "first fin() should return the first val")
-      test.equal(data[1], vals[1], "second fin() should return the second val")
-      test.done()
-    })
-}
-
-// test that fin() works with a synchronous reject
-exports.testSynchronousFailAndFin = function (test) {
-  var errs = []
-  errs.push(new Error('nope 1'))
-  errs.push(new Error('nope 2'))
-  var counter = 0
-
-  var promise1 = Q.reject(errs[0])
-  var promise2 = promise1.fin(function () {
-    counter++
-  })
-  var promise3 = promise2.fail(function (e) {
-    if (e === errs[0]) throw errs[1]
-  })
-  var promise4 = promise3.fin(function () {
-    counter++
-  })
-
-  Q.all([
-    promise2.fail(function (e) {
-      return e === errs[0]
-    }),
-    promise4.fail(function (e) {
-      return e === errs[1]
-    })
-  ])
-    .then(function (data) {
-      test.equal(counter, 2, "fin() should have been called twice")
-      test.equal(data[0] && data[1], true, "all promises should return true")
-      test.done()
-    })
-}
-
-// test that fin() works with an asynchrnous resolve
-exports.testAsynchronousThenAndFin = function (test) {
-  var vals = ['a', 'b']
-  var counter = 0
-
-  var defer = Q.defer()
-  setTimeout(function () {
-    defer.resolve(vals[0])
-  })
-  var promise1 = defer.promise
-  var promise2 = promise1.fin(function () {
-    counter++
-  })
-  var promise3 = promise2.then(function (data) {
-    if (data !== vals[0]) return
-
-    var defer = Q.defer()
-    setTimeout(function () {
-      defer.resolve(vals[1])
-    })
-    return defer.promise
-  })
-  var promise4 = promise3.fin(function () {
-    counter++
-  })
-
-  Q.all([promise2, promise4])
-    .then(function (data) {
-      test.equal(counter, 2, "fin() should have been called twice")
-      test.equal(data[0], vals[0], "first fin() should return the first val")
-      test.equal(data[1], vals[1], "second fin() should return the second val")
-      test.done()
-    })
-}
-
-// test that fin() works with an asynchronous reject
-exports.testAsynchronousFailAndFin = function (test) {
-  var errs = []
-  errs.push(new Error('nope 1'))
-  errs.push(new Error('nope 2'))
-  var counter = 0
-
-  var defer = Q.defer()
-  setTimeout(function () {
-    defer.reject(errs[0])
-  }, 10)
-  var promise1 = defer.promise
-  var promise2 = promise1.fin(function () {
-    counter++
-  })
-  var promise3 = promise2.fail(function (e) {
-    if (e !== errs[0]) return
-
-    var defer = Q.defer()
-    setTimeout(function () {
-      defer.reject(errs[1])
-    }, 10)
-
-    return defer.promise
-  })
-  var promise4 = promise3.fin(function () {
-    counter++
-  })
-
-  Q.all([
-    promise2.fail(function (e) {
-      return e === errs[0]
-    }),
-    promise4.fail(function (e) {
-      return e === errs[1]
-    })
-  ])
-    .then(function (data) {
-      test.equal(counter, 2, "fin() should have been called twice")
-      test.equal(data[0] && data[1], true, "all promises should return true")
-      test.done()
-    })
-}
-
-// test several thens chaining
-exports.testChainedThens = function (test) {
-  var promise1 = Q.resolve('a')
-  var promise2 = promise1.then(function(data) {
-    return data + 'b'
-  })
-  var promise3 = promise2.then(function (data) {
-    return data + 'c'
-  })
-  // testing the same promise again to make sure they can run side by side
-  var promise4 = promise2.then(function (data) {
-    return data + 'c'
-  })
-
-  Q.all([promise1, promise2, promise3, promise4])
-    .then(function (data) {
-      test.equal(data[0], 'a')
-      test.equal(data[1], 'ab')
-      test.equal(data[2], 'abc')
-      test.equal(data[3], 'abc')
-      test.done()
-    })
-}
-
-// test several fails chaining
-exports.testChainedFails = function (test) {
-  var errs = []
-  errs.push(new Error("first err"))
-  errs.push(new Error("second err"))
-  errs.push(new Error("third err"))
-
-  var promise1 = Q.reject(errs[0])
-  var promise2 = promise1.fail(function (e) {
-    if (e === errs[0]) throw errs[1]
-  })
-  var promise3 = promise2.fail(function (e) {
-    if (e === errs[1]) throw errs[2]
-  })
-  var promise4 = promise2.fail(function (e) {
-    if (e === errs[1]) throw errs[2]
-  })
-
-  Q.all([
-    promise1.fail(function (e) {
-      return e === errs[0]
-    }),
-    promise2.fail(function (e) {
-      return e === errs[1]
-    }),
-    promise3.fail(function (e) {
-      return e === errs[2]
-    }),
-    promise4.fail(function (e) {
-      return e === errs[2]
-    })
-  ])
-  .then(function (data) {
-    test.equal(data[0] && data[1] && data[2] && data[3], true)
-    test.done()
-  })
-}
-
-// test that we can call end without callbacks and not fail
-exports.testEndNoCallbacks = function (test) {
-  Q.resolve(true).end()
-  test.ok("Ended successfully")
-  test.done()
-}
-
-// test that we can call end with callbacks and fail
-exports.testEndNoCallbacksThrows = function (test) {
-  var testError = new Error('Testing')
-  try {
-    Q.reject(testError).end()
-    test.fail("Should throw an error")
-  } catch (e) {
-    test.equal(e, testError, "Should throw the correct error")
-  }
-  test.done()
-}
-
-// test chaining when a promise returns a promise
-exports.testChainedPromises = function (test) {
-  var err = new Error('nope')
-  var val = 'ok'
-
-  var shouldFail = Q.reject(err)
-  var shouldSucceed = Q.resolve(val)
-
-  Q.resolve("start")
-    .then(function () {
-      return shouldFail
-    })
-    .fail(function (e) {
-      if (e === err) return shouldSucceed
-      else throw e
-    })
-    .then(function (data) {
-      test.equal(data, val, "val should be returned")
-      test.done()
-    })
-}
-
-// test .end() is called with no parent scope (causing an uncaught exception)
-exports.testChainedEndUncaught = function (test) {
-  var uncaughtErrors = 0
-  var errs = []
-  errs.push(new Error('nope 1'))
-  errs.push(new Error('nope 2'))
-  errs.push(new Error('nope 3'))
-
-  var cb = function (e) {
-    uncaughtErrors++
-    if (e === errs[2]) {
-      test.equal(uncaughtErrors, 3, "Errors should be uncaught")
-      process.removeListener('uncaughtException', cb)
-      test.done()
-    }
-  }
-  process.on('uncaughtException', cb)
-
-  var defer = Q.defer()
-  defer.promise.end()
-
-  var promise1 = defer.promise
-  var promise2 = promise1.fail(function (e) {
-    if (e === errs[0]) throw errs[1]
-  })
-  var promise3 = promise2.fail(function (e) {
-    if (e === errs[1]) throw errs[2]
-  })
-
-  promise1.end()
-  promise2.end()
-  promise3.end()
-
-  setTimeout(function () {
-    defer.reject(errs[0])
-  }, 10)
-}
-
-// test .end() is called with a parent scope and is caught
-exports.testChainedCaught = function (test) {
-  var err = new Error('nope')
-
-  try {
-    Q.reject(err).end()
-  } catch (e) {
-    test.equal(e, err, "Error should be caught")
-    test.done()
-  }
-}
-
-// test a mix of fails and thens
-exports.testChainedMixed = function (test) {
-  var errs = []
-  errs.push(new Error('nope 1'))
-  errs.push(new Error('nope 2'))
-  errs.push(new Error('nope 3'))
-
-  var vals = [3, 2, 1]
-
-  var promise1 = Q.reject(errs[0])
-  var promise2 = promise1.fail(function (e) {
-    if (e === errs[0]) return vals[0]
-  })
-  var promise3 = promise2.then(function (data) {
-    if (data === vals[0]) throw errs[1]
-  })
-  var promise4 = promise3.fail(function (e) {
-    if (e === errs[1]) return vals[1]
-  })
-  var promise5 = promise4.then(function (data) {
-    if (data === vals[1]) throw errs[2]
-  })
-  var promise6 = promise5.fail(function (e) {
-    if (e === errs[2]) return vals[2]
-  })
-
-  Q.all([
-    promise1.fail(function (e) {
-      return e === errs[0]
-    }),
-    promise2.then(function (data) {
-      return data === vals[0]
-    }),
-    promise3.fail(function (e) {
-      return e === errs[1]
-    }),
-    promise4.then(function (data) {
-      return data === vals[1]
-    }),
-    promise5.fail(function (e) {
-      return e === errs[2]
-    }),
-    promise6.then(function (data) {
-      return data === vals[2]
-    })
-  ])
-  .then(function (data) {
-    test.equal(data[0] && data[1] && data[2] && data[3] && data[4] && data[5], true, "All values should return true")
-    test.done()
-  })
-}
-
-exports.testInteroperabilityWithOtherPromises = function(test) {
-  var promise1 = Q.defer()
-  promise1.then(function(value) {
-    return originalQ(1 + value)
-  }).then(function(result) {
-    test.equal(result, 11)
-  })
-
-  var promise2 = Q.defer(),
-      errToThrow = new Error('error')
-  promise2.then(function() {
-    return originalQ.reject(errToThrow)
-  }).fail(function(err) {
-    test.equal(err, errToThrow)
-  })
-
-  promise1.resolve(10)
-  promise2.resolve()
-
-  Q.all([promise1, promise2]).then(function() {
-    test.done()
-  })
-}
-
-exports.testAllSettled = function(test) {
-  var promise1 = Q.resolve('woot')
-  var promise2 = Q.reject(new Error('oops'))
-
-  Q.allSettled([promise1, promise2, 'just a string'])
-    .then(function (data) {
-      test.equals('fulfilled', data[0].state)
-      test.equals('woot', data[0].value)
-      test.equals('rejected', data[1].state)
-      test.equals('oops', data[1].reason.message)
-      test.equals('fulfilled', data[2].state)
-      test.equals('just a string', data[2].value)
-    })
-
-  Q.allSettled([])
-    .then(function (data) {
-      test.equals(0, data.length)
-      test.done()
-    })
-}
-
-exports.testTimeout = function(test) {
-  var promise = Q.delay(50).timeout(45, 'Timeout message')
-  promise.then(function () {
-    test.fail('The promise is supposed to be timeout')
-  })
-  .fail(function (e) {
-    test.equals('Timeout message', e.message, 'The error message should be the one passed into timeout()')
-  })
-  .fin(test.done)
-}
-
-exports.testNotTimeout = function(test) {
-  var promise = Q.delay('expected data', 40).timeout(45, 'Timeout message')
-  promise.then(function (data) {
-    test.equals('expected data', data, 'The data should be the data from the original promise')
-  })
-  .fail(function (e) {
-    test.fail('The promise is supposed to be resolved before the timeout')
-  })
-  .fin(test.done)
-}
-
-exports.testNotTimeoutButReject = function(test) {
-  var promise = Q.delay(40).then(function() {throw new Error('Reject message')}).timeout(45, 'Timeout message')
-  promise.then(function (data) {
-    test.fail('The promise is supposed to be rejected')
-  })
-  .fail(function (e) {
-    test.equals('Reject message', e.message, 'The error message should be from the original promise')
-  })
-  .fin(test.done)
-}
-
-exports.testDelay = function (test) {
-  var timePassed = false
-  setTimeout(function () {
-    timePassed = true
-  }, 10)
-  Q.resolve('expected').delay(20).then(function (result) {
-    test.equal('expected', result)
-    test.ok(timePassed)
-    test.done()
-  })
-}

package/example/node_modules/kew/test/closure_test.js

@@ -1,135 +0,0 @@
-/**
- * @fileoverview A sample file to test type-checking
- */
-
-var kew = require('../kew')
-var Promise = kew.Promise
-var all = kew.all
-var allSettled = kew.allSettled
-var fcall = kew.fcall
-var nfcall = kew.nfcall
-var bindPromise = kew.bindPromise
-
-/**
-@param {Array} result
-*/
-var callback = function (result) {};
-
-/**
-@param {Array} result
-@param {Array} context
-*/
-var callbackWithContext = function (result, context) {};
-
-/**
- * @param {number} n
- * @param {*} result
- */
-var callbackNeedsBind = function (n, result) {};
-
-/**
-@param {Error} error
-*/
-var errorCallback = function (error) {};
-
-/**
-@param {Error} error
-@param {Array} context
-*/
-var errorCallbackWithContext = function (error, context) {};
-
-/** @return {kew.Promise.<string>} */
-var stringPromise = function () {
-  return kew.resolve('string')
-}
-
-var exampleThen = function () {
-  var examplePromise = new Promise();
-  examplePromise.then(callback);
-  examplePromise.setContext([]);
-  examplePromise.then(callbackWithContext);
-
-  examplePromise.then(null, errorCallback);
-  examplePromise.then(null, errorCallbackWithContext);
-};
-
-
-var thenBound = function () {
-  stringPromise().thenBound(callbackNeedsBind, null, 3).failBound(callbackNeedsBind, null, 3);
-};
-
-var examplePromise = function () {
-  var promise = new Promise(callback);
-  promise = new Promise(callbackWithContext);
-  promise = new Promise(null, errorCallback);
-  promise = new Promise(null, errorCallbackWithContext);
-};
-
-var exampleFail = function () {
-  var promise = new Promise();
-  promise.fail(errorCallback);
-  promise.fail(errorCallbackWithContext);
-};
-
-var exampleResolver = function () {
-  var promise = new Promise();
-  var resolver = promise.makeNodeResolver();
-  // success
-  resolver(null, {});
-  // failure
-  resolver(new Error(), null);
-};
-
-var exampleAll = function () {
-  // should not compile, but does
-  all([5]);
-  all([{}]);
-  all([null]);
-  all([new Promise(), {}]);
-  all([new Promise(), null]);
-
-  // good
-  var promise = all([]);
-  all([new Promise(), new Promise()]);
-};
-
-var exampleAllSettled = function () {
-  allSettled([]);
-  allSettled([5, {}, null, 'string']);
-  var promise = allSettled([new Promise()]);
-  promise.then(function(results){});
-};
-
-var exampleTimeout = function () {
-  var promise = new Promise();
-  var timeoutPromise = promise.timeout(50);
-  timeoutPromise.then(function(result){});
-};
-
-var noArgsFunction = function () {};
-
-var exampleFcall = function () {
-  fcall(noArgsFunction);
-  fcall(callback, []);
-  fcall(callbackWithContext, [], 5);
-};
-
-/** @param {function(Error, *)} nodeCallback */
-var noArgsWithNodeCallback = function (nodeCallback) {};
-
-/**
-@param {!Array} argument
-@param {function(Error, *)} nodeCallback
-*/
-var oneArgWithNodeCallback = function (argument, nodeCallback) {};
-
-var exampleNfcall = function () {
-  var promise = nfcall(noArgsWithNodeCallback);
-  promise = nfcall(oneArgWithNodeCallback, []);
-};
-
-var exampleBindPromise = function () {
-  callback = bindPromise(noArgsWithNodeCallback, null);
-  callback = bindPromise(noArgsWithNodeCallback, {});
-  callback = bindPromise(oneArgWithNodeCallback, null, []);
-};

package/example/node_modules/kew/test/context.js

@@ -1,89 +0,0 @@
-var Q = require('../kew')
-
-// test that contexts are propogated based on position
-exports.testContextWithDelay = function (test) {
-
-	Q.resolve(true)
-	  .setContext({id: 1})
-	  .then(function (val, context) {
-	  	test.equal(context.id, 1, 'Should return the first context')
-	  	return Q.delay(500)
-	  })
-	  .setContext({id: 2})
-	  .then(function (val, context) {
-	  	test.equal(context.id, 2, 'Should return the second context')
-	  	return Q.delay(500)
-	  })
-	  .clearContext()
-	  .then(function (val, context) {
-	  	test.equal(typeof context, 'undefined', 'Should return an undefined context')
-	  	return Q.delay(500)
-	  })
-	  .setContext({id: 3})
-	  .fin(test.done)
-}
-
-// test adding and removing contexts
-exports.testGeneralContextFlow = function (test) {
-	Q.resolve(true)
-		// test no context exists
-	  .then(function (val, context) {
-	  	test.equal(typeof context, 'undefined', 'Context should be undefined')
-	  	throw new Error()
-	  })
-	  .fail(function (e, context) {
-	  	test.equal(typeof context, 'undefined', 'Context should be undefined')
-	  })
-
-	  // set the context and mutate it
-	  .setContext({counter: 1})
-	  .then(function (val, context) {
-	  	test.equal(context.counter, 1, 'Counter should be 1')
-	  	context.counter++
-	  })
-	  .then(function (val, context) {
-	  	test.equal(context.counter, 2, 'Counter should be 2')
-	  	context.counter++
-	  	throw new Error()
-	  })
-	  .fail(function (e, context) {
-	  	test.equal(context.counter, 3, 'Counter should be 3')
-	  })
-
-	  // return a context
-	  .then(function (val, context) {
-	  	return Q.resolve(false)
-	  	  .setContext({counter: 0})
-	  })
-	  .then(function (val, context) {
-	  	test.equal(context.counter, 0, 'Counter should be 0')
-	  	throw new Error()
-	  })
-	  .fail(function (e, context) {
-	  	test.equal(context.counter, 0, 'Counter should be 0')
-	  })
-
-	  // returning a promise with a cleared context won't clear the parent context
-	  .then(function (val, context) {
-	  	return Q.resolve(false).clearContext()
-	  })
-	  .then(function (val, context) {
-	  	test.equal(context.counter, 0, 'Counter should be 0')
-	  	throw new Error()
-	  })
-	  .fail(function (e, context) {
-	  	test.equal(context.counter, 0, 'Counter should be 0')
-	  })
-
-	  // test that clearing the context works
-	  .clearContext()
-	  .then(function (val, context) {
-	  	test.equal(typeof context, 'undefined', 'Context should be undefined')
-	  	throw new Error()
-	  })
-	  .fail(function (e, context) {
-	  	test.equal(typeof context, 'undefined', 'Context should be undefined')
-	  })
-
-	  .fin(test.done)
-}