android-dev-ext initial commit

jq-promise.js

@@ -0,0 +1,124 @@
+// a very stripped down polyfill implementation of jQuery's promise methods
+const util = require('util');   // for util.inspect
+var $ = this;
+
+// Deferred wraps a Promise into a jQuery-like object
+var Deferred = exports.Deferred = function(p, parent) {
+    var o = { 
+        _isdeferred:true,
+        _original:null,
+        _promise:null,
+        _fns:null,
+        _context:null,
+        _parent:null,
+        _root:null,
+        promise() { 
+            return this;
+        },
+        then(fn) {
+            var thendef = $.Deferred(null, this);
+            var p = this._promise.then(function(a) {
+                var res = this.fn.apply(a._ctx, a._args);
+                if (res === undefined)
+                    return a;
+                if (res && res._isdeferred)
+                    return res._promise;
+                return {_ctx:a._ctx, _args:[res]}
+            }.bind({def:thendef,fn:fn}));
+            thendef._promise = thendef._original = p;
+            return thendef;
+        },
+        fail(fn) { 
+            var faildef = $.Deferred(null, this);
+            var p = this._promise.catch(function(a) {
+                if (a.stack) {
+                    console.error(a.stack);
+                    a = [a];
+                }
+                if (this.def._context === null && this.def._parent)
+                    this.def._context = this.def._parent._context;
+                if (this.def._context === null && this.def._root)
+                    this.def._context = this.def._root._context;
+                var res = this.fn.apply(this.def._context,a);
+                if (res === undefined)
+                    return a;
+                return res;
+            }.bind({def:faildef,fn:fn}));
+            faildef._promise = faildef._original = p;
+            return faildef;
+        },
+        state() {
+            var m = util.inspect(this._original).match(/^Promise\s*\{\s*<(\w+)>/);     // urgh!
+            // anything that's not pending or rejected is resolved
+            return m ? m[1] : 'resolved';
+        },
+        resolve:function() {
+            return this.resolveWith(null, Array.prototype.map.call(arguments,x=>x));
+        },
+        resolveWith:function(ths, args) {
+            if (typeof(args) === 'undefined') args = [];
+            if (!Array.isArray(args))
+                throw new Error('resolveWith must be passed an array of arguments');
+            if (this._root) {
+                this._root.resolveWith(ths, args);
+                return this;
+            }
+            if (ths === null || ths === undefined) ths = this;
+            this._fns[0]({_ctx:ths,_args:args});
+            return this;
+        },
+        reject:function() {
+            return this.rejectWith(null, Array.prototype.map.call(arguments,x=>x));
+        },
+        rejectWith:function(ths,args) {
+            if (typeof(args) === 'undefined') args = [];
+            if (!Array.isArray(args))
+                throw new Error('rejectWith must be passed an array of arguments');
+            if (this._root) {
+                this._root.rejectWith(ths, args);
+                return this;
+            }
+            this._context = ths;
+            this._fns[1](args);
+            return this;
+        },
+    }
+    if (parent) {
+        o._original = o._promise = p;
+        o._parent = parent;
+        o._root = parent._root || parent;
+    } else {
+        o._original = o._promise = new Promise((res,rej) => {
+            o._fns = [res,rej];
+        });
+    }
+    return o;
+}
+
+// $.when() is jQuery's version of Promise.all()
+// - this version just scans the array of arguments waiting on any Deferreds in turn before finally resolving the return Deferred
+var when = exports.when = function() {
+    var x = {
+        def: $.Deferred(),
+        args: Array.prototype.map.call(arguments,x=>x),
+        idx:0,
+        next(x) {
+            if (x.idx >= x.args.length) {
+                return process.nextTick(x => {
+                    x.def.resolveWith(null, x.args);
+                }, x);
+            }
+            if ((x.args[x.idx]||{})._isdeferred) {
+                x.args[x.idx].then(function() {
+                    var x = this, result = Array.prototype.map.call(arguments,x=>x);
+                    x.args[x.idx] = result;
+                    x.idx++; x.next(x);
+                }.bind(x));
+                return;
+            }
+            x.idx++; x.next(x);
+        },
+    };
+    x.next(x);
+    return x.def;
+}