ig-types 6.24.5 → 6.24.8

package/Promise.js

@@ -30,7 +30,7 @@
 
 var object = require('ig-object')
 
-//var generator = require('./generator')
+var generator = require('./generator')
 
 
 
@@ -123,20 +123,50 @@ object.Constructor('IterablePromise', Promise, {
 	// 		stop will stop the handlers not yet run and not the next 
 	// 		handlers in sequence.
 	// 		XXX EXPEREMENTAL: STOP...
-	// XXX add support for async generators...
-	// 		...an async generator is not "parallel", i.e. intil one 
-	// 		returned promise is resolved the generator blocks (will not 
-	// 		advance)...
-	// 		...can we feed out a results one by one???
-	__pack: function(list, handler=undefined){
+	// XXX ITER can we unwind (sync/async) generators one by one???
+	__pack: function(list, handler=undefined, onerror=undefined){
 		var that = this
-		// handle iterable promise list...
+		// handle iterator...
+		// XXX ITER do we unwind the iterator here or wait to unwind later???
+		if(typeof(list) == 'object' 
+				&& Symbol.iterator in list){
+			if(!onerror){
+				list = [...list]
+			// handle errors in input generator...
+			} else {
+				var res = []
+				try{
+					for(var e of list){
+						res.push(e) }
+					list = res
+				}catch(err){
+					var r = onerror(err)
+					if(r === this.constructor.STOP
+							|| r instanceof this.constructor.STOP){
+						r instanceof this.constructor.STOP
+							&& res.push(r.value)
+						list = res 
+					} else {
+						list = r instanceof Array ?
+								r
+							: r ?
+								[r]
+							: [] } } } }
+		// handle iterable promise...
 		if(list instanceof IterablePromise){
-			return this.__handle(list.__packed, handler) }
-		// handle promise list...
-		if(list instanceof Promise){
-			return list.then(function(list){
-				return that.__pack(list, handler) }) }
+			return this.__handle(list.__packed, handler, onerror) }
+		// handle promise / async-iterator...
+		// XXX ITER do we unwind the iterator here or wait to unwind later???
+		if(typeof(list) == 'object' 
+					&& Symbol.asyncIterator in list){
+			return list
+				.iter(handler, onerror) 
+				.then(function(list){
+					return that.__pack(list) }) 
+		} else if(list instanceof Promise){
+			return list
+				.then(function(list){
+					return that.__pack(list, handler, onerror) }) }
 		// do the work...
 		// NOTE: packing and handling are mixed here because it's faster
 		// 		to do them both on a single list traverse...
@@ -146,7 +176,6 @@ object.Constructor('IterablePromise', Promise, {
 				return [elem] }
 
 		//* XXX EXPEREMENTAL: STOP...
-		var stoppable = false
 		var stop = false
 		var map = 'map'
 		var pack = function(){
@@ -162,10 +191,7 @@ object.Constructor('IterablePromise', Promise, {
 								&& !(elem.sync() instanceof Promise)) ?
 							handler(elem.sync())
 						: elem && elem.then ?
-					/*/
-					return elem && elem.then ?
-					//*/
-							(stoppable ?
+							(handleSTOP ?
 								// stoppable -- need to handle stop async...
 								elem
 									.then(function(res){
@@ -189,9 +215,9 @@ object.Constructor('IterablePromise', Promise, {
 
 		// pack (stoppable)...
 		if(!!this.constructor.STOP){
-			stoppable = true
 			map = 'smap'
 			var handleSTOP = function(err){
+				// handle stop...
 				stop = err
 				if(err === that.constructor.STOP
 						|| err instanceof that.constructor.STOP){
@@ -221,7 +247,7 @@ object.Constructor('IterablePromise', Promise, {
 					: handler(elem) }) },
 		//*/
 	// transform/handle packed array (sync)...
-	__handle: function(list, handler=undefined){
+	__handle: function(list, handler=undefined, onerror=undefined){
 		var that = this
 		if(typeof(list) == 'function'){
 			handler = list
@@ -231,7 +257,7 @@ object.Constructor('IterablePromise', Promise, {
 		// handle promise list...
 		if(list instanceof Promise){
 			return list.then(function(list){
-				return that.__handle(list, handler) }) }
+				return that.__handle(list, handler, onerror) }) }
 		// do the work...
 		// NOTE: since each section of the packed .__array is the same 
 		// 		structure as the input we'll use .__pack(..) to handle 
@@ -245,9 +271,9 @@ object.Constructor('IterablePromise', Promise, {
 		return list.map(function(elem){
 		//*/
 			return elem instanceof Array ?
-					that.__pack(elem, handler)
+					that.__pack(elem, handler, onerror)
 				: elem instanceof Promise ?
-					that.__pack(elem, handler)
+					that.__pack(elem, handler, onerror)
 						//.then(function(elem){
 						.then(function([elem]){
 							return elem })
@@ -274,11 +300,16 @@ object.Constructor('IterablePromise', Promise, {
 			// give up on a sync solution...
 			if(e instanceof Promise){
 				// XXX can we return an IterablePromise???
-				// XXX these will cause infinite recursion....
+				// XXX this will cause infinite recursion....
 				//return Promise.iter(list).flat() }
+				// XXX is there a more elegant way to do this???
 				return Promise.all(list)
 					.then(function(list){ 
-						return list.flat() }) }
+						return list.flat() })
+					.iter() }
+				//return Promise.all(list)
+				//	.then(function(list){ 
+				//		return list.flat() }) }
 			res.push(e) }
 		return res.flat() },
 	/*/
@@ -658,7 +689,7 @@ object.Constructor('IterablePromise', Promise, {
 	// NOTE: if 'types/Array' is imported this will support throwing STOP,
 	// 		for more info see notes for .__pack(..)
 	// 		XXX EXPEREMENTAL: STOP...
-	__new__: function(_, list, handler){
+	__new__: function(_, list, handler=undefined, onerror=undefined){
 		// instance...
 		var promise
 		var obj = Reflect.construct(
@@ -678,8 +709,8 @@ object.Constructor('IterablePromise', Promise, {
 			// handle/pack input data...
 			if(handler != 'raw'){
 				list = list instanceof IterablePromise ?
-					obj.__handle(list.__packed, handler)
-					: obj.__pack(list, handler) }
+					obj.__handle(list.__packed, handler, onerror)
+					: obj.__pack(list, handler, onerror) }
 			Object.defineProperty(obj, '__packed', {
 				value: list,
 				enumerable: false,
@@ -1003,10 +1034,9 @@ object.Constructor('SyncPromise', Promise, {
 		// async...
 		if(!error 
 				&& value instanceof Promise){
-			return value }
+			return object.ASIS(value) }
 		// sync...
 		var obj = Promise.resolve(value)
-		obj.__proto__ = this.prototype
 		obj.value = value
 		rejected
 			&& (obj.error = error)
@@ -1025,10 +1055,9 @@ object.Mixin('PromiseMixin', 'soft', {
 	cooperative: CooperativePromise,
 	sync: SyncPromise,
 	// XXX should this be implemented via SyncPromise??? 
-	awaitOrRun: function(data, func){
+	awaitOrRun: function(data, func, error){
 		data = [...arguments]
 		func = data.pop()
-		var error
 		if(typeof(data.at(-1)) == 'function'){
 			error = func
 			func = data.pop() }
@@ -1067,9 +1096,14 @@ var PromiseProtoMixin =
 module.PromiseProtoMixin =
 object.Mixin('PromiseProtoMixin', 'soft', {
 	as: ProxyPromise,
-	iter: function(handler=undefined){
-		return IterablePromise(this, handler) },
-	sync: function(){
+	iter: function(handler=undefined, onerror=undefined){
+		return IterablePromise(this, handler, onerror) },
+	// unify the general promise API with other promise types...
+	// XXX should this be here???
+	// XXX error if given must return the result... (???)
+	sync: function(error){
+		typeof(error) == 'function'
+			&& this.catch(error)
 		return this },
 })
 

package/README.md

@@ -88,6 +88,9 @@ Library of JavaScript type extensions, types and utilities.
       - [Array proxy methods returning `<promise-iter>`](#array-proxy-methods-returning-promise-iter)
       - [Array proxy methods returning a `<promise>`](#array-proxy-methods-returning-a-promise)
       - [`<promise-iter>.then(..)` / `<promise-iter>.catch(..)` / `<promise-iter>.finally(..)`](#promise-iterthen--promise-itercatch--promise-iterfinally)
+      - [`<promise-iter>.iterthen(..)`](#promise-iterthen)
+      - [`<promise-iter>.isSync(..)`](#promise-issync)
+      - [`<promise-iter>.sync(..)`](#promise-sync)
       - [`promise.IterablePromise.STOP` / `promise.IterablePromise.STOP(..)`](#promiseiterablepromisestop--promiseiterablepromisestop)
       - [Advanced handler](#advanced-handler)
       - [Stopping the iteration](#stopping-the-iteration)
@@ -1823,6 +1826,7 @@ These are similar to [`<array>.some(..)`](https://developer.mozilla.org/en-US/do
 and [`<array>.find(..)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) 
 see them for more info.
 
+
 #### Array proxy methods returning `<promise-iter>`
 
 - `<promise-iter>.sort(..)`
@@ -1887,6 +1891,24 @@ For more info see: [Stopping the iteration](#stopping-the-iteration) below, and
 [the 'Array' STOP section](#arraystop--arraystop)
 
 
+#### `<promise-iter>.iterthen(..)`
+
+Like `.then(..)` but will return an `IterablePromise` instance.
+
+
+#### `<promise-iter>.isSync()`
+
+Return `true` if all content is resolved, otherwise return `false`.
+
+
+#### `<promise-iter>.sync(..)`
+
+If all content is resolved return the promise value, otherwise return a promise.
+
+For more info see: [`<promise>.sync(..)`](#promisesync)
+
+
+
 #### Advanced handler
 
 ```bnf
@@ -2008,12 +2030,17 @@ the main `<promise>` is resolved.
 
 ### Sync/async promise
 
+The goal of this is to handle both sync and asynchronous data flows with 
+one promise-like API, if all of the data can be obtained in a sync manner 
+this will be sync otherwise we will revert to a normal promise.
+
 
 #### `Promise.sync(..)` / `promise.SyncPromise(..)`
 
 ```dnf
 Promise.sync(<func>)
 	-> <sync-promise>
+	-> <promise>
 
 <func>(<resolve>, <reject>)
 

package/generator.js

@@ -308,21 +308,31 @@ var GeneratorProtoMixin =
 module.GeneratorProtoMixin =
 object.Mixin('GeneratorProtoMixin', 'soft', {
 	// XXX use module.iter(..) ???
-	iter: stoppable(function*(handler){ 
-		if(handler){
-			var i = 0
-			for(var elem of this){
-				var res = handler.call(this, elem, i) 
-				// expand iterables...
-				if(typeof(res) == 'object' 
-						&& Symbol.iterator in res){
-					yield* res
-				// as-is...
-				} else {
-					yield res }}
-		// no handler...
-		} else {
-			yield* this } }),
+	iter: stoppable(function*(handler, onerror){ 
+		try{
+			if(handler){
+				var i = 0
+				for(var elem of this){
+					var res = handler.call(this, elem, i) 
+					// expand iterables...
+					if(typeof(res) == 'object' 
+							&& Symbol.iterator in res){
+						yield* res
+					// as-is...
+					} else {
+						yield res }}
+			// no handler...
+			} else {
+				yield* this } 
+		}catch(err){
+			if(onerror){
+				if(!(err === STOP 
+						|| err instanceof STOP)){
+					var res = onerror(err)
+					if(res){
+						yield res
+						return } } }
+			throw err }}),
 	//*/
 
 	at: function(i){
@@ -556,18 +566,27 @@ object.Mixin('AsyncGeneratorProtoMixin', 'soft', {
 		return this.unwind.finally(...arguments) },
 
 	// XXX might be a good idea to use this approach above...
-	iter: stoppable(async function*(handler=undefined){
-		var i = 0
-		if(handler){
-			for await(var e of this){
-				var res = handler.call(this, e, i++)
-				if(typeof(res) == 'object' 
-						&& Symbol.iterator in res){
-					yield* res
-				} else {
-					yield res } }
-		} else {
-			yield* this } }),
+	iter: stoppable(async function*(handler=undefined, onerror=undefined){
+		try{
+			var i = 0
+			if(handler){
+				for await(var e of this){
+					var res = handler.call(this, e, i++)
+					if(typeof(res) == 'object' 
+							&& Symbol.iterator in res){
+						yield* res
+					} else {
+						yield res } }
+			} else {
+				yield* this } 
+		}catch(err){
+			if(onerror){
+				if(!(err === STOP || err instanceof STOP)){
+					var res = onerror(err) 
+					if(res){
+						yield res } 
+					return } }
+			throw err } }),
 
 	map: async function*(func){
 		yield* this.iter(function(elem, i){

package/package.json

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