update Deferred, fix typos

dashboard-ui/thirdparty/apiclient/connectionmanager.js

@@ -5,7 +5,7 @@
     }
 
     globalScope.MediaBrowser.ConnectionState = {
-        Unavilable: 0,
+        Unavailable: 0,
         ServerSelection: 1,
         ServerSignIn: 2,
         SignedIn: 3,
@@ -38,8 +38,8 @@
 
             deferred.resolveWith(null, [
             {
-                state: MediaBrowser.ConnectionState.Unavilable,
+                State: MediaBrowser.ConnectionState.Unavailable,
-                connectUser: self.connectUser()
+                ConnectUser: self.connectUser()
             }]);
         }
 
@@ -229,7 +229,7 @@
 
         function ensureConnectUser(credentials) {
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             if (connectUser && connectUser.Id == credentials.ConnectUserId) {
                 deferred.resolveWith(null, [[]]);
@@ -313,7 +313,7 @@
 
         function validateAuthentication(server, connectionMode) {
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             var url = connectionMode == MediaBrowser.ConnectionMode.Local ? server.LocalAddress : server.RemoteAddress;
 
@@ -395,7 +395,7 @@
 
         self.user = function () {
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             var localUser;
 
@@ -454,7 +454,7 @@
                 }
             }
 
-            return Deferred.when(promises).done(function () {
+            return DeferredBuilder.when(promises).done(function () {
 
                 var credentials = credentialProvider.credentials();
 
@@ -494,7 +494,7 @@
 
             logger.log('Begin getConnectServers');
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             if (!self.connectToken() || !self.connectUserId()) {
                 deferred.resolveWith(null, [[]]);
@@ -544,7 +544,7 @@
             var credentials = credentialProvider.credentials();
             var servers = credentials.servers.slice(0);
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             getConnectServers().done(function (result) {
 
@@ -568,7 +568,7 @@
 
             logger.log('Begin connect');
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
             var isResolved = false;
 
             if (capabilities.SupportsOfflineAccess) {
@@ -602,7 +602,7 @@
 
             logger.log('Begin connectToServers, with ' + servers.length + ' servers');
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             if (servers.length == 1) {
 
@@ -661,11 +661,11 @@
 
         self.connectToServer = function (server, options) {
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             var tests = [];
 
-            if (server.LastConnectionMode) {
+            if (server.LastConnectionMode != null) {
                 tests.push(server.LastConnectionMode);
             }
             if (tests.indexOf(MediaBrowser.ConnectionMode.Manual) == -1) { tests.push(MediaBrowser.ConnectionMode.Manual); }
@@ -691,11 +691,21 @@
             return (str1 || '').toLowerCase() == (str2 || '').toLowerCase();
         }
 
+        function onFailedConnection(deferred) {
+
+            var result = {
+                State: MediaBrowser.ConnectionState.Unavailable,
+                ConnectUser: connectUser
+            };
+
+            deferred.resolveWith(null, [result]);
+        }
+
         function testNextConnectionMode(tests, index, isLocalNetworkAvailable, server, wakeOnLanSendTime, options, deferred) {
 
             if (index >= tests.length) {
 
-                OnFailedConnection(response);
+                onFailedConnection(deferred);
                 return;
             }
 
@@ -727,6 +737,8 @@
                 return;
             }
 
+            logger.log('testing connection mode ' + mode + ' with server ' + server.Name);
+
             tryConnect(address, timeout).done(function (result) {
 
                 onSuccessfulConnection(server, result, mode, options, deferred);
@@ -833,7 +845,7 @@
                 address = "http://" + address;
             }
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             tryConnect(address, 15000).done(function (publicInfo) {
 

dashboard-ui/thirdparty/apiclient/deferred.js

@@ -1,6 +1,6 @@
 (function (globalScope) {
 
-    globalScope.Deferred = {
+    globalScope.DeferredBuilder = {
 
         Deferred: function () {
             return jQuery.Deferred();

dashboard-ui/thirdparty/apiclient/deferredAlt.js

@@ -1,101 +1,314 @@
-(function (globalScope) {
+(function (global) {
+    function isArray(arr) {
+        return Object.prototype.toString.call(arr) === '[object Array]';
+    }
 
-    globalScope.Deferred = {
+    function foreach(arr, handler) {
+        if (isArray(arr)) {
+            for (var i = 0; i < arr.length; i++) {
+                handler(arr[i]);
+            }
+        }
+        else
+            handler(arr);
+    }
+
+    function D(fn) {
+        var status = 'pending',
+			doneFuncs = [],
+			failFuncs = [],
+			progressFuncs = [],
+			resultArgs = null,
+
+		promise = {
+		    done: function () {
+		        for (var i = 0; i < arguments.length; i++) {
+		            // skip any undefined or null arguments
+		            if (!arguments[i]) {
+		                continue;
+		            }
+
+		            if (isArray(arguments[i])) {
+		                var arr = arguments[i];
+		                for (var j = 0; j < arr.length; j++) {
+		                    // immediately call the function if the deferred has been resolved
+		                    if (status === 'resolved') {
+		                        arr[j].apply(this, resultArgs);
+		                    }
+
+		                    doneFuncs.push(arr[j]);
+		                }
+		            }
+		            else {
+		                // immediately call the function if the deferred has been resolved
+		                if (status === 'resolved') {
+		                    arguments[i].apply(this, resultArgs);
+		                }
+
+		                doneFuncs.push(arguments[i]);
+		            }
+		        }
+
+		        return this;
+		    },
+
+		    fail: function () {
+		        for (var i = 0; i < arguments.length; i++) {
+		            // skip any undefined or null arguments
+		            if (!arguments[i]) {
+		                continue;
+		            }
+
+		            if (isArray(arguments[i])) {
+		                var arr = arguments[i];
+		                for (var j = 0; j < arr.length; j++) {
+		                    // immediately call the function if the deferred has been resolved
+		                    if (status === 'rejected') {
+		                        arr[j].apply(this, resultArgs);
+		                    }
+
+		                    failFuncs.push(arr[j]);
+		                }
+		            }
+		            else {
+		                // immediately call the function if the deferred has been resolved
+		                if (status === 'rejected') {
+		                    arguments[i].apply(this, resultArgs);
+		                }
+
+		                failFuncs.push(arguments[i]);
+		            }
+		        }
+
+		        return this;
+		    },
+
+		    always: function () {
+		        return this.done.apply(this, arguments).fail.apply(this, arguments);
+		    },
+
+		    progress: function () {
+		        for (var i = 0; i < arguments.length; i++) {
+		            // skip any undefined or null arguments
+		            if (!arguments[i]) {
+		                continue;
+		            }
+
+		            if (isArray(arguments[i])) {
+		                var arr = arguments[i];
+		                for (var j = 0; j < arr.length; j++) {
+		                    // immediately call the function if the deferred has been resolved
+		                    if (status === 'pending') {
+		                        progressFuncs.push(arr[j]);
+		                    }
+		                }
+		            }
+		            else {
+		                // immediately call the function if the deferred has been resolved
+		                if (status === 'pending') {
+		                    progressFuncs.push(arguments[i]);
+		                }
+		            }
+		        }
+
+		        return this;
+		    },
+
+		    then: function () {
+		        // fail callbacks
+		        if (arguments.length > 1 && arguments[1]) {
+		            this.fail(arguments[1]);
+		        }
+
+		        // done callbacks
+		        if (arguments.length > 0 && arguments[0]) {
+		            this.done(arguments[0]);
+		        }
+
+		        // notify callbacks
+		        if (arguments.length > 2 && arguments[2]) {
+		            this.progress(arguments[2]);
+		        }
+		    },
+
+		    promise: function (obj) {
+		        if (obj == null) {
+		            return promise;
+		        } else {
+		            for (var i in promise) {
+		                obj[i] = promise[i];
+		            }
+		            return obj;
+		        }
+		    },
+
+		    state: function () {
+		        return status;
+		    },
+
+		    debug: function () {
+		        console.log('[debug]', doneFuncs, failFuncs, status);
+		    },
+
+		    isRejected: function () {
+		        return status === 'rejected';
+		    },
+
+		    isResolved: function () {
+		        return status === 'resolved';
+		    },
+
+		    pipe: function (done, fail, progress) {
+		        return D(function (def) {
+		            foreach(done, function (func) {
+		                // filter function
+		                if (typeof func === 'function') {
+		                    deferred.done(function () {
+		                        var returnval = func.apply(this, arguments);
+		                        // if a new deferred/promise is returned, its state is passed to the current deferred/promise
+		                        if (returnval && typeof returnval === 'function') {
+		                            returnval.promise().then(def.resolve, def.reject, def.notify);
+		                        }
+		                        else {	// if new return val is passed, it is passed to the piped done
+		                            def.resolve(returnval);
+		                        }
+		                    });
+		                }
+		                else {
+		                    deferred.done(def.resolve);
+		                }
+		            });
+
+		            foreach(fail, function (func) {
+		                if (typeof func === 'function') {
+		                    deferred.fail(function () {
+		                        var returnval = func.apply(this, arguments);
+
+		                        if (returnval && typeof returnval === 'function') {
+		                            returnval.promise().then(def.resolve, def.reject, def.notify);
+		                        } else {
+		                            def.reject(returnval);
+		                        }
+		                    });
+		                }
+		                else {
+		                    deferred.fail(def.reject);
+		                }
+		            });
+		        }).promise();
+		    }
+		},
+
+		deferred = {
+		    resolveWith: function (context) {
+		        if (status === 'pending') {
+		            status = 'resolved';
+		            var args = resultArgs = (arguments.length > 1) ? arguments[1] : [];
+		            for (var i = 0; i < doneFuncs.length; i++) {
+		                doneFuncs[i].apply(context, args);
+		            }
+		        }
+		        return this;
+		    },
+
+		    rejectWith: function (context) {
+		        if (status === 'pending') {
+		            status = 'rejected';
+		            var args = resultArgs = (arguments.length > 1) ? arguments[1] : [];
+		            for (var i = 0; i < failFuncs.length; i++) {
+		                failFuncs[i].apply(context, args);
+		            }
+		        }
+		        return this;
+		    },
+
+		    notifyWith: function (context) {
+		        if (status === 'pending') {
+		            var args = resultArgs = (arguments.length > 1) ? arguments[1] : [];
+		            for (var i = 0; i < progressFuncs.length; i++) {
+		                progressFuncs[i].apply(context, args);
+		            }
+		        }
+		        return this;
+		    },
+
+		    resolve: function () {
+		        return this.resolveWith(this, arguments);
+		    },
+
+		    reject: function () {
+		        return this.rejectWith(this, arguments);
+		    },
+
+		    notify: function () {
+		        return this.notifyWith(this, arguments);
+		    }
+		}
+
+        var obj = promise.promise(deferred);
+
+        if (fn) {
+            fn.apply(obj, [obj]);
+        }
+
+        return obj;
+    }
+
+    D.when = function () {
+        if (arguments.length < 2) {
+            var obj = arguments.length ? arguments[0] : undefined;
+            if (obj && (typeof obj.isResolved === 'function' && typeof obj.isRejected === 'function')) {
+                return obj.promise();
+            }
+            else {
+                return D().resolve(obj).promise();
+            }
+        }
+        else {
+            return (function (args) {
+                var df = D(),
+					size = args.length,
+					done = 0,
+					rp = new Array(size);	// resolve params: params of each resolve, we need to track down them to be able to pass them in the correct order if the master needs to be resolved
+
+                for (var i = 0; i < args.length; i++) {
+                    (function (j) {
+                        var obj = null;
+
+                        if (args[j].done) {
+                            args[j].done(function () { rp[j] = (arguments.length < 2) ? arguments[0] : arguments; if (++done == size) { df.resolve.apply(df, rp); } })
+                            .fail(function () { df.reject(arguments); });
+                        } else {
+                            obj = args[j];
+                            args[j] = new Deferred();
+
+                            args[j].done(function () { rp[j] = (arguments.length < 2) ? arguments[0] : arguments; if (++done == size) { df.resolve.apply(df, rp); } })
+                            .fail(function () { df.reject(arguments); }).resolve(obj);
+                        }
+                    })(i);
+                }
+
+                return df.promise();
+            })(arguments);
+        }
+    }
+
+    global.Deferred = D;
+})(window);
+
+(function (globalScope) {
+
+    globalScope.DeferredBuilder = {
 
         Deferred: function () {
-
+            return new globalScope.Deferred();
-            var self = this;
-            var done = [];
-            var fail = [];
-            var always = [];
-            var isOk = false;
-            var isDone = false;
-            var resolveScope;
-            var resolveArgs;
-
-            self.promise = function () {
-                return this;
-            };
-
-            self.done = function (fn) {
-                if (isDone && isOk) {
-                    fn.apply(resolveScope || {}, resolveArgs);
-                }
-                else {
-                    done.push(fn);
-                }
-                return self;
-            };
-
-            self.fail = function (fn) {
-
-                if (isDone && !isOk) {
-                    fn.apply(resolveScope || {}, resolveArgs);
-                }
-                else {
-                    fail.push(fn);
-                }
-                return self;
-            };
-
-            self.always = function (fn) {
-                if (isDone) {
-                    fn.apply(resolveScope || {}, resolveArgs);
-                }
-                else {
-                    always.push(fn);
-                }
-                return self;
-            };
-
-            self.resolveWith = function (scope, args) {
-                resolveScope = scope;
-                resolveArgs = args;
-                isOk = true;
-                isDone = true;
-                self.trigger();
-            };
-
-            self.rejectWith = function (scope, args) {
-                resolveScope = scope;
-                resolveArgs = args;
-                isOk = true;
-                isDone = true;
-                self.trigger();
-            };
-
-            self.trigger = function () {
-
-                var i, length;
-
-                if (isOk) {
-                    var doneClone = done.splice(0);
-                    for (i = 0, length = doneClone.length; i < length; i++) {
-
-                        doneClone[i].apply(resolveScope || {}, resolveArgs);
-                    }
-                }
-                else {
-                    var failClone = fail.splice(0);
-                    for (i = 0, length = failClone.length; i < length; i++) {
-
-                        failClone[i].apply(resolveScope || {}, resolveArgs);
-                    }
-                }
-
-                var alwaysClone = fail.splice(0);
-                for (i = 0, length = alwaysClone.length; i < length; i++) {
-
-                    alwaysClone[i].apply(resolveScope || {}, resolveArgs);
-                }
-            };
-
-            return this;
         },
 
-        when: function(promises) {
+        when: function (promises) {
-            
+
+            return globalScope.Deferred.when(promises);
         }
+
     };
 
 })(window);

dashboard-ui/thirdparty/apiclient/mediabrowser.apiclient.js

@@ -151,7 +151,7 @@
                 return AjaxApi.ajax(request).fail(onRequestFail);
             }
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
             self.ajaxWithFailover(request, deferred, true);
             return deferred.promise();
         };
@@ -218,7 +218,7 @@
 
         function tryReconnect() {
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
             setTimeout(function () {
                 tryReconnectInternal(deferred, self.connectionMode, 0);
             }, 500);
@@ -524,7 +524,7 @@
                 }).done(done);
             }
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
             deferred.resolveWith(null, []);
             return deferred.promise().done(done);
         };
@@ -1983,7 +1983,7 @@
                 throw new Error("File must be an image.");
             }
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             var reader = new FileReader();
 
@@ -2045,7 +2045,7 @@
 
             url += "/" + imageType;
 
-            var deferred = Deferred.Deferred();
+            var deferred = DeferredBuilder.Deferred();
 
             var reader = new FileReader();
 
@@ -3227,7 +3227,7 @@
 
             if (self.isWebSocketOpen()) {
 
-                var deferred = Deferred.Deferred();
+                var deferred = DeferredBuilder.Deferred();
 
                 var msg = JSON.stringify(options);
 
@@ -3260,7 +3260,7 @@
 
             if (self.isWebSocketOpen()) {
 
-                var deferred = Deferred.Deferred();
+                var deferred = DeferredBuilder.Deferred();
 
                 var msg = JSON.stringify(options);
 
@@ -3293,7 +3293,7 @@
 
             if (self.isWebSocketOpen()) {
 
-                var deferred = Deferred.Deferred();
+                var deferred = DeferredBuilder.Deferred();
 
                 var msg = JSON.stringify(options);