mascot-vis 1.11.1 → 1.12.0

package/dist/mascot.js

@@ -1,5 +1,5 @@
 /* eslint-disable */
-// version: 1.11.1
+// version: 1.12.0
 (function (global, factory) {
 	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3'), require('pixi.js')) :
 	typeof define === 'function' && define.amd ? define(['exports', 'd3', 'pixi.js'], factory) :
@@ -1382,7 +1382,15 @@
 				vy = this.vertices.map(d => d.y);
 
 			let left = Math.min(...vx), top = Math.min(...vy), right = Math.max(...vx), btm = Math.max(...vy);
+			
 			this._bounds = new Rectangle(left, top, right - left, btm - top);
+			if (this.type === ItemType.Line || this.type === ItemType.Path) {
+				let sw = this.styles["strokeWidth"] ? this.styles["strokeWidth"] : 1;
+				if (left === right)
+					this._bounds = new Rectangle(left - sw/2, top, right - left + sw, btm - top);
+				else if (top === btm)
+					this._bounds = new Rectangle(left, top - sw/2, right - left, btm - top + sw);
+			}
 		}
 
 		addVertex(x, y, i) {
@@ -1744,6 +1752,18 @@
 		return undefined;
 	}
 
+	function getCellIndexInLayout(item) {
+		let itm = item, parent = item.parent;
+		while (parent && parent.type != ItemType.Scene) {
+			if (parent.layout){
+				return parent.children.findIndex(d => d == itm);
+			}
+			itm = itm.parent;
+			parent = itm.parent;
+		}
+		return undefined;
+	}
+
 	function getCellBoundsInGridLayout(item) {
 		let itm = item, parent = item.parent;
 		while (parent && parent.type != ItemType.Scene) {
@@ -1789,6 +1809,10 @@
 		}
 	}
 
+	function sameClass(item1, item2) {
+		return getEncodingKey(item1).split("_")[0] === getEncodingKey(item2).split("_")[0];
+	}
+
 	function getParents(items) {
 		let result = [];
 		for (let p of items) {
@@ -2181,9 +2205,12 @@
 			while(item) {
 				if (item.classId && classIds.indexOf(item.classId) < 0)
 					classIds.push(item.classId);
-				if (item.children)
+				if (item.type === ItemType.Glyph) {
+					item.children.forEach(d => classIds.push(d.classId));
+					break;
+				} else if (item.children) {
 					item = item.children[0];
-				else
+				} else
 					break;
 			}
 			let result = [];
@@ -2467,6 +2494,10 @@
 		_updateTuples(field, value) {
 			this._tuples = this._tuples.filter(d => d[field] == value);
 		}
+
+		get tuples() {
+			return this._tuples;
+		}
 	}
 
 	function repeatItem(scene, compnt, field, datatable, callback) {
@@ -2753,13 +2784,22 @@
 		run() {
 			if (this.group == undefined || !this.group.children || this.group.children.length === 0)
 				return;
-			if (this.group.children[0].type == "area") {
-				this._stackAreas();
-			} else if (this.group.children[0].type == ItemType.Arc || this.group.children[0].type == ItemType.Pie) {
-				this._stackArcs();	
-			} else {
-				this._stackRects();	
-			} 
+			let leafMark = getLeafMarks(this.group)[0];
+			switch (leafMark.type) {
+				case ItemType.Area:
+					this._stackAreas();
+					break;
+				case ItemType.Arc:
+				case ItemType.Pie:
+					if (leafMark.parent === this.group)
+						this._stackArcs();
+					break;
+				case ItemType.Rect:
+				case ItemType.Image:
+				case ItemType.Circle:
+					this._stackRects();
+					break;
+			}
 		}
 
 		set vertCellAlignment(v) {
@@ -2815,6 +2855,8 @@
 		switch (compnt.type) {
 			case ItemType.Line:
 				return _doLineDivide(scene, compnt, f, datatable);
+			case ItemType.Path:
+				return _doPathDivide(scene, compnt, f, datatable);
 			case ItemType.Circle:
 				return _doCircleDivide(scene, compnt, orientation, f, datatable);
 			case ItemType.Rect:
@@ -2889,6 +2931,57 @@
 		return toReturn;
 	}
 
+	function _doPathDivide(scene, compnt, field, datatable) {
+		let peers = getPeers(compnt, scene);
+		let toReturn;
+		let ds = datatable.getFieldSummary(field).unique.map(d => new DataScope(datatable).cross(field, d));
+
+		let line2Scopes = {}, max = 0;
+		for (let p of peers) {
+			let scopes = ds;
+			if (p.dataScope) {
+				scopes = ds.map(d => d.merge(p.dataScope));
+				scopes = scopes.filter(d => !d.isEmpty());
+			}
+			if (scopes.length > max)
+				max = scopes.length;
+			line2Scopes[p.id] = scopes;
+		}
+		let collClassId;
+		for (let p of peers) {
+			let coll = scene.collection();
+			if (collClassId == undefined)
+				collClassId = coll.id;
+			coll.classId = collClassId;
+			coll.dataScope = p.dataScope;
+
+			let parent = p.parent;
+			//let index = parent.children.indexOf(p) - 1;
+			parent.addChild(coll);
+
+			let scopes = line2Scopes[p.id];
+			let x1 = p.bounds.left, y1 = p.bounds.top, x2 = p.bounds.right, y2 = p.bounds.bottom;
+
+			for (let i = 0; i < scopes.length; i++) {
+				let c = scene.mark("line", {x1: x1 + (x2 - x1) * i /max, x2: x1 + (x2 - x1) * (i + 1)/max, y1: y1 + (y2 - y1) * i /max, y2: y1 + (y2 - y1) * (i + 1)/max});
+				c.classId = compnt.id;
+				c.dataScope = scopes[i];
+				coll.addChild(c);
+			}
+
+			parent.removeChild(p);
+
+			if (p == compnt)
+				toReturn = coll;
+		}
+
+		let f = compnt.firstVertex.dataScope.fields[0];	
+		scene.densify(toReturn.firstChild, datatable, {field: f});
+		
+
+		return toReturn;
+	}
+
 
 
 	function _doRectDivide(scene, compnt, o, field, datatable) {
@@ -3277,6 +3370,9 @@
 			let lineDS = p.dataScope ? p.dataScope : new DataScope(datatable);
 			let ds = datatable.getFieldSummary(field).unique.map(d => lineDS.cross(field, d));
 			ds = ds.filter(d => !d.isEmpty());
+			if (ds.length === 1) {
+				ds.push(ds[0].clone());
+			}
 
 			let args = Object.assign({}, p.styles);
 			for (let vs of Vertex.styles){
@@ -3326,6 +3422,9 @@
 			let areaDS = p.dataScope ? p.dataScope : new DataScope(datatable);
 			let ds = datatable.getFieldSummary(field).unique.map(d => areaDS.cross(field, d));
 			ds = ft == DataType.Number? ds : ds.filter(d => !d.isEmpty());
+			if (ds.length === 1) {
+				ds.push(ds[0].clone());
+			}
 			
 			if (ft == DataType.Number || ft == DataType.Date) {
 				// sorting ds
@@ -3895,7 +3994,11 @@
 					max = Math.max(...this.data);
 					domain = [min, max];
 					if (this.scale) {
-						let domainValues = domain.concat(this.scale.domain);
+						// 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;
@@ -3933,17 +4036,23 @@
 					
 					if (this.scale) {
 						//where zero is included depends on the existing scale
-						let domainValues = domain.concat(this.scale._scale.domain());
-						domain = [Math.min(...domainValues), Math.max(...domainValues)]; //Scale.mergeDomain(domain, this.scale.domain);
-						//extent = Math.abs(this.scale.map(domain[0]) - this.scale.map(domain[1]));
+						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 = createScale(this.scaleType);
 						this.scale.isFlipped = this._flipScale;
 						this.scale.includeZero = this._includeZero;
-						//domain = this._includeZero ? [0, max] : [min, max];
 						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;
@@ -3964,9 +4073,26 @@
 			for (let enc of this.scale.encodings)
 				items = items.concat(enc.items);
 			if (channel == "x") {
-				let layout = getClosestLayout(this.anyItem, "grid");
+				//let layout = getClosestLayout(this.anyItem, "grid");
 				//let layout = getTopLevelCollection(this.anyItem) ? getTopLevelCollection(this.anyItem).layout : getClosestLayout(this.anyItem);
-				if (layout && layout.type == LayoutType.Grid){
+				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);
@@ -4015,9 +4141,27 @@
 				}
 				
 			} else {//channel y
-				let layout = getClosestLayout(this.anyItem, "grid");
 				//let layout = getTopLevelCollection(this.anyItem) ? getTopLevelCollection(this.anyItem).layout : getClosestLayout(this.anyItem);
-				if (layout && layout.type == LayoutType.Grid){
+				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];
@@ -4739,7 +4883,7 @@
 
 		set aggregator(a) {
 			this._aggregator = a;
-			this.scale = undefined;
+			//this.scale = undefined;
 			this.run();
 		}
 
@@ -6408,7 +6552,7 @@
 	            }
 	        } 
 	        
-	        if (this._item.type == ItemType.Area)
+	        if (this._item.type === ItemType.Area || this._item.parent.type === ItemType.Area)
 	            c = getCellBoundsInGridLayout(this._item);
 
 	        if (c === undefined) {
@@ -6571,6 +6715,7 @@
 	        this._orientation = "orientation" in args ? args["orientation"] : 
 	                                this._channel === "x" || this._channel == "width" ? "bottom" : "left";
 	        this._posArg = this._channel == "x" || this._channel == "width"? args["pathY"] : args["pathX"]; 
+	        this._padding = [ItemType.Line, ItemType.Path].indexOf(items[0].type) >= 0 ? 10 : 0;
 
 	        this._item = items[0];
 	        this._items = items;
@@ -6722,22 +6867,24 @@
 	            let num = this._channel == "x" ? this._mlayout.numRows : this._mlayout.numCols;
 	            if (this._channel == "x") {
 	                let left = cb[0].left, numCols = this._mlayout.numCols;
+	                let padding = this._orientation === "bottom" ? this._padding : - this._padding;
 	                for (let r = 0; r < num; r++){
 	                    this._rules.children[r]._setVertices([
-	                        [left, this._posArg ? cb[r * numCols][this._orientation] + this._posArg - cb[0][this._orientation] : cb[r * numCols][this._orientation] ],
-	                        [left + cb[0].width * numCols + this._mlayout.colGap * (numCols - 1), this._posArg ? cb[r * numCols][this._orientation] + this._posArg - cb[0][this._orientation] : cb[r * numCols][this._orientation]]
+	                        [left, this._posArg ? cb[r * numCols][this._orientation] + this._posArg - cb[0][this._orientation] : cb[r * numCols][this._orientation] + padding],
+	                        [left + cb[0].width * numCols + this._mlayout.colGap * (numCols - 1), this._posArg ? cb[r * numCols][this._orientation] + this._posArg - cb[0][this._orientation] : cb[r * numCols][this._orientation] + padding]
 	                    ]);
 	                }
 	            } else {
 	                let top = cb[0].top, numRows = this._mlayout.numRows;
+	                let padding = this._orientation === "left" ? this._padding : - this._padding;
 	                for (let c = 0; c < num; c++){
 	                    // this._rules.children[c]._setVertices([
 	                    //     [this._posArg ? cb[c * numRows][this._orientation] + this._posArg - cb[0][this._orientation] : cb[c * numRows][this._orientation], top ],
 	                    //     [this._posArg ? cb[c * numRows][this._orientation] + this._posArg - cb[0][this._orientation] : cb[c * numRows][this._orientation], top + cb[0].height * numRows + this._mlayout.rowGap * (numRows - 1), ]
 	                    // ]);
 	                    this._rules.children[c]._setVertices([
-	                        [this._posArg ? cb[c * numRows][this._orientation] + this._posArg - cb[0][this._orientation] : this._mlayout.group.bounds[this._orientation], top ],
-	                        [this._posArg ? cb[c * numRows][this._orientation] + this._posArg - cb[0][this._orientation] : this._mlayout.group.bounds[this._orientation], top + cb[0].height * numRows + this._mlayout.rowGap * (numRows - 1)]
+	                        [this._posArg ? cb[c * numRows][this._orientation] + this._posArg - cb[0][this._orientation] : this._mlayout.group.bounds[this._orientation] - padding, top ],
+	                        [this._posArg ? cb[c * numRows][this._orientation] + this._posArg - cb[0][this._orientation] : this._mlayout.group.bounds[this._orientation] - padding, top + cb[0].height * numRows + this._mlayout.rowGap * (numRows - 1)]
 	                    ]);
 	                }
 	            }
@@ -6764,9 +6911,10 @@
 	        let cb = this._mlayout.cellBounds;
 	        if (this._channel == "x") {
 	            let dir = this._orientation == "bottom" ? 1 : -1;
+	            let padding = this._orientation === "bottom" ? this._padding : - this._padding;
 	            for (let [i, t] of this._ticks.children.entries()) {
 	                let pos = this._posArg ? cb[i][this._orientation] + this._posArg - cb[0][this._orientation] + this._tickOffset * dir : 
-	                            cb[i][this._orientation] + this._tickOffset * dir;
+	                            cb[i][this._orientation] + this._tickOffset * dir + padding;
 	                t._setVertices([
 	                    [cb[i].x, pos],
 	                    [cb[i].x, pos + dir * this._tickSize]
@@ -6775,11 +6923,12 @@
 	            }
 	        } else if (this._channel == "y"){
 	            let dir = this._orientation == "left" ? -1 : 1;
+	            let padding = this._orientation === "left" ? this._padding : - this._padding;
 	            for (let [i, t] of this._ticks.children.entries()) {
 	                // let xPos = this._posArg ? cb[i][this._orientation] + this._posArg - cb[0][this._orientation] + this._tickOffset * dir : 
 	                //                 cb[i][this._orientation] + this._tickOffset * dir,
 	                let xPos = this._posArg ? cb[i][this._orientation] + this._posArg - cb[0][this._orientation] + this._tickOffset * dir : 
-	                                    this._mlayout.group.bounds[this._orientation] + this._tickOffset * dir,
+	                                    this._mlayout.group.bounds[this._orientation] + this._tickOffset * dir - padding,
 	                    yPos = this._tickAnchor == "middle" ? cb[i].y : cb[i][this._tickAnchor];
 	                t._setVertices([
 	                    [xPos, yPos],
@@ -6797,10 +6946,11 @@
 	        if (this._channel == "x") {
 	            let anchor = this._orientation == "bottom" ? ["center", "top"] : ["center", "bottom"],
 	                offset = this._orientation == "bottom" ? this._labelOffset : -this._labelOffset;
+	            let padding = this._orientation === "bottom" ? this._padding : - this._padding;
 	            for (let [i, l] of this._labels.children.entries()) {
 	                l.x = cb[i].x;
 	                l.y = this._posArg ? cb[i][this._orientation] + this._posArg - cb[0][this._orientation] + offset : 
-	                                cb[i][this._orientation] + offset;
+	                                cb[i][this._orientation] + offset + padding;
 	                l.anchor = anchor;
 	                if (this._labelRotation){
 	                    l._rotate = [this._labelRotation, l.x, l.y];
@@ -6811,11 +6961,12 @@
 	        } else if (this._channel == "y"){
 	            let anchor = this._orientation == "left" ? ["right", "middle"] : ["left", "middle"],
 	                offset = this._orientation == "left" ? - this._labelOffset : this._labelOffset;
+	            let padding = this._orientation === "left" ? this._padding : - this._padding;
 	            for (let [i, l] of this._labels.children.entries()) {
 	                // l.x = this._posArg ? cb[i][this._orientation] + this._posArg - cb[0][this._orientation] + offset 
 	                //             : cb[i][this._orientation] + offset;
 	                l.x = this._posArg ? cb[i][this._orientation] + this._posArg - cb[0][this._orientation] + offset 
-	                            : this._mlayout.group.bounds[this._orientation] + offset;
+	                            : this._mlayout.group.bounds[this._orientation] + offset - padding;
 	                l.y = this._tickAnchor == "middle" ? cb[i].y : cb[i][this._tickAnchor];
 	                l.anchor = anchor;
 	                if (this._labelRotation) {
@@ -6855,7 +7006,8 @@
 	    }
 
 	    matches(item) {
-	        return getEncodingKey(this._item).split("_")[0] === getEncodingKey(item).split("_")[0];
+	        return sameClass(this._item, item);
+	        //return getEncodingKey(this._item).split("_")[0] === getEncodingKey(item).split("_")[0];
 	    }
 	}
 
@@ -6982,17 +7134,18 @@
 	                    for (let i = 0; i < uniqueVals.length; i+= Math.ceil(uniqueVals.length/10))
 	                        stops.push(uniqueVals[i]);
 	                } else {
-	                    let interval = (domain[1] - domain[0])/9;
+	                    let incr = (domain[1] - domain[0])/9;
 	                    for (let i = 0; i < 10; i++)
-	                        stops.push(domain[0] + i * interval);
-	                    let decimalPlaces = 0;
-	                    while (interval < 1) {
-	                        interval *= 10;
-	                        decimalPlaces++;
-	                    }
-	                    stops = stops.map(d => d.toFixed(decimalPlaces));
+	                        stops.push(domain[0] + i * incr);
 	                }
 	            }
+	            //determine decimal places
+	            let decimalPlaces = 0, interval = (stops[stops.length - 1] - stops[0])/stops.length;
+	            while (interval < 1) {
+	                interval *= 10;
+	                decimalPlaces++;
+	            }
+	            stops = stops.map(d => d.toFixed(decimalPlaces));
 	            if (this._orientation == Orientation.Vertical) {
 	                gradient = new LinearGradient({x1: 0, y1: 100, x2: 0, y2: 0});
 	                stops.forEach(d => {
@@ -8343,7 +8496,7 @@
 			}
 
 	        for (let enc of scale.encodings) {
-				enc.scene._updateAncestorBounds(enc.item, enc.items);
+				enc.scene._relayoutAncestors(enc.item, enc.items);
 			}
 			//reapply constraints
 			let items = scale.encodings.map( d => d.anyItem), classId2item = {};
@@ -9106,7 +9259,7 @@
 	    }
 
 	    if (layout)
-	            scene.setProperties(c.firstChild, {layout: layout});
+	        scene.setProperties(c.firstChild, {layout: layout});
 	    //return results;
 	}
 
@@ -9450,7 +9603,7 @@
 			if (!("datatable" in args))
 				args.datatable = item.dataScope ? item.dataScope.dataTable : item.parent.dataScope.dataTable;
 			if (!("aggregator" in args))
-				args.aggregator = "sum";
+				args.aggregator = "mean";
 			if (!("flipScale" in args))
 				args.flipScale = false;
 			if (!("includeZero" in args))
@@ -9595,7 +9748,7 @@
 		axis(channel, field, params) {
 			//need to figure out if item has the corresponding encoding, or if item position is determined by layout
 			let args = params ? params : {}, enc = args.item ? this.getEncodingByItem(args.item, channel) : this.getEncodingByField(field, channel);
-			if (enc) {
+			if (enc && enc.field === field) {
 				if (enc.datatable.getFieldType(field) === DataType.Date && !("labelFormat" in args)) {
 					args.labelFormat = "%m/%d/%y";
 				}
@@ -9627,8 +9780,8 @@
 			let item = args.item? args.item : findItems(this, [{"field": field}])[0];
 			if (item === undefined) {
 				console.warn(Warnings.INCORRECT_AXIS_INFO + field);
+				return;
 			}
-
 			let layout = getClosestLayout(item);
 			if (!layout || (layout.type !== LayoutType.Grid && layout.type !== LayoutType.Stack)) return;
 
@@ -9674,7 +9827,7 @@
 				let p = c._item, found = false;
 				while (p.children && p.children.length > 0) {
 					for (let ic of p.children) {
-						if (ic.classId === item.classId) {
+						if (ic.classId === getEncodingKey(item).split("_")[0]) {
 							found = true;
 							axes.push(c);
 							break;
@@ -10797,6 +10950,8 @@
 			
 			if (this._mapping)
 				json.mapping = this._mapping;
+			if (this._baseItem)
+				json.baseItem = this._baseItem.id;
 			return json;
 		}
 
@@ -11808,7 +11963,7 @@
 	        return scn;
 	    }
 
-	    _loadScale(s) {
+	    _loadScale(s, scn) {
 	        let scale;
 	        // if (s.type === "sequentialColor" && s.scheme) {
 	        if (s.type.indexOf("Color") > 0 && s.scheme) {
@@ -11826,6 +11981,8 @@
 	        scale._mapping = s.mapping;
 	        if ("includeZero" in s)
 	            scale.includeZero = s.includeZero;
+	        if ("baseItem" in s)
+	            scale._baseItem = scn.getItem(s.baseItem);
 	        this.scales[scale.id] = scale;
 	        //console.log(scale.domain, scale.range);
 	    }
@@ -11839,6 +11996,7 @@
 	        //let item = scene.getItem(enc.anyItem);
 	        let items = enc.items.map(d => scene.getItem(d));
 	        scene._doEncode(items, enc.args);
+	        scene._relayoutAncestors(items[0], items);
 	    }
 
 	    _createGuide(scene, guide) {
@@ -24115,7 +24273,13 @@
 	}
 
 	function canRepeat(compnt) {
-		if ((isMark(compnt) || compnt.type == ItemType.Glyph) && !compnt.dataScope) {
+		if (Array.isArray(compnt)) {
+			for (let c of compnt) {
+				if (!isMark(c) || c.dataScope)
+					return false;
+			}
+			return true;
+		} else if ((isMark(compnt) || compnt.type == ItemType.Glyph) && !compnt.dataScope) {
 			return true;
 		} else if (compnt.type == ItemType.Collection) {
 			//TODO: check if repeatable
@@ -24125,9 +24289,13 @@
 	}
 
 	function canDivide(compnt) {
-		if ([ItemType.Line, ItemType.Circle, ItemType.Rect, ItemType.Area, ItemType.Ring, ItemType.Pie].indexOf(compnt.type) < 0) {
+		if ([ItemType.Line, ItemType.Circle, ItemType.Rect, ItemType.Area, ItemType.Ring, ItemType.Pie, ItemType.Path].indexOf(compnt.type) < 0) {
 			return false;
 		} 
+
+		if (compnt.type === ItemType.Path && (compnt.closed || !compnt.firstVertex.dataScope))
+			return false;
+
 		if (!compnt.dataScope) {
 			return true;
 		} else {
@@ -24146,8 +24314,7 @@
 		} 
 		if (!compnt.dataScope) {
 			return true;
-		}
-		else {
+		} else {
 			let peers = getPeers(compnt, compnt.getScene());
 			for (let p of peers) {
 				if (p.dataScope.numTuples > 1)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mascot-vis",
-	"version": "1.11.1",
+	"version": "1.12.0",
 	"description": "Manipulable Semantic Components in Data Visualization",
 	"scripts": {
 		"build": "rollup --config",