promise-useful-utils/lib/defer.js

useful functions for working with promises

/**
 * @class Deferred
 */
'use strict';

var _createClass = require('babel-runtime/helpers/create-class')['default'];

var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];

var _Promise = require('babel-runtime/core-js/promise')['default'];

Object.defineProperty(exports, '__esModule', {
  value: true
});
exports.defer = defer;

var Deferred = (function () {
  /**
   * @constructor
   */

  function Deferred() {
    var _this = this;

    _classCallCheck(this, Deferred);

    this._value = null;
    this._reason = null;

    this.promise = new _Promise(function (resolve, reject) {
      _this._resolve = resolve;
      _this._reject = reject;
    });
  }

  /**
   * @param {*} value
   */

  _createClass(Deferred, [{
    key: 'resolve',
    value: function resolve(value) {
      if (this.isPending()) {
        this._value = value;
        this._resolve(value);
      }
    }

    /**
     * @param {*} reason
     */
  }, {
    key: 'reject',
    value: function reject(reason) {
      if (this.isPending()) {
        this._reason = reason;
        this._reject(reason);
      }
    }

    /**
     * @return {boolean}
     */
  }, {
    key: 'isFulfilled',
    value: function isFulfilled() {
      return this._value !== null;
    }

    /**
     * @return {boolean}
     */
  }, {
    key: 'isRejected',
    value: function isRejected() {
      return this._reason !== null;
    }

    /**
     * @return {boolean}
     */
  }, {
    key: 'isPending',
    value: function isPending() {
      return this._value === null && this._reason === null;
    }

    /**
     * @return {*}
     * @throws {TypeError}
     */
  }, {
    key: 'value',
    value: function value() {
      if (!this.isFulfilled()) {
        throw new TypeError('cannot get fulfillment value of a non-fulfilled promise');
      }

      return this._value;
    }

    /**
     * @return {*}
     * @throws {TypeError}
     */
  }, {
    key: 'reason',
    value: function reason() {
      if (!this.isRejected()) {
        throw new TypeError('cannot get rejection reason of a non-rejected promise');
      }

      return this._reason;
    }
  }]);

  return Deferred;
})();

function defer() {
  return new Deferred();
}