ig-types 6.24.12 → 6.24.14

package/Promise.js

@@ -325,38 +325,42 @@ object.Constructor('IterablePromise', Promise, {
 			'smap'
 			: 'map'
 		var stop = false
+		// XXX do we handle generators here???
+		var each = function(elem){
+			return elem instanceof Array ?
+				elem
+					.map(handler)
+					.flat()
+				: handler(elem) }
 		return list
 			[map](
 				function(elem){
+					// NOTE: we are calling .flat() on the result so we 
+					// 		need to keep a handled array as a single 
+					// 		element by wrapping the return of handled(..)...
 					return elem instanceof IterablePromise ?
-							// XXX should this be expanded??? (like Array below)
 							(elem.isSync() ?
-								handler(elem.sync())
-								// XXX need to handle this but keep it IterablePromise...
-								: elem.iterthen(handler))
+								each(elem.sync())
+								: elem.iterthen(each))
+						// sync sync promise...
 						: (elem instanceof SyncPromise
 								&& !(elem.sync() instanceof Promise)) ?
-							// XXX should this be expanded??? (like Array below)
-							handler(elem.sync())
+							[each(elem.sync())]
 						// promise / promise-like...
 						: elem && elem.then ?
 							// NOTE: when this is explicitly stopped we 
-							// 		do not call any more handlers...
-							// XXX TEST!!!
+							// 		do not call any more handlers after 
+							// 		STOP is thrown/returned...
+							// NOTE: the promise protects this from .flat()
 							elem.then(function(elem){
 								return !stop ?
-									handler(
-										elem.length == 1 ?
-											elem[0]
-											:elem) 
+									each(elem)
 									: [] })
 						: elem instanceof Array ?
-							[handler(
-								elem.length == 1 ?
-									elem[0]
-									: elem)]
-						: handler(elem) },
-				function(res){
+							[each(elem)]
+						: each(elem) },
+				// handle STOP...
+				function(){
 					stop = true })
    			.flat() },
 	//*/
@@ -756,7 +760,8 @@ object.Constructor('IterablePromise', Promise, {
 		// instance...
 		var promise
 		var obj = Reflect.construct(
-			IterablePromise.__proto__, 
+			Promise,
+			//this.constructor.__proto__,
 			[function(resolve, reject){
 				// NOTE: this is here for Promise compatibility...
 				if(typeof(list) == 'function'){
@@ -765,13 +770,14 @@ object.Constructor('IterablePromise', Promise, {
 				if(list === false){
 					return reject() }
 				promise = {resolve, reject} }], 
-			IterablePromise)
+			this.constructor)
 
 		// populate new instance...
 		if(promise){
 			// handle/pack input data...
 			if(handler != 'raw'){
-				list = list instanceof IterablePromise ?
+				//list = list instanceof IterablePromise ?
+				list = list instanceof this.constructor ?
 					obj.__handle(list.__packed, handler, onerror)
 					: obj.__pack(list, handler, onerror) }
 			Object.defineProperty(obj, '__packed', {
@@ -811,53 +817,42 @@ object.Constructor('IterablePromise', Promise, {
 //---------------------------------------------------------------------
 // XXX EXPEREMENTAL/HACK...
 
-// XXX we are getting a list with promises triggered outside, we can't
-// 		control order of execution of this but we can control in what 
-// 		order the handler is called...
-// XXX this potentially shows a bug with IterablePromise:
-// 			Promise.seqiter(
-// 				[1, Promise.resolve(2), 3, Promise.resolve(4)], 
-// 				e => (console.log('---', e), e))
-// 		...this will not resolve/replace the 4's promise...
-// 		for context:
-// 			await Promise.resolve(Promise.resolve(Promise.resolve(123)))
-// 				-> 123
-// 		...is this just a nesting issue here???
-// 		Q: what IterablePromise does/should do if a promise resolves to 
-// 			a promise multiple times...
 // XXX not sure if this is a viable strategy....
 var IterableSequentialPromise =
 module.IterableSequentialPromise =
 object.Constructor('IterableSequentialPromise', IterablePromise, {
-	__new__: function(_, list, handler=undefined, onerror=undefined){
-		var [_, list, ...rest] = arguments
-		var res = list
-		// format the list...
-		if(list instanceof Array 
-				|| list instanceof Promise){
-
-			var pre_process = function(list, start=0){
-				if(list instanceof Promise){
-					return list.then(pre_process) }
-				res = []
-				for(let [i, e] of list.entries().slice(start)){
-					if(e instanceof Promise){
-						res.push(e.then(function(e){
-							return [e,
-								// XXX need to flatten this...
-								...pre_process(list, i+1)] })) 
-						break }
-					res.push(e) } 
-				return res }
-			
-			res = pre_process(list)
-				
-			var obj = IterablePromise.prototype.__new__.call(this, _, res, 'raw')
-
-			return obj
-		}
-		// XXX use .parentCall(..)...
-		return IterablePromise.prototype.__new__.call(this, _, res, ...rest) },
+	// XXX needs more work...
+	__pack: function(list, handler=undefined, onerror=undefined){
+		var seqiter = this.constructor
+
+		var repack = function(list){
+			var res = []
+			for(var [i, e] of list.entries()){
+				// XXX check for .then(..) instead???
+				if(e instanceof Promise 
+						// skip last promise -- nothing to wrap...
+						&& i < list.length-1){
+					res.push(e
+						.then(function(e){ 
+							return seqiter([...e, ...list.slice(i+1)]) }))
+					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 Array ?
+				repack(list)
+			// XXX check for .then(..) instead???
+			: list instanceof Promise ?
+				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.12",
+  "version": "6.24.14",
   "description": "Generic JavaScript types and type extensions...",
   "main": "main.js",
   "scripts": {

package/test.js

@@ -265,6 +265,33 @@ var cases = test.Cases({
 			await Promise.iter([1, Promise.resolve(2), 3]), 
 			[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)
 	},
 
 	// Date.js