Source: tools/Defer.js

  1. require('../../docs');
  4. /**
  5.  * A function that creates an awaitable timout.
  6.  * 
  7.  * @param {Number} ms Milliseconds to wait before resolving
  8.  * @returns {Promise<void>} a Promise that is resolved after
  9.  * the amount of milliseconds given.
  10.  */
  11. const timeout = ms => new Promise((resolve, reject) => {
  12. 	setTimeout(resolve, ms);
  13. });
  16. /**
  17.  * @template T
  18.  * 
  19.  * Creates a deferred Promise and returns an object with functions
  20.  * that can be used to resolve or reject the deferred.
  21.  * 
  22.  * @returns {Deferred<T>}
  23.  */
  24. const defer = () => {
  25. 	/** @type {DeferredClass<T>} */
  26. 	return new DeferredClass();
  27. };
  31. /**
  32.  * @template T
  33.  */
  34. class DeferredClass {
  35. 	constructor() {
  36. 		/** @private */
  37. 		this._resolve = null;
  38. 		/** @private */
  39. 		this._reject = null;
  41. 		const that = this;
  42. 		/** @private */
  43. 		this._promise = new Promise((resolve, reject) => {
  44. 			that._resolve = resolve;
  45. 			that._reject = reject;
  46. 		});
  48. 		/** @private */
  49. 		this._isResolved = false;
  50. 		/** @private */
  51. 		this._isRejected = false;
  52. 	};
  54. 	/**
  55. 	 * @type {Boolean}
  56. 	 */
  57. 	get isResolved() {
  58. 		return this._isResolved;
  59. 	};
  61. 	/**
  62. 	 * @type {Boolean}
  63. 	 */
  64. 	get isRejected() {
  65. 		return this._isRejected;
  66. 	};
  68. 	/**
  69. 	 * @type {Promise<T>}
  70. 	 */
  71. 	get promise() {
  72. 		return this._promise;
  73. 	};
  75. 	/**
  76. 	 * @param {T} useValue
  77. 	 * @returns {this}
  78. 	 */
  79. 	resolve(useValue) {
  80. 		if (this.isResolved) {
  81. 			throw new Error('Already resolved');
  82. 		}
  83. 		if (this.isRejected) {
  84. 			throw new Error('Already rejected');
  85. 		}
  86. 		this._isResolved = true;
  87. 		this._resolve(useValue);
  88. 		return this;
  89. 	};
  91. 	/**
  92. 	 * @param {any} [error]
  93. 	 * @returns {this}
  94. 	 */
  95. 	reject(error) {
  96. 		if (this.isRejected) {
  97. 			throw new Error('Already rejected')
  98. 		}
  99. 		if (this.isResolved) {
  100. 			throw new Error('Already resolved');
  101. 		}
  102. 		this._isRejected = true;
  103. 		this._reject(...arguments);
  104. 		return this;
  105. 	};
  106. };
  109. /**
  110.  * Mocha does not support this use case (async function with done):
  111.  * https://github.com/mochajs/mocha/issues/2407#issuecomment-237408877
  112.  * This function creates a deferred that can be resolved/rejected using
  113.  * a generic done-callback.
  114.  * 
  115.  * @returns {[Promise<any>, callbackHandler<any>]} an array where
  116.  * the first element is the promise that can be returned to mocha's test
  117.  * runner and the second element is the done-function, which, when called
  118.  * with no arguments, resolves the promise. Otherwise, it will reject the
  119.  * promise.
  120.  */
  121. const deferMocha = () => {
  122. 	const deferred = defer();
  124. 	return [deferred.promise, error => {
  125. 		if (error === void 0) {
  126. 			deferred.resolve();
  127. 		} else {
  128. 			deferred.reject(error);
  129. 		}
  130. 	}];
  131. };
  133. module.exports = Object.freeze({
  134. 	timeout,
  135. 	defer,
  136. 	deferMocha,
  137. 	DeferredClass
  138. });