ig-types 6.24.18 → 6.24.21

package/Promise.js

@@ -35,10 +35,53 @@ var generator = require('./generator')
 
 
 //---------------------------------------------------------------------
-// XXX EXPERIMENTING...
 
 // packed format API...
 //
+// This is separate from IterablePromise to enable low-level testing and
+// experimentation.
+//
+// Packed format
+// 	[
+// 		<value>,
+//
+// 		[
+// 			<value>,
+//
+// 			<promise( <value> )>,
+//
+// 			.. 
+// 		],
+//
+// 		<promise( <value> )>,
+//
+// 		<promise( [ <value>, .. ] )>,
+//
+// 		..
+// 	]
+//
+// 	<packed> ::=
+// 		<value>
+// 		| <packed-array>
+// 		| <promise( <value> )>
+// 		| <promise( <packed-array> )>
+//
+// 	<packed-array> ::=
+// 		[ <packed-item>, .. ]
+//
+// 	<packed-item> ::=
+// 		<value>
+// 		| [ <nested-value>, .. ]
+// 		| <promise( <value> )>
+// 		| <promise( [ <value>, .. ] )>
+//
+// 	<nested-value> ::=
+// 		<value>
+// 		| <promise( <value> )>
+//		
+// 	
+//
+// XXX revise bnf...
 // XXX should this be a container or just a set of function???
 // 		...for simplicity I'll keep it a stateless set of functions for 
 // 		now, to avoid yet another layer of indirection -- IterablePromise...
@@ -50,19 +93,6 @@ module.packed =
 	//	pack(<promise>)
 	//		-> <packed>
 	//
-	//	<packed> ::=
-	//		<packed-array>
-	//		| <packed-promise>
-	//
-	//	<packed-array> ::=
-	//		[
-	//			<item>
-	//			| <items>				- array
-	//			| <promise-item>
-	//			| <promise-items>,
-	//			...
-	//		]
-	//
 	// NOTE: when all promises are expanded the packed array can be unpacked 
 	// 		by simply calling .flat()
 	// NOTE: if 'types/Array' is imported this will support throwing STOP
@@ -72,14 +102,14 @@ module.packed =
 	// 		of order, as the nested promises resolve and thus throwing 
 	// 		stop will stop the handlers not yet run and not the next 
 	// 		handlers in sequence.
-	//
-	// XXX see if we should self-expand promises...
-	// XXX migrate these back into InteractivePromise...
 	// XXX does this need onerror(..) ???
+	// 		...essentially this can make sense only in generator expansion,
+	// 		but not sure if this should be done here as it is sync...
 	pack: function(list){
 		var that = this
 		// list: promise...
 		// XXX should we just test for typeof(list.then) == 'function'???
+		// XXX should we expand async generators here???
 		if(list instanceof Promise
 				// list: async promise...
 				|| (typeof(list) == 'object' 
@@ -92,18 +122,28 @@ module.packed =
 				&& !list.map
 				&& Symbol.iterator in list){
 			list = [...list] }
+		/* XXX on one hand this should be here and on the other I'm not 
+		// 		sure how are we going to thread handler and onerror to 
+		// 		here...
+		// list: promise / async-iterator...
+		if(typeof(list) == 'object' 
+					&& Symbol.asyncIterator in list){
+			return list
+				// XXX
+				.iter(handler, onerror) 
+				.then(function(list){
+					return that.pack(list) }) } 
+		//*/
 		// list: non-array / non-iterable...
 		if(typeof(list.map) != 'function'){
 			list = [list].flat() }
 		// list: array...
-		// XXX should we self-expand this???
 		return list
 			.map(function(elem){
 				// XXX should we expand generators here???
 				return elem instanceof Array ?
 						[elem]
 					// XXX should we just test for .then(..)???
-					// XXX should we self-expand this???
 					: elem instanceof Promise ?
 						elem.then(function(elem){
 							return elem instanceof Array ?
@@ -114,9 +154,6 @@ module.packed =
 	// 	handle(<packed>, <handler>[, <onerror>])
 	// 		-> <packed>
 	//
-	// XXX revise nested promise handling...
-	// 		...something like simplify(<packed>) -> <packed> ???
-	// XXX STOP_PROMISED_HANDLERS -- TEST
 	handle: function(packed, handler, onerror){
 		var that = this
 		var handlers = [...arguments].slice(1)
@@ -230,6 +267,8 @@ module.packed =
 }
 
 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
 //
 // 	itemResolved(<list>, <onupdate>[, <ondone>])
 // 	itemResolved(<list>, <options>)

package/package.json

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

package/runner.js

@@ -12,6 +12,8 @@
 * 		- ...
 * 	would be nice to make the task just a slightly extended or better
 * 	defined function/generator, ideally to make them interchangable...
+* XXX BUG: there seems to be an odd bug somplace here where each item 
+* 	gets processed once per "thread"... (ImageGrid.Viewer export)
 *
 **********************************************/  /* c8 ignore next 2 */
 ((typeof define)[0]=='u'?function(f){module.exports=f(require)}:define)
@@ -360,6 +362,7 @@ object.Constructor('Queue', Array, {
 			// report...
 			that.trigger('taskCompleted', task, res) }
 		var fail = {doc: 'fail runningDone(..)'}
+		// XXX should this also remove .__running when empty???
 		var runningDone = function(mode){
 			running.splice(0, running.length, 
 				// NOTE: there can be multiple occurrences of res...
@@ -409,7 +412,7 @@ object.Constructor('Queue', Array, {
 		// collect results...
 		this.collect_results
 			&& res !== module.SKIP
-			&& (this.__results = this.__results || []).push(res)
+			&& (this.__results = this.__results ?? []).push(res)
 
 		// handle task results...
 		//
@@ -516,6 +519,9 @@ object.Constructor('Queue', Array, {
 	//
 	// NOTE: this helps get around the argument number limitation in JS...
 	add: function(tasks){
+		tasks = tasks instanceof Array ?
+			tasks
+			: [tasks]
 		// handle too large a number of args...
 		var MAX_ARGS = 10000
 		if(tasks.length > MAX_ARGS){
@@ -568,37 +574,51 @@ module.FinalizableQueue =
 object.Constructor('FinalizableQueue', Queue, {
 	auto_stop: true,
 
+	// not for direct use...
+	// NOTE: we are intentionally not freezing .__results to allow them 
+	// 		to be consumed by the client...
+	// 		XXX is this correct???
+	__freeze: function(){
+		Object.freeze(this)
+		return this },
+
 	__onempty__: function(){
 		return this.trigger('done') },
 
 	done: events.Event('done', function(handle){
 		// abort only once...
-		if(this.state == 'aborted' || this.state == 'done'){
+		if(this.state == 'aborted' 
+				|| this.state == 'done'){
 			return handle(false) }
 		this.__state = 'done' 
-		Object.freeze(this) }),
+		this.__freeze() }),
 	abort: events.Event('abort', function(handle){
 		// abort only once...
-		if(this.state == 'aborted' || this.state == 'done'){
+		if(this.state == 'aborted' 
+				|| this.state == 'done'){
 			return handle(false) }
 		this.__state = 'aborted' 
-		Object.freeze(this) }),
+		this.__freeze() }),
 
 	// NOTE: each handler will get called once when the next time the 
 	// 		queue is emptied...
 	promise: function(){
+		return this.__promise },
+	then: function(onresolve, onreject){
+		return this.promise().then(...arguments) },
+	catch: function(onreject){
+		return this.promise().catch(...arguments) },
+
+	__init__: function(options){
 		var that = this
-		return new Promise(function(resolve, reject){
+		this.__promise = new Promise(function(resolve, reject){
 			that
 				.one('done', function(){
 					resolve(...(that.collect_results ? 
-						[that.__results || []]
+						[that.__results ?? []]
 						: [])) })
-				.one('abort', reject) }) },
-	then: function(onresolve, onreject){
-		return this.promise().then(...arguments) },
-	catch: function(onreject){
-		return this.promise().catch(...arguments) },
+				.one('abort', reject) })
+		return object.parentCall(FinalizableQueue.prototype.__init__, this, ...arguments) },
 })
 
 

package/test.js

@@ -145,16 +145,44 @@ var cases = test.Cases({
 					[1, 2, 3]) },
 			promise_nested_array_mixed: function(assert){
 				return create(assert, 
-					Promise.resolve([1, Promise.resolve(2), [3], Promise.resolve([4])]),
+					Promise.resolve([
+						1, 
+						Promise.resolve(2), 
+						[3],
+						Promise.resolve([4]),
+					]),
 					[1, 2, [3], [4]]) },
 		})
 		this.Modifier({
 			nest: function(assert, setup){
 				setup.output = Promise.iter(setup.output)
 				return setup },
-			iter: function(assert, setup){
+			iter_noargs: function(assert, setup){
 				setup.output = setup.output.iter()
 				return setup },
+			iter_asis: function(assert, setup){
+				setup.output = setup.output
+					.iter(function(e){ 
+						return [e] })
+				return setup },
+			iter_clear: function(assert, setup){
+				return {
+					input: [],
+					output: setup.output
+						.iter(function(e){ 
+							return [] }),
+				} },
+			/* XXX does not account for promises as input...
+			iter_flat: async function(assert, setup){
+				return {
+					input: setup.input instanceof Array ?
+						(await Promise.all(setup.input)).flat()
+						: [await setup.input],
+					output: setup.output
+						.iter(function(e){ 
+							return e }),
+				} },
+			//*/
 
 			map_asis: function(assert, setup){
 				setup.output = setup.output