ig-types 6.24.14 → 6.24.16

package/Promise.js

@@ -817,11 +817,31 @@ object.Constructor('IterablePromise', Promise, {
 //---------------------------------------------------------------------
 // XXX EXPEREMENTAL/HACK...
 
+// This like IterablePromise but guarantees handler execution in order 
+// element occurrence.
+//
+// For comparison:
+// 		Promise.all([ .. ]).then(func)
+// 			- func is called on element list
+// 			- func is called when all the elements are resolved
+// 		Promise.iter([ .. ]).iter(func)
+// 			- func per element
+// 			- func is called when an element is resolved/ready 
+// 				in any order
+// 		Promise.seqiter([ .. ]).iter(func)
+// 			- func per element
+// 			- func is called when an element is resolved/ready 
+// 				and when all elements before it are handled
+//
+// NOTE: that here a promise will block handling of later promises even 
+// 		if they are resolved before it.
+//
+// XXX check if this behaves correctly (call order) on concatenation and
+// 		other methods...
 // XXX not sure if this is a viable strategy....
 var IterableSequentialPromise =
 module.IterableSequentialPromise =
 object.Constructor('IterableSequentialPromise', IterablePromise, {
-	// XXX needs more work...
 	__pack: function(list, handler=undefined, onerror=undefined){
 		var seqiter = this.constructor
 
@@ -829,28 +849,33 @@ object.Constructor('IterableSequentialPromise', IterablePromise, {
 			var res = []
 			for(var [i, e] of list.entries()){
 				// XXX check for .then(..) instead???
-				if(e instanceof Promise 
+				//if(e instanceof Promise 
+				if(e.then
 						// skip last promise -- nothing to wrap...
 						&& i < list.length-1){
 					res.push(e
 						.then(function(e){ 
-							return seqiter([...e, ...list.slice(i+1)]) }))
+							return seqiter(
+									[e, ...list.slice(i+1)])
+								.flat() }))
 					break }
 				res.push(e) }
 			return res }
 
 		// NOTE: we are not handling the list here...
 		list = object.parentCall(IterableSequentialPromise.prototype.__pack, this, list) 
-
+		list = list instanceof SyncPromise ?
+			list.sync()
+			: list
 		list = list instanceof Array ?
 				repack(list)
 			// XXX check for .then(..) instead???
-			: list instanceof Promise ?
+			//: list instanceof Promise ?
+			: list.then ?
 				list.then(repack)
 			: list 
 
 		return handler ?
-			// XXX this seems to be wrong...
 			this.__handle(list, handler, onerror)
 			: list },
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ig-types",
-  "version": "6.24.14",
+  "version": "6.24.16",
   "description": "Generic JavaScript types and type extensions...",
   "main": "main.js",
   "scripts": {

package/test.js

@@ -266,32 +266,40 @@ var cases = test.Cases({
 			[1, 2, 3], 
 				'promises as elements')
 
-		// XXX need a recursive assert...
-		var should_be = [ [1], [2], [3], [4], [5], [6] ]
-		var got = await Promise.iter([
-				[1,1,1], 
-				Promise.sync.resolve([2,2,2]), 
-				Promise.resolve([3,3,3]), 
-				Promise.iter([4,4,4]), 
-				Promise.iter.resolve([5,5,5]), 
-				Promise.all([6,6,6]),
-			], 
-			function(e){
-				return e instanceof Array ? 
-					[[ e[0] ]] 
-					// XXX
-					: e })
-		assert(
-			should_be
-				.reduce(function(res, e, i){
-					//console.log('---', e, got[i])
-					if(res === false){
-						return false }
-					return e instanceof Array 
-						&& got[i] instanceof Array
-						&& e.length == got[i].length
-						&& e[0] == got[i][0] }, true), 
-			'pack/unpack:', got)
+		// XXX split this into separate cases...
+		for(var meth of ['iter', 'seqiter']){
+			// XXX need a recursive assert...
+			var should_be = [ [1], [2], [3], [4], [5], [6] ]
+			var got = await Promise[meth]([
+					[1,1,1], 
+					Promise.sync.resolve([2,2,2]), 
+					Promise.resolve([3,3,3]), 
+					Promise.iter([4,4,4]), 
+					Promise.iter.resolve([5,5,5]), 
+					Promise.all([6,6,6]),
+				], 
+				function(e){
+					return e instanceof Array ? 
+						[[ e[0] ]] 
+						// XXX
+						: e })
+			assert(
+				should_be
+					.reduce(function(res, e, i){
+						//console.log('---', e, got[i])
+						if(res === false){
+							return false }
+						return e instanceof Array 
+							&& got[i] instanceof Array
+							&& e.length == got[i].length
+							&& e[0] == got[i][0] }, true), 
+				'pack/unpack', meth, got)
+
+			assert.array(
+				await Promise[meth]([1, Promise.resolve(2), Promise.resolve(3)]),
+				[1,2,3],
+					'flat unpack', meth)
+		}
 	},
 
 	// Date.js