ig-types 6.21.0 → 6.22.1

package/Promise.js

@@ -793,6 +793,65 @@ object.Constructor('ProxyPromise', Promise, {
 
 
 
+//---------------------------------------------------------------------
+
+// XXX like promise but if a value can be generated sync then this will 
+// 		run in sync otherwise it will fall back to being a promise...
+// 		...not sure where to return the sync value...
+// XXX potential problem is recursion (depth) on the sync stage...
+// XXX not sure if we need this..
+var MaybePromice =
+module.MaybePromice =
+object.Constructor('MaybePromise', Promise, {
+	// XXX can we get into this without either .__error or .__result ???
+	then: function(resolve, reject){
+		if(this.hasOwnProperty('__error')){
+			return this.constructor.reject(
+				reject ?
+					reject(this.__error)
+					: this.__error) }
+		if(this.hasOwnProperty('__result')){
+			return this.constructor.resolve(
+				resolve(this.__result)) } },
+	//catch: function(func){
+	//},
+	//finally: function(func){
+	//},
+
+	//__error: undefined,
+	//__result: undefined,
+	__new__: function(context, func){
+		var result
+		var resolve = function(res){
+			result = res }
+		var error
+		var reject = function(err){
+			error = err }
+
+		try{
+			func(resolve, reject)
+		}catch(err){
+			reject(err) }
+
+		if(error){
+			this.__error = error
+
+		// async...
+		} else if(result instanceof Promise){
+			return result }
+
+		// sync...
+		this.__result = result
+		// XXX
+		var obj = Reflect.construct(
+			MaybePromise.__proto__,
+			[],
+			MaybePromise)
+		return obj
+	},
+})
+
+
 //---------------------------------------------------------------------
 
 var PromiseMixin =
@@ -801,6 +860,43 @@ object.Mixin('PromiseMixin', 'soft', {
 	iter: IterablePromise,
 	interactive: InteractivePromise,
 	cooperative: CooperativePromise,
+	// XXX
+	//maybe: MaybePromise,
+	
+	// XXX need error support...
+	awaitOrRun: function(data, func){
+		data = [...arguments]
+		func = data.pop()
+		var error
+		if(typeof(data.at(-1)) == 'function'){
+			error = func
+			func = data.pop() }
+		// ceck if we need to await...
+		return data
+				.reduce(function(res, e){
+					return res 
+						|| e instanceof Promise }, false) ?
+			// NOTE: we will not reach this on empty data...
+			(data.length > 1 ?
+				Promise.all(data)
+					.then(
+						function(res){ 
+							return func(...res) }, 
+						...(error ? 
+							[error] 
+							: []))
+				: data[0].then(
+					func, 
+					...(error ? 
+						[error] 
+						: [])))
+			: error ?
+				function(){
+					try{
+						func(...data)
+					}catch(err){
+						error(err) } }()
+			: func(...data) },
 })
 
 PromiseMixin(Promise)

package/README.md

@@ -94,6 +94,8 @@ Library of JavaScript type extensions, types and utilities.
     - [Promise proxies](#promise-proxies)
       - [`<promise>.as(..)`](#promiseas)
       - [`<promise-proxy>.<method>(..)`](#promise-proxymethod)
+    - [Promise utilities](#promise-utilities)
+      - [`Promise.awaitOrRun(..)`](#promiseawaitorrun)
   - [Generator extensions and utilities](#generator-extensions-and-utilities)
     - [The basics](#the-basics)
       - [`generator.Generator`](#generatorgenerator)
@@ -636,11 +638,17 @@ Compare to arrays ignoring element order and count.
 Sort array as a different array.
 ```bnf
 <array>.sortAs(<other>)
+<array>.sortAs(<other>, 'head')
+    -> <array>
+
+<array>.sortAs(<other>, 'tail')
     -> <array>
 ```
 
 Elements not present in `<other>` retain their relative order and are
-placed after the sorted elements.
+placed after the sorted elements if `'head'` (i.e. _"sorted at head of 
+array"_) is passed as second argument (default) and before them if 
+`'tail'` (_"sorted at tail"_) is passed.
 
 Example:
 ```javascript
@@ -1993,6 +2001,25 @@ the main `<promise>` is resolved.
 
 
 
+### Promise utilities
+
+#### `Promise.awaitOrRun(..)`
+
+Await for inputs if any of them is a promise and then run a function with 
+the results, otherwise run the function in sync.
+
+```dnf
+Promise.awaitOrRun(<value>, <func>[, <onerror>])
+Promise.awaitOrRun(<value>, .. , <func>[, <onerror>])
+	-> <promise(value)>
+	-> <value>
+```
+
+Note that if the last `<value>` is a function and no `<onerror>` function
+is given then `.awaitOrRun(..)` will confuse the `<value>` for `<func>`,
+to avoid this one needs to explicitly pass `null`/`undefined` as `<onerror>`.
+
+
 ## Generator extensions and utilities
 
 ```javascript

package/package.json

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