ig-types 6.24.4 → 6.24.7

package/Promise.js

@@ -30,7 +30,7 @@
 
 var object = require('ig-object')
 
-//var generator = require('./generator')
+var generator = require('./generator')
 
 
 
@@ -70,12 +70,15 @@ function(name){
 		return this.constructor(
 			this.then(function(lst){
 				return lst[name](...args) })) } }
+
+// XXX ASYNC should this be async or simply return a SyncPromise/Promise???
 var promiseProxy =
 module.promiseProxy =
 function(name){
 	return async function(...args){
 		return (await this)[name](...args) } }
 
+
 var IterablePromise =
 module.IterablePromise =
 object.Constructor('IterablePromise', Promise, {
@@ -120,18 +123,22 @@ 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???
+	// XXX ITER can we unwind (sync/async) generators one by one???
 	__pack: function(list, handler=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){
+			list = [...list] }
+		// handle iterable promise...
 		if(list instanceof IterablePromise){
 			return this.__handle(list.__packed, handler) }
-		// handle promise list...
-		if(list instanceof Promise){
+		// handle promise / async-iterator...
+		// XXX ITER do we unwind the iterator here or wait to unwind later???
+		if(list instanceof Promise
+				|| (typeof(list) == 'object' 
+					&& Symbol.asyncIterator in list)){
 			return list.then(function(list){
 				return that.__pack(list, handler) }) }
 		// do the work...
@@ -149,7 +156,23 @@ object.Constructor('IterablePromise', Promise, {
 		var pack = function(){
 			return [list].flat()
 				[map](function(elem){
+					// XXX EXPEREMENTAL -- not sure about this yet...
+					//elem = Symbol.iterator in elem ?
+					//	[...elem]
+					//	: elem
+					// XXX EXPEREMENTAL...
+					return elem instanceof IterablePromise ?
+							(elem.isSync() ?
+								handler(elem.sync())
+								// XXX need to handle this but keep it IterablePromise...
+								: elem.iterthen(handler))
+						: (elem instanceof SyncPromise
+								&& !(elem.sync() instanceof Promise)) ?
+							handler(elem.sync())
+						: elem && elem.then ?
+					/*/
 					return elem && elem.then ?
+					//*/
 							(stoppable ?
 								// stoppable -- need to handle stop async...
 								elem
@@ -238,6 +261,40 @@ object.Constructor('IterablePromise', Promise, {
 							return elem })
 				: [handler(elem)] })
    			.flat() },
+	// XXX EXPEREMENTAL...
+	// XXX this should return IterablePromise if .__packed is partially sync (???)
+	// unpack array (sync/async)...
+	__unpack: function(list){
+		list = list 
+			?? this.__packed
+		// handle promise list...
+		if(list instanceof IterablePromise){
+			return list.__unpack() }
+		if(list instanceof Promise){
+			return list
+				.then(this.__unpack.bind(this)) }
+		var res = []
+		for(var e of list){
+			if(e instanceof IterablePromise){
+				e = e.__unpack() }
+			if(e instanceof SyncPromise){
+				e = e.sync() }
+			// give up on a sync solution...
+			if(e instanceof Promise){
+				// XXX can we return an IterablePromise???
+				// 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() })
+					.iter() }
+				//return Promise.all(list)
+				//	.then(function(list){ 
+				//		return list.flat() }) }
+			res.push(e) }
+		return res.flat() },
+	/*/
 	// unpack array (async)...
 	__unpack: async function(list){
 		list = list 
@@ -248,11 +305,12 @@ object.Constructor('IterablePromise', Promise, {
 			// do the work...
 			: (await Promise.all(list))
 				.flat() },
-
+	//*/
+	
 	[Symbol.asyncIterator]: async function*(){
 		var list = this.__packed
 		if(list instanceof Promise){
-			yield this.__unpack(await list) 
+			yield* await this.__unpack(list) 
 			return }
 		for await(var elem of list){
 			yield* elem instanceof Array ?
@@ -387,6 +445,7 @@ object.Constructor('IterablePromise', Promise, {
 	// NOTE: methods that are guaranteed to return an array will return
 	// 		an iterable promise (created with iterPromiseProxy(..))...
 	//
+	// XXX ASYNC should this be async or simply return a SyncPromise/Promise???
 	at: async function(i){
 		var list = this.__packed
 		return ((i != 0 && i != -1)
@@ -453,6 +512,8 @@ object.Constructor('IterablePromise', Promise, {
 	// 			to resolve...
 	// 		- if no clients are available this can lead to wasted 
 	// 			CPU time...
+	//
+	// XXX ASYNC should this be async or simply return a SyncPromise/Promise???
 	find: async function(func, result='value'){
 		var that = this
 		// NOTE: not using pure await here as this is simpler to actually 
@@ -484,11 +545,13 @@ object.Constructor('IterablePromise', Promise, {
 	findIndex: promiseProxy('findIndex'),
 
 	// NOTE: this is just a special-case of .find(..)
+	// XXX ASYNC should this be async or simply return a SyncPromise/Promise???
 	some: async function(func){
 		return this.find(func, 'bool') },
 	every: promiseProxy('every'),
 
 
+	// XXX ASYNC should this be async or simply return a SyncPromise/Promise???
 	join: async function(){
 		return [...(await this)]
 			.join(...arguments) },
@@ -510,7 +573,10 @@ object.Constructor('IterablePromise', Promise, {
 	// NOTE: this is slightly different from .then(..) in that it can be 
 	// 		called without arguments and return a promise wrapper. This can
 	// 		be useful to hide special promise functionality...
-	then: function (onfulfilled, onrejected){
+	//
+	// NOTE: this is internally linked to the actual (via: ..then.call(this, ..)) 
+	// 		state and will be resolved in .__new__(..) below.
+	then: function(onfulfilled, onrejected){
 		var p = new Promise(
 			function(resolve, reject){
 				Promise.prototype.then.call(this,
@@ -525,6 +591,47 @@ object.Constructor('IterablePromise', Promise, {
 		return arguments.length > 0 ?
 			p.then(...arguments) 
 			: p },
+	// XXX EXPEREMENTAL revise...
+	// Like .then(..) but returns an IterablePromise instance...
+	iterthen: function(onfulfilled, onrejected){
+		if(this.isSync()){
+			var res = onfulfilled ?
+				this.constructor(onfulfilled(this.__unpack()))
+				: this.constructor(this.__unpack()) 
+			onrejected
+				&& res.catch(onrejected) 
+			return res }
+		// XXX we need to feed the output of onfulfilled to the value of 
+		// 		res, but to this without wrapping the whole thing in a 
+		// 		promise (possible???)...
+		return arguments.length > 0 ?
+			this.constructor(this.then(...arguments))
+			: this.constructor(this.__packed, 'raw') },
+
+	// XXX EXPEREMENTAL
+	isSync: function(){
+		return !(this.__packed instanceof Promise
+			|| this.__packed
+				.filter(function(e){
+					return e instanceof IterablePromise ?
+							!e.isSync()
+						: e instanceof Promise 
+								&& !(e instanceof SyncPromise) })
+				.length > 0) },
+	sync: function(error=false){
+		try{
+			var res = this.__unpack()
+		}catch(err){
+			if(error == false){
+				return }
+			if(typeof(error) == 'function'){
+				return error(err) }
+			throw err }
+		return error !== false 
+				&& res instanceof Promise ?
+			// XXX should this be an IterablePromise???
+			res.catch(error)
+			: res },
 
 
 	// constructor...
@@ -584,18 +691,37 @@ object.Constructor('IterablePromise', Promise, {
 			// handle/pack input data...
 			if(handler != 'raw'){
 				list = list instanceof IterablePromise ?
-					this.__handle(list.__packed, handler)
-					: this.__pack(list, handler) }
+					obj.__handle(list.__packed, handler)
+					: obj.__pack(list, handler) }
 			Object.defineProperty(obj, '__packed', {
 				value: list,
 				enumerable: false,
+				// NOTE: this is needed for self-resolve...
+				writable: true,
 			})
 			// handle promise state...
-			this.__unpack(list)
-				.then(function(list){
-					promise.resolve(list) })
-				.catch(promise.reject) }
-
+			try{
+				var res = obj.__unpack(list)
+			}catch(err){
+				promise.reject(err) }
+			res instanceof Promise ?
+				res
+					.then(function(list){
+						promise.resolve(list) })
+					.catch(promise.reject) 
+				: promise.resolve(res) 
+			// XXX EXPEREMENTAL
+			// XXX do we handle errors here???
+			// self-resolve state...
+			list instanceof Promise ?
+				list.then(function(list){
+					obj.__packed = list })
+				: list.forEach(function(elem, i){
+					elem instanceof Promise
+						&& elem.then(function(elem){
+							lst = obj.__packed.slice()
+							lst[i] = elem
+							obj.__packed = lst }) }) }
 		return obj },
 })
 
@@ -863,6 +989,13 @@ object.Constructor('SyncPromise', Promise, {
 					resolve(this.value)) 
 			// XXX should we return a copy???
 			: this },
+	sync: function(error='throw'){
+		if(error !== false 
+				&& 'error' in this){
+			if(typeof(error) != 'function'){
+				throw this.error }
+			return error(this.error) }
+		return this.value },
 
 	// NOTE: if func calls resolve(..) with a promise then this will return
 	// 		that promise...
@@ -883,10 +1016,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)
@@ -894,6 +1026,7 @@ object.Constructor('SyncPromise', Promise, {
 })
 
 
+
 //---------------------------------------------------------------------
 
 var PromiseMixin =
@@ -948,16 +1081,12 @@ object.Mixin('PromiseProtoMixin', 'soft', {
 	as: ProxyPromise,
 	iter: function(handler=undefined){
 		return IterablePromise(this, handler) },
-	// XXX should we try and return a sync value if normal promise is resolved???
-	// 		...sould need to hook .then(..) to do this...
-	sync: function(error='throw'){
-		if(this instanceof SyncPromise){
-			if(error !== false 
-					&& 'error' in this){
-				if(typeof(error) != 'function'){
-					throw this.error }
-				return error(this.error) }
-			return this.value }
+	// 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

@@ -77,7 +77,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<promise>.iter()`](#promiseiter)
       - [`<promise-iter>.iter()`](#promise-iteriter)
       - [`<promise-iter>.map(..)` / `<promise-iter>.filter(..)` / `<promise-iter>.reduce(..)`](#promise-itermap--promise-iterfilter--promise-iterreduce)
-    - [`<promise-iter>.between(..)`](#promise-iterbetween)
+      - [`<promise-iter>.between(..)`](#promise-iterbetween)
       - [`<promise-iter>.flat(..)`](#promise-iterflat)
       - [`<promise-iter>.reverse()`](#promise-iterreverse)
       - [`<promise-iter>.concat(..)`](#promise-iterconcat)
@@ -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)
@@ -95,7 +98,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<promise>.as(..)`](#promiseas)
       - [`<promise-proxy>.<method>(..)`](#promise-proxymethod)
     - [Sync/async promise](#syncasync-promise)
-      - [`Promise.sync(..)` / `promise.SyncPromice(..)`](#promisesync--promisesyncpromice)
+      - [`Promise.sync(..)` / `promise.SyncPromise(..)`](#promisesync--promisesyncpromise)
       - [`<promise>.sync(..)`](#promisesync)
       - [`<sync-promise>.value` / `<sync-promise>.error`](#sync-promisevalue--sync-promiseerror)
       - [`Promise.sync.all(..)` / `Promise.sync.allSettled(..)` / `Promise.sync.any(..)` / `Promise.sync.race(..)`](promisesyncall--promisesyncallsettled--promisesyncany--promisesyncrace`)
@@ -1706,7 +1709,7 @@ Note that since `.reduce(..)` handler's execution order can not be known,
 there is no point in implementing `.reduceRigth(..)`.
 
 
-### `<promise-iter>.between(..)`
+#### `<promise-iter>.between(..)`
 
 ```bnf
 <promise-iter>.between(<value>)
@@ -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.SyncPromice(..)`
+#### `Promise.sync(..)` / `promise.SyncPromise(..)`
 
 ```dnf
 Promise.sync(<func>)
 	-> <sync-promise>
+	-> <promise>
 
 <func>(<resolve>, <reject>)
 

package/package.json

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