BODY TITLE
Body content' + * }); + * + * // The click handler will only be called when the click occurs on the + * // delegate: h1.myTitle ("h1" tag with class "myTitle") + * panel.on({ + * click: function (e) { + * console.log(e.getTarget().innerHTML); + * }, + * element: 'body', + * delegate: 'h1.myTitle' + * }); + * + * @return {Object} **Only when the `destroyable` option is specified.** + * + * A `Destroyable` object. An object which implements the `destroy` method which removes + * all listeners added in this call. For example: + * + * this.btnListeners = = myButton.on({ + * destroyable: true + * mouseover: function() { console.log('mouseover'); }, + * mouseout: function() { console.log('mouseout'); }, + * click: function() { console.log('click'); } + * }); + * + * And when those listeners need to be removed: + * + * Ext.destroy(this.btnListeners); + * + * or + * + * this.btnListeners.destroy(); + */ + addListener: function(eventName, fn, scope, options, order, caller) { + var me = this, + namedScopes = Ext._namedScopes, + config, namedScope, isClassListener, innerScope, eventOptions; + // Object listener hash passed + if (typeof eventName !== 'string') { + options = eventName; + scope = options.scope; + namedScope = scope && namedScopes[scope]; + isClassListener = namedScope && namedScope.isSelf; + // give subclasses the opportunity to switch the valid eventOptions + // (Ext.Component uses this when the "element" option is used) + eventOptions = ((me.isComponent || me.isWidget) && options.element) ? me.$elementEventOptions : me.$eventOptions; + for (eventName in options) { + config = options[eventName]; + if (!eventOptions[eventName]) { + /* This would be an API change so check removed until https://sencha.jira.com/browse/EXTJSIV-7183 is fully implemented in 4.2 + // Test must go here as well as in the simple form because of + // the attempted property access here on the config object. + if (!config || (typeof config !== 'function' && !config.fn)) { + Ext.raise('No function passed for event ' + me.$className + '.' + + ename); + } + */ + innerScope = config.scope; + // for proper scope resolution, scope:'controller' specified on an + // inner object, must be translated to 'self.controller' if the + // listeners object was declared on the class body. + // see also Ext.util.Observable#prepareClass and + // Ext.mixin.Inheritable#resolveListenerScope + if (innerScope && isClassListener) { + namedScope = namedScopes[innerScope]; + if (namedScope && namedScope.isController) { + innerScope = 'self.controller'; + } + } + me.doAddListener(eventName, config.fn || config, innerScope || scope, config.fn ? config : options, order, caller); + } + } + if (options && options.destroyable) { + return new ListenerRemover(me, options); + } + } else { + me.doAddListener(eventName, fn, scope, options, order, caller); + if (options && options.destroyable) { + return new ListenerRemover(me, eventName, fn, scope, options); + } + } + return me; + }, + /** + * Removes an event handler. + * + * @param {String} eventName The type of event the handler was associated with. + * @param {Function} fn The handler to remove. **This must be a reference to the function + * passed into the + * {@link Ext.util.Observable#addListener addListener} call.** + * @param {Object} scope (optional) The scope originally specified for the handler. It + * must be the same as the scope argument specified in the original call to + * {@link Ext.util.Observable#addListener} or the listener will not be removed. + * @param eventOptions (private) + * + * **Convenience Syntax** + * + * You can use the {@link Ext.util.Observable#addListener addListener} + * `destroyable: true` config option in place of calling un(). For example: + * + * var listeners = cmp.on({ + * scope: cmp, + * afterrender: cmp.onAfterrender, + * beforehide: cmp.onBeforeHide, + * destroyable: true + * }); + * + * // Remove listeners + * listeners.destroy(); + * // or + * cmp.un( + * scope: cmp, + * afterrender: cmp.onAfterrender, + * beforehide: cmp.onBeforeHide + * ); + * + * **Exception - DOM event handlers using the element config option** + * + * You must go directly through the element to detach an event handler attached using + * the {@link Ext.util.Observable#addListener addListener} _element_ option. + * + * panel.on({ + * element: 'body', + * click: 'onBodyCLick' + * }); + * + * panel.body.un({ + * click: 'onBodyCLick' + * }); + */ + removeListener: function(eventName, fn, scope, eventOptions) { + var me = this, + config, options; + if (typeof eventName !== 'string') { + options = eventName; + // give subclasses the opportunity to switch the valid eventOptions + // (Ext.Component uses this when the "element" option is used) + eventOptions = eventOptions || me.$eventOptions; + for (eventName in options) { + if (options.hasOwnProperty(eventName)) { + config = options[eventName]; + if (!me.$eventOptions[eventName]) { + me.doRemoveListener(eventName, config.fn || config, config.scope || options.scope); + } + } + } + } else { + me.doRemoveListener(eventName, fn, scope); + } + return me; + }, + /** + * Appends a before-event handler. Returning `false` from the handler will stop the event. + * + * Same as {@link Ext.util.Observable#addListener addListener} with `order` set + * to `'before'`. + * + * @param {String/String[]/Object} eventName The name of the event to listen for. + * @param {Function/String} fn The method the event invokes. + * @param {Object} [scope] The scope for `fn`. + * @param {Object} [options] An object containing handler configuration. + */ + onBefore: function(eventName, fn, scope, options) { + return this.addListener(eventName, fn, scope, options, 'before'); + }, + /** + * Appends an after-event handler. + * + * Same as {@link Ext.util.Observable#addListener addListener} with `order` set + * to `'after'`. + * + * @param {String/String[]/Object} eventName The name of the event to listen for. + * @param {Function/String} fn The method the event invokes. + * @param {Object} [scope] The scope for `fn`. + * @param {Object} [options] An object containing handler configuration. + */ + onAfter: function(eventName, fn, scope, options) { + return this.addListener(eventName, fn, scope, options, 'after'); + }, + /** + * Removes a before-event handler. + * + * Same as {@link #removeListener} with `order` set to `'before'`. + * + * @param {String/String[]/Object} eventName The name of the event the handler + * was associated with. + * @param {Function/String} fn The handler to remove. + * @param {Object} [scope] The scope originally specified for `fn`. + * @param {Object} [options] Extra options object. + */ + unBefore: function(eventName, fn, scope, options) { + return this.removeListener(eventName, fn, scope, options, 'before'); + }, + /** + * Removes a before-event handler. + * + * Same as {@link #removeListener} with `order` set to `'after'`. + * + * @param {String/String[]/Object} eventName The name of the event the handler + * was associated with. + * @param {Function/String} fn The handler to remove. + * @param {Object} [scope] The scope originally specified for `fn`. + * @param {Object} [options] Extra options object. + */ + unAfter: function(eventName, fn, scope, options) { + return this.removeListener(eventName, fn, scope, options, 'after'); + }, + /** + * Alias for {@link #onBefore}. + */ + addBeforeListener: function() { + return this.onBefore.apply(this, arguments); + }, + /** + * Alias for {@link #onAfter}. + */ + addAfterListener: function() { + return this.onAfter.apply(this, arguments); + }, + /** + * Alias for {@link #unBefore}. + */ + removeBeforeListener: function() { + return this.unBefore.apply(this, arguments); + }, + /** + * Alias for {@link #unAfter}. + */ + removeAfterListener: function() { + return this.unAfter.apply(this, arguments); + }, + /** + * Removes all listeners for this object including the managed listeners + */ + clearListeners: function() { + var me = this, + events = me.events, + hasListeners = me.hasListeners, + event, key; + if (events) { + for (key in events) { + if (events.hasOwnProperty(key)) { + event = events[key]; + if (event.isEvent) { + delete hasListeners[key]; + event.clearListeners(); + } + } + } + me.events = null; + } + me.clearManagedListeners(); + }, + purgeListeners: function() { + if (Ext.global.console) { + Ext.global.console.warn('Observable: purgeListeners has been deprecated. ' + 'Please use clearListeners.'); + } + return this.clearListeners.apply(this, arguments); + }, + /** + * Removes all managed listeners for this object. + */ + clearManagedListeners: function() { + var me = this, + managedListeners = me.managedListeners, + i, len; + if (managedListeners) { + // So that Event#removeListener doesn't find a managedListeners array from which + // to remove the listener it is removing. It iterates the array to find a match, + // and splices it. + me.managedListeners = null; + for (i = 0 , len = managedListeners.length; i < len; i++) { + me.removeManagedListenerItem(true, managedListeners[i]); + } + managedListeners.length = 0; + } + me.managedListeners = managedListeners; + }, + /** + * Remove a single managed listener item + * @private + * @param {Boolean} isClear True if this is being called during a clear + * @param {Object} managedListener The managed listener item + * @param {Object} item + * @param {String} ename + * @param {Function} fn + * @param {Object} scope + * See removeManagedListener for other args + */ + removeManagedListenerItem: function(isClear, managedListener, item, ename, fn, scope) { + if (isClear || (managedListener.item === item && managedListener.ename === ename && (!fn || managedListener.fn === fn) && (!scope || managedListener.scope === scope))) { + // Pass along the options for mixin.Observable, for example if using delegate. + // If the item has already been destroyed, its listeners were already cleared. + if (!managedListener.item.destroyed) { + managedListener.item.doRemoveListener(managedListener.ename, managedListener.fn, managedListener.scope, managedListener.options); + } + if (!isClear) { + Ext.Array.remove(this.managedListeners, managedListener); + } + } + }, + purgeManagedListeners: function() { + if (Ext.global.console) { + Ext.global.console.warn('Observable: purgeManagedListeners has been deprecated. ' + 'Please use clearManagedListeners.'); + } + return this.clearManagedListeners.apply(this, arguments); + }, + /** + * Checks to see if this object has any listeners for a specified event, or whether + * the event bubbles. The answer indicates whether the event needs firing or not. + * + * @param {String} eventName The name of the event to check for + * @return {Boolean} `true` if the event is being listened for or bubbles, else `false` + */ + hasListener: function(eventName) { + eventName = Ext.canonicalEventName(eventName); + return !!this.hasListeners[eventName]; + }, + /** + * Checks if all events, or a specific event, is suspended. + * @param {String} [event] The name of the specific event to check + * @return {Boolean} `true` if events are suspended + */ + isSuspended: function(event) { + var suspended = this.eventsSuspended > 0, + events = this.events; + if (!suspended && event && events) { + event = events[event]; + if (event && event.isEvent) { + return event.isSuspended(); + } + } + return suspended; + }, + /** + * Suspends the firing of all events. (see {@link #resumeEvents}) + * + * @param {Boolean} queueSuspended `true` to queue up suspended events to be fired + * after the {@link #resumeEvents} call instead of discarding all suspended events. + */ + suspendEvents: function(queueSuspended) { + ++this.eventsSuspended; + if (queueSuspended && !this.eventQueue) { + this.eventQueue = []; + } + }, + /** + * Suspends firing of the named event(s). + * + * After calling this method to suspend events, the events will no longer fire when + * requested to fire. + * + * **Note that if this is called multiple times for a certain event, the converse method + * {@link #resumeEvent} will have to be called the same number of times for it to resume + * firing.** + * + * @param {String...} eventName Multiple event names to suspend. + */ + suspendEvent: function() { + var me = this, + events = me.events, + len = arguments.length, + i, event, ename; + for (i = 0; i < len; i++) { + ename = arguments[i]; + ename = Ext.canonicalEventName(ename); + event = events[ename]; + // we need to spin up the Event instance so it can hold the suspend count + if (!event || !event.isEvent) { + event = me._initEvent(ename); + } + event.suspend(); + } + }, + /** + * Resumes firing of the named event(s). + * + * After calling this method to resume events, the events will fire when requested to fire. + * + * **Note that if the {@link #suspendEvent} method is called multiple times for a certain + * event, this converse method will have to be called the same number of times for it + * to resume firing.** + * + * @param {String...} eventName Multiple event names to resume. + */ + resumeEvent: function() { + var events = this.events || 0, + len = events && arguments.length, + i, event, ename; + for (i = 0; i < len; i++) { + ename = Ext.canonicalEventName(arguments[i]); + event = events[ename]; + // If it exists, and is an Event object (not still a boolean placeholder), resume it + if (event && event.resume) { + event.resume(); + } + } + }, + /** + * Resumes firing events (see {@link #suspendEvents}). + * + * If events were suspended using the `queueSuspended` parameter, then all events fired + * during event suspension will be sent to any listeners now. + * + * @param {Boolean} [discardQueue] `true` to prevent any previously queued events from firing + * while we were suspended. See {@link #suspendEvents}. + */ + resumeEvents: function(discardQueue) { + var me = this, + queued = me.eventQueue, + qLen, q; + if (me.eventsSuspended && !--me.eventsSuspended) { + delete me.eventQueue; + if (!discardQueue && queued) { + qLen = queued.length; + for (q = 0; q < qLen; q++) { + // Important to call fireEventArgs here so MVC can hook in + me.fireEventArgs.apply(me, queued[q]); + } + } + } + }, + /** + * Relays selected events from the specified Observable as if the events were fired + * by `this`. + * + * For example if you are extending Grid, you might decide to forward some events from + * store. So you can do this inside your initComponent: + * + * this.relayEvents(this.getStore(), ['load']); + * + * The grid instance will then have an observable 'load' event which will be passed + * the parameters of the store's load event and any function fired with the grid's + * load event would have access to the grid using the this keyword (unless the event + * is handled by a controller's control/listen event listener in which case 'this' + * will be the controller rather than the grid). + * + * @param {Object} origin The Observable whose events this object is to relay. + * @param {String[]/Object} events Array of event names to relay or an Object with key/value + * pairs translating to ActualEventName/NewEventName respectively. For example: + * this.relayEvents(this, {add:'push', remove:'pop'}); + * + * Would now redispatch the add event of this as a push event and the remove event + * as a pop event. + * + * @param {String} [prefix] A common prefix to prepend to the event names. For example: + * + * this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); + * + * Now the grid will forward 'load' and 'clear' events of store as 'storeload' and + * 'storeclear'. + * + * @return {Object} A `Destroyable` object. An object which implements the `destroy` method + * which, when destroyed, removes all relayers. For example: + * + * this.storeRelayers = this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); + * + * Can be undone by calling + * + * Ext.destroy(this.storeRelayers); + * + * or + * this.store.relayers.destroy(); + */ + relayEvents: function(origin, events, prefix) { + var me = this, + len = events.length, + i = 0, + oldName, newName, + relayers = {}; + if (Ext.isObject(events)) { + for (i in events) { + newName = events[i]; + relayers[i] = me.createRelayer(newName); + } + } else { + for (; i < len; i++) { + oldName = events[i]; + // Build up the listener hash. + relayers[oldName] = me.createRelayer(prefix ? prefix + oldName : oldName); + } + } + // Add the relaying listeners as ManagedListeners so that they are removed when + // this.clearListeners is called (usually when _this_ is destroyed) + // Explicitly pass options as undefined so that the listener does not get + // an extra options param which then has to be sliced off in the relayer. + me.mon(origin, relayers, null, null, undefined); + // relayed events are always destroyable. + return new ListenerRemover(me, origin, relayers); + }, + /** + * @private + * Creates an event handling function which re-fires the event from this object + * as the passed event name. + * @param {String} newName The name under which to re-fire the passed parameters. + * @param {Array} beginEnd (optional) The caller can specify on which indices to slice. + * @return {Function} + */ + createRelayer: function(newName, beginEnd) { + var me = this; + return function() { + // eslint-disable-next-line max-len + return me.fireEventArgs.call(me, newName, beginEnd ? arraySlice.apply(arguments, beginEnd) : arguments); + }; + }, + /** + * Enables events fired by this Observable to bubble up an owner hierarchy by calling + * `this.getBubbleTarget()` if present. There is no implementation in the Observable + * base class. + * + * This is commonly used by Ext.Components to bubble events to owner Containers. + * See {@link Ext.Component#getBubbleTarget}. The default implementation in Ext.Component + * returns the Component's immediate owner. But if a known target is required, this can be + * overridden to access the required target more quickly. + * + * Example: + * + * Ext.define('Ext.overrides.form.field.Base', { + * override: 'Ext.form.field.Base', + * + * // Add functionality to Field's initComponent to enable + * // the change event to bubble + * initComponent: function () { + * this.callParent(); + * this.enableBubble('change'); + * } + * }); + * + * var myForm = Ext.create('Ext.form.Panel', { + * title: 'User Details', + * items: [{ + * ... + * }], + * listeners: { + * change: function() { + * // Title goes red if form has been modified. + * myForm.header.setStyle('color', 'red'); + * } + * } + * }); + * + * @param {String/String[]} eventNames The event name to bubble, or an Array of event names. + */ + enableBubble: function(eventNames) { + if (eventNames) { + // eslint-disable-next-line vars-on-top + var me = this, + names = (typeof eventNames === 'string') ? arguments : eventNames, + // we must create events now if we have not yet + events = me.events, + length = events && names.length, + ename, event, i; + for (i = 0; i < length; ++i) { + ename = names[i]; + ename = Ext.canonicalEventName(ename); + event = events[ename]; + if (!event || !event.isEvent) { + event = me._initEvent(ename); + } + // Event must fire if it bubbles (We don't know if anyone up the + // bubble hierarchy has listeners added) + me.hasListeners._incr_(ename); + event.bubble = true; + } + } + }, + /** + * @private + * Destructor for classes that extend Observable. + */ + destroy: function() { + this.clearListeners(); + this.callParent(); + this.destroyObservable(true); + }, + destroyObservable: function(skipClearListeners) { + var me = this, + clearPropertiesOnDestroy = me.clearPropertiesOnDestroy; + if (me.$observableDestroyed) { + return; + } + if (!skipClearListeners) { + me.clearListeners(); + } + // This method is called after the Base destructor, and most of the instances + // should be already destroyed at this point. However Classic Components are + // conditionally destructible and so can possibly *not* be destroyed before + // our mixed-in destructor is called. Component's destructor will take care + // of that by calling this method explicitly. + if (me.destroyed) { + if (clearPropertiesOnDestroy) { + if (clearPropertiesOnDestroy === true && !me.$nulled) { + me.$reap(); + } + // At this point we can safely assume that the instance is completely + // destroyed and should not be able to fire events anymore. We don't + // want to do this when the prototype is going to be cleared below, + // because having these emptyFns on the object instance will defy + // the purpose of prototype clearing. + if (!me.clearPrototypeOnDestroy) { + me.fireEvent = me.fireEventArgs = me.fireAction = me.fireEventedAction = Ext.emptyFn; + } + // We do not null hasListeners reference since it's a) very special, + // and b) can't possibly lead to significant leaks. (In theory, right). + me.events = me.managedListeners = me.eventedBeforeEventNames = null; + me.$observableDestroyed = true; + } + // Due to the way Observable mixin installs the after handler, + // this can be called twice in a row. Doing that the second time + // will most probably blow up on some method call -- and that is + // totally what we are about, except in this particular case. + if (me.clearPrototypeOnDestroy && Object.setPrototypeOf && !me.$alreadyNulled) { + Object.setPrototypeOf(me, null); + me.$alreadyNulled = true; + } + } + }, + privates: { + doAddListener: function(ename, fn, scope, options, order, caller, manager) { + var me = this, + ret = false, + event, priority; + order = order || (options && options.order); + if (order) { + priority = (options && options.priority); + if (!priority) { + // priority option takes precedence over order + // do not mutate the user's options + options = options ? Ext.Object.chain(options) : {}; + options.priority = me.$orderToPriority[order]; + } + } + ename = Ext.canonicalEventName(ename); + if (!fn) { + Ext.raise("Cannot add '" + ename + "' listener to " + me.$className + " instance. No function specified."); + } + event = (me.events || (me.events = {}))[ename]; + if (!event || !event.isEvent) { + event = me._initEvent(ename); + } + if (fn !== emptyFn) { + // Check whether the listener should be managed. + // Event#addListener will add it to the manager's managedListeners stack + // upon successful add of the listener to the event. + if (!manager && (scope && scope.isObservable && (scope !== me))) { + manager = scope; + } + if (event.addListener(fn, scope, options, caller, manager)) { + // If a new listener has been added (Event.addListener rejects + // duplicates of the same fn+scope) + // then increment the hasListeners counter + me.hasListeners._incr_(ename); + ret = true; + } + } + return ret; + }, + doRemoveListener: function(ename, fn, scope) { + var me = this, + ret = false, + events = me.events, + event; + ename = Ext.canonicalEventName(ename); + event = events && events[ename]; + if (!fn) { + Ext.raise("Cannot remove '" + ename + "' listener to " + me.$className + " instance. No function specified."); + } + if (event && event.isEvent) { + if (event.removeListener(fn, scope)) { + me.hasListeners._decr_(ename); + ret = true; + } + } + return ret; + }, + _initEvent: function(eventName) { + return (this.events[eventName] = new Ext.util.Event(this, eventName)); + } + }, + deprecated: { + '5.0': { + methods: { + addEvents: null + } + } + } + }; +}, function() { + var Observable = this, + proto = Observable.prototype, + HasListeners = function() {}, + prepareMixin = function(T) { + var proto = T.prototype; + if (!T.HasListeners) { + // Keep track of whether we were added via a mixin or not, this becomes + // important later when discovering merged listeners on the class. + proto.$observableMixedIn = 1; + // Classes that use us as a mixin (best practice) need to be prepared. + Observable.prepareClass(T, this); + // Now that we are mixed in to class T, we need to watch T for derivations + // and prepare them also. + T.onExtended(function(U, data) { + if (Ext.classSystemMonitor) { + Ext.classSystemMonitor('extend mixin', arguments); + } + Observable.prepareClass(U, null, data); + }); + // Also, if a class uses us as a mixin and that class is then used as + // a mixin, we need to be notified of that as well. + if (proto.onClassMixedIn) { + // play nice with other potential overrides... + Ext.override(T, { + onClassMixedIn: function(U) { + prepareMixin.call(this, U); + this.callParent(arguments); + } + }); + } else { + // just us chickens, so add the method... + proto.onClassMixedIn = function(U) { + prepareMixin.call(this, U); + }; + } + } + superOnClassMixedIn.call(this, T); + }, + // We are overriding the onClassMixedIn of Ext.Mixin. Save a reference to it + // so we can call it after our onClassMixedIn. + superOnClassMixedIn = proto.onClassMixedIn; + HasListeners.prototype = { + // $$: 42 // to make sure we have a proper prototype + _decr_: function(ev, count) { + // count is optionally passed when clearing listeners in bulk + // e.g. when clearListeners is called on a component that has listeners that + // were attached using the "delegate" option + if (count == null) { + count = 1; + } + if (!(this[ev] -= count)) { + // Delete this entry, since 0 does not mean no one is listening, just + // that no one is *directly* listening. This allows the eventBus or + // class observers to "poke" through and expose their presence. + delete this[ev]; + } + }, + _incr_: function(ev) { + if (this.hasOwnProperty(ev)) { + // if we already have listeners at this level, just increment the count... + ++this[ev]; + } else { + // otherwise, start the count at 1 (which hides whatever is in our prototype + // chain)... + this[ev] = 1; + } + } + }; + proto.HasListeners = Observable.HasListeners = HasListeners; + Observable.createAlias({ + /** + * @method on + * @inheritdoc Ext.util.Observable#method-addListener + */ + on: 'addListener', + /** + * @method un + * Shorthand for {@link #removeListener}. + * @inheritdoc Ext.util.Observable#method-removeListener + */ + un: 'removeListener', + /** + * @method mon + * Shorthand for {@link #addManagedListener}. + * @inheritdoc Ext.util.Observable#method-addManagedListener + */ + mon: 'addManagedListener', + /** + * @method mun + * Shorthand for {@link #removeManagedListener}. + * @inheritdoc Ext.util.Observable#method-removeManagedListener + */ + mun: 'removeManagedListener', + /** + * @method + * An alias for {@link Ext.util.Observable#addListener addListener}. In + * versions prior to 5.1, {@link #listeners} had a generated setter which could + * be called to add listeners. In 5.1 the listeners config is not processed + * using the config system and has no generated setter, so this method is + * provided for backward compatibility. The preferred way of adding listeners + * is to use the {@link #on} method. + * @param {Object} listeners The listeners + */ + setListeners: 'addListener' + }); + // deprecated, will be removed in 5.0 + Observable.observeClass = Observable.observe; + // Used by Ext.mixin.Hookable to create sequences. + function getMethodEvent(method) { + var event = (this.methodEvents = this.methodEvents || {})[method], + returnValue, v, cancel, + me = this, + makeCall; + if (!event) { + me.methodEvents[method] = event = {}; + event.originalFn = me[method]; + event.methodName = method; + event.before = []; + event.after = []; + makeCall = function(fn, scope, args) { + scope = scope || me; + if (typeof fn === 'string') { + fn = scope[fn]; + } + if ((v = fn.apply(scope, args)) !== undefined) { + if (typeof v === 'object') { + if (v.returnValue !== undefined) { + returnValue = v.returnValue; + } else { + returnValue = v; + } + cancel = !!v.cancel; + } else if (v === false) { + cancel = true; + } else { + returnValue = v; + } + } + }; + me[method] = function() { + var args = Array.prototype.slice.call(arguments, 0), + argsLen = args.length, + b, i, len; + returnValue = v = undefined; + cancel = false; + for (i = 0 , len = event.before.length; i < len; i++) { + b = event.before[i]; + if (b.extraArgs) { + args.push.apply(args, b.extraArgs); + } + makeCall(b.fn, b.scope, args); + args.length = argsLen; + if (cancel || b.preventDefault) { + return returnValue; + } + } + if ((v = event.originalFn.apply(me, args)) !== undefined) { + returnValue = v; + } + for (i = 0 , len = event.after.length; i < len; i++) { + b = event.after[i]; + if (b.extraArgs) { + args.push.apply(args, b.extraArgs); + } + makeCall(b.fn, b.scope, args); + args.length = argsLen; + if (cancel || b.preventDefault) { + return returnValue; + } + } + return returnValue; + }; + } + return event; + } + Ext.apply(proto, { + onClassMixedIn: prepareMixin, + // adds an 'interceptor' called before the original method + beforeMethod: function(method, fn, scope, preventDefault, extraArgs) { + getMethodEvent.call(this, method).before.push({ + fn: fn, + scope: scope, + extraArgs: extraArgs, + preventDefault: preventDefault + }); + }, + // adds a 'sequence' called after the original method + afterMethod: function(method, fn, scope, preventDefault, extraArgs) { + getMethodEvent.call(this, method).after.push({ + fn: fn, + scope: scope, + extraArgs: extraArgs, + preventDefault: preventDefault + }); + }, + removeMethodListener: function(method, fn, scope) { + var e = getMethodEvent.call(this, method), + i, len; + for (i = 0 , len = e.before.length; i < len; i++) { + // eslint-disable-next-line eqeqeq + if (e.before[i].fn == fn && e.before[i].scope == scope) { + Ext.Array.erase(e.before, i, 1); + return; + } + } + for (i = 0 , len = e.after.length; i < len; i++) { + // eslint-disable-next-line eqeqeq + if (e.after[i].fn == fn && e.after[i].scope == scope) { + Ext.Array.erase(e.after, i, 1); + return; + } + } + }, + toggleEventLogging: function(toggle) { + Ext.util.Observable[toggle ? 'capture' : 'releaseCapture'](this, function(en) { + if (Ext.isDefined(Ext.global.console)) { + Ext.global.console.log(en, arguments); + } + }); + } + }); +}); + +/** + * Represents a collection of a set of key and value pairs. Each key in the HashMap + * must be unique, the same key cannot exist twice. Access to items is provided via + * the key only. Sample usage: + * + * var map = new Ext.util.HashMap(); + * map.add('key1', 1); + * map.add('key2', 2); + * map.add('key3', 3); + * + * map.each(function(key, value, length){ + * console.log(key, value, length); + * }); + * + * The HashMap is an unordered class, + * there is no guarantee when iterating over the items that they will be in any particular + * order. If this is required, then use a {@link Ext.util.MixedCollection}. + */ +Ext.define('Ext.util.HashMap', { + mixins: [ + Ext.mixin.Observable + ], + /** + * Mutation counter which is incremented upon add and remove. + * @readonly + */ + generation: 0, + config: { + /** + * @cfg {Function} keyFn A function that is used to retrieve a default key for a passed + * object. A default is provided that returns the `id` property on the object. This function + * is only used if the `add` method is called with a single argument. + */ + keyFn: null + }, + /** + * @event add + * Fires when a new item is added to the hash. + * @param {Ext.util.HashMap} this + * @param {String} key The key of the added item. + * @param {Object} value The value of the added item. + */ + /** + * @event clear + * Fires when the hash is cleared. + * @param {Ext.util.HashMap} this + */ + /** + * @event remove + * Fires when an item is removed from the hash. + * @param {Ext.util.HashMap} this + * @param {String} key The key of the removed item. + * @param {Object} value The value of the removed item. + */ + /** + * @event replace + * Fires when an item is replaced in the hash. + * @param {Ext.util.HashMap} this + * @param {String} key The key of the replaced item. + * @param {Object} value The new value for the item. + * @param {Object} old The old value for the item. + */ + /** + * Creates new HashMap. + * @param {Object} config (optional) Config object. + */ + constructor: function(config) { + var me = this, + fn; + // Will call initConfig + me.mixins.observable.constructor.call(me, config); + me.clear(true); + fn = me.getKeyFn(); + if (fn) { + me.getKey = fn; + } + }, + /** + * Gets the number of items in the hash. + * @return {Number} The number of items in the hash. + */ + getCount: function() { + return this.length; + }, + /** + * Implementation for being able to extract the key from an object if only + * a single argument is passed. + * @private + * @param {String} key The key + * @param {Object} value The value + * @return {Array} [key, value] + */ + getData: function(key, value) { + // if we have no value, it means we need to get the key from the object + if (value === undefined) { + value = key; + key = this.getKey(value); + } + return [ + key, + value + ]; + }, + /** + * Extracts the key from an object. This is a default implementation, it may be overridden + * @param {Object} o The object to get the key from + * @return {String} The key to use. + */ + getKey: function(o) { + return o.id; + }, + /** + * Adds an item to the collection. Fires the {@link #event-add} event when complete. + * + * @param {String/Object} key The key to associate with the item, or the new item. + * + * If a {@link #getKey} implementation was specified for this HashMap, + * or if the key of the stored items is in a property called `id`, + * the HashMap will be able to *derive* the key for the new item. + * In this case just pass the new item in this parameter. + * + * @param {Object} [value] The item to add. + * @return {Object} The item added. + */ + add: function(key, value) { + var me = this; + // Need to check arguments length here, since we could have called: + // map.add('foo', undefined); + if (arguments.length === 1) { + value = key; + key = me.getKey(value); + } + if (me.containsKey(key)) { + return me.replace(key, value); + } + me.map[key] = value; + ++me.length; + me.generation++; + if (me.hasListeners.add) { + me.fireEvent('add', me, key, value); + } + return value; + }, + /** + * Replaces an item in the hash. If the key doesn't exist, the + * {@link #method-add} method will be used. + * @param {String} key The key of the item. + * @param {Object} value The new value for the item. + * @return {Object} The new value of the item. + */ + replace: function(key, value) { + var me = this, + map = me.map, + old; + // Need to check arguments length here, since we could have called: + // map.replace('foo', undefined); + if (arguments.length === 1) { + value = key; + key = me.getKey(value); + } + if (!me.containsKey(key)) { + me.add(key, value); + } + old = map[key]; + map[key] = value; + me.generation++; + if (me.hasListeners.replace) { + me.fireEvent('replace', me, key, value, old); + } + return value; + }, + /** + * Remove an item from the hash. + * @param {Object} o The value of the item to remove. + * @return {Boolean} True if the item was successfully removed. + */ + remove: function(o) { + var key = this.findKey(o); + if (key !== undefined) { + return this.removeAtKey(key); + } + return false; + }, + /** + * Remove an item from the hash. + * @param {String} key The key to remove. + * @return {Boolean} True if the item was successfully removed. + */ + removeAtKey: function(key) { + var me = this, + value; + if (me.containsKey(key)) { + value = me.map[key]; + delete me.map[key]; + --me.length; + me.generation++; + if (me.hasListeners.remove) { + me.fireEvent('remove', me, key, value); + } + return true; + } + return false; + }, + /** + * Retrieves an item with a particular key. + * @param {String} key The key to lookup. + * @return {Object} The value at that key. If it doesn't exist, `undefined` is returned. + */ + get: function(key) { + var map = this.map; + return map.hasOwnProperty(key) ? map[key] : undefined; + }, + /** + * @ignore + */ + clear: function(initial) { + // We use the above syntax because we don't want the initial param to be part + // of the public API + var me = this; + // Only clear if it has ever had any content + if (initial || me.generation) { + me.map = {}; + me.length = 0; + me.generation = initial ? 0 : me.generation + 1; + } + if (initial !== true && me.hasListeners.clear) { + me.fireEvent('clear', me); + } + return me; + }, + /** + * Checks whether a key exists in the hash. + * @param {String} key The key to check for. + * @return {Boolean} True if they key exists in the hash. + */ + containsKey: function(key) { + var map = this.map; + return map.hasOwnProperty(key) && map[key] !== undefined; + }, + /** + * Checks whether a value exists in the hash. + * @param {Object} value The value to check for. + * @return {Boolean} True if the value exists in the dictionary. + */ + contains: function(value) { + return this.containsKey(this.findKey(value)); + }, + /** + * Return all of the keys in the hash. + * @return {Array} An array of keys. + */ + getKeys: function() { + return this.getArray(true); + }, + /** + * Return all of the values in the hash. + * @return {Array} An array of values. + */ + getValues: function() { + return this.getArray(false); + }, + /** + * Gets either the keys/values in an array from the hash. + * @private + * @param {Boolean} isKey True to extract the keys, otherwise, the value + * @return {Array} An array of either keys/values from the hash. + */ + getArray: function(isKey) { + var arr = [], + key, + map = this.map; + for (key in map) { + if (map.hasOwnProperty(key)) { + arr.push(isKey ? key : map[key]); + } + } + return arr; + }, + /** + * Executes the specified function once for each item in the hash. + * Returning false from the function will cease iteration. + * + * @param {Function} fn The function to execute. + * @param {String} fn.key The key of the item. + * @param {Number} fn.value The value of the item. + * @param {Number} fn.length The total number of items in the hash. + * @param {Object} [scope] The scope to execute in. Defaults to this. + * @return {Ext.util.HashMap} this + */ + each: function(fn, scope) { + // copy items so they may be removed during iteration. + var items = Ext.apply({}, this.map), + key, + length = this.length; + scope = scope || this; + for (key in items) { + if (items.hasOwnProperty(key)) { + if (fn.call(scope, key, items[key], length) === false) { + break; + } + } + } + return this; + }, + /** + * Performs a shallow copy on this hash. + * @return {Ext.util.HashMap} The new hash object. + */ + clone: function() { + var hash = new this.self(this.initialConfig), + map = this.map, + key; + hash.suspendEvents(); + for (key in map) { + if (map.hasOwnProperty(key)) { + hash.add(key, map[key]); + } + } + hash.resumeEvents(); + return hash; + }, + /** + * @private + * Find the key for a value. + * @param {Object} value The value to find. + * @return {Object} The value of the item. Returns undefined if not found. + */ + findKey: function(value) { + var key, + map = this.map; + for (key in map) { + if (map.hasOwnProperty(key) && map[key] === value) { + return key; + } + } + return undefined; + } +}, function(HashMap) { + var prototype = HashMap.prototype; + /** + * @method removeByKey + * An alias for {@link #removeAtKey} + * @inheritdoc Ext.util.HashMap#removeAtKey + */ + prototype.removeByKey = prototype.removeAtKey; +}); + +// +// 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; + } + } + }; +}, function(Consequence) { + // eslint-disable-line comma-style + Consequence.dispatch.$skipTimerCheck = true; +}); + +/* + Ext.promise.Deferred 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). + */ +/** + * Deferreds are the mechanism used to create new Promises. A Deferred has a single + * associated Promise that can be safely returned to external consumers to ensure they do + * not interfere with the resolution or rejection of the deferred operation. + * + * A Deferred is typically used within the body of a function that performs an asynchronous + * operation. When that operation succeeds, the Deferred should be resolved; if that + * operation fails, the Deferred should be rejected. + * + * Each Deferred has an associated Promise. A Promise delegates `then` calls to its + * Deferred's `then` method. In this way, access to Deferred operations are divided between + * producer (Deferred) and consumer (Promise) roles. + * + * When a Deferred's `resolve` method is called, it fulfills with the optionally specified + * value. If `resolve` is called with a then-able (i.e.a Function or Object with a `then` + * function, such as another Promise) it assimilates the then-able's result; the Deferred + * provides its own `resolve` and `reject` methods as the onFulfilled or onRejected + * arguments in a call to that then-able's `then` function. If an error is thrown while + * calling the then-able's `then` function (prior to any call back to the specified + * `resolve` or `reject` methods), the Deferred rejects with that error. If a Deferred's + * `resolve` method is called with its own Promise, it rejects with a TypeError. + * + * When a Deferred's `reject` method is called, it rejects with the optionally specified + * reason. + * + * Each time a Deferred's `then` method is called, it captures a pair of optional + * onFulfilled and onRejected callbacks and returns a Promise of the Deferred's future + * value as transformed by those callbacks. + * + * @private + * @since 6.0.0 + */ +Ext.define('Ext.promise.Deferred', { + /** + * @property {Ext.promise.Promise} promise Promise of the future value of this Deferred. + */ + promise: null, + /** + * @property {Ext.promise.Consequence[]} consequences Pending Consequences chained + * to this Deferred. + * + * @private + */ + consequences: [], + /** + * @property {Boolean} completed Indicates whether this Deferred has been completed. + * + * @private + */ + completed: false, + /** + * @property {String} completeAction The completion action (i.e. 'fulfill' or 'reject'). + * + * @private + */ + completionAction: null, + /** + * @property {Mixed} completionValue The completion value (i.e. resolution value + * or rejection error). + * + * @private + */ + completionValue: null, + constructor: function() { + var me = this; + me.promise = new Ext.promise.Promise(me); + me.consequences = []; + me.completed = false; + me.completionAction = null; + me.completionValue = null; + }, + /** + * Used to specify onFulfilled and onRejected callbacks that will be + * notified when the future value becomes available. + * + * Those callbacks can subsequently transform the value that was + * fulfilled or the error that was rejected. Each call to `then` + * returns a new Promise of that transformed value; i.e., a Promise + * that is fulfilled with the callback return value or rejected with + * any error thrown by the callback. + * + * @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. + * + * @return Promise that is fulfilled with the callback return value or rejected with + * any error thrown by the callback. + */ + then: function(onFulfilled, onRejected, onProgress) { + var me = this, + consequence = new Ext.promise.Consequence(onFulfilled, onRejected, onProgress); + if (me.completed) { + consequence.trigger(me.completionAction, me.completionValue); + } else { + me.consequences.push(consequence); + } + return consequence.promise; + }, + /** + * Resolve this Deferred with the (optional) specified value. + * + * If called with a then-able (i.e.a Function or Object with a `then` + * function, such as another Promise) it assimilates the then-able's + * result; the Deferred provides its own `resolve` and `reject` methods + * as the onFulfilled or onRejected arguments in a call to that + * then-able's `then` function. If an error is thrown while calling + * the then-able's `then` function (prior to any call back to the + * specified `resolve` or `reject` methods), the Deferred rejects with + * that error. If a Deferred's `resolve` method is called with its own + * Promise, it rejects with a TypeError. + * + * Once a Deferred has been fulfilled or rejected, it is considered to be complete + * and subsequent calls to `resolve` or `reject` are ignored. + * + * @param {Mixed} value Value to resolve as either a fulfillment value or rejection + * reason. + */ + resolve: function(value) { + var me = this, + isHandled, thenFn; + if (me.completed) { + return; + } + try { + if (value === me.promise) { + throw new TypeError('A Promise cannot be resolved with itself.'); + } + if (value != null && (typeof value === 'object' || Ext.isFunction(value)) && Ext.isFunction(thenFn = value.then)) { + isHandled = false; + try { + thenFn.call(value, function(value) { + if (!isHandled) { + isHandled = true; + me.resolve(value); + } + }, function(error) { + if (!isHandled) { + isHandled = true; + me.reject(error); + } + }); + } catch (e1) { + if (!isHandled) { + me.reject(e1); + } + } + } else { + me.complete('fulfill', value); + } + } catch (e2) { + me.reject(e2); + } + }, + /** + * Reject this Deferred with the specified reason. + * + * Once a Deferred has been rejected, it is considered to be complete + * and subsequent calls to `resolve` or `reject` are ignored. + * + * @param {Error} reason Rejection reason. + */ + reject: function(reason) { + if (this.completed) { + return; + } + this.complete('reject', reason); + }, + /** + * Updates progress for this Deferred, if it is still pending, triggering it to + * execute the `onProgress` callback and propagate the resulting transformed progress + * value to Deferreds that originate from this Deferred. + * + * @param {Mixed} progress The progress value. + */ + update: function(progress) { + var consequences = this.consequences, + consequence, i, len; + if (this.completed) { + return; + } + for (i = 0 , len = consequences.length; i < len; i++) { + consequence = consequences[i]; + consequence.update(progress); + } + }, + /** + * Complete this Deferred with the specified action and value. + * + * @param {String} action Completion action (i.e. 'fufill' or 'reject'). + * @param {Mixed} value Fulfillment value or rejection reason. + * + * @private + */ + complete: function(action, value) { + var me = this, + consequences = me.consequences, + consequence, i, len; + me.completionAction = action; + me.completionValue = value; + me.completed = true; + for (i = 0 , len = consequences.length; i < len; i++) { + consequence = consequences[i]; + consequence.trigger(me.completionAction, me.completionValue); + } + me.consequences = null; + } +}); + +/* + Ext.promise.Deferred adapted from: + [DeftJS](https://github.com/deftjs/deftjs5) + Copyright (c) 2012-2014 [DeftJS Framework Contributors](http://deftjs.org) + Open source under the [MIT License](http://en.wikipedia.org/wiki/MIT_License). + */ +/** + * Promises represent a future value; i.e., a value that may not yet be available. + * + * Users should **not** create instances of this class directly. Instead user code should + * use `new {@link Ext.Promise}()` or `new {@link Ext.Deferred}()` to create and manage + * promises. If the browser supports the standard `Promise` constructor, this class will + * not be used by `Ext.Promise`. This class will always be used by `Ext.Deferred` in order + * to provide enhanced capabilities beyond standard promises. + * + * A Promise's `{@link #then then()}` method is used to specify onFulfilled and onRejected + * callbacks that will be notified when the future value becomes available. Those callbacks + * can subsequently transform the value that was resolved or the reason that was rejected. + * Each call to `then` returns a new Promise of that transformed value; i.e., a Promise + * that is resolved with the callback return value or rejected with any error thrown by + * the callback. + * + * ## Basic Usage + * + * this.companyService.loadCompanies().then( + * function(records) { + * // Do something with result. + * }, + * function(error) { + * // Do something on failure. + * }). + * always(function() { + * // Do something whether call succeeded or failed + * }); + * + * The above code uses the `Promise` returned from the `companyService.loadCompanies()` + * method and uses `then()` to attach success and failure handlers. Finally, an `always()` + * method call is chained onto the returned promise. This specifies a callback function + * that will run whether the underlying call succeeded or failed. + * + * See `{@link Ext.Deferred}` for an example of using the returned Promise. + * + * [1]: http://wiki.ecmascript.org/doku.php?id=harmony:specification_drafts#april_14_2015_rev_38_final_draft + * + * @since 6.0.0 + */ +Ext.define('Ext.promise.Promise', function(ExtPromise) { + var Deferred; + /* eslint-disable indent */ + return { + statics: { + /** + * @property CancellationError + * @static + * The type of `Error` propagated by the `{@link #method-cancel}` method. If + * the browser provides a native `CancellationError` then that type is used. If + * not, a basic `Error` type is used. + */ + CancellationError: Ext.global.CancellationError || Error, + _ready: function() { + // Our requires are met, so we can cache Ext.promise.Deferred + Deferred = Ext.promise.Deferred; + }, + /** + * Returns a new Promise that will only resolve once all the specified + * `promisesOrValues` have resolved. + * + * The resolution value will be an Array containing the resolution value of each + * of the `promisesOrValues`. + * + * The public API's to use instead of this method are `{@link Ext.Promise#all}` + * and `{@link Ext.Deferred#all}`. + * + * @param {Mixed[]/Ext.promise.Promise[]/Ext.promise.Promise} promisesOrValues An + * Array of values or Promises, or a Promise of an Array of values or Promises. + * @return {Ext.promise.Promise} A Promise of an Array of the resolved values. + * + * @static + * @private + */ + all: function(promisesOrValues) { + if (!(Ext.isArray(promisesOrValues) || ExtPromise.is(promisesOrValues))) { + Ext.raise('Invalid parameter: expected an Array or Promise of an Array.'); + } + return ExtPromise.when(promisesOrValues).then(function(promisesOrValues) { + var deferred = new Deferred(), + remainingToResolve = promisesOrValues.length, + results = new Array(remainingToResolve), + index, promiseOrValue, resolve, i, len; + if (!remainingToResolve) { + deferred.resolve(results); + } else { + resolve = function(item, index) { + return ExtPromise.when(item).then(function(value) { + results[index] = value; + if (!--remainingToResolve) { + deferred.resolve(results); + } + return value; + }, function(reason) { + return deferred.reject(reason); + }); + }; + for (index = i = 0 , len = promisesOrValues.length; i < len; index = ++i) { + promiseOrValue = promisesOrValues[index]; + if (index in promisesOrValues) { + resolve(promiseOrValue, index); + } else { + remainingToResolve--; + } + } + } + return deferred.promise; + }); + }, + /** + * Determines whether the specified value is a Promise (including third-party + * untrusted Promises or then()-ables), based on the Promises/A specification + * feature test. + * + * @param {Mixed} value A potential Promise. + * @return {Boolean} `true` if the given value is a Promise, otherwise `false`. + * @static + * @private + */ + is: function(value) { + return value != null && (typeof value === 'object' || Ext.isFunction(value)) && Ext.isFunction(value.then); + }, + /** + * Returns a promise that resolves or rejects as soon as one of the promises in the array + * resolves or rejects, with the value or reason from that promise. + * @param {Ext.promise.Promise[]} promises The promises. + * @return {Ext.promise.Promise} The promise to be resolved when the race completes. + * + * @private + * @static + * @since 6.5.0 + */ + race: function(promises) { + var deferred = new Deferred(), + len = promises.length, + i; + if (!Ext.isArray(promises)) { + Ext.raise('Invalid parameter: expected an Array.'); + } + for (i = 0; i < len; ++i) { + deferred.resolve(promises[i]); + } + return deferred.promise; + }, + /** + * Rethrows the specified Error on the next turn of the event loop. + * @static + * @private + */ + rethrowError: function(error) { + Ext.asap(function() { + throw error; + }); + }, + /** + * Returns a new Promise that either + * + * * Resolves immediately for the specified value, or + * * Resolves or rejects when the specified promise (or third-party Promise or + * then()-able) is resolved or rejected. + * + * The public API's to use instead of this method are `{@link Ext.Promise#resolve}` + * and `{@link Ext.Deferred#resolved}`. + * + * @param {Mixed} value A Promise (or third-party Promise or then()-able) + * or value. + * @return {Ext.Promise} A Promise of the specified Promise or value. + * + * @static + * @private + */ + when: function(value) { + var deferred = new Deferred(); + deferred.resolve(value); + return deferred.promise; + } + }, + /** + * @property {Ext.promise.Deferred} Reference to this promise's + * `{@link Ext.promise.Deferred Deferred}` instance. + * + * @readonly + * @private + */ + owner: null, + /** + * NOTE: {@link Ext.promise.Deferred Deferreds} are the mechanism used to create new + * Promises. + * @param {Ext.promise.Deferred} owner The owning `Deferred` instance. + * + * @private + */ + constructor: function(owner) { + this.owner = owner; + }, + /** + * Attaches onFulfilled and onRejected callbacks that will be notified when the future + * value becomes available. + * + * Those callbacks can subsequently transform the value that was fulfilled or the error + * that was rejected. Each call to `then` returns a new Promise of that transformed + * value; i.e., a Promise that is fulfilled with the callback return value or rejected + * with any error thrown by the callback. + * + * @param {Function} onFulfilled Optional callback to execute to transform a + * fulfillment value. + * @param {Function} onRejected Optional callback to execute to transform a rejection + * reason. + * @param {Function} onProgress Optional callback function to be called with progress + * updates. + * @param {Object} scope Optional scope for the callback(s). + * @return {Ext.promise.Promise} Promise that is fulfilled with the callback return + * value or rejected with any error thrown by the callback. + */ + then: function(onFulfilled, onRejected, onProgress, scope) { + var ref; + if (arguments.length === 1 && Ext.isObject(arguments[0])) { + ref = arguments[0]; + onFulfilled = ref.success; + onRejected = ref.failure; + onProgress = ref.progress; + scope = ref.scope; + } + if (scope) { + if (onFulfilled) { + onFulfilled = onFulfilled.bind(scope); + } + if (onRejected) { + onRejected = onRejected.bind(scope); + } + if (onProgress) { + onProgress = onProgress.bind(scope); + } + } + return this.owner.then(onFulfilled, onRejected, onProgress); + }, + /** + * Attaches an onRejected callback that will be notified if this Promise is rejected. + * + * The callback can subsequently transform the reason that was rejected. Each call to + * `otherwise` returns a new Promise of that transformed value; i.e., a Promise that + * is resolved with the original resolved value, or resolved with the callback return + * value or rejected with any error thrown by the callback. + * + * @param {Function} onRejected Callback to execute to transform a rejection reason. + * @param {Object} scope Optional scope for the callback. + * @return {Ext.promise.Promise} Promise of the transformed future value. + * + * @since 6.5.0 + */ + 'catch': function(onRejected, scope) { + var ref; + if (arguments.length === 1 && Ext.isObject(arguments[0])) { + ref = arguments[0]; + onRejected = ref.fn; + scope = ref.scope; + } + if (scope != null) { + onRejected = onRejected.bind(scope); + } + return this.owner.then(null, onRejected); + }, + /** + * An alias for the {@link #catch} method. To be used for browsers + * where catch cannot be used as a method name. + */ + otherwise: function(onRejected, scope) { + return this['catch'].apply(this, arguments); + }, + // eslint-disable-line dot-notation + /** + * Attaches an onCompleted callback that will be notified when this Promise is completed. + * + * Similar to `finally` in `try... catch... finally`. + * + * NOTE: The specified callback does not affect the resulting Promise's outcome; any + * return value is ignored and any Error is rethrown. + * + * @param {Function} onCompleted Callback to execute when the Promise is resolved or + * rejected. + * @param {Object} scope Optional scope for the callback. + * @return {Ext.promise.Promise} A new "pass-through" Promise that is resolved with + * the original value or rejected with the original reason. + */ + always: function(onCompleted, scope) { + var ref; + if (arguments.length === 1 && Ext.isObject(arguments[0])) { + ref = arguments[0]; + onCompleted = ref.fn; + scope = ref.scope; + } + if (scope != null) { + onCompleted = onCompleted.bind(scope); + } + return this.owner.then(function(value) { + try { + onCompleted(); + } catch (e) { + ExtPromise.rethrowError(e); + } + return value; + }, function(reason) { + try { + onCompleted(); + } catch (e) { + ExtPromise.rethrowError(e); + } + throw reason; + }); + }, + /** + * Terminates a Promise chain, ensuring that unhandled rejections will be rethrown as + * Errors. + * + * One of the pitfalls of interacting with Promise-based APIs is the tendency for + * important errors to be silently swallowed unless an explicit rejection handler is + * specified. + * + * For example: + * + * promise.then(function() { + * // logic in your callback throws an error and it is interpreted as a + * // rejection. throw new Error("Boom!"); + * }); + * + * // The Error was not handled by the Promise chain and is silently swallowed. + * + * This problem can be addressed by terminating the Promise chain with the done() + * method: + * + * promise.then(function() { + * // logic in your callback throws an error and it is interpreted as a + * // rejection. throw new Error("Boom!"); + * }).done(); + * + * // The Error was not handled by the Promise chain and is rethrown by done() on + * // the next tick. + * + * The `done()` method ensures that any unhandled rejections are rethrown as Errors. + */ + done: function() { + this.owner.then(null, ExtPromise.rethrowError); + }, + /** + * Cancels this Promise if it is still pending, triggering a rejection with a + * `{@link #CancellationError}` that will propagate to any Promises originating from + * this Promise. + * + * NOTE: Cancellation only propagates to Promises that branch from the target Promise. + * It does not traverse back up to parent branches, as this would reject nodes from + * which other Promises may have branched, causing unintended side-effects. + * + * @param {Error} reason Cancellation reason. + */ + cancel: function(reason) { + if (reason == null) { + reason = null; + } + this.owner.reject(new this.self.CancellationError(reason)); + }, + /** + * Logs the resolution or rejection of this Promise with the specified category and + * optional identifier. Messages are logged via all registered custom logger functions. + * + * @param {String} identifier An optional identifier to incorporate into the + * resulting log entry. + * + * @return {Ext.promise.Promise} A new "pass-through" Promise that is resolved with + * the original value or rejected with the original reason. + */ + log: function(identifier) { + if (identifier == null) { + identifier = ''; + } + return this.owner.then(function(value) { + Ext.log("" + (identifier || 'Promise') + " resolved with value: " + value); + return value; + }, function(reason) { + Ext.log("" + (identifier || 'Promise') + " rejected with reason: " + reason); + throw reason; + }); + } + }; +}, function(ExtPromise) { + ExtPromise._ready(); +}); + +/** + * This class provides an API compatible implementation of the ECMAScript 6 Promises API + * (providing an implementation as necessary for browsers that do not natively support the + * `Promise` class). + * + * This class will use the native `Promise` implementation if one is available. The + * native implementation, while standard, does not provide all of the features of the + * Ext JS Promises implementation. + * + * To use the Ext JS enhanced Promises implementation, see `{@link Ext.Deferred}` for + * creating enhanced promises and additional static utility methods. + * + * Typical usage: + * + * function getAjax (url) { + * // The function passed to Ext.Promise() is called immediately to start + * // the asynchronous action. + * // + * return new Ext.Promise(function (resolve, reject) { + * Ext.Ajax.request({ + * url: url, + * + * success: function (response) { + * // Use the provided "resolve" method to deliver the result. + * // + * resolve(response.responseText); + * }, + * + * failure: function (response) { + * // Use the provided "reject" method to deliver error message. + * // + * reject(response.status); + * } + * }); + * }); + * } + * + * getAjax('http://stuff').then(function (content) { + * // content is responseText of ajax response + * }); + * + * To adapt the Ext JS `{@link Ext.data.Store store}` to use a Promise, you might do + * something like this: + * + * loadCompanies: function() { + * var companyStore = this.companyStore; + * + * return new Ext.Promise(function (resolve, reject) { + * companyStore.load({ + * callback: function(records, operation, success) { + * if (success) { + * // Use the provided "resolve" method to drive the promise: + * resolve(records); + * } + * else { + * // Use the provided "reject" method to drive the promise: + * reject("Error loading Companies."); + * } + * } + * }); + * }); + * } + * + * @since 6.0.0 + */ +Ext.define('Ext.Promise', function() { + /* eslint-disable indent */ + var Polyfiller; + return { + statics: { + _ready: function() { + // We can cache this now that our requires are met + Polyfiller = Ext.promise.Promise; + }, + /** + * Returns a new Promise that will only resolve once all the specified + * `promisesOrValues` have resolved. + * + * The resolution value will be an Array containing the resolution value of each + * of the `promisesOrValues`. + * + * @param {Mixed[]/Ext.Promise[]/Ext.Promise} promisesOrValues An Array of values + * or Promises, or a Promise of an Array of values or Promises. + * + * @return {Ext.Promise} A Promise of an Array of the resolved values. + * @static + */ + all: function() { + return Polyfiller.all.apply(Polyfiller, arguments); + }, + /** + * Returns a promise that resolves or rejects as soon as one of the promises in the + * array resolves or rejects, with the value or reason from that promise. + * @param {Ext.promise.Promise[]} promises The promises. + * @return {Ext.promise.Promise} The promise to be resolved when the race completes. + * + * @static + * @since 6.5.0 + */ + race: function() { + return Polyfiller.race.apply(Polyfiller, arguments); + }, + /** + * Convenience method that returns a new Promise rejected with the specified + * reason. + * + * @param {Error} reason Rejection reason. + * @return {Ext.Promise} The rejected Promise. + * @static + */ + reject: function(reason) { + var deferred = new Ext.promise.Deferred(); + deferred.reject(reason); + return deferred.promise; + }, + /** + * Returns a new Promise that either + * + * * Resolves immediately for the specified value, or + * * Resolves or rejects when the specified promise (or third-party Promise or + * then()-able) is resolved or rejected. + * + * @param {Mixed} value A Promise (or third-party Promise or then()-able) + * or value. + * @return {Ext.Promise} A Promise of the specified Promise or value. + * @static + */ + resolve: function(value) { + var deferred = new Ext.promise.Deferred(); + deferred.resolve(value); + return deferred.promise; + } + }, + constructor: function(action) { + var deferred = new Ext.promise.Deferred(); + action(deferred.resolve.bind(deferred), deferred.reject.bind(deferred)); + return deferred.promise; + } + }; +}, function(ExtPromise) { + var P = Ext.global.Promise; + if (P && P.resolve && !Ext.useExtPromises) { + Ext.Promise = P; + } else { + ExtPromise._ready(); + } +}); + +// +// Ext.Deferred 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). +// +// when(), all(), any(), some(), map(), reduce(), delay() and timeout() +// sequence(), parallel(), pipeline() +// methods adapted from: [when.js](https://github.com/cujojs/when) +// Copyright (c) B Cavalier & J Hann +// Open source under the [MIT License](http://en.wikipedia.org/wiki/MIT_License). +// +/** + * Deferreds are the mechanism used to create new Promises. A Deferred has a single + * associated Promise that can be safely returned to external consumers to ensure they do + * not interfere with the resolution or rejection of the deferred operation. + * + * This implementation of Promises is an extension of the ECMAScript 6 Promises API as + * detailed [here][1]. For a compatible, though less full featured, API see `{@link Ext.Promise}`. + * + * A Deferred is typically used within the body of a function that performs an asynchronous + * operation. When that operation succeeds, the Deferred should be resolved; if that + * operation fails, the Deferred should be rejected. + * + * Each Deferred has an associated Promise. A Promise delegates `then` calls to its + * Deferred's `then` method. In this way, access to Deferred operations are divided between + * producer (Deferred) and consumer (Promise) roles. + * + * ## Basic Usage + * + * In it's most common form, a method will create and return a Promise like this: + * + * // A method in a service class which uses a Store and returns a Promise + * // + * loadCompanies: function () { + * var deferred = new Ext.Deferred(); // create the Ext.Deferred object + * + * this.companyStore.load({ + * callback: function (records, operation, success) { + * if (success) { + * // Use "deferred" to drive the promise: + * deferred.resolve(records); + * } + * else { + * // Use "deferred" to drive the promise: + * deferred.reject("Error loading Companies."); + * } + * } + * }); + * + * return deferred.promise; // return the Promise to the caller + * } + * + * You can see this method first creates a `{@link Ext.Deferred Deferred}` object. It then + * returns its `Promise` object for use by the caller. Finally, in the asynchronous + * callback, it resolves the `deferred` object if the call was successful, and rejects the + * `deferred` if the call failed. + * + * When a Deferred's `resolve` method is called, it fulfills with the optionally specified + * value. If `resolve` is called with a then-able (i.e.a Function or Object with a `then` + * function, such as another Promise) it assimilates the then-able's result; the Deferred + * provides its own `resolve` and `reject` methods as the onFulfilled or onRejected + * arguments in a call to that then-able's `then` function. If an error is thrown while + * calling the then-able's `then` function (prior to any call back to the specified + * `resolve` or `reject` methods), the Deferred rejects with that error. If a Deferred's + * `resolve` method is called with its own Promise, it rejects with a TypeError. + * + * When a Deferred's `reject` method is called, it rejects with the optionally specified + * reason. + * + * Each time a Deferred's `then` method is called, it captures a pair of optional + * onFulfilled and onRejected callbacks and returns a Promise of the Deferred's future + * value as transformed by those callbacks. + * + * See `{@link Ext.promise.Promise}` for an example of using the returned Promise. + * + * @since 6.0.0 + */ +Ext.define('Ext.Deferred', function(Deferred) { + /* eslint indent: "off" */ + var ExtPromise, rejected, resolved, when; + // eslint-disable-line + return { + extend: Ext.promise.Deferred, + statics: { + _ready: function() { + // Our requires are met, so we can cache Ext.promise.Deferred + ExtPromise = Ext.promise.Promise; + when = Ext.Promise.resolve; + }, + /** + * Returns a new Promise that will only resolve once all the specified + * `promisesOrValues` have resolved. + * + * The resolution value will be an Array containing the resolution value of each + * of the `promisesOrValues`. + * + * @param {Mixed[]/Ext.promise.Promise[]/Ext.promise.Promise} promisesOrValues An + * Array of values or Promises, or a Promise of an Array of values or Promises. + * @return {Ext.promise.Promise} A Promise of an Array of the resolved values. + * @static + */ + all: function() { + return ExtPromise.all.apply(ExtPromise, arguments); + }, + /** + * Initiates a competitive race, returning a new Promise that will resolve when + * any one of the specified `promisesOrValues` have resolved, or will reject when + * all `promisesOrValues` have rejected or cancelled. + * + * The resolution value will the first value of `promisesOrValues` to resolve. + * + * @param {Mixed[]/Ext.promise.Promise[]/Ext.promise.Promise} promisesOrValues An + * Array of values or Promises, or a Promise of an Array of values or Promises. + * @return {Ext.promise.Promise} A Promise of the first resolved value. + * @static + */ + any: function(promisesOrValues) { + if (!(Ext.isArray(promisesOrValues) || ExtPromise.is(promisesOrValues))) { + Ext.raise('Invalid parameter: expected an Array or Promise of an Array.'); + } + return Deferred.some(promisesOrValues, 1).then(function(array) { + return array[0]; + }, function(error) { + if (error instanceof Error && error.message === 'Too few Promises were resolved.') { + Ext.raise('No Promises were resolved.'); + } else { + throw error; + } + }); + }, + /** + * Returns a new Promise that will automatically resolve with the specified + * Promise or value after the specified delay (in milliseconds). + * + * @param {Mixed} promiseOrValue A Promise or value. + * @param {Number} milliseconds A delay duration (in milliseconds). + * @return {Ext.promise.Promise} A Promise of the specified Promise or value that + * will resolve after the specified delay. + * @static + */ + delay: function(promiseOrValue, milliseconds) { + var deferred; + if (arguments.length === 1) { + milliseconds = promiseOrValue; + promiseOrValue = undefined; + } + milliseconds = Math.max(milliseconds, 1); + deferred = new Deferred(); + deferred.timeoutId = Ext.defer(function() { + delete deferred.timeoutId; + deferred.resolve(promiseOrValue); + }, milliseconds); + return deferred.promise; + }, + /** + * Get a shared cached rejected promise. Assumes Promises + * have been required. + * @return {Ext.Promise} + * + * @private + * @since 6.5.0 + */ + getCachedRejected: function() { + if (!rejected) { + // Prevent Cmd from requiring + rejected = Ext.Promise.reject(); + } + return rejected; + }, + /** + * Get a shared cached resolved promise. Assumes Promises + * have been required. + * @return {Ext.Promise} + * + * @private + * @since 6.5.0 + */ + getCachedResolved: function() { + if (!resolved) { + // Prevent Cmd from requiring + resolved = Ext.Promise.resolve(); + } + return resolved; + }, + /** + * Traditional map function, similar to `Array.prototype.map()`, that allows + * input to contain promises and/or values. + * + * The specified map function may return either a value or a promise. + * + * @param {Mixed[]/Ext.promise.Promise[]/Ext.promise.Promise} promisesOrValues An + * Array of values or Promises, or a Promise of an Array of values or Promises. + * @param {Function} mapFn A Function to call to transform each resolved value in + * the Array. + * @return {Ext.promise.Promise} A Promise of an Array of the mapped resolved + * values. + * @static + */ + map: function(promisesOrValues, mapFn) { + if (!(Ext.isArray(promisesOrValues) || ExtPromise.is(promisesOrValues))) { + Ext.raise('Invalid parameter: expected an Array or Promise of an Array.'); + } + if (!Ext.isFunction(mapFn)) { + Ext.raise('Invalid parameter: expected a function.'); + } + return Deferred.resolved(promisesOrValues).then(function(promisesOrValues) { + var deferred, index, promiseOrValue, remainingToResolve, resolve, results, i, len; + remainingToResolve = promisesOrValues.length; + results = new Array(promisesOrValues.length); + deferred = new Deferred(); + if (!remainingToResolve) { + deferred.resolve(results); + } else { + resolve = function(item, index) { + return Deferred.resolved(item).then(function(value) { + return mapFn(value, index, results); + }).then(function(value) { + results[index] = value; + if (!--remainingToResolve) { + deferred.resolve(results); + } + return value; + }, function(reason) { + return deferred.reject(reason); + }); + }; + for (index = i = 0 , len = promisesOrValues.length; i < len; index = ++i) { + promiseOrValue = promisesOrValues[index]; + if (index in promisesOrValues) { + resolve(promiseOrValue, index); + } else { + remainingToResolve--; + } + } + } + return deferred.promise; + }); + }, + /** + * Returns a new function that wraps the specified function and caches the + * results for previously processed inputs. + * + * Similar to {@link Ext.Function#memoize Ext.Function.memoize()}, except it + * allows for parameters that are Promises and/or values. + * + * @param {Function} fn A Function to wrap. + * @param {Object} scope An optional scope in which to execute the wrapped function. + * @param {Function} hashFn An optional function used to compute a hash key for + * storing the result, based on the arguments to the original function. + * @return {Function} The new wrapper function. + * @static + */ + memoize: function(fn, scope, hashFn) { + var memoizedFn = Ext.Function.memoize(fn, scope, hashFn); + return function() { + return Deferred.all(Ext.Array.slice(arguments)).then(function(values) { + return memoizedFn.apply(scope, values); + }); + }; + }, + /** + * Execute an Array (or {@link Ext.promise.Promise Promise} of an Array) of + * functions in parallel. + * + * The specified functions may optionally return their results as + * {@link Ext.promise.Promise Promises}. + * + * @param {Function[]/Ext.promise.Promise} fns The Array (or Promise of an Array) + * of functions to execute. + * @param {Object} scope Optional scope in which to execute the specified functions. + * @return {Ext.promise.Promise} Promise of an Array of results for each function + * call (in the same order). + * @static + */ + parallel: function(fns, scope) { + var args; + if (scope == null) { + scope = null; + } + args = Ext.Array.slice(arguments, 2); + return Deferred.map(fns, function(fn) { + if (!Ext.isFunction(fn)) { + throw new Error('Invalid parameter: expected a function.'); + } + return fn.apply(scope, args); + }); + }, + /** + * Execute an Array (or {@link Ext.promise.Promise Promise} of an Array) of + * functions as a pipeline, where each function's result is passed to the + * subsequent function as input. + * + * The specified functions may optionally return their results as + * {@link Ext.promise.Promise Promises}. + * + * @param {Function[]/Ext.promise.Promise} fns The Array (or Promise of an Array) + * of functions to execute. + * @param {Object} initialValue Initial value to be passed to the first function + * in the pipeline. + * @param {Object} scope Optional scope in which to execute the specified functions. + * @return {Ext.promise.Promise} Promise of the result value for the final + * function in the pipeline. + * @static + */ + pipeline: function(fns, initialValue, scope) { + if (scope == null) { + scope = null; + } + return Deferred.reduce(fns, function(value, fn) { + if (!Ext.isFunction(fn)) { + throw new Error('Invalid parameter: expected a function.'); + } + return fn.call(scope, value); + }, initialValue); + }, + /** + * Returns a promise that resolves or rejects as soon as one of the promises + * in the array resolves or rejects, with the value or reason from that promise. + * @param {Ext.promise.Promise[]} promises The promises. + * @return {Ext.promise.Promise} The promise to be resolved when the race completes. + * + * @static + * @since 6.5.0 + */ + race: function() { + return ExtPromise.race.apply(ExtPromise, arguments); + }, + /** + * Traditional reduce function, similar to `Array.reduce()`, that allows input to + * contain promises and/or values. + * + * @param {Mixed[]/Ext.promise.Promise[]/Ext.promise.Promise} values An + * Array of values or Promises, or a Promise of an Array of values or Promises. + * @param {Function} reduceFn A Function to call to transform each successive + * item in the Array into the final reduced value. + * @param {Mixed} initialValue An initial Promise or value. + * @return {Ext.promise.Promise} A Promise of the reduced value. + * @static + */ + reduce: function(values, reduceFn, initialValue) { + var initialValueSpecified; + if (!(Ext.isArray(values) || ExtPromise.is(values))) { + Ext.raise('Invalid parameter: expected an Array or Promise of an Array.'); + } + if (!Ext.isFunction(reduceFn)) { + Ext.raise('Invalid parameter: expected a function.'); + } + initialValueSpecified = arguments.length === 3; + return Deferred.resolved(values).then(function(promisesOrValues) { + var reduceArguments = [ + promisesOrValues, + function(previousValueOrPromise, currentValueOrPromise, currentIndex) { + return Deferred.resolved(previousValueOrPromise).then(function(previousValue) { + return Deferred.resolved(currentValueOrPromise).then(function(currentValue) { + return reduceFn(previousValue, currentValue, currentIndex, promisesOrValues); + }); + }); + } + ]; + if (initialValueSpecified) { + reduceArguments.push(initialValue); + } + return Ext.Array.reduce.apply(Ext.Array, reduceArguments); + }); + }, + /** + * Convenience method that returns a new Promise rejected with the specified + * reason. + * + * @param {Error} reason Rejection reason. + * @return {Ext.promise.Promise} The rejected Promise. + * @static + */ + rejected: function(reason) { + var deferred = new Ext.Deferred(); + deferred.reject(reason); + return deferred.promise; + }, + /** + * Returns a new Promise that either + * + * * Resolves immediately for the specified value, or + * * Resolves or rejects when the specified promise (or third-party Promise or + * then()-able) is resolved or rejected. + * + * @param {Mixed} promiseOrValue A Promise (or third-party Promise or then()-able) + * or value. + * @return {Ext.promise.Promise} A Promise of the specified Promise or value. + * @static + */ + resolved: function(promiseOrValue) { + var deferred = new Ext.Deferred(); + deferred.resolve(promiseOrValue); + return deferred.promise; + }, + /** + * Execute an Array (or {@link Ext.promise.Promise Promise} of an Array) of + * functions sequentially. + * + * The specified functions may optionally return their results as {@link + * Ext.promise.Promise Promises}. + * + * @param {Function[]/Ext.promise.Promise} fns The Array (or Promise of an Array) + * of functions to execute. + * @param {Object} scope Optional scope in which to execute the specified functions. + * @return {Ext.promise.Promise} Promise of an Array of results for each function + * call (in the same order). + * @static + */ + sequence: function(fns, scope) { + var args; + if (scope == null) { + scope = null; + } + args = Ext.Array.slice(arguments, 2); + return Deferred.reduce(fns, function(results, fn) { + if (!Ext.isFunction(fn)) { + throw new Error('Invalid parameter: expected a function.'); + } + return Deferred.resolved(fn.apply(scope, args)).then(function(result) { + results.push(result); + return results; + }); + }, []); + }, + /** + * Initiates a competitive race, returning a new Promise that will resolve when + * `howMany` of the specified `promisesOrValues` have resolved, or will reject + * when it becomes impossible for `howMany` to resolve. + * + * The resolution value will be an Array of the first `howMany` values of + * `promisesOrValues` to resolve. + * + * @param {Mixed[]/Ext.promise.Promise[]/Ext.promise.Promise} promisesOrValues An + * Array of values or Promises, or a Promise of an Array of values or Promises. + * @param {Number} howMany The expected number of resolved values. + * @return {Ext.promise.Promise} A Promise of the expected number of resolved + * values. + * @static + */ + some: function(promisesOrValues, howMany) { + if (!(Ext.isArray(promisesOrValues) || ExtPromise.is(promisesOrValues))) { + Ext.raise('Invalid parameter: expected an Array or Promise of an Array.'); + } + if (!Ext.isNumeric(howMany) || howMany <= 0) { + Ext.raise('Invalid parameter: expected a positive integer.'); + } + return Deferred.resolved(promisesOrValues).then(function(promisesOrValues) { + var deferred, index, onReject, onResolve, promiseOrValue, remainingToReject, remainingToResolve, values, i, len; + values = []; + remainingToResolve = howMany; + remainingToReject = (promisesOrValues.length - remainingToResolve) + 1; + deferred = new Deferred(); + if (promisesOrValues.length < howMany) { + deferred.reject(new Error('Too few Promises were resolved.')); + } else { + onResolve = function(value) { + if (remainingToResolve > 0) { + values.push(value); + } + remainingToResolve--; + if (remainingToResolve === 0) { + deferred.resolve(values); + } + return value; + }; + onReject = function(reason) { + remainingToReject--; + if (remainingToReject === 0) { + deferred.reject(new Error('Too few Promises were resolved.')); + } + return reason; + }; + for (index = i = 0 , len = promisesOrValues.length; i < len; index = ++i) { + promiseOrValue = promisesOrValues[index]; + if (index in promisesOrValues) { + Deferred.resolved(promiseOrValue).then(onResolve, onReject); + } + } + } + return deferred.promise; + }); + }, + /** + * Returns a new Promise that will automatically reject after the specified + * timeout (in milliseconds) if the specified promise has not resolved or + * rejected. + * + * @param {Mixed} promiseOrValue A Promise or value. + * @param {Number} milliseconds A timeout duration (in milliseconds). + * @return {Ext.promise.Promise} A Promise of the specified Promise or value that + * enforces the specified timeout. + * @static + */ + timeout: function(promiseOrValue, milliseconds) { + var deferred = new Deferred(), + timeoutId; + timeoutId = Ext.defer(function() { + if (timeoutId) { + deferred.reject(new Error('Promise timed out.')); + } + }, milliseconds); + Deferred.resolved(promiseOrValue).then(function(value) { + Ext.undefer(timeoutId); + timeoutId = null; + deferred.resolve(value); + }, function(reason) { + Ext.undefer(timeoutId); + timeoutId = null; + deferred.reject(reason); + }); + return deferred.promise; + } + } + }; +}, function(Deferred) { + Deferred._ready(); +}); + +// @define Ext.Factory +/** + * @class Ext.Factory + * Manages factories for families of classes (classes with a common `alias` prefix). The + * factory for a class family is a function stored as a `static` on `Ext.Factory`. These + * are created either by directly calling `Ext.Factory.define` or by using the + * `Ext.mixin.Factoryable` interface. + * + * To illustrate, consider the layout system's use of aliases. The `hbox` layout maps to + * the `"layout.hbox"` alias that one typically provides via the `layout` config on a + * Container. + * + * Under the covers this maps to a call like this: + * + * Ext.Factory.layout('hbox'); + * + * Or possibly: + * + * Ext.Factory.layout({ + * type: 'hbox' + * }); + * + * The value of the `layout` config is passed to the `Ext.Factory.layout` function. The + * exact signature of a factory method matches `{@link Ext.Factory#method!create}`. + * + * To define this factory directly, one could call `Ext.Factory.define` like so: + * + * Ext.Factory.define('layout', 'auto'); // "layout.auto" is the default type + * + * @since 5.0.0 + */ +Ext.Factory = function(type) { + var me = this; + me.aliasPrefix = type + '.'; + me.cache = {}; + me.name = type.replace(me.fixNameRe, me.fixNameFn); + me.type = type; + /** + * @cfg {String} [creator] + * The name of the method used to prepare config objects for creation. This defaults + * to `'create'` plus the capitalized name (e.g., `'createLayout'` for the 'laoyut' + * alias family). + */ + me.creator = 'create' + Ext.String.capitalize(me.name); +}; +Ext.Factory.prototype = { + /** + * @cfg {String} [aliasPrefix] + * The prefix to apply to `type` values to form a complete alias. This defaults to the + * proper value in most all cases and should not need to be specified. + * + * @since 5.0.0 + */ + /** + * @cfg {String} [defaultProperty="type"] + * The config property to set when the factory is given a config that is a string. + * + * @since 5.0.0 + */ + defaultProperty: 'type', + /** + * @cfg {String} [defaultType=null] + * An optional type to use if none is given to the factory at invocation. This is a + * suffix added to the `aliasPrefix`. For example, if `aliasPrefix="layout."` and + * `defaultType="hbox"` the default alias is `"layout.hbox"`. This is an alternative + * to `xclass` so only one should be provided. + * + * @since 5.0.0 + */ + /** + * @cfg {String} [instanceProp="isInstance"] + * The property that identifies an object as instance vs a config. + * + * @since 5.0.0 + */ + instanceProp: 'isInstance', + /** + * @cfg {String} [xclass=null] + * The full classname of the type of instance to create when none is provided to the + * factory. This is an alternative to `defaultType` so only one should be specified. + * + * @since 5.0.0 + */ + /** + * @property {Ext.Class} [defaultClass=null] + * The Class reference of the type of instance to create when none is provided to the + * factory. This property is set from `xclass` when the factory instance is created. + * @private + * @readonly + * + * @since 5.0.0 + */ + /** + * @cfg {String} [typeProperty="type"] + * The property from which to read the type alias suffix. + * @since 6.5.0 + */ + typeProperty: 'type', + /** + * Creates an instance of this class family given configuration options. + * + * @param {Object/String} [config] The configuration or instance (if an Object) or + * just the type (if a String) describing the instance to create. + * @param {String} [config.xclass] The full class name of the class to create. + * @param {String} [config.type] The type string to add to the alias prefix for this + * factory. + * @param {String/Object} [defaultType] The type to create if no type is contained in the + * `config`, or an object containing a default set of configs. + * @return {Object} The newly created instance. + * + * @since 5.0.0 + */ + create: function(config, defaultType) { + var me = this, + Manager = Ext.ClassManager, + cache = me.cache, + typeProperty = me.typeProperty, + alias, className, klass, suffix; + if (config) { + if (config[me.instanceProp]) { + return config; + } + if (typeof config === 'string') { + suffix = config; + config = {}; + config[me.defaultProperty] = suffix; + } + className = config.xclass; + suffix = config[typeProperty]; + } + if (defaultType && defaultType.constructor === Object) { + config = Ext.apply({}, config, defaultType); + defaultType = defaultType[typeProperty]; + } + if (className) { + if (!(klass = Manager.get(className))) { + return Manager.instantiate(className, config); + } + } else { + if (!(suffix = suffix || defaultType || me.defaultType)) { + klass = me.defaultClass; + } + if (!suffix && !klass) { + Ext.raise('No type specified for ' + me.type + '.create'); + } + if (!klass && !(klass = cache[suffix])) { + alias = me.aliasPrefix + suffix; + className = Manager.getNameByAlias(alias); + // this is needed to support demand loading of the class + if (!(klass = className && Manager.get(className))) { + return Manager.instantiateByAlias(alias, config); + } + cache[suffix] = klass; + } + } + return klass.isInstance ? klass : new klass(config); + }, + fixNameRe: /\.[a-z]/ig, + fixNameFn: function(match) { + return match.substring(1).toUpperCase(); + }, + clearCache: function() { + this.cache = {}; + this.instanceCache = {}; + }, + /** + * Sets a hook on the creation process. If the hook `fn` returns `undefined` then + * the original `create` method is called. + * + * @param {Function} fn The hook function to call when `create` is invoked. + * @param {Function} fn.original The original `create` method. + * @param {String/Object} fn.config See {@link #method!create create}. + * @param {String/Object} fn.defaultType See {@link #method!create create}. + * @private + * @since 6.5.0 + */ + hook: function(fn) { + var me = this, + original = me.create; + me.create = function(config, defaultType) { + var ret = fn.call(me, original, config, defaultType); + if (ret === undefined) { + ret = original.call(me, config, defaultType); + } + return ret; + }; + }, + /** + * This method accepts a `config` object and an existing `instance` if one exists + * (can be `null`). + * + * The details are best explained by example: + * + * config: { + * header: { + * xtype: 'itemheader' + * } + * }, + * + * applyHeader: function (header, oldHeader) { + * return Ext.Factory.widget.update(oldHeader, header, + * this, 'createHeader'); + * }, + * + * createHeader: function (header) { + * return Ext.apply({ + * xtype: 'itemheader', + * ownerCmp: this + * }, header); + * } + * + * Normally the `applyHeader` method would have to coordinate potential reuse of + * the `oldHeader` and perhaps call `setConfig` on it with the new `header` config + * options. If there was no `oldHeader`, of course, a new instance must be created + * instead. These details are handled by this method. If the `oldHeader` is not + * reused, it will be {@link Ext.Base#method!destroy destroyed}. + * + * For derived class flexibility, the pattern of calling out to a "creator" method + * that only returns the config object has become widely used in many components. + * This pattern is also covered in this method. The goal is to allow the derived + * class to `callParent` and yet not end up with an instantiated component (since + * the type may not yet be known). + * + * This mechanism should be used in favor of `Ext.factory()`. + * + * @param {Ext.Base} instance + * @param {Object/String} config The configuration (see {@link #method!create}). + * @param {Object} [creator] If passed, this object must provide the `creator` + * method or the `creatorMethod` parameter. + * @param {String} [creatorMethod] The name of a creation wrapper method on the + * given `creator` instance that "upgrades" the raw `config` object into a final + * form for creation. + * @param {String} [defaultsConfig] The name of a config property (on the provided + * `creator` instance) that contains defaults to be used to create instances. These + * defaults are present in the config object passed to the `creatorMethod`. + * @return {Object} The reconfigured `instance` or a newly created one. + * @since 6.5.0 + */ + update: function(instance, config, creator, creatorMethod, defaultsConfig) { + var me = this, + aliases, defaults, reuse, type; + // If config is falsy or a valid instance, destroy the current instance + // (if it exists) and replace with the new one + if (!config || config.isInstance) { + if (config && !config[me.instanceProp]) { + Ext.raise('Config instance failed ' + me.instanceProp + ' requirement'); + } + if (instance && instance !== config) { + instance.destroy(); + } + return config; + } + if (typeof config === 'string') { + type = config; + config = {}; + config[me.defaultProperty] = type; + } + // See if the existing instance can just be reconfigured: + if (instance) { + if (config === true) { + return instance; + } + if (!(type = config.xclass)) { + if (!(type = config.xtype)) { + type = config[me.typeProperty]; + if (type) { + // instance must have the right alias... + type = me.aliasPrefix + type; + aliases = instance.self.prototype; + // The alias for the class is on the prototype (derived + // classes do not really own their inherited aliases since + // they won't be created when using them): + if (aliases.hasOwnProperty('alias')) { + aliases = aliases.alias; + if (aliases) { + reuse = aliases === type || aliases.indexOf(type) > -1; + } + } + } + } else { + // config = { xtype: ... } + reuse = instance.isXType(type, /* shallow= */ + true); + } + } else { + // config = { xclass: ... } so we're good if they match + reuse = instance.$className === type; + } + if (reuse) { + instance.setConfig(config); + return instance; + } + instance.destroy(); + } + if (config === true) { + config = {}; + } + if (creator) { + if (defaultsConfig) { + defaults = Ext.Config.map[defaultsConfig]; + defaults = creator[defaults.names.get](); + if (defaults) { + config = Ext.merge(Ext.clone(defaults), config); + } + } + creatorMethod = creatorMethod || me.creator; + if (creator[creatorMethod]) { + config = creator[creatorMethod](config); + if (!config) { + Ext.raise('Missing return value from ' + creatorMethod + ' on class ' + creator.$className); + } + } + } + return me.create(config); + } +}; +/** + * For example, the layout alias family could be defined like this: + * + * Ext.Factory.define('layout', { + * defaultType: 'auto' + * }); + * + * To define multiple families at once: + * + * Ext.Factory.define({ + * layout: { + * defaultType: 'auto' + * } + * }); + * + * @param {String} type The alias family (e.g., "layout"). + * @param {Object/String} [config] An object specifying the config for the `Ext.Factory` + * to be created. If a string is passed it is treated as the `defaultType`. + * @return {Function} + * @static + * @since 5.0.0 + */ +Ext.Factory.define = function(type, config) { + var Factory = Ext.Factory, + cacheable = config && config.cacheable, + defaultClass, factory, fn; + if (type.constructor === Object) { + Ext.Object.each(type, Factory.define, Factory); + } else { + factory = new Ext.Factory(type); + if (config) { + if (config.constructor === Object) { + Ext.apply(factory, config); + if (typeof (defaultClass = factory.xclass) === 'string') { + factory.defaultClass = Ext.ClassManager.get(defaultClass); + } + } else { + factory.defaultType = config; + } + } + /* + * layout = Ext.Factory.layout('hbox'); + */ + Factory[factory.name] = fn = function(config, defaultType) { + // maintain indirection through "create" name on instance to allow + // the hook() mechanism to replace it. + return factory.create(config, defaultType); + }; + if (cacheable) { + factory.instanceCache = {}; + factory.hook(function(original, config, defaultType) { + var cache = this.instanceCache, + v; + if (typeof config === 'string' && !(v = cache[config])) { + v = original.call(this, config, defaultType); + // Validator may have cacheable:false to force new instances each time, + // avoiding the cache + if (v.cacheable !== false) { + cache[config] = v; + // this should catch some improper modifications to the shared + // cached instance, during development but not in production. + Ext.Object.freeze(v); + } + } + return v; + }); + } + fn.instance = factory; + /* + * Typically called by an applier: + * + * applyLayout: function (layout, oldLayout) { + * return Ext.Factory.layout.update(oldLayout, layout, this); + * }, + * + * createLayout: function (config) { + * return Ext.apply({ + * //.. stuff + * }, config); + * } + */ + fn.update = function(instance, config, creator, creatorMethod, defaultsConfig) { + return factory.update(instance, config, creator, creatorMethod, defaultsConfig); + }; + } + return fn; +}; +Ext.Factory.clearCaches = function() { + var Factory = Ext.Factory, + key, item; + for (key in Factory) { + item = Factory[key]; + item = item.instance; + if (item) { + item.clearCache(); + } + } +}; +Ext.Factory.on = function(name, fn) { + Ext.Factory[name].instance.hook(fn); +}; +/** + * This mixin automates use of `Ext.Factory`. When mixed in to a class, the `alias` of the + * class is retrieved and combined with an optional `factoryConfig` property on that class + * to produce the configuration to pass to `Ext.Factory`. + * + * The factory method created by `Ext.Factory` is also added as a static method to the + * target class. + * + * Given a class declared like so: + * + * Ext.define('App.bar.Thing', { + * mixins: [ + * 'Ext.mixin.Factoryable' + * ], + * + * alias: 'bar.thing', // this is detected by Factoryable + * + * factoryConfig: { + * defaultType: 'thing', // this is the default deduced from the alias + * // other configs + * }, + * + * ... + * }); + * + * The produced factory function can be used to create instances using the following + * forms: + * + * var obj; + * + * obj = App.bar.Thing.create('thing'); // same as "new App.bar.Thing()" + * + * obj = App.bar.Thing.create({ + * type: 'thing' // same as above + * }); + * + * obj = App.bar.Thing.create({ + * xclass: 'App.bar.Thing' // same as above + * }); + * + * var obj2 = App.bar.Thing.create(obj); + * // obj === obj2 (passing an instance returns the instance) + * + * Alternatively the produced factory is available as a static method of `Ext.Factory`. + * + * @since 5.0.0 + */ +Ext.define('Ext.mixin.Factoryable', { + mixinId: 'factoryable', + onClassMixedIn: function(targetClass) { + var proto = targetClass.prototype, + factoryConfig = proto.factoryConfig, + alias = proto.alias, + config = {}, + dot, createFn; + alias = alias && alias.length && alias[0]; + if (alias && (dot = alias.lastIndexOf('.')) > 0) { + config.type = alias.substring(0, dot); + config.defaultType = alias.substring(dot + 1); + } + if (factoryConfig) { + delete proto.factoryConfig; + Ext.apply(config, factoryConfig); + } + createFn = Ext.Factory.define(config.type, config); + if (targetClass.create === Ext.Base.create) { + // allow targetClass to override the create method + targetClass.create = createFn; + } + } +}); +/** + * @property {Object} [factoryConfig] + * If this property is specified by the target class of this mixin its properties are + * used to configure the created `Ext.Factory`. + */ + +/** + * This class manages a pending Ajax request. Instances of this type are created by the + * `{@link Ext.data.Connection#request}` method. + * @since 6.0.0 + */ +Ext.define('Ext.data.request.Base', { + mixins: [ + Ext.mixin.Factoryable + ], + // Since this class is abstract, we don't have an alias of our own for Factoryable + // to use. + factoryConfig: { + type: 'request', + defaultType: 'ajax' + }, + // this is the default deduced from the alias + result: null, + success: null, + timer: null, + constructor: function(config) { + var me = this; + // ownerConfig contains default values for config options + // applicable to every Request spawned by that owner; + // however the values can be overridden in the options + // object passed to owner's request() method. + Ext.apply(me, config.options || {}, config.ownerConfig); + me.id = ++Ext.data.Connection.requestId; + me.owner = config.owner; + me.options = config.options; + me.requestOptions = config.requestOptions; + }, + /** + * Start the request. + */ + start: function() { + var me = this, + timeout = me.getTimeout(); + if (timeout && me.async) { + me.timer = Ext.defer(me.onTimeout, timeout, me); + } + }, + abort: function() { + var me = this; + me.clearTimer(); + if (!me.timedout) { + me.aborted = true; + } + me.abort = Ext.emptyFn; + }, + createDeferred: function() { + var me = this, + result = me.result, + d = new Ext.Deferred(); + if (me.completed) { + if (me.success) { + d.resolve(result); + } else { + d.reject(result); + } + } + me.deferred = d; + return d; + }, + getDeferred: function() { + return this.deferred || this.createDeferred(); + }, + getPromise: function() { + return this.getDeferred().promise; + }, + /** + * @method then + * Returns a new promise resolving to the value of the called method. + * @param {Function} success Called when the Promise is fulfilled. + * @param {Function} failure Called when the Promise is rejected. + * @returns {Ext.promise.Promise} + */ + then: function() { + var promise = this.getPromise(); + return promise.then.apply(promise, arguments); + }, + /** + * @method isLoading + * Determines whether this request is in progress. + * + * @return {Boolean} `true` if this request is in progress, `false` if complete. + */ + onComplete: function() { + var me = this, + deferred = me.deferred, + result = me.result; + me.clearTimer(); + if (deferred) { + if (me.success) { + deferred.resolve(result); + } else { + deferred.reject(result); + } + } + me.completed = true; + }, + onTimeout: function() { + var me = this; + me.timedout = true; + me.timer = null; + me.abort(true); + }, + getTimeout: function() { + return this.timeout; + }, + clearTimer: function() { + this.timer = Ext.undefer(this.timer); + }, + destroy: function() { + var me = this; + me.abort(); + me.owner = me.options = me.requestOptions = me.result = null; + me.callParent(); + }, + privates: { + /** + * Creates the exception object + * @param {Object} request + * @private + */ + createException: function() { + var me = this, + result; + result = { + request: me, + requestId: me.id, + status: me.aborted ? -1 : 0, + statusText: me.aborted ? 'transaction aborted' : 'communication failure', + getResponseHeader: me._getHeader, + getAllResponseHeaders: me._getHeaders + }; + if (me.aborted) { + result.aborted = true; + } + if (me.timedout) { + result.timedout = true; + } + return result; + }, + _getHeader: function(name) { + var headers = this.headers; + return headers && headers[name.toLowerCase()]; + }, + _getHeaders: function() { + return this.headers; + } + } +}); + +/** + * + * Simulates an XMLHttpRequest object's methods and properties as returned + * form the flash polyfill plugin. Used in submitting binary data in browsers that do + * not support doing so from JavaScript. + * NOTE: By default this will look for the flash object in the ext directory. When packaging and + * deploying the app, copy the `ext/plugins` directory and its contents to your root + * directory. For custom deployments where just the `FlashPlugin.swf` file gets copied + * (e.g. to `/resources/FlashPlugin.swf`), make sure to notify the framework of the location + * of the plugin before making the first attempt to post binary data, e.g. in the `launch` + * method of your app do: + * + * Ext.flashPluginPath="/resources/FlashPlugin.swf"; + * + * @private + */ +Ext.define('Ext.data.flash.BinaryXhr', { + statics: { + /** + * Called by the flash plugin once it's installed and open for business. + * @private + */ + flashPluginActivated: function() { + Ext.data.flash.BinaryXhr.flashPluginActive = true; + Ext.data.flash.BinaryXhr.flashPlugin = document.getElementById("ext-flash-polyfill"); + Ext.GlobalEvents.fireEvent("flashready"); + }, + // let all pending connections know + /** + * Set to `trut` once the plugin registers and is active. + * @private + */ + flashPluginActive: false, + /** + * Flag to avoid installing the plugin twice. + * @private + */ + flashPluginInjected: false, + /** + * Counts IDs for new connections. + * @private + */ + connectionIndex: 1, + /** + * Placeholder for active connections. + * @private + */ + liveConnections: {}, + /** + * Reference to the actual plugin, once activated. + * @private + */ + flashPlugin: null, + /** + * Called by the flash plugin once the state of one of the active connections changes. + * @param {Number/number} javascriptId the ID of the connection. + * @param {number} state the state of the connection. Equivalent to readyState numbers in + * XHR. + * @param {Object} data optional object containing the returned data, error and status + * codes. + * @private + */ + onFlashStateChange: function(javascriptId, state, data) { + var connection; + // Identify the request this is for. Make sure its a native number + connection = this.liveConnections[Number(javascriptId)]; + if (connection) { + connection.onFlashStateChange(state, data); + } else { + Ext.warn.log("onFlashStateChange for unknown connection ID: " + javascriptId); + } + }, + /** + * Adds the BinaryXhr object to the tracked connection list and assigns it an ID + * @param {Ext.data.flash.BinaryXhr} conn the connection to register + * @return {Number} id + * @private + */ + registerConnection: function(conn) { + var i = this.connectionIndex; + this.conectionIndex = this.connectionIndex + 1; + this.liveConnections[i] = conn; + return i; + }, + /** + * Injects the flash polyfill plugin to allow posting binary data. + * This is done in two steps: First we load the javascript loader for flash objects, + * then we call it to inject the flash object. + * @private + */ + injectFlashPlugin: function() { + var me = this, + flashLoaderPath, flashObjectPath; + /* eslint-disable max-len */ + // Generate the following HTML set of tags: + // + ''
+ // + '
'
+ // + '
'
+ me.flashPolyfillEl = Ext.getBody().appendChild({
+ id: 'ext-flash-polyfill',
+ cn: [
+ {
+ tag: 'p',
+ html: 'To view this page ensure that Adobe Flash Player version 11.1.0 or greater is installed.'
+ },
+ {
+ tag: 'a',
+ href: 'http://www.adobe.com/go/getflashplayer',
+ cn: [
+ {
+ tag: 'img',
+ src: window.location.protocol + '//www.adobe.com/images/shared/download_buttons/get_flash_player.gif',
+ alt: 'Get Adobe Flash player'
+ }
+ ]
+ }
+ ]
+ });
+ // Now load the flash-loading script
+ flashLoaderPath = [
+ Ext.Loader.getPath('Ext.data.Connection'),
+ '../../../plugins/flash/swfobject.js'
+ ].join('/');
+ flashObjectPath = "/plugins/flash/FlashPlugin.swf";
+ flashObjectPath = [
+ Ext.Loader.getPath('Ext.data.Connection'),
+ '../../plugins/flash/FlashPlugin.swf'
+ ].join('/');
+ /* eslint-enable max-len */
+ if (Ext.flashPluginPath) {
+ flashObjectPath = Ext.flashPluginPath;
+ }
+ Ext.Loader.loadScript({
+ url: flashLoaderPath,
+ onLoad: function() {
+ // For version detection, set to min. required Flash Player version,
+ // or 0 (or 0.0.0), for no version detection.
+ // To use express install, set to playerProductInstall.swf, otherwise
+ // the empty string.
+ var swfVersionStr = "11.4.0",
+ xiSwfUrlStr = "playerProductInstall.swf",
+ flashvars = {},
+ params = {},
+ attributes = {};
+ params.quality = "high";
+ params.bgcolor = "#ffffff";
+ params.allowscriptaccess = "sameDomain";
+ params.allowfullscreen = "true";
+ attributes.id = "ext-flash-polyfill";
+ attributes.name = "polyfill";
+ attributes.align = "middle";
+ /* eslint-disable-next-line no-undef */
+ swfobject.embedSWF(flashObjectPath, "ext-flash-polyfill", "0", "0", // no size so it's not visible.
+ swfVersionStr, xiSwfUrlStr, flashvars, params, attributes);
+ },
+ onError: function() {
+ /* eslint-disable-next-line no-undef */
+ Ext.raise("Could not load flash-loader file swfobject.js from " + flashLoader);
+ },
+ scope: me
+ });
+ Ext.data.flash.BinaryXhr.flashPluginInjected = true;
+ }
+ },
+ /**
+ * @property {number} readyState The connection's simulated readyState. Note that the only
+ * supported values are 0, 1 and 4. States 2 and 3 will never be reported.
+ */
+ readyState: 0,
+ /**
+ * @property {number} status Connection status code returned by flash or the server.
+ */
+ status: 0,
+ /**
+ * Status text (if any) returned by flash or the server.
+ */
+ statusText: "",
+ /**
+ * @property {Array} responseBytes The binary bytes returned.
+ */
+ responseBytes: null,
+ /**
+ * An ID representing this connection with flash.
+ * @private
+ */
+ javascriptId: null,
+ /**
+ * Creates a new instance of BinaryXhr.
+ */
+ constructor: function(config) {
+ var me = this;
+ // first, make sure flash is loading if needed
+ if (!Ext.data.flash.BinaryXhr.flashPluginInjected) {
+ Ext.data.flash.BinaryXhr.injectFlashPlugin();
+ }
+ Ext.apply(me, config);
+ me.requestHeaders = {};
+ },
+ /**
+ * Abort this connection. Sets its readyState to 4.
+ */
+ abort: function() {
+ var me = this;
+ // if complete, nothing to abort
+ if (me.readyState === 4) {
+ Ext.warn.log("Aborting a connection that's completed its transfer: " + this.url);
+ return;
+ }
+ // Mark as aborted
+ me.aborted = true;
+ // Remove ourselves from the listeners if flash isn't active yet
+ if (!Ext.data.flash.BinaryXhr.flashPluginActive) {
+ Ext.GlobalEvents.removeListener("flashready", me.onFlashReady, me);
+ return;
+ }
+ // Flash is already live, so we should have a javascriptID and should have called flash
+ // to get the request going. Cancel:
+ Ext.data.flash.BinaryXhr.flashPlugin.abortRequest(me.javascriptId);
+ // remove from list
+ delete Ext.data.flash.BinaryXhr.liveConnections[me.javascriptId];
+ },
+ /**
+ * As in XMLHttpRequest.
+ */
+ getAllResponseHeaders: function() {
+ var headers = [];
+ Ext.Object.each(this.responseHeaders, function(name, value) {
+ headers.push(name + ': ' + value);
+ });
+ return headers.join('\r\n');
+ },
+ /**
+ * As in XMLHttpRequest.
+ */
+ getResponseHeader: function(header) {
+ var headers = this.responseHeaders;
+ return (headers && headers[header]) || null;
+ },
+ /**
+ * As in XMLHttpRequest.
+ */
+ open: function(method, url, isAsync, user, password) {
+ var me = this;
+ me.method = method;
+ me.url = url;
+ me.async = isAsync !== false;
+ // eslint-disable-line id-blacklist
+ me.user = user;
+ me.password = password;
+ if (!me.async) {
+ Ext.raise("Binary posts are only supported in async mode: " + url);
+ }
+ if (me.method !== "POST") {
+ Ext.log.warn("Binary data can only be sent as a POST request: " + url);
+ }
+ },
+ /**
+ * As in XMLHttpRequest.
+ */
+ overrideMimeType: function(mimeType) {
+ this.mimeType = mimeType;
+ },
+ /**
+ * Initiate the request.
+ * @param {Array} body an array of byte values to send.
+ */
+ send: function(body) {
+ var me = this;
+ me.body = body;
+ if (!Ext.data.flash.BinaryXhr.flashPluginActive) {
+ Ext.GlobalEvents.addListener("flashready", me.onFlashReady, me);
+ } else {
+ this.onFlashReady();
+ }
+ },
+ /**
+ * Called by send, or once flash is loaded, to actually send the bytes.
+ * @private
+ */
+ onFlashReady: function() {
+ var me = this,
+ req;
+ me.javascriptId = Ext.data.flash.BinaryXhr.registerConnection(me);
+ // Create the request object we're sending to flash
+ req = {
+ method: me.method,
+ // ignored since we always POST binary data
+ url: me.url,
+ user: me.user,
+ password: me.password,
+ mimeType: me.mimeType,
+ requestHeaders: me.requestHeaders,
+ body: me.body,
+ javascriptId: me.javascriptId
+ };
+ Ext.data.flash.BinaryXhr.flashPlugin.postBinary(req);
+ },
+ /**
+ * Updates readyState and notifies listeners.
+ * @private
+ */
+ setReadyState: function(state) {
+ var me = this;
+ if (me.readyState !== state) {
+ me.readyState = state;
+ me.onreadystatechange();
+ }
+ },
+ /**
+ * As in XMLHttpRequest.
+ */
+ setRequestHeader: function(header, value) {
+ this.requestHeaders[header] = value;
+ },
+ /**
+ * @method
+ * As in XMLHttpRequest.
+ */
+ onreadystatechange: Ext.emptyFn,
+ /**
+ * Parses data returned from flash once a connection is done.
+ * @param {Object} data the data object send from Flash.
+ * @private
+ */
+ parseData: function(data) {
+ var me = this;
+ // parse data and set up variables so that listeners can use this XHR
+ this.status = data.status || 0;
+ // we get back no response headers, so fake what we know:
+ me.responseHeaders = {};
+ if (me.mimeType) {
+ me.responseHeaders["content-type"] = me.mimeType;
+ }
+ if (data.reason === "complete") {
+ // Transfer complete and data received
+ this.responseBytes = data.data;
+ me.responseHeaders["content-length"] = data.data.length;
+ } else if (data.reason === "error" || data.reason === "securityError") {
+ this.statusText = data.text;
+ me.responseHeaders["content-length"] = 0;
+ } else // we don't get the error response data
+ {
+ Ext.raise("Unkown reason code in data: " + data.reason);
+ }
+ },
+ /**
+ * Called once flash calls back with updates about the connection
+ * @param {Number} state the readyState of the connection.
+ * @param {Object} data optional data object.
+ * @private
+ */
+ onFlashStateChange: function(state, data) {
+ var me = this;
+ if (state === 4) {
+ // parse data and prepare for handing back to initiator
+ me.parseData(data);
+ // remove from list
+ delete Ext.data.flash.BinaryXhr.liveConnections[me.javascriptId];
+ }
+ me.setReadyState(state);
+ }
+});
+// notify all listeners
+
+/**
+ * This class manages a pending Ajax request. Instances of this type are created by the
+ * `{@link Ext.data.Connection#request}` method.
+ * @since 6.0.0
+ */
+Ext.define('Ext.data.request.Ajax', {
+ extend: Ext.data.request.Base,
+ alias: 'request.ajax',
+ statics: {
+ /**
+ * Checks if the response status was successful
+ * @param {Number} status The status code
+ * @param {Object} response The Response object
+ * @return {Object} An object containing success/status state
+ * @private
+ */
+ parseStatus: function(status, response) {
+ var type, len, success, isException;
+ if (response) {
+ // We have to account for binary and other response types
+ type = response.responseType;
+ if (type === 'arraybuffer') {
+ len = response.byteLength;
+ } else if (type === 'blob') {
+ len = response.response.size;
+ } else if ((type === 'json' || type === 'document') && response.response) {
+ len = 0;
+ } else if ((type === 'text' || type === '' || !type) && response.responseText) {
+ len = response.responseText.length;
+ }
+ }
+ // see: https://prototype.lighthouseapp.com/projects/8886/tickets/129-ie-mangles-http-response-status-code-204-to-1223
+ status = status === 1223 ? 204 : status;
+ isException = false;
+ // Status can be 0 for file:/// requests
+ success = (status >= 200 && status < 300) || status === 304 || (status === 0 && Ext.isNumber(len));
+ if (!success) {
+ switch (status) {
+ case 12002:
+ case 12029:
+ case 12030:
+ case 12031:
+ case 12152:
+ case 13030:
+ isException = true;
+ break;
+ }
+ }
+ return {
+ success: success,
+ isException: isException
+ };
+ }
+ },
+ start: function(data) {
+ var me = this,
+ options = me.options,
+ requestOptions = me.requestOptions,
+ isXdr = me.isXdr,
+ xhr;
+ xhr = me.xhr = me.openRequest(options, requestOptions, me.async, me.username, me.password);
+ // XDR doesn't support setting any headers
+ if (!isXdr) {
+ me.setupHeaders(xhr, options, requestOptions.data, requestOptions.params);
+ }
+ if (me.async) {
+ if (!isXdr) {
+ xhr.onreadystatechange = me.bindStateChange();
+ }
+ }
+ if (isXdr) {
+ me.processXdrRequest(me, xhr);
+ }
+ // Parent will set the timeout if needed
+ me.callParent([
+ data
+ ]);
+ // start the request!
+ xhr.send(data);
+ if (!me.async) {
+ return me.onComplete();
+ }
+ return me;
+ },
+ /**
+ * Aborts an active request.
+ */
+ abort: function(force) {
+ var me = this,
+ xhr = me.xhr;
+ if (force || me.isLoading()) {
+ /*
+ * Clear out the onreadystatechange here, this allows us
+ * greater control, the browser may/may not fire the function
+ * depending on a series of conditions.
+ */
+ try {
+ xhr.onreadystatechange = null;
+ } catch (e) {
+ // Setting onreadystatechange to null can cause problems in IE, see
+ // http://www.quirksmode.org/blog/archives/2005/09/xmlhttp_notes_a_1.html
+ xhr.onreadystatechange = Ext.emptyFn;
+ }
+ xhr.abort();
+ me.callParent([
+ force
+ ]);
+ me.onComplete();
+ me.cleanup();
+ }
+ },
+ /**
+ * Cleans up any left over information from the request
+ */
+ cleanup: function() {
+ this.xhr = null;
+ delete this.xhr;
+ },
+ isLoading: function() {
+ var me = this,
+ xhr = me.xhr,
+ state = xhr && xhr.readyState,
+ C = Ext.data.flash && Ext.data.flash.BinaryXhr;
+ if (!xhr || me.aborted || me.timedout) {
+ return false;
+ }
+ // if there is a connection and readyState is not 0 or 4, or in case of
+ // BinaryXHR, not 4
+ if (C && xhr instanceof C) {
+ return state !== 4;
+ }
+ return state !== 0 && state !== 4;
+ },
+ /**
+ * Creates and opens an appropriate XHR transport for a given request on this browser.
+ * This logic is contained in an individual method to allow for overrides to process all
+ * of the parameters and options and return a suitable, open connection.
+ * @private
+ */
+ openRequest: function(options, requestOptions, isAsync, username, password) {
+ var me = this,
+ xhr = me.newRequest(options);
+ if (username) {
+ xhr.open(requestOptions.method, requestOptions.url, isAsync, username, password);
+ } else {
+ if (me.isXdr) {
+ xhr.open(requestOptions.method, requestOptions.url);
+ } else {
+ xhr.open(requestOptions.method, requestOptions.url, isAsync);
+ }
+ }
+ if (options.binary || me.binary) {
+ if (window.Uint8Array) {
+ xhr.responseType = 'arraybuffer';
+ } else if (xhr.overrideMimeType) {
+ // In some older non-IE browsers, e.g. ff 3.6, that do not
+ // support Uint8Array, a mime type override is required so that
+ // the unprocessed binary data can be read from the responseText
+ // (see createResponse())
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ } else if (!Ext.isIE) {
+ Ext.log.warn("Your browser does not support loading binary data using Ajax.");
+ }
+ }
+ if (options.responseType) {
+ xhr.responseType = options.responseType;
+ }
+ if (options.withCredentials || me.withCredentials) {
+ xhr.withCredentials = true;
+ }
+ return xhr;
+ },
+ /**
+ * Creates the appropriate XHR transport for a given request on this browser. On IE
+ * this may be an `XDomainRequest` rather than an `XMLHttpRequest`.
+ * @private
+ */
+ newRequest: function(options) {
+ var me = this,
+ xhr;
+ if (options.binaryData) {
+ // This is a binary data request. Handle submission differently for differnet browsers
+ if (window.Uint8Array) {
+ xhr = me.getXhrInstance();
+ } else {
+ // catch all for all other browser types
+ xhr = new Ext.data.flash.BinaryXhr();
+ }
+ } else if (me.cors && Ext.isIE9m) {
+ xhr = me.getXdrInstance();
+ me.isXdr = true;
+ } else {
+ xhr = me.getXhrInstance();
+ me.isXdr = false;
+ }
+ return xhr;
+ },
+ /**
+ * Setup all the headers for the request
+ * @private
+ * @param {Object} xhr The xhr object
+ * @param {Object} options The options for the request
+ * @param {Object} data The data for the request
+ * @param {Object} params The params for the request
+ */
+ setupHeaders: function(xhr, options, data, params) {
+ var me = this,
+ headers = Ext.apply({}, options.headers || {}, me.defaultHeaders),
+ contentType = me.defaultPostHeader,
+ jsonData = options.jsonData,
+ xmlData = options.xmlData,
+ type = 'Content-Type',
+ useHeader = me.useDefaultXhrHeader,
+ key, header;
+ if (!headers.hasOwnProperty(type) && (data || params)) {
+ if (data) {
+ if (options.rawData) {
+ contentType = 'text/plain';
+ } else {
+ if (xmlData && Ext.isDefined(xmlData)) {
+ contentType = 'text/xml';
+ } else if (jsonData && Ext.isDefined(jsonData)) {
+ contentType = 'application/json';
+ }
+ }
+ }
+ headers[type] = contentType;
+ }
+ if (useHeader && !headers['X-Requested-With']) {
+ headers['X-Requested-With'] = me.defaultXhrHeader;
+ }
+ // If undefined/null, remove it and don't set the header.
+ // Allow the browser to do so.
+ if (headers[type] === undefined || headers[type] === null) {
+ delete headers[type];
+ }
+ // set up all the request headers on the xhr object
+ try {
+ for (key in headers) {
+ if (headers.hasOwnProperty(key)) {
+ header = headers[key];
+ xhr.setRequestHeader(key, header);
+ }
+ }
+ } catch (e) {
+ // TODO Request shouldn't fire events from its owner
+ me.owner.fireEvent('exception', key, header);
+ }
+ return headers;
+ },
+ /**
+ * Creates the appropriate XDR transport for this browser.
+ * - IE 7 and below don't support CORS
+ * - IE 8 and 9 support CORS with native XDomainRequest object
+ * - IE 10 (and above?) supports CORS with native XMLHttpRequest object
+ * @private
+ */
+ getXdrInstance: function() {
+ var xdr;
+ if (Ext.ieVersion >= 8) {
+ xdr = new XDomainRequest();
+ } else // eslint-disable-line no-undef
+ {
+ Ext.raise({
+ msg: 'Your browser does not support CORS'
+ });
+ }
+ return xdr;
+ },
+ /**
+ * @private
+ * Do not remove this method. This is where Ajax simulator injects request stubs.
+ */
+ getXhrInstance: function() {
+ return new XMLHttpRequest();
+ },
+ processXdrRequest: function(request, xhr) {
+ var me = this;
+ // Mutate the request object as per XDR spec.
+ delete request.headers;
+ request.contentType = request.options.contentType || me.defaultXdrContentType;
+ xhr.onload = me.bindStateChange(true);
+ xhr.onerror = xhr.ontimeout = me.bindStateChange(false);
+ },
+ processXdrResponse: function(response, xhr) {
+ // Mutate the response object as per XDR spec.
+ response.getAllResponseHeaders = function() {
+ return [];
+ };
+ response.getResponseHeader = function() {
+ return '';
+ };
+ response.contentType = xhr.contentType || this.defaultXdrContentType;
+ },
+ bindStateChange: function(xdrResult) {
+ var me = this;
+ return function() {
+ Ext.elevate(function() {
+ me.onStateChange(xdrResult);
+ });
+ };
+ },
+ onStateChange: function(xdrResult) {
+ var me = this,
+ xhr = me.xhr;
+ // Using CORS with IE doesn't support readyState so we fake it.
+ if ((xhr && xhr.readyState === 4) || me.isXdr) {
+ me.clearTimer();
+ me.onComplete(xdrResult);
+ me.cleanup();
+ }
+ },
+ /**
+ * To be called when the request has come back from the server
+ * @param {Object} xdrResult
+ * @return {Object} The response
+ * @private
+ */
+ onComplete: function(xdrResult) {
+ var me = this,
+ owner = me.owner,
+ options = me.options,
+ xhr = me.xhr,
+ failure = {
+ success: false,
+ isException: false
+ },
+ result, success, response;
+ if (!xhr || me.destroyed) {
+ return me.result = failure;
+ }
+ try {
+ result = Ext.data.request.Ajax.parseStatus(xhr.status, xhr);
+ if (result.success) {
+ // This is quite difficult to reproduce, however if we abort a request
+ // just before it returns from the server, occasionally the status will be
+ // returned correctly but the request is still yet to be complete.
+ result.success = xhr.readyState === 4;
+ }
+ } catch (e) {
+ // In some browsers we can't access the status if the readyState is not 4,
+ // so the request has failed
+ result = failure;
+ }
+ success = me.success = me.isXdr ? xdrResult : result.success;
+ if (success) {
+ response = me.createResponse(xhr);
+ if (owner.hasListeners.requestcomplete) {
+ owner.fireEvent('requestcomplete', owner, response, options);
+ }
+ if (options.success) {
+ Ext.callback(options.success, options.scope, [
+ response,
+ options
+ ]);
+ }
+ } else {
+ if (result.isException || me.aborted || me.timedout) {
+ response = me.createException(xhr);
+ } else {
+ response = me.createResponse(xhr);
+ }
+ if (owner.hasListeners.requestexception) {
+ owner.fireEvent('requestexception', owner, response, options);
+ }
+ if (options.failure) {
+ Ext.callback(options.failure, options.scope, [
+ response,
+ options
+ ]);
+ }
+ }
+ me.result = response;
+ if (options.callback) {
+ Ext.callback(options.callback, options.scope, [
+ options,
+ success,
+ response
+ ]);
+ }
+ owner.onRequestComplete(me);
+ me.callParent([
+ xdrResult
+ ]);
+ return response;
+ },
+ /**
+ * Creates the response object
+ * @param {Object} xhr
+ * @private
+ */
+ createResponse: function(xhr) {
+ var me = this,
+ isXdr = me.isXdr,
+ headers = {},
+ lines = isXdr ? [] : xhr.getAllResponseHeaders().replace(/\r\n/g, '\n').split('\n'),
+ count = lines.length,
+ line, index, key, response;
+ while (count--) {
+ line = lines[count];
+ index = line.indexOf(':');
+ if (index >= 0) {
+ key = line.substr(0, index).toLowerCase();
+ if (line.charAt(index + 1) === ' ') {
+ ++index;
+ }
+ headers[key] = line.substr(index + 1);
+ }
+ }
+ response = {
+ request: me,
+ requestId: me.id,
+ status: xhr.status,
+ statusText: xhr.statusText,
+ getResponseHeader: function(header) {
+ return headers[header.toLowerCase()];
+ },
+ getAllResponseHeaders: function() {
+ return headers;
+ }
+ };
+ if (isXdr) {
+ me.processXdrResponse(response, xhr);
+ }
+ if (me.binary) {
+ response.responseBytes = me.getByteArray(xhr);
+ } else {
+ if (xhr.responseType) {
+ response.responseType = xhr.responseType;
+ }
+ if (xhr.responseType === 'blob') {
+ response.responseBlob = xhr.response;
+ } else if (xhr.responseType === 'json') {
+ response.responseJson = xhr.response;
+ } else if (xhr.responseType === 'document') {
+ response.responseXML = xhr.response;
+ } else {
+ // an error is thrown when trying to access responseText or responseXML
+ // on an xhr object with responseType with any value but "text" or "",
+ // so only attempt to set these properties in the response if we're not
+ // dealing with other specified response types
+ response.responseText = xhr.responseText;
+ response.responseXML = xhr.responseXML;
+ }
+ }
+ return response;
+ },
+ destroy: function() {
+ this.xhr = null;
+ this.callParent();
+ },
+ privates: {
+ /**
+ * Gets binary data from the xhr response object and returns it as a byte array
+ * @param {Object} xhr the xhr response object
+ * @return {Uint8Array/Array}
+ * @private
+ */
+ getByteArray: function(xhr) {
+ var response = xhr.response,
+ responseBody = xhr.responseBody,
+ Cls = Ext.data.flash && Ext.data.flash.BinaryXhr,
+ byteArray, responseText, len, i;
+ if (xhr instanceof Cls) {
+ // If this was a BinaryXHR request via flash, we already have the bytes ready
+ byteArray = xhr.responseBytes;
+ } else if (window.Uint8Array) {
+ // Modern browsers (including IE10) have a native byte array
+ // which can be created by passing the ArrayBuffer (returned as
+ // the xhr.response property) to the Uint8Array constructor.
+ /* eslint-disable-next-line no-undef */
+ byteArray = response ? new Uint8Array(response) : [];
+ } else if (Ext.isIE9p) {
+ // In IE9 and below the responseBody property contains a byte array
+ // but it is not directly accessible using javascript.
+ // In IE9p we can get the bytes by constructing a VBArray
+ // using the responseBody and then converting it to an Array.
+ try {
+ /* eslint-disable-next-line no-undef */
+ byteArray = new VBArray(responseBody).toArray();
+ } catch (e) {
+ // If the binary response is empty, the VBArray constructor will
+ // choke on the responseBody. We can't simply do a null check
+ // on responseBody because responseBody is always falsy when it
+ // contains binary data.
+ byteArray = [];
+ }
+ } else if (Ext.isIE) {
+ // IE8 and below also have a VBArray constructor, but throw a
+ // "VBArray Expected" error if you try to pass the responseBody to
+ // the VBArray constructor.
+ // http://msdn.microsoft.com/en-us/library/ye3x9by3%28v=vs.71%29.aspx
+ // so we have to use vbscript injection to access the bytes
+ if (!this.self.vbScriptInjected) {
+ this.injectVBScript();
+ }
+ /* eslint-disable-next-line no-undef */
+ getIEByteArray(xhr.responseBody, byteArray = []);
+ } else {
+ // in other older browsers make a best-effort attempt to read the
+ // bytes from responseText
+ byteArray = [];
+ responseText = xhr.responseText;
+ len = responseText.length;
+ for (i = 0; i < len; i++) {
+ // Some characters have an extra byte 0xF7 in the high order
+ // position. Throw away the high order byte and then push the
+ // result onto the byteArray.
+ byteArray.push(responseText.charCodeAt(i) & 255);
+ }
+ }
+ return byteArray;
+ },
+ /**
+ * Injects a vbscript tag containing a 'getIEByteArray' method for reading
+ * binary data from an xhr response in IE8 and below.
+ * @private
+ */
+ injectVBScript: function() {
+ var scriptTag = document.createElement('script');
+ scriptTag.type = 'text/vbscript';
+ /* eslint-disable indent */
+ scriptTag.text = [
+ 'Function getIEByteArray(byteArray, out)',
+ 'Dim len, i',
+ 'len = LenB(byteArray)',
+ 'For i = 1 to len',
+ 'out.push(AscB(MidB(byteArray, i, 1)))',
+ 'Next',
+ 'End Function'
+ ].join('\n');
+ /* eslint-enable indent */
+ Ext.getHead().dom.appendChild(scriptTag);
+ this.self.vbScriptInjected = true;
+ }
+ }
+});
+
+/**
+ * This class manages a pending form submit. Instances of this type are created by the
+ * `{@link Ext.data.Connection#request}` method.
+ * @since 6.0.0
+ */
+Ext.define('Ext.data.request.Form', {
+ extend: Ext.data.request.Base,
+ alias: 'request.form',
+ start: function(data) {
+ var me = this,
+ options = me.options,
+ requestOptions = me.requestOptions;
+ // Parent will set the timeout
+ me.callParent([
+ data
+ ]);
+ me.form = me.upload(options.form, requestOptions.url, requestOptions.data, options);
+ return me;
+ },
+ abort: function(force) {
+ var me = this,
+ frame;
+ if (me.isLoading()) {
+ try {
+ frame = me.frame.dom;
+ if (frame.stop) {
+ frame.stop();
+ } else {
+ frame.document.execCommand('Stop');
+ }
+ } catch (e) {}
+ }
+ // ignore
+ me.callParent([
+ force
+ ]);
+ me.onComplete();
+ me.cleanup();
+ },
+ /*
+ * Clean up any left over information from the form submission.
+ */
+ cleanup: function() {
+ var me = this,
+ frame = me.frame;
+ if (frame) {
+ // onComplete hasn't fired yet if frame != null so need to clean up
+ frame.un('load', me.onComplete, me);
+ Ext.removeNode(frame);
+ }
+ me.frame = me.form = null;
+ },
+ isLoading: function() {
+ return !!this.frame;
+ },
+ /**
+ * Uploads a form using a hidden iframe.
+ * @param {String/HTMLElement/Ext.dom.Element} form The form to upload
+ * @param {String} url The url to post to
+ * @param {String} params Any extra parameters to pass
+ * @param {Object} options The initial options
+ * @private
+ */
+ upload: function(form, url, params, options) {
+ form = Ext.getDom(form);
+ options = options || {};
+ /* eslint-disable-next-line vars-on-top */
+ var frameDom = document.createElement('iframe'),
+ frame = Ext.get(frameDom),
+ id = frame.id,
+ hiddens = [],
+ encoding = 'multipart/form-data',
+ buf = {
+ target: form.target,
+ method: form.method,
+ encoding: form.encoding,
+ enctype: form.enctype,
+ action: form.action
+ },
+ addField = function(name, value) {
+ hiddenItem = document.createElement('input');
+ Ext.fly(hiddenItem).set({
+ type: 'hidden',
+ value: value,
+ name: name
+ });
+ form.appendChild(hiddenItem);
+ hiddens.push(hiddenItem);
+ },
+ hiddenItem, obj, value, name, vLen, v, hLen, h;
+ /*
+ * Originally this behaviour was modified for Opera 10 to apply the secure URL after
+ * the frame had been added to the document. It seems this has since been corrected in
+ * Opera so the behaviour has been reverted, the URL will be set before being added.
+ */
+ frame.set({
+ name: id,
+ cls: Ext.baseCSSPrefix + 'hidden-display',
+ src: Ext.SSL_SECURE_URL,
+ tabIndex: -1
+ });
+ document.body.appendChild(frameDom);
+ document.body.appendChild(form);
+ // This is required so that IE doesn't pop the response up in a new window.
+ if (document.frames) {
+ document.frames[id].name = id;
+ }
+ Ext.fly(form).set({
+ target: id,
+ method: 'POST',
+ enctype: encoding,
+ encoding: encoding,
+ action: url || buf.action
+ });
+ // add dynamic params
+ if (params) {
+ obj = Ext.Object.fromQueryString(params) || {};
+ for (name in obj) {
+ if (obj.hasOwnProperty(name)) {
+ value = obj[name];
+ if (Ext.isArray(value)) {
+ vLen = value.length;
+ for (v = 0; v < vLen; v++) {
+ addField(name, value[v]);
+ }
+ } else {
+ addField(name, value);
+ }
+ }
+ }
+ }
+ this.frame = frame;
+ frame.on({
+ load: this.onComplete,
+ scope: this,
+ // Opera introduces multiple 'load' events, so account for extras as well
+ single: !Ext.isOpera
+ });
+ form.submit();
+ document.body.removeChild(form);
+ // Restore form to previous settings
+ Ext.fly(form).set(buf);
+ for (hLen = hiddens.length , h = 0; h < hLen; h++) {
+ Ext.removeNode(hiddens[h]);
+ }
+ return form;
+ },
+ getDoc: function() {
+ var frame = this.frame.dom;
+ return (frame && (frame.contentWindow.document || frame.contentDocument)) || (window.frames[frame.id] || {}).document;
+ },
+ getTimeout: function() {
+ // For a form post, since it can include large file uploads, we do not use the
+ // default timeout from the owner. Only explicit timeouts passed in the options
+ // are meaningful here.
+ return this.options.timeout;
+ },
+ /**
+ * Callback handler for the upload function. After we've submitted the form via the
+ * iframe this creates a bogus response object to simulate an XHR and populates its
+ * responseText from the now-loaded iframe's document body (or a textarea inside the
+ * body). We then clean up by removing the iframe.
+ * @private
+ */
+ onComplete: function() {
+ var me = this,
+ frame = me.frame,
+ owner = me.owner,
+ options = me.options,
+ callback, doc, success, contentNode, response;
+ // Nulled out frame means onComplete was fired already
+ if (!frame) {
+ return;
+ }
+ if (me.aborted || me.timedout) {
+ me.result = response = me.createException();
+ response.responseXML = null;
+ response.responseText = Ext.encode({
+ success: false,
+ message: Ext.String.trim(response.statusText)
+ });
+ response.request = me;
+ callback = options.failure;
+ success = false;
+ } else {
+ try {
+ doc = me.getDoc();
+ // bogus response object
+ me.result = response = {
+ responseText: '',
+ responseXML: null,
+ request: me
+ };
+ // Opera will fire an extraneous load event on about:blank
+ // We want to ignore this since the load event will be fired twice
+ if (doc) {
+ // TODO: See if this still applies vs Current opera-webkit releases
+ if (Ext.isOpera && doc.location === Ext.SSL_SECURE_URL) {
+ return;
+ }
+ if (doc.body) {
+ // Response sent as Content-Type: text/json or text/plain.
+ // Browser will embed it in a To view this page ensure that Adobe Flash Player version 11.1.0 or greater is installed, and that the FlashPlugin.swf file was correctly placed in the /resources directory.
' + // + ''
+ // + ' element.
+ // Note: The statement below tests the result of an assignment.
+ if ((contentNode = doc.body.firstChild) && /pre/i.test(contentNode.tagName)) {
+ response.responseText = contentNode.textContent || contentNode.innerText;
+ }
+ // Response sent as Content-Type: text/html. We must still support
+ // JSON response wrapped in textarea.
+ // Note: The statement below tests the result of an assignment.
+ else if ((contentNode = doc.getElementsByTagName('textarea')[0])) {
+ response.responseText = contentNode.value;
+ } else // Response sent as Content-Type: text/html with no wrapping. Scrape
+ // JSON response out of text
+ {
+ response.responseText = doc.body.textContent || doc.body.innerText;
+ }
+ }
+ // in IE the document may still have a body even if returns XML.
+ // TODO What is this about?
+ response.responseXML = doc.XMLDocument || doc;
+ callback = options.success;
+ success = true;
+ response.status = 200;
+ } else {
+ Ext.raise("Could not acquire a suitable connection for the " + "file upload service.");
+ }
+ } catch (e) {
+ me.result = response = me.createException();
+ // Report any error in the message property
+ response.status = 400;
+ response.statusText = (e.message || e.description) + '';
+ response.responseText = Ext.encode({
+ success: false,
+ message: Ext.String.trim(response.statusText)
+ });
+ response.responseXML = null;
+ callback = options.failure;
+ success = false;
+ }
+ }
+ me.frame = null;
+ me.success = success;
+ owner.fireEvent(success ? 'requestcomplete' : 'requestexception', owner, response, options);
+ Ext.callback(callback, options.scope, [
+ response,
+ options
+ ]);
+ Ext.callback(options.callback, options.scope, [
+ options,
+ success,
+ response
+ ]);
+ owner.onRequestComplete(me);
+ // Must defer slightly to permit full exit from load event before destruction
+ Ext.asap(frame.destroy, frame);
+ me.callParent();
+ },
+ destroy: function() {
+ this.cleanup();
+ this.callParent();
+ }
+});
+
+/**
+ * The Connection class encapsulates a connection to the page's originating domain, allowing
+ * requests to be made either to a configured URL, or to a URL specified at request time.
+ *
+ * Requests made by this class are asynchronous, and will return immediately. No data from the
+ * server will be available to the statement immediately following the {@link #request} call.
+ * To process returned data, use a success callback in the request options object, or an
+ * {@link #requestcomplete event listener}.
+ *
+ * # File Uploads
+ *
+ * File uploads are not performed using normal "Ajax" techniques, that is they are not performed
+ * using XMLHttpRequests. Instead the form is submitted in the standard manner with the DOM
+ * <form> element temporarily modified to have its target set to refer to a dynamically
+ * generated, hidden <iframe> which is inserted into the document but removed after the
+ * return data has been gathered.
+ *
+ * The server response is parsed by the browser to create the document for the IFRAME. If the
+ * server is using JSON to send the return object, then the Content-Type header must be set to
+ * "text/html" in order to tell the browser to insert the text unchanged into the document body.
+ *
+ * Characters which are significant to an HTML parser must be sent as HTML entities, so encode
+ * `<` as `<`, `&` as `&` etc.
+ *
+ * The response text is retrieved from the document, and a fake XMLHttpRequest object is created
+ * containing a responseText property in order to conform to the requirements of event handlers and
+ * callbacks.
+ *
+ * Be aware that file upload packets are sent with the content type multipart/form and some server
+ * technologies (notably JEE) may require some custom processing in order to retrieve parameter
+ * names and parameter values from the packet content.
+ *
+ * Also note that it's not possible to check the response code of the hidden iframe, so the success
+ * handler will ALWAYS fire.
+ *
+ * # Binary Posts
+ *
+ * The class supports posting binary data to the server by using native browser capabilities,
+ * or a flash polyfill plugin in browsers that do not support native binary posting (e.g.
+ * Internet Explorer version 9 or less). A number of limitations exist when the polyfill is used:
+ *
+ * - Only asynchronous connections are supported.
+ * - Only the POST method can be used.
+ * - The return data can only be binary for now. Set the {@link Ext.data.Connection#binary binary}
+ * parameter to `true`.
+ * - Only the 0, 1 and 4 (complete) readyState values will be reported to listeners.
+ * - The flash object will be injected at the bottom of the document and should be invisible.
+ * - Important: See note about packaing the flash plugin with the app in the documenetation of
+ * {@link Ext.data.flash.BinaryXhr BinaryXhr}.
+ *
+ */
+Ext.define('Ext.data.Connection', {
+ mixins: {
+ observable: Ext.mixin.Observable
+ },
+ statics: {
+ requestId: 0
+ },
+ enctypeRe: /multipart\/form-data/i,
+ config: {
+ /**
+ * @cfg {String} url
+ * The URL for this connection.
+ */
+ url: null,
+ /**
+ * @cfg {Boolean} async
+ * `true` if this request should run asynchronously. Setting this to `false` should
+ * generally be avoided, since it will cause the UI to be blocked, the user won't be able
+ * to interact with the browser until the request completes.
+ */
+ async: true,
+ // eslint-disable-line id-blacklist
+ /**
+ * @cfg {String} username
+ * The username to pass when using {@link #withCredentials}.
+ */
+ username: '',
+ /**
+ * @cfg {String} password
+ * The password to pass when using {@link #withCredentials}.
+ */
+ password: '',
+ /**
+ * @cfg {Boolean} disableCaching
+ * True to add a unique cache-buster param to GET requests.
+ */
+ disableCaching: true,
+ /**
+ * @cfg {Boolean} withCredentials
+ * True to set `withCredentials = true` on the XHR object
+ */
+ withCredentials: false,
+ /**
+ * @cfg {Boolean} binary
+ * True if the response should be treated as binary data. If true, the binary
+ * data will be accessible as a "responseBytes" property on the response object.
+ */
+ binary: false,
+ /**
+ * @cfg {Boolean} cors
+ * True to enable CORS support on the XHR object. Currently the only effect of this option
+ * is to use the XDomainRequest object instead of XMLHttpRequest if the browser is IE8
+ * or above.
+ */
+ cors: false,
+ isXdr: false,
+ defaultXdrContentType: 'text/plain',
+ /**
+ * @cfg {String} disableCachingParam
+ * Change the parameter which is sent went disabling caching through a cache buster.
+ */
+ disableCachingParam: '_dc',
+ /**
+ * @cfg {Number} [timeout=30000] The timeout in milliseconds to be used for
+ * requests.
+ * Defaults to 30000 milliseconds (30 seconds).
+ *
+ * When a request fails due to timeout the XMLHttpRequest response object will
+ * contain:
+ *
+ * timedout: true
+ */
+ timeout: 30000,
+ /**
+ * @cfg {Object} [extraParams] Any parameters to be appended to the request.
+ */
+ extraParams: null,
+ /**
+ * @cfg {Boolean} [autoAbort=false]
+ * Whether this request should abort any pending requests.
+ */
+ autoAbort: false,
+ /**
+ * @cfg {String} method
+ * The default HTTP method to be used for requests.
+ *
+ * If not set, but {@link #request} params are present, POST will be used;
+ * otherwise, GET will be used.
+ */
+ method: null,
+ /**
+ * @cfg {Object} defaultHeaders
+ * An object containing request headers which are added to each request made by this object.
+ */
+ defaultHeaders: null,
+ /**
+ * @cfg {String} defaultPostHeader
+ * The default header to be sent out with any post request.
+ */
+ defaultPostHeader: 'application/x-www-form-urlencoded; charset=UTF-8',
+ /**
+ * @cfg {Boolean} useDefaultXhrHeader
+ * `true` to send the {@link #defaultXhrHeader} along with any request.
+ */
+ useDefaultXhrHeader: true,
+ /**
+ * @cfg {String}
+ * The header to send with Ajax requests. Also see {@link #useDefaultXhrHeader}.
+ */
+ defaultXhrHeader: 'XMLHttpRequest'
+ },
+ /**
+ * @event beforerequest
+ * @preventable
+ * Fires before a network request is made to retrieve a data object.
+ * @param {Ext.data.Connection} conn This Connection object.
+ * @param {Object} options The options config object passed to the {@link #request} method.
+ */
+ /**
+ * @event requestcomplete
+ * Fires if the request was successfully completed.
+ * @param {Ext.data.Connection} conn This Connection object.
+ * @param {Object} response The XHR object containing the response data.
+ * See [The XMLHttpRequest Object](http://www.w3.org/TR/XMLHttpRequest/) for details.
+ * @param {Object} options The options config object passed to the {@link #request} method.
+ */
+ /**
+ * @event requestexception
+ * Fires if an error HTTP status was returned from the server. This event may also
+ * be listened to in the event that a request has timed out or has been aborted.
+ * See [HTTP Status Code Definitions](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)
+ * for details of HTTP status codes.
+ * @param {Ext.data.Connection} conn This Connection object.
+ * @param {Object} response The XHR object containing the response data.
+ * See [The XMLHttpRequest Object](http://www.w3.org/TR/XMLHttpRequest/) for details.
+ * @param {Object} options The options config object passed to the {@link #request} method.
+ */
+ constructor: function(config) {
+ // Will call initConfig
+ this.mixins.observable.constructor.call(this, config);
+ this.requests = {};
+ },
+ /**
+ * @method request
+ * Sends an HTTP (Ajax) request to a remote server.
+ *
+ * **Important:** Ajax server requests are asynchronous, and this call will
+ * return before the response has been received.
+ *
+ * Instead, process any returned data using a promise:
+ *
+ * Ext.Ajax.request({
+ * url: 'ajax_demo/sample.json'
+ * }).then(function(response, opts) {
+ * var obj = Ext.decode(response.responseText);
+ * console.dir(obj);
+ * },
+ * function(response, opts) {
+ * console.log('server-side failure with status code ' + response.status);
+ * });
+ *
+ * Or in callback functions:
+ *
+ * Ext.Ajax.request({
+ * url: 'ajax_demo/sample.json',
+ *
+ * success: function(response, opts) {
+ * var obj = Ext.decode(response.responseText);
+ * console.dir(obj);
+ * },
+ *
+ * failure: function(response, opts) {
+ * console.log('server-side failure with status code ' + response.status);
+ * }
+ * });
+ *
+ * To execute a callback function in the correct scope, use the `scope` option.
+ *
+ * @param {Object} options An object which may contain the following properties:
+ *
+ * (The options object may also contain any other property which might be needed to perform
+ * postprocessing in a callback because it is passed to callback functions.)
+ *
+ * @param {String/Function} options.url The URL to which to send the request, or a function
+ * to call which returns a URL string. The scope of the function is specified by the `scope`
+ * option. Defaults to the configured `url`.
+ *
+ * @param {Boolean} options.async `true` if this request should run asynchronously.
+ * Setting this to `false` should generally be avoided, since it will cause the UI to be
+ * blocked, the user won't be able to interact with the browser until the request completes.
+ * Defaults to `true`.
+ *
+ * @param {Object/String/Function} options.params An object containing properties which are
+ * used as parameters to the request, a url encoded string or a function to call to get either.
+ * The scope of the function is specified by the `scope` option.
+ *
+ * @param {String} options.method The HTTP method to use
+ * for the request. Defaults to the configured method, or if no method was configured,
+ * "GET" if no parameters are being sent, and "POST" if parameters are being sent. Note that
+ * the method name is case-sensitive and should be all caps.
+ *
+ * @param {Function} options.callback The function to be called upon receipt of the HTTP
+ * response. The callback is called regardless of success or failure and is passed the
+ * following parameters:
+ * @param {Object} options.callback.options The parameter to the request call.
+ * @param {Boolean} options.callback.success True if the request succeeded.
+ * @param {Object} options.callback.response The XMLHttpRequest object containing the response
+ * data. See [www.w3.org/TR/XMLHttpRequest/](http://www.w3.org/TR/XMLHttpRequest/) for details
+ * about accessing elements of the response.
+ *
+ * @param {Function} options.success The function to be called upon success of the request.
+ * The callback is passed the following parameters:
+ * @param {Object} options.success.response The XMLHttpRequest object containing the response
+ * data.
+ * @param {Object} options.success.options The parameter to the request call.
+ *
+ * @param {Function} options.failure The function to be called upon failure of the request.
+ * The callback is passed the following parameters:
+ * @param {Object} options.failure.response The XMLHttpRequest object containing the response
+ * data.
+ * @param {Object} options.failure.options The parameter to the request call.
+ *
+ * @param {Object} options.scope The scope in which to execute the callbacks: The "this" object
+ * for the callback function. If the `url`, or `params` options were specified as functions
+ * from which to draw values, then this also serves as the scope for those function calls.
+ * Defaults to the browser window.
+ *
+ * @param {Number} options.timeout The timeout in milliseconds to be used for this
+ * request.
+ * Defaults to 30000 milliseconds (30 seconds).
+ *
+ * When a request fails due to timeout the XMLHttpRequest response object will
+ * contain:
+ *
+ * timedout: true
+ *
+ * @param {Ext.Element/HTMLElement/String} options.form The `