mascot-vis 3.0.0 → 3.0.1

package/src-old/bind/bindToPosition.js

@@ -1,283 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,235 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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;
-}