Home Reference Source

src/utils/Queue.js


/**
 * @private
 * @typedef {Object} QueueItem
 * @property {Function} resolve The function to be called when resolution success.
 * @property {Function} reject The function to be called when resolution fails.
 * @property {Object} data The required data to be processed.
 */

/**
 * @private
 * @typedef {Object} QueueObserver
 * @property {Function<Array<QueueItem>>} commit
 */

/**
 * When a burst of calls to a function occurs, it stores all of
 * them and tries to get the result through an observer.
 * This allows to group those operations that can be carried out by
 * a single call.
 * @private
 */
export class Queue {

	/**
	 * @param {QueueObserver} observer Burst end observer
	 */
	constructor(observer) {

		/**
		 * List of queued request.
		 * @private
		 * @type {Array<QueueItem>}
		 */
		this._pending = [];

		/**
		 * Commit timer reference.
		 * @private
		 * @type {Number}
		 */
		this._timer = null;

		/**
		 * Commit function
		 * @private
		 * @type {QueueObserver}
		 */
		this._observer = observer;
	}

	/**
	 * Burst end observer
	 * @type {QueueObserver}
	 */
	set observer(observer) {
		this._observer = observer;
	}

	/**
	 * Add an element to burst queue
	 * @param {Object} data
	 * @return {Promise} resolved on success by burst observer.
	 */
	addToQueue(data) {
		if (this._timer) {
			clearTimeout(this._timer);
			this._timer = null;
		}
		return new Promise((resolve, reject) => {
			this._pending.push({
				resolve: resolve,
				reject: reject,
				data: data,
			});
			this._timer = setTimeout(() => {
				let pending = this._pending;
				this._pending = [];
				this._observer.commit(pending);
			}, 10);
		});
	}
}