reworked .map(..)...

Signed-off-by: Alex A. Naanou <alex.nanou@gmail.com>

ui (gen4)/lib/widget/browse2.js

@@ -1147,79 +1147,75 @@ var BaseBrowserPrototype = {
 		path = path instanceof Array ? path : [path]
 		var options = args.pop() || {}
 
+		// options...
 		options = Object.assign(Object.create(this.options || {}), options || {})
 		var iterateNonIterable = options.iterateAll || options.iterateNonIterable
 		var iterateCollapsed = options.iterateAll || options.iterateCollapsed
 		var skipNested = !options.iterateAll && options.skipNested
-
-		// XXX this does not handle nesting in a correct manner
 		var reverse = !!options.reverseIteration
 		
-		var doElem = function(elem){
+		// NOTE: func is in closure as it will not change within one run 
+		// 		on any level of nesting...
+		var doElem = function(elem, path){
 			return [func ? 
 				func.call(that, elem, path.concat(elem.id), that) 
 				: elem] }
-
+		var doLevel = function(elem, nested, path){
-		var _render
+			return [ 
-		return this.items
+				doElem(elem, path),
-			// check if we need to go from the end...
+				(!iterateCollapsed && elem.collapsed) ?
+					[]
+					: nested ]
+				// reverse level order...
+				.run(function(){
+					reverse 
+						&& this.reverse() })
+				.flat() }
 		// NOTE: we need to reverse two things:
 		// 		- level order (done here)
 		// 		- linearization order (done below)
+		var walk = function(path, list){
+			return list 
+				// reverse the items...
 				.run(function(){
 					return reverse ?
+						// NOTE: we .slice() as we do not want to affect 
+						// 		the actual list...
 						this.slice().reverse() 
 						: this })
-			// XXX need path threaded into this -- not sure how to do it yet...
+				.map(function(elem){
-			.map(_render = function(elem){
 					return (
-					// item not iterable -- skip...
+						// item not iterable -> skip...
 						(!iterateNonIterable && elem.noniterable) ?
 							[]
-					// value is Browser (inline) -- list browser items...
+						// value is Browser (inline)...
 						: elem.value instanceof Browser ?
 							elem.value.map(func, 
 								options.inlinedPaths ?
 									path.concat(elem.id)
 									: path.slice(), 
 								options)	
-					// .sublist is Browser (nested) -- list header then browser items...
+						// .sublist is Browser (nested)...
 						: (!skipNested 
 								&& elem.sublist instanceof Browser) ?
-						[doElem(elem),
+							doLevel(
-							(!iterateCollapsed && elem.collapsed) ?
+								elem,
-								[]
+								elem.sublist
-								: elem.sublist.map(func, path.concat(elem.id), options)]
+									.map(func, path.concat(elem.id), options), 
-							// handle reverse...
+								path)
-							.run(function(){
+						// .sublist is Array (nested)...
-								reverse 
-									&& this.reverse() })
-							.flat()
-					// .sublist is Array (nested) -- list header then array content...
-					// XXX this skips nested browser .sublists...
 						: (!skipNested 
 								&& elem.sublist instanceof Array) ?
-						doElem(elem)
+							doLevel(
-							.concat((!iterateCollapsed && elem.collapsed) ?
+								elem,
-								[]
+								walk(path.concat(elem.id), elem.sublist),
-								/*/ XXX need to path.concat(..) in the context for this...
+								path)
-								: elem.sublist.map(_render)).flat()
+						// normal item...
-								/*/
+						: doElem(elem, path) ) })
-								: (func ? 
+				.flat() }
-									elem.sublist
+
-										.map(function(e){ 
+		return walk(path, this.items) 
-											return func.call(that, e, path.concat(elem.id, e.id), that) })
+	},
-									: elem.sublist.slice()))
-								//*/
-							// handle reverse...
-							// XXX if we support nested browsers in lists 
-							// 		this will mess things up...
-							.run(function(){
-								reverse 
-									&& this.reverse() })
-					// normal item -- list...
-					: doElem(elem) ) })
-			.flat() },
 
 	// Sublist map functions...
 	// NOTE: there are different from .map(..) in that instead of paths