postdoc 0.2.0.beta4 → 0.2.4

data/node_modules/es6-promise/lib/es6-promise/promise/all.js

@@ -1,52 +0,0 @@
-import Enumerator from '../enumerator';
-
-/**
-  `Promise.all` accepts an array of promises, and returns a new promise which
-  is fulfilled with an array of fulfillment values for the passed promises, or
-  rejected with the reason of the first passed promise to be rejected. It casts all
-  elements of the passed iterable to promises as it runs this algorithm.
-
-  Example:
-
-  ```javascript
-  let promise1 = resolve(1);
-  let promise2 = resolve(2);
-  let promise3 = resolve(3);
-  let promises = [ promise1, promise2, promise3 ];
-
-  Promise.all(promises).then(function(array){
-    // The array here would be [ 1, 2, 3 ];
-  });
-  ```
-
-  If any of the `promises` given to `all` are rejected, the first promise
-  that is rejected will be given as an argument to the returned promises's
-  rejection handler. For example:
-
-  Example:
-
-  ```javascript
-  let promise1 = resolve(1);
-  let promise2 = reject(new Error("2"));
-  let promise3 = reject(new Error("3"));
-  let promises = [ promise1, promise2, promise3 ];
-
-  Promise.all(promises).then(function(array){
-    // Code here never runs because there are rejected promises!
-  }, function(error) {
-    // error.message === "2"
-  });
-  ```
-
-  @method all
-  @static
-  @param {Array} entries array of promises
-  @param {String} label optional string for labeling the promise.
-  Useful for tooling.
-  @return {Promise} promise that is fulfilled when all `promises` have been
-  fulfilled, or rejected if any of them become rejected.
-  @static
-*/
-export default function all(entries) {
-  return new Enumerator(this, entries).promise;
-}

data/node_modules/es6-promise/lib/es6-promise/promise/race.js

@@ -1,84 +0,0 @@
-import {
-  isArray
-} from "../utils";
-
-/**
-  `Promise.race` returns a new promise which is settled in the same way as the
-  first passed promise to settle.
-
-  Example:
-
-  ```javascript
-  let promise1 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 1');
-    }, 200);
-  });
-
-  let promise2 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 2');
-    }, 100);
-  });
-
-  Promise.race([promise1, promise2]).then(function(result){
-    // result === 'promise 2' because it was resolved before promise1
-    // was resolved.
-  });
-  ```
-
-  `Promise.race` is deterministic in that only the state of the first
-  settled promise matters. For example, even if other promises given to the
-  `promises` array argument are resolved, but the first settled promise has
-  become rejected before the other promises became fulfilled, the returned
-  promise will become rejected:
-
-  ```javascript
-  let promise1 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 1');
-    }, 200);
-  });
-
-  let promise2 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      reject(new Error('promise 2'));
-    }, 100);
-  });
-
-  Promise.race([promise1, promise2]).then(function(result){
-    // Code here never runs
-  }, function(reason){
-    // reason.message === 'promise 2' because promise 2 became rejected before
-    // promise 1 became fulfilled
-  });
-  ```
-
-  An example real-world use case is implementing timeouts:
-
-  ```javascript
-  Promise.race([ajax('foo.json'), timeout(5000)])
-  ```
-
-  @method race
-  @static
-  @param {Array} promises array of promises to observe
-  Useful for tooling.
-  @return {Promise} a promise which settles in the same way as the first passed
-  promise to settle.
-*/
-export default function race(entries) {
-  /*jshint validthis:true */
-  let Constructor = this;
-
-  if (!isArray(entries)) {
-    return new Constructor((_, reject) => reject(new TypeError('You must pass an array to race.')));
-  } else {
-    return new Constructor((resolve, reject) => {
-      let length = entries.length;
-      for (let i = 0; i < length; i++) {
-        Constructor.resolve(entries[i]).then(resolve, reject);
-      }
-    });
-  }
-}

data/node_modules/es6-promise/lib/es6-promise/promise/reject.js

@@ -1,46 +0,0 @@
-import {
-  noop,
-  reject as _reject
-} from '../-internal';
-
-/**
-  `Promise.reject` returns a promise rejected with the passed `reason`.
-  It is shorthand for the following:
-
-  ```javascript
-  let promise = new Promise(function(resolve, reject){
-    reject(new Error('WHOOPS'));
-  });
-
-  promise.then(function(value){
-    // Code here doesn't run because the promise is rejected!
-  }, function(reason){
-    // reason.message === 'WHOOPS'
-  });
-  ```
-
-  Instead of writing the above, your code now simply becomes the following:
-
-  ```javascript
-  let promise = Promise.reject(new Error('WHOOPS'));
-
-  promise.then(function(value){
-    // Code here doesn't run because the promise is rejected!
-  }, function(reason){
-    // reason.message === 'WHOOPS'
-  });
-  ```
-
-  @method reject
-  @static
-  @param {Any} reason value that the returned promise will be rejected with.
-  Useful for tooling.
-  @return {Promise} a promise rejected with the given `reason`.
-*/
-export default function reject(reason) {
-  /*jshint validthis:true */
-  let Constructor = this;
-  let promise = new Constructor(noop);
-  _reject(promise, reason);
-  return promise;
-}

data/node_modules/es6-promise/lib/es6-promise/promise/resolve.js

@@ -1,48 +0,0 @@
-import {
-  noop,
-  resolve as _resolve
-} from '../-internal';
-
-/**
-  `Promise.resolve` returns a promise that will become resolved with the
-  passed `value`. It is shorthand for the following:
-
-  ```javascript
-  let promise = new Promise(function(resolve, reject){
-    resolve(1);
-  });
-
-  promise.then(function(value){
-    // value === 1
-  });
-  ```
-
-  Instead of writing the above, your code now simply becomes the following:
-
-  ```javascript
-  let promise = Promise.resolve(1);
-
-  promise.then(function(value){
-    // value === 1
-  });
-  ```
-
-  @method resolve
-  @static
-  @param {Any} value value that the returned promise will be resolved with
-  Useful for tooling.
-  @return {Promise} a promise that will become fulfilled with the given
-  `value`
-*/
-export default function resolve(object) {
-  /*jshint validthis:true */
-  let Constructor = this;
-
-  if (object && typeof object === 'object' && object.constructor === Constructor) {
-    return object;
-  }
-
-  let promise = new Constructor(noop);
-  _resolve(promise, object);
-  return promise;
-}

data/node_modules/es6-promise/lib/es6-promise/then.js

@@ -1,32 +0,0 @@
-import {
-  invokeCallback,
-  subscribe,
-  FULFILLED,
-  REJECTED,
-  noop,
-  makePromise,
-  PROMISE_ID
-} from './-internal';
-
-import { asap } from './asap';
-
-export default function then(onFulfillment, onRejection) {
-  const parent = this;
-
-  const child = new this.constructor(noop);
-
-  if (child[PROMISE_ID] === undefined) {
-    makePromise(child);
-  }
-
-  const { _state } = parent;
-
-  if (_state) {
-    const callback = arguments[_state - 1];
-    asap(() => invokeCallback(_state, child, callback, parent._result));
-  } else {
-    subscribe(parent, child, onFulfillment, onRejection);
-  }
-
-  return child;
-}

data/node_modules/es6-promise/lib/es6-promise/utils.js

@@ -1,21 +0,0 @@
-export function objectOrFunction(x) {
-  let type = typeof x;
-  return x !== null && (type === 'object' || type === 'function');
-}
-
-export function isFunction(x) {
-  return typeof x === 'function';
-}
-
-export function isMaybeThenable(x) {
-  return x !== null && typeof x === 'object';
-}
-
-let _isArray;
-if (Array.isArray) {
-  _isArray = Array.isArray;
-} else {
-  _isArray = x => Object.prototype.toString.call(x) === '[object Array]';
-}
-
-export const isArray = _isArray;

data/node_modules/es6-promise/package.json

@@ -1,75 +0,0 @@
-{
-  "name": "es6-promise",
-  "namespace": "es6-promise",
-  "version": "4.2.4",
-  "description": "A lightweight library that provides tools for organizing asynchronous code",
-  "main": "dist/es6-promise.js",
-  "typings": "es6-promise.d.ts",
-  "directories": {
-    "lib": "lib"
-  },
-  "files": [
-    "dist",
-    "lib",
-    "es6-promise.d.ts",
-    "auto.js",
-    "!dist/test"
-  ],
-  "devDependencies": {
-    "babel-plugin-transform-es2015-arrow-functions": "^6.22.0",
-    "babel-plugin-transform-es2015-block-scoping": "^6.24.1",
-    "babel-plugin-transform-es2015-classes": "^6.24.1",
-    "babel-plugin-transform-es2015-computed-properties": "^6.24.1",
-    "babel-plugin-transform-es2015-constants": "^6.1.4",
-    "babel-plugin-transform-es2015-destructuring": "^6.23.0",
-    "babel-plugin-transform-es2015-parameters": "^6.24.1",
-    "babel-plugin-transform-es2015-shorthand-properties": "^6.24.1",
-    "babel-plugin-transform-es2015-spread": "^6.22.0",
-    "babel-plugin-transform-es2015-template-literals": "^6.22.0",
-    "babel6-plugin-strip-class-callcheck": "^6.0.0",
-    "broccoli-babel-transpiler": "^6.0.0",
-    "broccoli-concat": "^3.1.0",
-    "broccoli-merge-trees": "^2.0.0",
-    "broccoli-rollup": "^2.0.0",
-    "broccoli-stew": "^1.5.0",
-    "broccoli-uglify-js": "^0.2.0",
-    "broccoli-watchify": "^1.0.1",
-    "ember-cli": "2.18.0-beta.2",
-    "ember-cli-dependency-checker": "^2.1.0",
-    "git-repo-version": "1.0.1",
-    "json3": "^3.3.2",
-    "mocha": "^4.0.1",
-    "promises-aplus-tests-phantom": "^2.1.0-revise"
-  },
-  "scripts": {
-    "build": "ember build --environment production",
-    "start": "ember s",
-    "test": "ember test",
-    "test:server": "ember test --server",
-    "test:node": "ember test --launch Mocha",
-    "test:browser": "ember test --launch PhantomJS",
-    "prepublishOnly": "ember build --environment production"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/stefanpenner/es6-promise.git"
-  },
-  "bugs": {
-    "url": "https://github.com/stefanpenner/es6-promise/issues"
-  },
-  "browser": {
-    "vertx": false
-  },
-  "keywords": [
-    "promises",
-    "promise",
-    "polyfill",
-    "futures"
-  ],
-  "author": "Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)",
-  "license": "MIT",
-  "spm": {
-    "main": "dist/es6-promise.js"
-  },
-  "dependencies": {}
-}

data/node_modules/es6-promisify/README.md

@@ -1,89 +0,0 @@
-[![Travis CI](https://travis-ci.org/digitaldesignlabs/es6-promisify.svg)](https://travis-ci.org/digitaldesignlabs/es6-promisify)
-
-# es6-promisify
-
-Converts callback-based functions to Promise-based functions.
-
-## Install
-
-Install with [npm](https://npmjs.org/package/es6-promisify)
-
-```bash
-npm install --save es6-promisify
-```
-
-## Example
-
-```js
-"use strict";
-
-// Declare variables
-const promisify = require("es6-promisify");
-const fs = require("fs");
-
-// Convert the stat function
-const stat = promisify(fs.stat);
-
-// Now usable as a promise!
-stat("example.txt").then(function (stats) {
-    console.log("Got stats", stats);
-}).catch(function (err) {
-    console.error("Yikes!", err);
-});
-```
-
-## Promisify methods
-```js
-"use strict";
-
-// Declare variables
-const promisify = require("es6-promisify");
-const redis = require("redis").createClient(6379, "localhost");
-
-// Create a promise-based version of send_command
-const client = promisify(redis.send_command, redis);
-
-// Send commands to redis and get a promise back
-client("ping").then(function (pong) {
-    console.log("Got", pong);
-}).catch(function (err) {
-    console.error("Unexpected error", err);
-}).then(function () {
-    redis.quit();
-});
-```
-
-## Handle callback multiple arguments
-```js
-"use strict";
-
-// Declare functions
-function test(cb) {
-    return cb(undefined, 1, 2, 3);
-}
-
-// Declare variables
-const promisify = require("es6-promisify");
-
-// Create promise-based version of test
-const single = promisify(test);
-const multi = promisify(test, {multiArgs: true});
-
-// Discards additional arguments
-single().then(function (result) {
-    console.log(result); // 1
-});
-
-// Returns all arguments as an array
-multi().then(function (result) {
-    console.log(result); // [1, 2, 3]
-});
-```
-
-### Tests
-Test with nodeunit
-```bash
-$ npm test
-```
-
-Published under the [MIT License](http://opensource.org/licenses/MIT).