mascot-vis 2.0.0 → 3.0.0

package/src-old/bind/bindToPosition.js

@@ -0,0 +1,283 @@
+import {getParents, getClosestLayout, getCellBoundsInLayout, sameClass, getPeers, getCellIndexInLayout} from "../util/ItemUtil";
+import {DataType, ItemType, LayoutType} from "../util/Constants";
+import Scale from "../core/Scale";
+
+export function bindToPosition(encoding){
+
+	encoding._query = function() {
+		this.data = [];
+		
+		let field = this.field, items = this.items;
+		let dataScopes = ((this.anyItem.type == "vertex" || this.anyItem.type == "segment") && !this.anyItem.dataScope) ? 
+							items.map(d => d.parent.dataScope) : items.map(d => d.dataScope);
+
+		switch (this.datatable.getFieldType(field)) {
+			case DataType.Boolean:
+				break;
+
+			case DataType.Date:
+				this.data = dataScopes.map(d => d.getFieldValue(field));
+				break;
+
+			case DataType.String:
+				try {
+					this.data = dataScopes.map(d => d.getFieldValue(field));
+				} catch (error) {
+					throw new Error("Cannot bind " + this.channel + " to " + field + " : " + error);
+				}
+				break;
+
+			default: //integer or number
+				this.data = dataScopes.map(d => d.aggregateNumericalField(field, this.aggregator));
+				break;
+		}
+	}
+
+	encoding._map = function() {
+		let channel = this.channel, fieldType = this.datatable.getFieldType(this.field);
+
+		//to be used for determining the range of scale 
+		//TODO: need to update cellBounds dynamically for _map() and _apply()
+		let extent;
+		let layout = getClosestLayout(this.anyItem);
+		if (layout && layout.type == LayoutType.Grid) {
+			let cellBounds = layout.cellBounds;
+			extent = channel == "x" ? cellBounds[0].width : cellBounds[0].height;
+		} else if (this.anyItem.type === "vertex" && this.anyItem.parent.type === ItemType.Area) {
+			extent = channel == "x" ? this.anyItem.parent.bounds.width : this.anyItem.parent.bounds.height;
+		} else {
+			let pos = this.items.map(d => d[channel]);
+			extent = Math.max(...pos) - Math.min(...pos);
+			if (extent < 100) extent = 100;
+			else if (extent > 500) extent = 500;
+		}
+
+		let min, max, domain, range;
+		switch (fieldType) {
+			case DataType.Boolean:
+				break;
+
+			case DataType.Date:
+				min = Math.min(...this.data); 
+				max = Math.max(...this.data);
+				domain = [min, max];
+				if (this.scale) {
+					// let domainValues = domain.concat(this.scale.domain);
+					let domainValues = this.data;
+					for (let enc of this.scale.encodings) {
+						domainValues = domainValues.concat(enc.data);
+					}
+					domain = [Math.min(...domainValues), Math.max(...domainValues)];
+					//extent = Math.abs(this.scale.map(domain[0]) - this.scale.map(domain[1]));
+					range = this.scale.range;
+				} else {
+					this.scale = new Scale("time");
+					this.scale.isFlipped = this._flipScale;
+					range = [0, extent];
+					this.scale._baseItem = this.anyItem;
+				}
+				break;
+
+			case DataType.String:
+				domain = Array.from(new Set(this.data));
+				range = [0, extent];
+				if (this.scale) {
+					let od = this.scale.domain;
+					//the following lines preserve the order of values in existing domain
+					for (let d of domain) {
+						if (od.indexOf(d) < 0)
+							od.push(d);
+					}
+					domain = od;
+					//domain = Array.from(new Set(domain.concat(this.scale.domain)));
+					range = this.scale.range;
+				} else {
+					this.scale = new Scale("point");
+					this.scale.isFlipped = this._flipScale;
+					range = [0, extent];
+					this.scale._baseItem = this.anyItem;
+				}
+				break;
+
+			default: //integer or number
+				min = Math.min(...this.data); 
+				max = Math.max(...this.data);
+				domain = [min, max];
+				
+				if (this.scale) {
+					//where zero is included depends on the existing scale
+					let domainValues = this.data;
+					for (let enc of this.scale.encodings) {
+						domainValues = domainValues.concat(enc.data);
+					}
+					// let domainValues = domain.concat(this.scale._scale.domain());
+					domain = [Math.min(...domainValues), Math.max(...domainValues)]; 
+
+					range = this.scale.range;
+				} else {
+					this.scale = new Scale(this.scaleType);
+					this.scale.isFlipped = this._flipScale;
+					this.scale.includeZero = this._includeZero;
+					range = [0, extent];
+					//remember the item that was used to first create this scale,
+					//so that when the scale is reused later, we can refer to the base item
+					//to get absoluate positions
+					this.scale._baseItem = this.anyItem;
+				}
+				if (domain[0] == domain[1])
+					domain[1] = domain[0] * 1.1;
+				break;
+		}
+
+		this.scale._scale.domain(domain);
+		this.scale._setRange(range);
+
+		//TODO: need to adjust according to scale type
+		this.scale._addEncoding(this);
+	}
+
+	encoding._apply = function() {
+		let items = [], channel = this.channel;
+		//if the scale is shared across multiple encodings, need to find the offset based on all items using this scale
+		//use case: box plot, where lines, rect segments and line vertices share the same scale
+		for (let enc of this.scale.encodings)
+			items = items.concat(enc.items);
+		if (channel == "x") {
+			//let layout = getClosestLayout(this.anyItem, "grid");
+			//let layout = getTopLevelCollection(this.anyItem) ? getTopLevelCollection(this.anyItem).layout : getClosestLayout(this.anyItem);
+			let layout = getClosestLayout(this.anyItem, "grid"), baseLayout = this.scale._baseItem ? getClosestLayout(this.scale._baseItem, "grid"): undefined;
+			if (this.scale._baseItem && !sameClass(this.anyItem, this.scale._baseItem) && layout && baseLayout && layout.numRows === baseLayout.numRows && layout.numCols === baseLayout.numCols) {
+				let tx = baseLayout.group.bounds.left - layout.group.bounds.left,
+					ty = 0;
+				layout.group.getScene().translate(layout.group, tx, ty);
+				layout._colGap = baseLayout.colGap;
+				let cellIndices = this.items.map(d => getCellIndexInLayout(d)),
+					baseCellBounds = baseLayout.cellBounds;
+				for (let i = 0; i < this.items.length; i++) {
+					let itm = this.items[i];
+					let dx = baseCellBounds[cellIndices[i]].left + this.scale.map(this.data[i]) - itm[channel],
+						dy = 0;
+					itm._doTranslate(dx, dy);
+					if (itm.type == "vertex" || itm.type == "segment")
+						itm.parent._updateBounds();
+				}
+				this.anyItem.parent.getScene()._updateAncestorBounds(this.anyItem, this.items);
+			} else if (layout && layout.type == LayoutType.Grid){
+				//do not use scale.offset, use cell bounds
+				for (let i = 0; i < this.items.length; i++) {
+					let itm = this.items[i], itmCb = getCellBoundsInLayout(itm);
+					let dx = itmCb.left + this.scale.map(this.data[i]) - itm[channel],
+						dy = 0;
+					itm._doTranslate(dx, dy);
+					if (itm.type == "vertex" || itm.type == "segment")
+						itm.parent._updateBounds();
+				}
+			} else if (this.anyItem.type === "vertex" && this.anyItem.parent.type === ItemType.Area) {
+				//this is to make sure that the encoding of vertex position is within the bounds of an area mark
+				let marks = getParents(this.items);
+				if (this.scale.offset === undefined)
+					this.scale.offset = Math.min(...marks.map(d => d.bounds.left));
+				for (let i = 0; i < this.items.length; i++) {
+					let peer = this.items[i], parent = peer.parent;
+					let dx = parent.bounds.left + this.scale.map(this.data[i]) - peer[channel],
+						dy = 0;
+					peer._doTranslate(dx, dy);
+					peer.parent._updateBounds();
+				}
+			}  else if (this.anyItem.type == "vertex" || this.anyItem.type == "segment") {
+				//TODO: right now using the leftmost mark peer as the baseline, which will not work for cases like bullet chart
+				//need to check if marks are part of a glyph, and use the leftmose glyph peer.
+				let marks = getParents(this.items);
+				if (this.scale.offset === undefined)
+					this.scale.offset = Math.min(...marks.map(d => d.bounds.left));
+				for (let i = 0; i < this.items.length; i++) {
+					let peer = this.items[i];
+					let dx = this.scale.offset + this.scale.map(this.data[i]) - peer[channel],
+						dy = 0;
+					peer._doTranslate(dx, dy);
+					peer.parent._updateBounds();
+				}
+			} else {
+				if (this.scale.offset === undefined)
+					this.scale.offset = Math.min(...items.map(d => d[channel]));
+				if (this.items[0].type === ItemType.PointText)
+					this.items.forEach(d => d.horzAnchor = "center");
+				for (let i = 0; i < this.items.length; i++) {
+					let peer = this.items[i];
+					let dx = this.scale.offset + this.scale.map(this.data[i]) - peer[channel],
+						dy = 0;
+					peer._doTranslate(dx, dy);
+				}
+			}
+			
+		} else {//channel y
+			//let layout = getTopLevelCollection(this.anyItem) ? getTopLevelCollection(this.anyItem).layout : getClosestLayout(this.anyItem);
+			let layout = getClosestLayout(this.anyItem, "grid"), baseLayout = this.scale._baseItem ? getClosestLayout(this.scale._baseItem, "grid"): undefined;
+			if (this.scale._baseItem && !sameClass(this.anyItem, this.scale._baseItem) && layout && baseLayout && layout.numRows === baseLayout.numRows && layout.numCols === baseLayout.numCols) {
+			//if (this.scale._baseItem && !sameClass(this.anyItem, this.scale._baseItem) && baseLayout && baseLayout.numRows === 1) {
+				//let peers = getPeers(this.scale._baseItem, this.scale._baseItem.parent.getScene());
+				let tx = 0,
+					ty = baseLayout.group.bounds.top - layout.group.bounds.top;
+				layout.group.getScene().translate(layout.group, tx, ty);
+				layout._rowGap = baseLayout.rowGap;
+				let cellIndices = this.items.map(d => getCellIndexInLayout(d)),
+					baseCellBounds = baseLayout.cellBounds;
+				for (let i = 0; i < this.items.length; i++) {
+					let itm = this.items[i];
+					let dx = 0,
+						dy = baseCellBounds[cellIndices[i]].bottom - this.scale.map(this.data[i]) - itm[channel];
+					itm._doTranslate(dx, dy);
+					if (itm.type == "vertex" || itm.type == "segment")
+						itm.parent._updateBounds();
+				}
+				this.anyItem.parent.getScene()._updateAncestorBounds(this.anyItem, this.items);
+			} else if (layout && layout.type == LayoutType.Grid){
+				let cellBounds = this.items.map(d => getCellBoundsInLayout(d));
+				for (let i = 0; i < this.items.length; i++) {
+					let itm = this.items[i];
+					let dx = 0,
+						dy = cellBounds[i].bottom - this.scale.map(this.data[i]) - itm[channel];
+					itm._doTranslate(dx, dy);
+					if (itm.type == "vertex" || itm.type == "segment")
+						itm.parent._updateBounds();
+				}
+			} else if (this.anyItem.type === "vertex" && this.anyItem.parent.type === ItemType.Area) {
+				if (this.scale.offset === undefined)
+					this.scale.offset = Math.min(...this.items.map(d => d.y));
+				for (let i = 0; i < this.items.length; i++) {
+					let peer = this.items[i], parent = peer.parent;
+					let dx = 0,
+						dy = parent.bounds.top + this.scale.rangeExtent - this.scale.map(this.data[i]) - peer[channel];
+					peer._doTranslate(dx, dy);
+					peer.parent._updateBounds();
+				}
+			}  else if (this.anyItem.type == "vertex" || this.anyItem.type == "segment") {
+				if (this.scale.offset === undefined)
+					this.scale.offset = Math.min(...this.items.map(d => d.y));
+				for (let i = 0; i < this.items.length; i++) {
+					let peer = this.items[i];
+					let dx = 0,
+						dy = this.scale.offset + this.scale.rangeExtent - this.scale.map(this.data[i]) - peer[channel];
+					peer._doTranslate(dx, dy);
+					peer.parent._updateBounds();
+				}
+			} else {
+				if (this.scale.offset === undefined)
+					this.scale.offset = Math.min(...items.map(d => d.bounds.y));
+				if (this.items[0].type === ItemType.PointText)
+					this.items.forEach(d => d.vertAnchor = "middle");
+				for (let i = 0; i < this.items.length; i++) {
+					let peer = this.items[i];
+					let dx = 0,
+						dy = this.scale.offset + this.scale.rangeExtent - this.scale.map(this.data[i]) - peer.refBounds[channel];
+					peer._doTranslate(dx, dy);
+				}
+			}
+		}
+	}
+
+	encoding.run();
+	if (encoding.rangeExtent)
+		encoding.scale.rangeExtent = encoding.rangeExtent;
+	return encoding;
+}

package/src-old/bind/bindToRadialDistance.js

@@ -0,0 +1,62 @@
+import Scale from "../core/Scale";
+import {DataType} from "../util/Constants";
+import {polar2Cartesian} from "../util/ItemUtil";
+
+export function bindToRadialDistance(encoding){
+
+    encoding._query = function() {
+        this.data = [];
+		
+		let field = this.field, items = this.items;
+		let dataScopes = ((this.anyItem.type == "vertex" || this.anyItem.type == "segment") && !this.anyItem.dataScope) ? 
+							items.map(d => d.parent.dataScope) : items.map(d => d.dataScope);
+
+		switch (this.datatable.getFieldType(field)) {
+			case DataType.Boolean:
+				break;
+
+			case DataType.Date:
+				this.data = dataScopes.map(d => d.getFieldValue(field));
+				break;
+
+			case DataType.String:
+				try {
+					this.data = dataScopes.map(d => d.getFieldValue(field));
+				} catch (error) {
+					throw new Error("Cannot bind " + this.channel + " to " + field + " : " + error);
+				}
+				break;
+
+			default: //integer or number
+				this.data = dataScopes.map(d => d.aggregateNumericalField(field, this.aggregator));
+				break;
+		}
+    }
+
+
+    encoding._map = function() {
+		let data = this.data;
+		if (!this.scale){
+			this.scale = new Scale("linear");
+			this.scale.domain = [0, Math.max(...data)];
+			this.scale._setRange([0, this.anyItem.parent.radius]);
+			
+		}
+		this.scale._addEncoding(this);
+	}
+
+    encoding._apply = function() {
+		for (let i = 0; i < this.items.length; i++) {
+			let peer = this.items[i], rd = this.scale.map(this.data[i]);
+            let coords = polar2Cartesian(this.anyItem.parent.x, this.anyItem.parent.y, rd, peer.polarAngle);
+            peer.x = coords[0];
+            peer.y = coords[1];
+		}
+
+		//relayout if needed
+		this.scene._relayoutAncestors(this.anyItem, this.items);
+	}
+
+    encoding.run();
+	return encoding;
+}

package/src-old/bind/bindToSize.js

@@ -0,0 +1,235 @@
+import Scale from "../core/Scale";
+import {DataType, ItemType, LayoutType} from "../util/Constants";
+import { uniqueNumbers } from "../util/DataUtil";
+
+export function bindToSize(encoding){
+
+	encoding._query = function() {
+		this.data = [];		
+		let field = this.field, items = this.items, aggregator = this.aggregator;
+		switch (this.datatable.getFieldType(field)) {
+			case DataType.Boolean:
+				break;
+
+			case DataType.Date:
+				this.data = items.map(d => d.dataScope.getFieldValue(field));
+				break;
+
+			case DataType.String:
+				break;
+
+			default: //integer or number
+				this.data = items.map(d => d.dataScope.aggregateNumericalField(field, aggregator));	
+				break;
+		}
+	}
+
+	encoding._map = function() {
+		let items = this.items, data = this.data, channel = this.channel, scale;
+		
+		scale = new Scale(this.scaleType);
+
+		if (this.data.find(d => d < 0) != undefined && (channel == "width" || channel == "height") && items[0].type.indexOf("rect") == 0) {
+			this._rectNegativeValues = true;
+			scale.domain = [Math.min(...data), Math.max(...data)];
+			if (channel == "width") {
+				// let left = Math.min(...(items.map(d => d.bounds.left))),
+				// 	right = Math.max(...(items.map(d => d.bounds.right)));
+				// scale._setRange([0, right - left]);
+
+				//TODO: check if item width has already been encoded with a different field
+				//the code below assumes width hasn't been bound to data
+				scale._setRange([0, this.rangeExtent ? this.rangeExtent : Math.max(...(items.map(d => d.width)))]);
+			} else {
+				// let top = Math.min(...(items.map(d => d.bounds.top))),
+				// 	bottom = Math.max(...(items.map(d => d.bounds.bottom)));
+				// scale._setRange([0, bottom - top]);
+
+				//TODO: check if item height has already been encoded with a different field
+				//the code below assumes height hasn't been bound to data
+				scale._setRange([0, this.rangeExtent ? this.rangeExtent : Math.max(...(items.map(d => d.height)))]);
+			}
+		} else {
+			scale.domain = [0, Math.max(...data)];
+			let min, max;
+			if (channel == "radius" || channel == "outerRadius" || channel == "innerRadius") {
+				min = 0;
+				max = Math.max(...(items.map(d => d[channel])));
+				if (max < 20)	max = 20;
+			} else if (channel == "area") {
+				min = 0;
+				max = Math.max(...(items.map(d => d.bounds.width * d.bounds.height)));
+				if (max < 400)	max = 400;
+			} else if (channel == "fontSize") {
+				min = 2;
+				max = Math.max(...(items.map(d => parseFloat(d.styles.fontSize))));
+			} else if (channel == "strokeWidth") {
+				min = 1;
+				max = Math.max(...(items.map(d => parseFloat(d.styles.strokeWidth))));
+				if (max == min)
+					max = min + 5;
+			}  else {
+				min = 0;
+				max = Math.max(...(items.map(d => d.bounds[channel])));
+			}
+			if (this.rangeExtent)
+				max = min + this.rangeExtent;
+			if (this.range) {
+				min = this.range[0];
+				max = this.range[1];
+			}
+			scale._setRange([min, max]);
+		}
+
+		if (this.scale){
+			// TODO	
+		} else {
+			this.scale = scale;
+		}
+
+		this.scale._addEncoding(this);
+	}
+
+	encoding._apply = function() {
+		if (this.channel == "radius" || this.channel == "outerRadius" || this.channel == "innerRadius") {
+			for (let i = 0; i < this.items.length; i++) {
+				let peer = this.items[i];
+				peer[this.channel] = this.scale.map(this.data[i]);
+			}
+			this.scene._relayoutAncestors(this.anyItem, this.items);
+		} else if (this._rectNegativeValues){
+			let dMax = Math.max(...this.data), dMin = Math.min(...this.data),
+				base = this.channel === "width" ? Math.min(...this.items.map(d => d.bounds.left)) : 
+							Math.min(...this.items.map(d => d.bounds.top)) + this.scale.rangeExtent,
+				maxSide = this.channel === "width" ? "right" : "top",
+				minSide = this.channel === "width" ? "left" : "bottom";
+			for (let i = 0; i < this.items.length; i++) {
+				let offset, peer = this.items[i];
+				if (peer.parent && peer.parent.type === ItemType.Collection) {
+					let pp = peer.parent.parent;
+					if (pp.type === ItemType.Collection && pp.layout && pp.layout.type === LayoutType.Grid) {
+						let idx = pp.children.indexOf(peer.parent);
+						offset = pp.layout.cellBounds[idx][minSide];
+					} else {
+						offset = peer.parent.refBounds[minSide];
+					}
+				} else {
+					offset = base;
+				}
+				if (this.channel === "width") {
+					peer.leftSegment._doTranslate(offset + this.scale.map(0) - peer.leftSegment.vertex1.x, 0);
+					peer.rightSegment._doTranslate(offset + this.scale.map(this.data[i]) -  peer.rightSegment.vertex1.x, 0);
+				} else {
+					peer.topSegment._doTranslate(0, offset - this.scale.map(this.data[i]) - peer.topSegment.vertex1.y);
+					peer.bottomSegment._doTranslate(0, offset - this.scale.map(0) - peer.bottomSegment.vertex1.y);
+				}
+
+				peer._updateBounds();
+				if (this.data[i] > 0) {
+					peer.boundsOffsets[maxSide] = this.scale.map(dMax) - this.scale.map(this.data[i]);
+					peer.boundsOffsets[minSide] = this.scale.map(0) - this.scale.map(dMin);
+				} else {
+					peer.boundsOffsets[minSide] = this.scale.map(this.data[i]) - this.scale.map(dMin);
+					peer.boundsOffsets[maxSide] = this.scale.map(dMax) - this.scale.map(0);
+				}
+			}
+
+
+			// if (this.channel == "width") {
+			// 	let base = Math.min(...this.items.map(d => d.bounds.left));
+			// 	for (let i = 0; i < this.items.length; i++) {
+			// 		let offset, peer = this.items[i], left = peer.leftSegment.vertex1.x, right = peer.rightSegment.vertex1.x;
+			// 		if (peer.parent && peer.parent.type == ItemType.Collection) {
+			// 			offset = peer.parent.bounds.left;
+			// 		} else {
+			// 			offset = base;
+			// 		}
+			// 		peer.rightSegment._doTranslate(offset + this.scale.map(this.data[i]) - right, 0);
+			// 		peer.leftSegment._doTranslate(offset + this.scale.map(0) - left, 0);
+			// 		peer._updateBounds();
+			// 		if (this.data[i] > 0) {
+			// 			peer.boundsOffsets.right = this.scale.map(dMax) - this.scale.map(this.data[i]);
+			// 			peer.boundsOffsets.left = this.scale.map(0) - this.scale.map(dMin);
+			// 		} else {
+			// 			peer.boundsOffsets.left = this.scale.map(this.data[i]) - this.scale.map(dMin);
+			// 			peer.boundsOffsets.right = this.scale.map(dMax) - this.scale.map(0);
+			// 		}
+			// 	}
+			// } else if (this.channel == "height") {
+			// 	for (let i = 0; i < this.items.length; i++) {
+			// 		let offset, peer = this.items[i], top = peer.topSegment.vertex1.y, btm = peer.bottomSegment.vertex1.y;
+			// 		if (peer.parent && peer.parent.type === ItemType.Collection) {
+			// 			let pp = peer.parent.parent;
+			// 			if (pp.type === ItemType.Collection && pp.layout && pp.layout.type === LayoutType.Grid) {
+			// 				let idx = pp.children.indexOf(peer.parent);
+			// 				offset = pp.layout.cellBounds[idx].bottom;
+			// 			} else {
+			// 				offset = peer.parent.refBounds.bottom;
+			// 			}
+			// 		} else {
+			// 			let base = Math.min(...this.items.map(d => d.bounds.top)) + this.scale.rangeExtent;
+			// 			offset = base;
+			// 		}
+			// 		peer.topSegment._doTranslate(0, offset - this.scale.map(this.data[i]) - top);
+			// 		peer.bottomSegment._doTranslate(0, offset - this.scale.map(0) - btm);
+			// 		peer._updateBounds();
+			// 		if (this.data[i] > 0) {
+			// 			peer.boundsOffsets.top = this.scale.map(dMax) - this.scale.map(this.data[i]);
+			// 			peer.boundsOffsets.bottom = this.scale.map(0) - this.scale.map(dMin);
+			// 		} else {
+			// 			peer.boundsOffsets.bottom = this.scale.map(this.data[i]) - this.scale.map(dMin);
+			// 			peer.boundsOffsets.top = this.scale.map(dMax) - this.scale.map(0);
+			// 		}
+			// 	}
+			// }
+		} else if (this.channel == "area") {
+			for (let i = 0; i < this.items.length; i++) {
+				let peer = this.items[i], s = Math.sqrt(this.scale.map(this.data[i]));
+				peer.resize(s, s);
+			}
+			this.scene._relayoutAncestors(this.anyItem, this.items);
+		} else if (this.channel == "fontSize") {
+			for (let i = 0; i < this.items.length; i++) {
+				let peer = this.items[i], s = this.scale.map(this.data[i]);
+				peer.styles.fontSize = s+ "px";
+			}
+			this.scene._relayoutAncestors(this.anyItem, this.items);
+		} else if (this.channel == "strokeWidth") {
+			for (let i = 0; i < this.items.length; i++) {
+				let peer = this.items[i], s = this.scale.map(this.data[i]);
+				peer.styles.strokeWidth = s;
+			}
+			this.scene._relayoutAncestors(this.anyItem, this.items);
+		} else {
+			let xRef = 'left', yRef = 'bottom';
+			//if glyph item, check alignment
+			if (this.anyItem.parent && this.anyItem.parent.type == ItemType.Glyph) {
+				let children = this.anyItem.parent.children;
+				if (uniqueNumbers(children.map(d=>d.bounds.right)).length == 1)
+					xRef = 'right';
+				if (uniqueNumbers(children.map(d=>d.bounds.top)).length == 1)
+					yRef = 'top';
+			}
+			
+			if (this.anyItem.type === ItemType.Collection && this.anyItem.layout && this.anyItem.layout[this.channel]) {
+				//for cases like treemap barchart, where the collection size is bound to data before dividing
+				for (let i = 0; i < this.items.length; i++) {
+					let peer = this.items[i], s = this.scale.map(this.data[i]);
+					peer.layout[this.channel] = s;
+				}
+			} else {
+				for (let i = 0; i < this.items.length; i++) {
+					let peer = this.items[i], s = this.scale.map(this.data[i]);
+					let wd = this.channel == "width" ? s : peer.bounds.width,
+						ht = this.channel == "height" ? s : peer.bounds.height;
+					peer.resize(wd, ht, xRef, yRef);
+				}
+			}
+			
+			this.scene._relayoutAncestors(this.anyItem, this.items);
+		}
+	}
+
+	encoding.run();
+	return encoding;
+}

package/src-old/bind/bindToText.js

@@ -0,0 +1,60 @@
+import {DataType} from "../util/Constants";
+import DataScope from "../data/DataScope";
+import { nodeId } from "../util/Constants";
+import Scale from "../core/Scale";
+
+export function bindToText(encoding){
+
+	encoding._query = function() {
+		this.data = [];
+		
+		let field, items = this.items, dt;
+		if (this.field.startsWith("parent.") || this.field.startsWith("child.")) {
+			dt = this.datatable.tree.nodeTable;
+			field = this.field.split(".")[1];
+			let s = this.field.split(".")[0];
+			let nodeIds = items.map(d => d.dataScope).map(d => d.getFieldValue(s));
+			if (dt.getFieldType(field) == DataType.Integer || dt.getFieldType(field) == DataType.Number)
+				this.data = nodeIds.map(d => (new DataScope(dt)).cross(nodeId, d).aggregateNumericalField(field));
+			else
+				this.data = nodeIds.map(d => (new DataScope(dt)).cross(nodeId, d).getFieldValue(field));
+		} else {
+			dt = this.datatable;
+			field = this.field;
+			if (dt.getFieldType(field) == DataType.Integer || dt.getFieldType(field) == DataType.Number)
+				this.data = items.map(d => d.dataScope.aggregateNumericalField(field, this.aggregator));
+			else
+				this.data = items.map(d => d.dataScope.getFieldValue(field));
+		}
+	}
+
+	encoding._map = function() {
+		if (this.scale) {
+		} else {
+			switch (this.datatable.getFieldType(this.field)) {
+				case DataType.Boolean:
+					break;
+
+				case DataType.Date:
+					break;
+
+				case DataType.String:
+				default: //integer or number
+					this.scale = new Scale("ordinal");
+					this.scale.domain = [...new Set(this.data)];
+                    this.scale._scale.range(this.scale.domain.map(d => d + ""));
+					break;
+			}
+		}
+	}
+
+	encoding._apply = function() {
+		for (let i = 0; i < this.items.length; i++) {
+			let peer = this.items[i], value = this.scale.map(this.data[i]);
+			peer.text = value;
+		}
+	}
+
+	encoding.run();
+	return encoding;
+}