ig-types 6.10.1 → 6.11.0

package/Promise.js

@@ -417,6 +417,58 @@ object.Constructor('CooperativePromise', Promise, {
 
 //---------------------------------------------------------------------
 
+var ProxyPromise =
+module.ProxyPromise =
+object.Constructor('ProxyPromise', Promise, {
+	__new__: function(context, constructor){
+		var proto = 'prototype' in constructor ?
+			constructor.prototype
+			: constructor
+		var obj = Reflect.construct(
+			ProxyPromise.__proto__, 
+			[function(resolve, reject){
+				context.then(resolve)
+				context.catch(reject) }], 
+			ProxyPromise) 
+		// populate...
+		// NOTE: we are not using object.deepKeys(..) here as we need 
+		// 		the key origin not to trigger property getters...
+		var seen = new Set()
+		while(proto != null){
+			Object.entries(Object.getOwnPropertyDescriptors(proto))
+				.forEach(function([key, value]){
+					// skip overloaded keys...
+					if(seen.has(key)){
+						return }
+					// skip non-functions...
+					if(typeof(value.value) != 'function'){
+						return }
+					// skip non-enumerable except for Object.prototype.run(..)...
+					if(!(key == 'run' 
+								&& Object.prototype.run === value.value) 
+							&& !value.enumerable){
+						return }
+					// proxy...
+					obj[key] = function(...args){
+						// XXX should we also .catch(..) here???
+						return context.then(function(res){
+							return res[key](...args) }) } })
+			proto = proto.__proto__ } 
+		return obj },
+})
+
+
+
+//---------------------------------------------------------------------
+
+// XXX EXPEREMENTAL...
+var PromiseProtoMixin =
+module.PromiseProtoMixin =
+object.Mixin('PromiseProtoMixin', 'soft', {
+	as: ProxyPromise,
+})
+
+
 var PromiseMixin =
 module.PromiseMixin =
 object.Mixin('PromiseMixin', 'soft', {
@@ -425,9 +477,11 @@ object.Mixin('PromiseMixin', 'soft', {
 	cooperative: CooperativePromise,
 })
 
-
 PromiseMixin(Promise)
 
+// XXX EXPEREMENTAL...
+PromiseProtoMixin(Promise.prototype)
+
 
 
 

package/README.md

@@ -74,6 +74,9 @@ Library of JavaScript type extensions, types and utilities.
       - [`<promise-iter>.flat(..)`](#promise-iterflat)
       - [`<promise-iter>.then(..)` / `<promise-iter>.catch(..)` / `<promise-iter>.finally(..)`](#promise-iterthen--promise-itercatch--promise-iterfinally)
       - [Advanced handler](#advanced-handler)
+    - [Promise proxies](#promise-proxies)
+      - [`<promise>.as(..)`](#promiseas)
+      - [`<promise-proxy>.<method>(..)`](#promise-proxymethod)
   - [Generator extensions and utilities](#generator-extensions-and-utilities)
     - [The basics](#the-basics)
       - [`generator.Generator`](#generatorgenerator)
@@ -1621,6 +1624,56 @@ var p = Promise.iter(
 ```
 
 
+### Promise proxies
+
+_Promise proxies_ generate a set of prototype methods returning promises that when the parent promise is resolved will resolve to a specific method call.
+
+Example:
+```javascript
+var o = {
+    method: function(...args){
+        console.log('method:', ...args)
+    },
+}
+
+var p = Peomise.cooperative().as(o)
+
+p.method(1, 2, 3) // returns a promise...
+
+// ...
+
+// resolving a promise will trigger all the proxy emthod execution, so 
+// here 'method: 1, 2, 3' will get printed...
+p.set(o)
+
+```
+
+#### `<promise>.as(..)`
+
+Create a promise proxy
+
+```bnf
+<promise>.as(<object>)
+<promise>.as(<constructor>)
+    -> <promise-proxy>
+```
+
+A proxy promise will be populated with proxy methods to all the methods of the `<object>` or `<constructor>.prototype`.
+
+#### `<promise-proxy>.<method>(..)`
+
+When `<promise>` resolves, call the `.<method>(..)` on the resolved value.
+
+```bnf
+<promise-proxy>.<method>(..)
+    -> <method-promise>
+```
+
+`<method-promise>` will resolve the the return value of the `<method>` when 
+the main `<promise>` is resolved.
+
+
+
 ## Generator extensions and utilities
 
 ```javascript

package/package.json

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