ig-types 6.24.2 → 6.24.4

package/Promise.js

@@ -795,6 +795,7 @@ object.Constructor('ProxyPromise', Promise, {
 
 //---------------------------------------------------------------------
 
+// XXX should this support async generators???
 var syncAllProxy = 
 function(name){
 	return function(lst){
@@ -809,6 +810,7 @@ function(name){
 			: Promise[name](lst) } }
 
 // XXX REVISE/TEST...
+// XXX should this support async generators???
 var syncAnyProxy =
 function(name){
 	return function(lst){
@@ -837,6 +839,8 @@ object.Constructor('SyncPromise', Promise, {
 		return new this(function(resolve){ resolve(value) }) },
 	reject: function(error){
 		return new this(function(_, reject){ reject(error) }) },
+	// NOTE: these essentially add a special case where the inputs are
+	// 		either not promises or SyncPromise instances...
 	all: syncAllProxy('all'),
 	allSettled: syncAllProxy('allSettled'),
 	any: syncAnyProxy('any'),
@@ -849,13 +853,16 @@ object.Constructor('SyncPromise', Promise, {
 	// 		mode and thus set .value and possibly .error, soe there is no 
 	// 		need to check for .value...
 	then: function(resolve, reject){
-		if(this.hasOwnProperty('error')){
-			return this.constructor.reject(
-				reject ?
-					reject(this.error)
-					: this.error) }
-		return this.constructor.resolve(
-			resolve(this.value)) },
+		return this.hasOwnProperty('error') ?
+				this.constructor.reject(
+					reject ?
+						reject(this.error)
+						: this.error)
+			: resolve ?
+				this.constructor.resolve(
+					resolve(this.value)) 
+			// XXX should we return a copy???
+			: this },
 
 	// NOTE: if func calls resolve(..) with a promise then this will return
 	// 		that promise...
@@ -895,10 +902,8 @@ object.Mixin('PromiseMixin', 'soft', {
 	iter: IterablePromise,
 	interactive: InteractivePromise,
 	cooperative: CooperativePromise,
-	// XXX EXPEREMENTAL...
 	sync: SyncPromise,
-	
-	// XXX need error support...
+	// XXX should this be implemented via SyncPromise??? 
 	awaitOrRun: function(data, func){
 		data = [...arguments]
 		func = data.pop()
@@ -943,11 +948,15 @@ object.Mixin('PromiseProtoMixin', 'soft', {
 	as: ProxyPromise,
 	iter: function(handler=undefined){
 		return IterablePromise(this, handler) },
-	// XXX revise...
-	sync: function(){
+	// 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' in this){
-				throw this.error }
+			if(error !== false 
+					&& 'error' in this){
+				if(typeof(error) != 'function'){
+					throw this.error }
+				return error(this.error) }
 			return this.value }
 		return this },
 })

package/README.md

@@ -2034,10 +2034,29 @@ Example:
 -->
 
 
-#### `<promise>.sync()`
+#### `<promise>.sync(..)`
 
 Synchronously return the resolved value if `<sync-promise>` resolved, and
-if it _rejected_ then re-throw the `<error>`.
+if it _rejected_ then re-throw the `<error>`. Normal promises will return self.
+
+```bnf
+<promise>.sync()
+	-> <value>
+	-> <promise>
+```
+
+To suppress errors pass `false` to `.sync(..)` and to handle them differently 
+pass an error handler function.
+```bnf
+<promise>.sync(false)
+	-> <value>
+
+<promise>.sync(<onerror>)
+	-> <value>
+
+<onerror>(<error>)
+	-> <value>
+```
 
 
 #### `<sync-promise>.value` / `<sync-promise>.error`
@@ -2048,8 +2067,8 @@ rejection `.error`.
 
 #### `Promise.sync.all(..)` / `Promise.sync.allSettled(..)` / `Promise.sync.any(..)` / `Promise.sync.race(..)`
 
-Equivalents to `Promise`'s version but will run sync if the relevant 
-items in the input are either non-promises or `<sync-promise>`s.
+Equivalents to `Promise`'s respective versions but will run sync if the 
+relevant items in the input are either non-promises or `<sync-promise>`s.
 
 
 

package/package.json

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