ig-types 6.24.1 → 6.24.3

package/Promise.js

@@ -795,6 +795,34 @@ object.Constructor('ProxyPromise', Promise, {
 
 //---------------------------------------------------------------------
 
+var syncAllProxy = 
+function(name){
+	return function(lst){
+		var sync = true
+		for(var e of lst){
+			if(e instanceof Promise 
+					&& !(e instanceof SyncPromise)){
+				sync = false
+				break } }
+		return sync ?
+			this.resolve(lst)
+			: Promise[name](lst) } }
+
+// XXX REVISE/TEST...
+var syncAnyProxy =
+function(name){
+	return function(lst){
+		for(var e of lst){
+			if(e instanceof SyncPromise 
+					&& !('error' in e)){
+				return e }
+			if(!(e instanceof Promise)){
+				return this.resolve(e) } }
+		return Promise[name](list) } }
+
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
 // XXX EXPEREMENTAL...
 // XXX DOCS...
 // XXX like promise but if a value can be generated sync then this will 
@@ -803,6 +831,17 @@ object.Constructor('ProxyPromise', Promise, {
 var SyncPromise =
 module.SyncPromise =
 object.Constructor('SyncPromise', Promise, {
+	// NOTE: we need to overload these as the builtin versions sneak-in 
+	// 		async-ness before we can catch it in .__new__(..)
+	resolve: function(value){
+		return new this(function(resolve){ resolve(value) }) },
+	reject: function(error){
+		return new this(function(_, reject){ reject(error) }) },
+	all: syncAllProxy('all'),
+	allSettled: syncAllProxy('allSettled'),
+	any: syncAnyProxy('any'),
+	race: syncAnyProxy('race'),
+},{
 	//value: undefined,
 	//error: undefined,
 
@@ -810,25 +849,28 @@ 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...
 	__new__: function(context, func){
-		var result
+		var value
 		var resolve = function(res){
-			result = res }
+			return (value = res) }
 		var rejected
 		var error
 		var reject = function(err){
 			rejected = true
-			error = err }
+			return (error = err) }
 		// call...
 		try{
 			func(resolve, reject)
@@ -836,12 +878,12 @@ object.Constructor('SyncPromise', Promise, {
 			reject(err) }
 		// async...
 		if(!error 
-				&& result instanceof Promise){
-			return result }
+				&& value instanceof Promise){
+			return value }
 		// sync...
-		var obj = Promise.resolve(result)
+		var obj = Promise.resolve(value)
 		obj.__proto__ = this.prototype
-		obj.value = result
+		obj.value = value
 		rejected
 			&& (obj.error = error)
 		return obj },
@@ -856,10 +898,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()
@@ -904,11 +944,12 @@ object.Mixin('PromiseProtoMixin', 'soft', {
 	as: ProxyPromise,
 	iter: function(handler=undefined){
 		return IterablePromise(this, handler) },
-	// XXX revise...
-	sync: function(){
+	sync: function(error='throw'){
 		if(this instanceof SyncPromise){
 			if('error' in this){
-				throw this.error }
+				if(typeof(error) != 'function'){
+					throw this.error }
+				return error(this.error) }
 			return this.value }
 		return this },
 })

package/README.md

@@ -98,6 +98,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`Promise.sync(..)` / `promise.SyncPromice(..)`](#promisesync--promisesyncpromice)
       - [`<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`)
     - [Promise utilities](#promise-utilities)
       - [`Promise.awaitOrRun(..)`](#promiseawaitorrun)
   - [Generator extensions and utilities](#generator-extensions-and-utilities)
@@ -2045,6 +2046,12 @@ if it _rejected_ then re-throw the `<error>`.
 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.
+
+
 
 ### Promise utilities
 

package/package.json

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