ig-types 6.13.2 → 6.13.7

package/Promise.js

@@ -58,6 +58,7 @@ object.Constructor('IterablePromise', Promise, {
 	//
 	// Format:
 	// 	[
+	//		<non-array-value>,
 	//		[ <value> ],
 	//		<promise>,
 	//		...
@@ -66,24 +67,33 @@ object.Constructor('IterablePromise', Promise, {
 	__list: null,
 
 	// low-level .__list handlers/helpers...
+	//
 	// NOTE: these can be useful for debugging and extending...
-	__normalize: function(list, handler){
+	__pack: function(list, handler){
+		var that = this
+		// handle iterable promise list...
+		if(list instanceof IterablePromise){
+			return this.__handle(list.__list, handler) }
 		// handle promise list...
 		if(list instanceof Promise){
-			var that = this
 			return list.then(function(list){
-				return that.__normalize(list, handler) }) }
-
+				return that.__pack(list, handler) }) }
+		// do the work...
+		// NOTE: packing and handling are mixed here because it's faster
+		// 		to do them both on a single list traverse...
 		var handle = !!handler
 		handler = handler 
 			?? function(elem){ 
 				return [elem] }
 		return [list].flat()
 			.map(function(elem){
-				return elem instanceof Array ?
-						handler(elem)
-					: elem && elem.then ?
+				return elem && elem.then ?
+						//that.__pack(elem, handler)
 						elem.then(handler)
+					: elem instanceof Array ?
+						handler(elem)
+					// NOTE: we keep things that do not need protecting 
+					// 		from .flat() as-is...
 					: !handle ?
 						elem
 					: handler(elem) }) },
@@ -98,25 +108,28 @@ object.Constructor('IterablePromise', Promise, {
 		if(list instanceof Promise){
 			return list.then(function(list){
 				return that.__handle(list, handler) }) }
-
+		// do the work...
+		// NOTE: since each section of the packed .__array is the same 
+		// 		structure as the input we'll use .__pack(..) to handle 
+		// 		them, this also keeps all the handling code in one place.
 		return list.map(function(elem){
 			return elem instanceof Array ?
-					that.__normalize(elem, handler)
+					that.__pack(elem, handler)
 				: elem instanceof Promise ?
-					that.__normalize([elem], handler).pop()
+					that.__pack(elem, handler)
 						.then(function(elem){
 							return elem.flat() })
-				: handler(elem) })
+				: [handler(elem)] })
    			.flat() },
-	__denormalize: function(list){
+	__unpack: function(list){
 		list = list 
 			?? this.__list
 		// handle promise list...
 		if(list instanceof Promise){
 			var that = this
 			return list.then(function(list){
-				return that.__denormalize(list) }) }
-
+				return that.__unpack(list) }) }
+		// do the work...
 		return Promise.all(list)
 			.then(function(list){
 				return list.flat() }) },
@@ -150,12 +163,9 @@ object.Constructor('IterablePromise', Promise, {
 	// 			.includes(..)
 	// 			.some(..) / .every(..)
 	// 			.sort(..)
-	//
-	// XXX should these support STOP???
 	map: function(func){
 		return this.constructor(this, 
 			function(e){
-				//return [func(e)] }) },
 				var res = func(e)
 				return res instanceof Promise ?
 		   			res.then(function(e){ 
@@ -164,27 +174,21 @@ object.Constructor('IterablePromise', Promise, {
 	filter: function(func){
 		return this.constructor(this, 
 			function(e){
-				//return func(e) ? 
-				//	[e] 
-				//	: [] }) },
 				var res = func(e)
+				var _filter = function(elem){
+					return res ?
+						[elem]
+						: [] }
 				return res instanceof Promise ?
-						res.then(function(res){
-							return res ?
-								[e]
-								: [] })
-					: res ?
-						[e]
-					: [] }) },
+					res.then(_filter)
+					: _filter(e) }) },
 	// NOTE: this does not return an iterable promise as we can't know 
 	// 		what the user reduces to...
 	// 		XXX we could look at the initial state though...
 	// NOTE: the items can be handled out of order because the nested 
-	// 		promises can resolve in any order.
-	//		XXX doc how to go around this...
+	// 		promises can resolve in any order...
 	// NOTE: since order of execution can not be guaranteed there is no
 	// 		point in implementing .reduceRight(..)
-	// XXX should func be able to return a promise???
 	reduce: function(func, res){
 		return this.constructor(this, 
 				function(e){
@@ -192,14 +196,6 @@ object.Constructor('IterablePromise', Promise, {
 					return [] })
 			.then(function(){ 
 				return res }) },
-	/* // XXX since order of execution is not fixed there is no point in 
-	//		adding this.
-	reduceRight: function(func, res){
-		return this
-			.reverse()
-			.reduce(...arguments)
-			.reverse() },
-	//*/
 	flat: function(depth=1){
 		return this.constructor(this, 
 			function(e){ 
@@ -231,13 +227,25 @@ object.Constructor('IterablePromise', Promise, {
 				.reverse(),
 			'raw') },
 
-	// NOTE: these can create an unresolved promise from a resolved 
-	// 		promise...
+	// NOTE: the following methods can create an unresolved promise from 
+	// 		a resolved promise...
 	concat: function(other){
+		var that = this
+		var cur = this.__pack(this)
+		var other = this.__pack(other)
 		return this.constructor(
-				this.__list
-					.concat(this.__normalize(other)),
-				'raw') },
+			// NOTE: we need to keep things as exposed as possible, this 
+			// 		is why we're not blanketing all the cases with 
+			// 		Promise.all(..)...
+			(cur instanceof Promise 
+					&& other instanceof Promise) ?
+				[cur, other]
+			: cur instanceof Promise ?
+				[cur, ...other]
+			: other instanceof Promise ?
+				[...cur, other]
+			: [...cur, ...other],
+			'raw') },
 	push: function(elem){
 		return this.concat([elem]) },
 	unshift: function(elem){
@@ -248,6 +256,7 @@ object.Constructor('IterablePromise', Promise, {
 	// 			.pop()
 	// 			.shift()
 	// 			.first() / .last()
+	// 			.at(..)
 	// 		...would be nice if these could stop everything that's not
 	// 		needed to execute...
 	
@@ -290,14 +299,14 @@ object.Constructor('IterablePromise', Promise, {
 	// 		-> []
 	//
 	//
-	// NOTE: element index is unknowable untill the full list is expanded
+	// NOTE: element index is unknowable until the full list is expanded
 	// 		as handler(..)'s return value can expand to any number of 
 	// 		items...
 	// 		XXX we can make the index a promise, then if the client needs
 	// 			the value they can wait for it...
 	//
 	//
-	// Spectial cases usefull for extending this constructor...
+	// Special cases useful for extending this constructor...
 	//
 	//	Set raw .__list without any pre-processing...
 	//	Promise.iter([ .. ], 'raw')
@@ -308,45 +317,25 @@ object.Constructor('IterablePromise', Promise, {
 	//		-> iterable-promise
 	//
 	//
-	// XXX if list is an iterator, can we fill this async???
 	// XXX iterator/generator as input:
 	// 		- do we unwind here or externally?
 	// 			...feels like with the generator external unwinding is 
 	// 			needed...
-	// XXX would be nice to support trowing STOP...
+	// XXX would be nice to support throwing STOP...
 	// 		- this is more complicated than simply suing .smap(..) instead 
 	// 			of .map(..) because the list can contain async promises...
 	// 			...would need to wrap each .then(..) call in try-catch and
 	// 			manually handle the stop...
 	// 		- another issue here is that the stop would happen in order of 
 	// 			execution and not order of elements...
-	// XXX DOC:
-	// 		inputs:
-	// 			- Chaining -- list instanceof IterablePromise
-	// 				After all the promises resolve .flat() should 
-	// 				turn this into the input list.
-	// 				For this to work we'll need to at least wrap all 
-	// 				arrays and promise results in arrays.
-	// 				(currently each value is wrapped)
-	// 				-> __list
-	// 					- promise (value | array)
-	// 					- array of:
-	// 						- array
-	// 							- value
-	// 						- promise (value | array)
-	// 			- New
-	// 				- promise (value | array)
-	// 				- value (non-array)
-	// 				- array of:
-	// 					- value
-	// 					- promise (value)
+	// XXX how do we handle errors???
 	__new__: function(_, list, handler){
 		// instance...
 		var promise
 		var obj = Reflect.construct(
 			IterablePromise.__proto__, 
 			[function(resolve, reject){
-				// NOTE: this is here for Promise compatibilty...
+				// NOTE: this is here for Promise compatibility...
 				if(typeof(list) == 'function'){
 					return list.call(this, ...arguments) } 
 				// initial reject... 
@@ -355,19 +344,19 @@ object.Constructor('IterablePromise', Promise, {
 				promise = {resolve, reject} }], 
 			IterablePromise)
 
+		// new instance...
 		if(promise){
+			// handle/pack input data...
 			if(handler != 'raw'){
 				list = list instanceof IterablePromise ?
 					this.__handle(list.__list, handler)
-					: this.__normalize(list, handler) }
-
+					: this.__pack(list, handler) }
 			Object.defineProperty(obj, '__list', {
 				value: list,
 				enumerable: false,
 			})
-
 			// handle promise state...
-			this.__denormalize(list)
+			this.__unpack(list)
 				.then(function(list){
 					promise.resolve(list) })
 				.catch(promise.reject) }
@@ -570,15 +559,12 @@ object.Mixin('PromiseMixin', 'soft', {
 PromiseMixin(Promise)
 
 
-// XXX EXPEREMENTAL...
 var PromiseProtoMixin =
 module.PromiseProtoMixin =
 object.Mixin('PromiseProtoMixin', 'soft', {
 	as: ProxyPromise,
-
-	// XXX
-	iter: function(){
-		return IterablePromise(this) },
+	iter: function(handler){
+		return IterablePromise(this, handler) },
 })
 
 PromiseProtoMixin(Promise.prototype)

package/package.json

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

package/test.js

@@ -183,6 +183,23 @@ var cases = test.Cases({
 						.filter(function(e){ return false }),
 				} },
 
+			/* XXX need tuning...
+			concat_basic: function(assert, {input, output}){
+				return {
+					input: [input].flat()
+						.concat(['a', 'b', 'c']),
+					output: output
+						.concat(['a', 'b', 'c']),
+				} },
+			concat_nested_array: function(assert, {input, output}){
+				return {
+					input: [input].flat()
+						.concat(['a', ['b'], 'c']),
+					output: output
+						.concat(['a', ['b'], 'c']),
+				} },
+			//*/
+
 		})
 		this.Test({
 			value: async function(assert, {input, output}){