ig-types 6.10.0 → 6.11.1

package/Array.js

@@ -492,6 +492,7 @@ object.Mixin('ArrayProtoMixin', 'soft', {
 	smap: stoppableList('map'),
 	sfilter: stoppableList('filter'),
 	sreduce: stoppableValue('reduce'),
+	sreduceRight: stoppableValue('reduceRight'),
 	sforEach: stoppableValue('map', true),
 
 	// Chunk iteration...

package/Promise.js

@@ -80,12 +80,13 @@ object.Constructor('IterablePromise', Promise, {
 	// NOTE: these are different to Array's equivalents in that the handler
 	// 		is called not in the order of the elements but rather in order 
 	// 		of promise resolution...
-	// NOTE: index of items is unknowable because items can expand on 
+	// NOTE: index of items is unknowable because items can expand and
 	// 		contract depending on handlrs (e.g. .filter(..) can remove 
 	// 		items)...
 	// 		This the following can not be implemented here:
 	// 			.slice(..)
 	// 			.splice(..)
+	// 			.values() / .keys()
 	// 			.at(..)
 	// 			[Symbol.iterator]()		- needs to be sync...
 	// 		The followng methods are questionable:
@@ -93,36 +94,61 @@ object.Constructor('IterablePromise', Promise, {
 	// 			.includes(..)
 	// 			.some(..) / .every(..)
 	// 			.sort(..)
+	// XXX BUG:
+	// 			Promise.iter([1,2,3])
+	// 				.map(e => e)
+	// 		is not the same as:
+	// 			Promise.iter([1,2,3])
+	// 				.map(e => e)
+	// 				.map(e => e)
 	// XXX should these support STOP???
 	map: function(func){
-		return this.constructor(this.__list, 
+		return this.constructor(this.__list.flat(), 
 			function(e){
 				return [func(e)] }) },
 	filter: function(func){
-		return this.constructor(this.__list, 
+		return this.constructor(this.__list.flat(), 
 			function(e){
 				return func(e) ? 
 					[e] 
 					: [] }) },
+	// NOTE: this does not return an iterable promise as we can't know 
+	// 		what the user reduces to...
 	reduce: function(func, res){
-		return this.constructor(this.__list, 
+		return this.constructor(this.__list.flat(), 
 				function(e){
 					res = func(res, e)
 					return [] })
 			.then(function(){ 
 				return res }) },
+	/*/ XXX this is wrong...
+	reduceRight: function(func, res){
+		return this.constructor(this.__list.flat().reverse(), 
+				function(e){
+					res = func(res, e)
+					return [] })
+			.then(function(){ 
+				return res }) },
+	// XXX this is wrong...
+	reverse: function(){
+		return this.constructor(this.__list.flat().reverse()) },
 	flat: function(depth=1){
-		return this.constructor(this.__list, 
+		return this.constructor(this.__list.flat(), 
 			function(e){ 
-				return (e && e.flat) ? 
-					e.flat(depth) 
-					: e }) },
-	// XXX do we need this???
-	//iter: function(){
-	//	return this },
-
-
-	// XXX do we need:
+				return (depth > 1 
+							&& e != null 
+							&& e.flat) ? 
+						e.flat(depth-1) 
+					: depth != 0 ?
+						e
+					: [e] }) },
+
+	// compatibility with root promise...
+	iter: function(){
+		return this.constructor(this.__list.flat()) },
+	//*/
+	
+	// XXX do we need these?
 	// 			.pop()
 	// 			.shift()
 	// 			.first() / .last()
@@ -204,9 +230,8 @@ object.Constructor('IterablePromise', Promise, {
 	// 		- another issue here is that the stop would happen in order of 
 	// 			execution and not order of elements...
 	__new__: function(_, list, handler){
-		var promise
-
 		// instance...
+		var promise
 		var obj = Reflect.construct(
 			IterablePromise.__proto__, 
 			[function(resolve, reject){
@@ -220,49 +245,29 @@ object.Constructor('IterablePromise', Promise, {
 			IterablePromise)
 
 		if(promise){
-			//var __stop = false
-			// apply handler(..) to the list...
-			//
-			// NOTE: the top level promises are not wrapped in arrays...
-			list =
-				// apply the handler...
-				handler ?
-					// XXX can we handle STOP here???
-					// 		...we will not be able to stop already started 
-					// 		promises...
-					list.map(function(block){
-						//* XXX STOP...
-						return (block instanceof Array ? 
-								block 
-								: [block])
-						/*/
-						// NOTE: we are not using Array's .iter() so as to
-						// 		keep the dependency minimal...
-						return generator.iter(
-								block instanceof Array ? 
-									block 
-									: [block])
-						//*/
-							.map(function(e){
-								// NOTE: we are counting actual expanded 
-								// 		values and not the "blocks"...
-								return (e && e.then && e.catch) ?
-									// promise...
-									e.then(function(v){ 
-										return handler(v) })
-									// basic value...
-									: handler(e) }) })
-						.flat()
-						// XXX STOP
-						//.toArray()
-				// normal constructor...
-				: handler === undefined ?
-					list.map(function(e){ 
-						return e instanceof Promise ?
-							e
-							: [e] })
-				// clone...
-				: list.slice()
+			// clone/normalize...
+			list = list
+				.map(function(e){
+					return (e && e.then) ?
+						e.then(function(e){ 
+							return [e] })
+						: [e] })
+
+			if(handler){
+				// NOTE: this is recursive to handle expanding nested promises...
+				var handle = function(elem){
+					// call the handler...
+					return (elem && elem.then) ?
+						elem.then(function(elems){
+							return elems
+								.map(handle)
+								.flat() })
+						: elem
+							.map(handler)
+							.flat() }
+
+				// handle the list...
+				list = list.map(handle) }
 
 			Object.defineProperty(obj, '__list', {
 				value: list,
@@ -415,6 +420,51 @@ object.Constructor('CooperativePromise', Promise, {
 
 
 
+//---------------------------------------------------------------------
+
+// XXX EXPEREMENTAL...
+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 },
+})
+
+
+
 //---------------------------------------------------------------------
 
 var PromiseMixin =
@@ -425,10 +475,19 @@ object.Mixin('PromiseMixin', 'soft', {
 	cooperative: CooperativePromise,
 })
 
-
 PromiseMixin(Promise)
 
 
+// XXX EXPEREMENTAL...
+var PromiseProtoMixin =
+module.PromiseProtoMixin =
+object.Mixin('PromiseProtoMixin', 'soft', {
+	as: ProxyPromise,
+})
+
+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/event.js

@@ -63,6 +63,11 @@ module.TRIGGER = module.EventCommand('TRIGGER')
 //		-> true
 //		-> false
 //
+//	trigger event handlers and overload handler arguments...
+//	handle(true, ...)
+//		-> true
+//		-> false
+//
 //	prevent event handlers from triggering...
 //	handle(false)
 //		-> undefined
@@ -151,11 +156,15 @@ object.Constructor('Eventful', {
 		// NOTE: to explicitly disable calling the handlers func must 
 		// 		call handle(false)
 		var did_handle = false
-		var handle = function(run=true){
+		var handle = function(run=true, ...alt_args){
 			did_handle = true
-			var a = args[0] instanceof EventCommand ?
-				args.slice(1)
+			var a = (run === true 
+					&& arguments.length > 1) ?
+				alt_args
 				: args
+			a = a[0] instanceof EventCommand ?
+				a.slice(1)
+				: a
 			return run ?
 				handlers
 					.reduce(function(res, handler){ 

package/generator.js

@@ -210,6 +210,7 @@ object.Mixin('GeneratorMixin', 'soft', {
 	map: makeGenerator('map'),
 	filter: makeGenerator('filter'),
 	reduce: makeGenerator('reduce'),
+	reduceRight: makeGenerator('reduceRight'),
 
 	// non-generators...
 	//

package/package.json

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