//// Ext.promise.Consequence adapted from:// [DeftJS](https://github.com/deftjs/deftjs5)// Copyright (c) 2012-2013 [DeftJS Framework Contributors](http://deftjs.org)// Open source under the [MIT License](http://en.wikipedia.org/wiki/MIT_License).// /** * Consequences are used internally by a Deferred to capture and notify callbacks, and * propagate their transformed results as fulfillment or rejection. * * Developers never directly interact with a Consequence. * * A Consequence forms a chain between two Deferreds, where the result of the first * Deferred is transformed by the corresponding callback before being applied to the * second Deferred. * * Each time a Deferred's `then` method is called, it creates a new Consequence that will * be triggered once its originating Deferred has been fulfilled or rejected. A Consequence * captures a pair of optional onFulfilled and onRejected callbacks. * * Each Consequence has its own Deferred (which in turn has a Promise) that is resolved or * rejected when the Consequence is triggered. When a Consequence is triggered by its * originating Deferred, it calls the corresponding callback and propagates the transformed * result to its own Deferred; resolved with the callback return value or rejected with any * error thrown by the callback. * * @since 6.0.0 * @private */Ext.define('Ext.promise.Consequence', function(Consequence) { return { // eslint-disable-line brace-style, max-len /** * @property {Ext.promise.Promise} * Promise of the future value of this Consequence. */ promise: null, /** * @property {Ext.promise.Deferred} deferred Internal Deferred for this Consequence. * * @private */ deferred: null, /** * @property {Function} onFulfilled Callback to execute when this Consequence is triggered * with a fulfillment value. * * @private */ onFulfilled: null, /** * @property {Function} onRejected Callback to execute when this Consequence is triggered * with a rejection reason. * * @private */ onRejected: null, /** * @property {Function} onProgress Callback to execute when this Consequence is updated * with a progress value. * * @private */ onProgress: null, /** * @param {Function} onFulfilled Callback to execute to transform a fulfillment value. * @param {Function} onRejected Callback to execute to transform a rejection reason. * @param {Function} onProgress Callback to execute to transform a progress value. */ constructor: function(onFulfilled, onRejected, onProgress) { var me = this; me.onFulfilled = onFulfilled; me.onRejected = onRejected; me.onProgress = onProgress; me.deferred = new Ext.promise.Deferred(); me.promise = me.deferred.promise; }, /** * Trigger this Consequence with the specified action and value. * * @param {String} action Completion action (i.e. fulfill or reject). * @param {Mixed} value Fulfillment value or rejection reason. */ trigger: function(action, value) { var me = this, deferred = me.deferred; switch (action) { case 'fulfill': me.propagate(value, me.onFulfilled, deferred, deferred.resolve); break; case 'reject': me.propagate(value, me.onRejected, deferred, deferred.reject); break; } }, /** * Update this Consequence with the specified progress value. * * @param {Mixed} progress Progress value. */ update: function(progress) { if (Ext.isFunction(this.onProgress)) { progress = this.onProgress(progress); } this.deferred.update(progress); }, /** * Transform and propagate the specified value using the * optional callback and propagate the transformed result. * * @param {Mixed} value Value to transform and/or propagate. * @param {Function} [callback] Callback to use to transform the value. * @param {Function} deferred Deferred to use to propagate the value, if no callback * was specified. * @param {Function} deferredMethod Deferred method to call to propagate the value, * if no callback was specified. * * @private */ propagate: function(value, callback, deferred, deferredMethod) { if (Ext.isFunction(callback)) { this.schedule(function() { try { deferred.resolve(callback(value)); } catch (e) { deferred.reject(e); } }); } else { deferredMethod.call(this.deferred, value); } }, /** * Schedules the specified callback function to be executed on the next turn of the * event loop. * * @param {Function} callback Callback function. * * @private */ schedule: function(callback) { var n = Consequence.queueSize++; Consequence.queue[n] = callback; if (!n) { // if (queue was empty) Ext.asap(Consequence.dispatch); } }, statics: { /** * @property {Function[]} queue The queue of callbacks pending. This array is never * shrunk to reduce GC thrash but instead its elements will be set to `null`. * * @private */ queue: new Array(10000), /** * @property {Number} queueSize The number of callbacks in the `queue`. * * @private */ queueSize: 0, /** * This method drains the callback queue and calls each callback in order. * * @private */ dispatch: function() { var queue = Consequence.queue, fn, i; // The queue could grow on each call, so we cannot cache queueSize here. for (i = 0; i < Consequence.queueSize; ++i) { fn = queue[i]; queue[i] = null; // release our reference on the callback fn(); } Consequence.queueSize = 0; } }};}//<debug>, function(Consequence) { // eslint-disable-line comma-style Consequence.dispatch.$skipTimerCheck = true;}//</debug>);