All files resolvable-promise.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7x
258x
 
258x
258x
258x
 
 
258x
 
 
 
 
 
 
 
258x
258x
 
 
258x
258x
 
 
258x
 
 
 
 
 
 
 
 
81x
 
79x
79x
79x
 
79x
 
 
 
 
 
 
 
 
9x
 
7x
7x
7x
 
7x
 
 
 
 
 
 
 
90x
4x
 
 
 
/**
 * © 2014 Liferay, Inc. <https://liferay.com>
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later
 */
 
/**
 * A Promise with resolve() and reject() methods so that it can be fulfilled
 * asynchronously from outside instead of the callback.
 *
 * Because Promise cannot be extended in the usual way, we need to do some
 * magic to define this class.
 */
export default class ResolvablePromise {
	/**
	 * Don't construct ResolvablePromise objects directly: rely on
	 * ResolvablePromise.new() instead.
	 */
	constructor() {
		throw new Error(
			"Don't construct ResolvablePromise objects directly: " +
				'rely on ResolvablePromise.new() instead'
		);
	}
}
 
ResolvablePromise.new = () => {
	const capture = {};
 
	const promise = new Promise((resolve, reject) => {
		capture._resolve = resolve;
		capture._reject = reject;
	});
 
	Object.assign(promise, capture, {
		fulfilled: false,
		resolved: false,
		rejected: false,
		resolution: undefined,
		rejection: undefined,
	});
 
	promise.resolve = value => resolve(promise, value);
	promise.reject = error => reject(promise, error);
 
	// This is to avoid UnhandledPromiseRejectionWarning errors during the tests
	Eif (typeof jest !== 'undefined') {
		promise.catch(() => {});
	}
 
	return promise;
};
 
/**
 * Resolve the promise
 * @param {ResolvablePromise} resolvablePromise
 * @param {*} value
 */
function resolve(resolvablePromise, value) {
	_assertNotFulfilled(resolvablePromise);
 
	resolvablePromise.fulfilled = true;
	resolvablePromise.resolved = true;
	resolvablePromise.resolution = value;
 
	resolvablePromise._resolve(value);
}
 
/**
 * Reject the Promise
 * @param {ResolvablePromise} resolvablePromise
 * @param {Error} error
 */
function reject(resolvablePromise, error) {
	_assertNotFulfilled(resolvablePromise);
 
	resolvablePromise.fulfilled = true;
	resolvablePromise.rejected = true;
	resolvablePromise.rejection = error;
 
	resolvablePromise._reject(error);
}
 
/**
 * Throws if Promise is already fulfilled
 * @param {ResolvablePromise} resolvablePromise
 */
function _assertNotFulfilled(resolvablePromise) {
	if (resolvablePromise.fulfilled) {
		throw new Error('Promise already fulfilled');
	}
}