ig-types 6.24.23 → 6.25.0

package/Promise.js

@@ -163,8 +163,8 @@ module.packed =
 				return that.handle(packed, ...handlers) }) }
 
 		var handleSTOP = function(err){
+			stop = true
 			if(err && err === Array.STOP){
-				stop = true
 				return []
 			} else if(err && err instanceof Array.STOP){
 				return err.value }
@@ -174,66 +174,78 @@ module.packed =
 		var map = Array.STOP ?
 			'smap'
 			: 'map'
-		return packed
-			// NOTE: we do not need to rapack after this because the handlers 
-			// 		will get the correct (unpacked) values and it's their 
-			// 		responsibility to pack them if needed...
-			// NOTE: this removes the need to handle sub-arrays unless they are
-			// 		in a promise...
-			.flat()
-			[map](
-				function(elem){
-					return elem instanceof Promise ?
-						elem.then(function(elem){
-							if(stop){
-								return [] }
-							try{
-								var has_promise = false
-								// NOTE: do the same thing handle(..) does 
-								// 		but on a single level, without expanding 
-								// 		arrays...
-								if(elem instanceof Array){
-									var res = elem.map(function(elem){
-										var res = elem instanceof Promise ?
-											elem.then(function(elem){
-												try{
-													return !stop ?
-														handler(elem) 
-														: [] 
-												} catch(err){
-													return handleSTOP(err) } })
-											: handler(elem)
-										has_promise = has_promise
-											|| res instanceof Promise
-										return res })
-								// non-arrays...
-								} else {
-									// NOTE: we are wrapping the result in an array to 
-									// 		normalize it with the above...
-									res = [handler(elem)]
-									has_promise = has_promise 
-										|| res[0] instanceof Promise }
-
-								// compensate for the outer .flat()...
-								// NOTE: at this point res is always an array...
-								return has_promise ?
-									// NOTE: since we are already in a promise 
-									// 		grouping things here is not a big 
-									// 		deal, however this is needed to link 
-									// 		nested promises with the containing 
-									// 		promise...
-									Promise.all(res)
-										.then(function(res){
-											return res.flat() })
-									: res.flat() 
-							} catch(err){
-								return handleSTOP(err) } })
-						: handler(elem) },
-				// onerror...
-				function(err){
-					stop = true
-					typeof(onerror) == 'function'
-						&& onerror(err) }) },
+		try{
+			return packed
+				// NOTE: we do not need to rapack after this because the handlers 
+				// 		will get the correct (unpacked) values and it's their 
+				// 		responsibility to pack them if needed...
+				// NOTE: this removes the need to handle sub-arrays unless they are
+				// 		in a promise...
+				.flat()
+				[map](
+					function(elem){
+						return elem instanceof Promise ?
+							elem
+								.then(function(elem){
+									if(stop){
+										return [] }
+									try{
+										var has_promise = false
+										// NOTE: do the same thing handle(..) does 
+										// 		but on a single level, without expanding 
+										// 		arrays...
+										if(elem instanceof Array){
+											var res = elem
+												.map(function(elem){
+													var res = elem instanceof Promise ?
+														elem.then(function(elem){
+															try{
+																return !stop ?
+																	handler(elem) 
+																	: [] 
+															}catch(err){
+																return handleSTOP(err) } })
+														: handler(elem)
+													has_promise = has_promise
+														|| res instanceof Promise
+													return res })
+										// non-arrays...
+										} else {
+											// NOTE: we are wrapping the result in an array to 
+											// 		normalize it with the above...
+											res = [handler(elem)]
+											has_promise = has_promise 
+												|| res[0] instanceof Promise }
+
+										// compensate for the outer .flat()...
+										// NOTE: at this point res is always an array...
+										return has_promise ?
+											// NOTE: since we are already in a promise 
+											// 		grouping things here is not a big 
+											// 		deal, however this is needed to link 
+											// 		nested promises with the containing 
+											// 		promise...
+											Promise.all(res)
+												.then(function(res){
+													return res.flat() })
+											: res.flat() 
+									} catch(err){
+										return handleSTOP(err) } })
+								// err...
+								.catch(function(err){
+									stop = true
+									typeof(onerror) == 'function'
+										&& onerror(err)
+									return [] })
+							: handler(elem) }) 
+				}catch(err){
+					// err
+					if(err !== Array.STOP 
+							&& !(err instanceof Array.STOP)
+							&& typeof(onerror) == 'function'){
+						onerror(err) 
+						return [] }
+					throw err } },
 	//
 	// 	unpack(<packed>)
 	// 		-> <array>
@@ -822,12 +834,17 @@ object.Constructor('IterablePromise', Promise, {
 
 		// populate new instance...
 		if(promise){
+			// handle onerror(..)
+			var handleError = function(err){
+				onerror ?
+					promise.resolve(onerror(err))
+					: promise.reject(err) }
 			// handle/pack input data...
 			if(handler != 'raw'){
 				//list = list instanceof IterablePromise ?
 				list = list instanceof this.constructor ?
-					obj.__handle(list.__packed, handler, onerror)
-					: obj.__pack(list, handler, onerror) }
+					obj.__handle(list.__packed, handler, handleError)
+					: obj.__pack(list, handler, handleError) }
 			Object.defineProperty(obj, '__packed', {
 				value: list,
 				enumerable: false,
@@ -944,27 +961,30 @@ object.Constructor('IterableSequentialStartPromise', IterablePromise, {
 
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-// XXX might also be a good idea to implement a version of the above to
-// 		handle the next element only after the promise returned by the
-// 		previous handler is resolved -- depth first...
-// 		...this would help prevent the await execution uncertainty, i.e.:
-//			console.log(1)
-//			// note that we are NOTE await'ing for the function here...
-//			(async function f(){ 
-//				console.log(2)})()
-//			console.log(3)
-//				-> prints 1, 2, 3
-//		and:
-//			console.log(1)
-//			(async function f(){ 
-//				// note the await -- this is the only difference...
-//				console.log(await 2)})()
-//			console.log(3)
-//				-> prints 1, 3, 2
-//		this is bad because of a handler has two execution paths one with
-//		an await and one without the order of actual handler execution can
-//		not be controlled unless we wait for the whole thing to resolve...
-// 		
+// Like IterableSequentialStartPromise(..) but each handler will be 
+// called after the previous handler's return value is resolved (if it
+// is a promise).
+//
+// This is needed to control the "unpredictable" behavior of await's in 
+// JavaScript, here is a trivial example with an async function starting 
+// as if it was sync and as a promise on the next execution frame:
+// 		console.log(1)
+// 		// note that we are NOTE await'ing for the function here...
+// 		(async function f(){ 
+// 			console.log(2)})()
+// 		console.log(3)
+// 			-> prints 1, 2, 3
+// and:
+// 		console.log(1)
+// 		(async function f(){ 
+// 			// note the await -- this is the only difference...
+// 			console.log(await 2)})()
+// 		console.log(3)
+// 			-> prints 1, 3, 2
+// this is bad because if a handler has two execution paths one with
+// an await and one without the order of actual handler execution can
+// not be controlled predictably unless we wait for the whole thing to 
+// resolve...
 var IterableSequentialPromise =
 module.IterableSequentialPromise =
 object.Constructor('IterableSequentialPromise', IterableSequentialStartPromise, {
@@ -1327,8 +1347,8 @@ object.Mixin('PromiseMixin', 'soft', {
 			// XXX should we just check for .then(..) ???
 			// XXX update README if this changes...
 			: (data.length == 1 
-					&& Symbol.asyncIterator in data[0]
-					&& 'then' in data[0]) ?
+					&& data[0][Symbol.asyncIterator]
+					&& data[0].then) ?
 				data[0].then(func, ...error)
 			: error.length > 0 ?
 				function(){

package/package.json

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

package/test.js

@@ -451,6 +451,51 @@ var cases = test.Cases({
 			'.seqiter(..): STOP(..): delayed')
 
 		// XXX test .seqstartiter(..)
+		
+
+
+		// error...
+		for(var iter of ['iter', 'seqiter', 'seqstartiter']){
+			assert(
+				await Promise[iter]([1,2,Promise.resolve(3),4,5], 
+						function(e){
+							if(e == 2){
+								throw 'ERROR' }
+							return e })
+					.catch(function(err){
+						return 'done' })
+				== 'done',
+				`.${iter}(..): .catch(..)`)
+			assert(
+				await Promise[iter]([1,2,Promise.resolve(3),4,5], 
+					function(e){
+						if(e == 2){
+							throw 'ERROR' }
+						return e },
+					function(err){
+						return 'done' })
+				== 'done',
+				`.${iter}(..): onerror(..)`)
+			assert(
+				await Promise[iter]([1,2,Promise.resolve(3),4,5], 
+					function(e){
+						if(e == 3){
+							throw 'ERROR' }
+						return e },
+					function(err){
+						return 'done' })
+				== 'done',
+				`.${iter}(..): edge onerror(..)`)
+			assert(
+				await Promise[iter]([1,2,Promise.resolve(3),4,5], 
+					function(e){
+						if(e == 4){
+							throw 'ERROR' }
+						return e },
+					function(err){
+						return 'done' })
+				== 'done',
+				`.${iter}(..): late onerror(..)`) }
 	},
 
 	// Date.js