mascot-vis 3.0.0 → 3.0.1

package/src-old/core/SceneValidator.js

@@ -1,232 +0,0 @@
-import LayoutAxis from "../item/refs/LayoutAxis";
-import { LayoutType, Orientation } from "../util/Constants";
-import { getEncodingKey, getPeers, isGuide } from "../util/ItemUtil";
-
-const SceneValidator = {
-
-    itemTranslated: function(item, dx, dy) {
-        let scene = item.getScene();
-        if (!isGuide(item))
-			scene._reapplyConstraints(item);
-
-        let axes = scene.getRelatedAxes(item);
-		axes.forEach(a => {
-			if (a.encoding && a.encoding.scale.offset !== undefined)
-				a.encoding.scale.offset += a.channel === "x" || a.channel === "width" ? dx : dy;
-            if (dy !== 0 && (a.channel === "x" || a.channel === "width") && a._posArg !== undefined) {
-                a._posArg = a._posArg + dy;
-            }
-            if (dx !== 0 && (a.channel === "y" || a.channel === "height") && a._posArg !== undefined) {
-                a._posArg = a._posArg + dx;
-            }
-			a.reposition();
-		});
-		let gl = scene.getRelatedGridlines(item);
-		gl.forEach(l => l.updateLinePositions());
-    },
-
-    layoutChanged: function(item, peers, props) {
-        let scene = item.getScene();
-        scene._relayoutAncestors(item, peers);
-
-        let items = [item], c = item.firstChild
-        while (c) {
-            items.push(c);
-            c = c.firstChild;
-        }
-        for (let i of items)
-			i.getScene()._reapplyConstraints(i);
-
-        let reGenerateAxes = false;
-        for (let p of props) {
-            if (["numRows", "numCols", "layout", "childrenOrder"].indexOf(p) >= 0) {
-                reGenerateAxes = true;
-                break;
-            }
-        }
-
-        //if grid layout changes to a single column or row, or stack layout's orientation changes, update axis channel
-        let updateChannel = false, channel;
-        if (item.layout) {
-            if (item.layout.type === LayoutType.Grid && (item.layout.numRows === 1 || item.layout.numCols === 1)) {
-                updateChannel = true;
-                channel = item.layout.numRows === 1 ? "x" : "y";
-            } else if (item.layout.type === LayoutType.Stack && props.indexOf("orientation") >= 0) {
-                updateChannel = true;
-                channel = item.layout.orientation === Orientation.Horizontal ? "x" : "y";
-            }
-        }
-        if (updateChannel) {
-            let axes = scene.getRelatedAxes(item).filter(d => d instanceof LayoutAxis && d._item.parent.classId === item.classId);
-            for (let a of axes) {
-                scene.removeItem(a);
-                let args = a.toJSON().args;
-                delete args["orientation"];
-                args.item = item.firstChild;
-                scene.axis(channel, a.field, args);
-            }
-        }
-        
-        if (reGenerateAxes) {
-            scene.reCreateRelatedAxes(item);
-        } else {
-            let axes = scene.getRelatedAxes(item);
-            axes.forEach(a => a.reposition());
-        }
-
-        let gl = scene.getRelatedGridlines(item);
-		gl.forEach(l => l.updateLinePositions());
-    },
-
-    scaleDomainSet: function(scale) {
-        for (let enc of scale.encodings) {
-			enc._map();
-			enc._apply();
-		}
-
-        for (let enc of scale.encodings) {
-			enc.scene._updateAncestorBounds(enc.item, enc.items);
-		}
-		//reapply constraints
-		let items = scale.encodings.map( d => d.anyItem), classId2item = {};
-		for (let item of items) {
-			if (item.type === "vertex" || item.type === "segment")
-				classId2item[item.parent.classId] = item.parent;
-			else
-				classId2item[item.classId] = item;
-		}
-		for (let i of Object.values(classId2item))
-			i.getScene()._reapplyConstraints(i);
-
-        for (let enc of scale.encodings) {
-            let item = enc.anyItem;
-            let axes = enc.scene.getRelatedAxes(item);
-            for (let a of axes) {
-                if (a.encoding && a.encoding.scale === scale) {
-                    a.tickValues = enc._inferTickValues(enc);
-                    a.labelValues = enc._inferTickValues(enc);
-                    a._positionPath();
-                    if (a._showTitle)
-                        a._positionTitle();
-                    if (a._channel === "radialDistance" && a._rotate){
-                        a._rotate = [a._rotate[0], a._item.parent.x, a._item.parent.y];
-                    }
-                    a._updateBounds();
-                }
-            }
-            let gl = enc.scene.getRelatedGridlines(item);
-            gl.forEach(l => l.updateLinePositions());
-        }
-    },
-
-    scaleRangeSet: function(scale) {
-        for (let enc of scale.encodings) {
-			//enc._map();
-			enc._apply();
-		}
-
-        for (let enc of scale.encodings) {
-			enc.scene._relayoutAncestors(enc.item, enc.items);
-		}
-		//reapply constraints
-		let items = scale.encodings.map( d => d.anyItem), classId2item = {};
-		for (let item of items) {
-			if (item.type === "vertex" || item.type === "segment")
-				classId2item[item.parent.classId] = item.parent;
-			else
-				classId2item[item.classId] = item;
-		}
-		for (let i of Object.values(classId2item))
-			i.getScene()._reapplyConstraints(i);
-
-        for (let enc of scale.encodings) {
-            let item = enc.anyItem;
-            let axes = enc.scene.getRelatedAxes(item);
-            axes.forEach(a => a.reposition());
-            let gl = enc.scene.getRelatedGridlines(item);
-            gl.forEach(l => l.updateLinePositions());
-        }
-    },
-    
-    itemResized: function(item, peers) {
-        let scene = item.getScene();
-        scene._relayoutAncestors(item, peers);
-		scene._reapplyConstraints(item);
-        let axes = scene.getRelatedAxes(item);
-        axes.forEach(a => a.reposition());
-        let gl = scene.getRelatedGridlines(item);
-        gl.forEach(l => l.updateLinePositions());
-    },
-
-    markDivided: function(path, collection) {
-        //update axis item argument
-        let scene = collection.getScene();
-        let axes = scene.getRelatedAxes(path);
-        for (let a of axes) {
-            if (a._item.classId === path.classId) {
-                a._item = collection;
-                a._items = getPeers(collection, scene);
-            }
-        }
-
-        //update encoding item
-        let e = scene.encodings[getEncodingKey(path)];
-        if (e) {
-            scene.encodings[getEncodingKey(collection)] = {};
-            for (let channel of ["x", "y"]) {
-                const enc = e[channel];
-                if (!enc)
-                    continue;
-                enc.anyItem = collection;
-                enc.items = getPeers(collection, scene);
-                scene.encodings[getEncodingKey(collection)][channel] = enc;
-                delete scene.encodings[getEncodingKey(path)][channel];
-            }
-            if (Object.keys(e).length === 0)
-                delete scene.encodings[getEncodingKey(path)];
-        }
-        //TODO: update constraints
-    },
-
-    markDensified: function(item, newItem) {
-        let scene = newItem.getScene();
-        let e = scene.encodings[getEncodingKey(item)];
-        if (e) {
-            scene.encodings[getEncodingKey(newItem)] = {};
-            for (let channel of ["x", "y"]) {
-                const enc = e[channel];
-                if (!enc)
-                    continue;
-                enc.anyItem = newItem;
-                enc.items = getPeers(newItem, scene);
-                scene.encodings[getEncodingKey(newItem)][channel] = enc;
-                delete scene.encodings[getEncodingKey(item)][channel];
-            }
-            if (Object.keys(e) === 0)
-                delete scene.encodings[getEncodingKey(item)];
-        }
-
-        let axes = scene.getRelatedAxes(item);
-        for (let a of axes) {
-            if (a._item.classId === item.classId) {
-                a._item = newItem;
-                a._items = getPeers(newItem, scene);
-            }
-        }
-        //TODO: update constraints
-    },
-
-    areaRebased: function(item) {
-        let scene = item.getScene();
-        let encodings = scene.encodings[getEncodingKey(item)];
-        for (let channel in encodings) {
-            encodings[channel]._apply();
-        }
-        let axes = scene.getRelatedAxes(item);
-        axes.forEach(a => a.reposition());
-        let gl = scene.getRelatedGridlines(item);
-        gl.forEach(l => l.updateLinePositions());
-    }
-};
-
-export default SceneValidator;

package/src-old/core/SpecExecutor.js

@@ -1,113 +0,0 @@
-import { importCSV } from "../data/DataImporter";
-import Scene from "../item/composite/Scene";
-import { ConstraintType } from "../util/Constants";
-import { getLayout } from "../util/ItemUtil";
-import Scale from "./Scale";
-
-export default class SpecExecutor {
-
-    constructor() {
-        
-    }
-
-    async run(spec) {
-        let scn;
-        let itmHash = {}, dataHash = {}, scales = {};
-        let data;
-        // console.log("spec");
-        for (let c of spec) {
-            //console.log(c);
-            switch (c.cmd) {
-                case "scene":
-                    scn = new Scene(c.args);
-                    break;
-                case "data":
-                    data = await importCSV(c.url);
-                    dataHash[c.output] = data;
-                    break;
-                case "transform":
-                    dataHash[c.output] = dataHash[c.input].transform(c.type, c.args);
-                    break;
-                case "mark":
-                    itmHash[c.output] = scn.mark(c.type, c.args);
-                    break;
-                case "glyph":
-                    itmHash[c.output] = scn.glyph(...c.input.map(d => itmHash[d]));
-                    break;
-                case "attach":
-                    scn.attach(itmHash[c.input], dataHash[c.data]);
-                    break;
-                case "repeat": {
-                    let coll = scn.repeat(itmHash[c.input], dataHash[c.data], c.args);
-                    itmHash[c.output] = coll;
-                    break;
-                }
-                case "divide": {
-                    let coll = scn.divide(itmHash[c.input], dataHash[c.data], c.args);
-                    itmHash[c.output] = coll;
-                    break;
-                }
-                case "layout":
-                    itmHash[c.input].layout = getLayout(c.type, c.args);
-                    break;
-                case "sortChildren":
-                    if ("field" in c.args)
-                        itmHash[c.input].sortChildrenByData(c.args.field, c.args.reverse, c.args.order);
-                    else if ("channel" in c.args)
-                        itmHash[c.input].sortChildren(c.args.channel, c.args.reverse);
-                    break;
-                case "scale": {
-                    let scale = new Scale(c.type);
-                    scale.id = c.id;
-                    scale.domain = c.type == "time" ? c.domain.map(d => new Date(d)) : c.domain;
-                    scale.range = c.range;
-                    scale.clamp = c.clamp;
-                    scale.isFlipped = c.isFlipped;
-                    if ("offset" in c)
-                        scale.offset = c.offset;
-                    scales[scale.id] = scale;
-                    break;
-                }
-                case "encode": {
-                    let itm, encKey = c.input;
-                    if (encKey.indexOf("_v_") > 0) {
-                        let idx = parseInt(encKey.split("_v_")[1]);
-                        itm = itmHash[encKey.split("_v_")[0]].vertices[idx];
-                    } else if (encKey.indexOf("_v") > 0) {
-                        //TODO
-                    } else if (encKey.indexOf("_s_") > 0) {
-                        let idx = parseInt(encKey.split("_s_")[1]);
-                        itm = itmHash[encKey.split("_s_")[0]].segments[idx];
-                    } else if (encKey.indexOf("_s") > 0) {
-                        //TODO
-                    } else {
-                        itm = itmHash[c.input];
-                    }
-                    if(c.scale && scales[c.scale])
-                        c.args.scale = scales[c.scale];
-                    scn.encode(itm, c.args);
-                    break;
-                }
-                case "constraint":
-                    switch (c.type) {
-                        case ConstraintType.Affix:
-                            scn.affix(itmHash[c.item], itmHash[c.baseItem], c.channel, c.args);
-                            break;
-                        case ConstraintType.Align:
-                            //TODO
-                            break;
-                    }
-                    break;
-                case "axis":
-                    scn.axis(c.channel, c.field, c.args);
-                    break;
-                case "legend":
-                    scn.legend(c.channel, c.field, c.args);
-                    break;
-                case "gridlines":
-                    scn.gridlines(c.channel, c.field, c.args);
-            }
-        }
-        return scn;
-    }
-}

package/src-old/core/SpecGenerator.js

@@ -1,350 +0,0 @@
-import Collection from "../item/composite/Collection";
-import Glyph from "../item/composite/Glyph";
-import Group from "../item/composite/Group";
-import Mark from "../item/mark/Mark";
-import { atlas_rowId, ConstraintType, ItemType, LayoutType } from "../util/Constants";
-import { getEncodingKey, getPeers } from "../util/ItemUtil";
-
-/**
- * Generates an array of commands that would reconstruct a given scene
- */
-export default class SpecGenerator {
-
-    constructor() {
-        this.axes = {};
-        this.guideCmds = [];
-        this.collectionCmds = [];
-        this.glyphCmds = [];
-        this.spec = [];
-    }
-
-    run(scene) {
-        for (let c of scene.children) {
-            switch (c.type) {
-                case ItemType.Axis: {
-                    let id = c.classId ? c.classId : c.id;
-                    this.axes[id] = c;
-                    break;
-                }
-                case ItemType.Gridlines:
-                case ItemType.Legend:{
-                    let json = c.toJSON();
-                    this.guideCmds.push({
-                        cmd: c.type,
-                        channel: json.channel,
-                        field: json.field,
-                        args: json.args
-                    });
-                    break;
-                }
-                case ItemType.Collection:
-                case ItemType.Group:
-                case ItemType.Glyph: {
-                    let struct = [];
-                    this._analyze(c, struct);
-                    // console.log("struct", c.type);
-                    // for (let s of struct)
-                    //     console.log(s);
-                    for (let i = struct.length - 1; i > 0; i--) {
-                        for (let f of struct[i].fields)
-                            struct[i - 1].fields.delete(f);
-                    }
-                    for (let [i, s] of struct.entries()) {
-                        if (s.item instanceof Mark) {
-                            let m = {
-                                cmd: "mark",
-                                type: s.item.type,
-                                output: s.item,
-                                args: s.item.toJSON().args
-                            };
-                            this._inferMarkArgs(m, scene);
-                            this.collectionCmds.push(m);
-                        } else if (s.item instanceof Glyph) {
-                            this.collectionCmds.push({
-                                cmd: "glyph",
-                                output: s.item,
-                                input: struct.slice(0, i).map(d => d.item),
-                                args: {}
-                            })
-                        } else if (s.item instanceof Collection) {
-                            let f = [...struct[i-1].fields][0];
-                            let o = {
-                                cmd: "join",
-                                input: struct[i-1].item,
-                                output: s.item,
-                                data: struct[i-1].item.dataScope.dataTable.id,
-                                args: {field: f}
-                            };
-                            if (f == atlas_rowId)
-                                delete o.field;
-                            this.collectionCmds.push(o);
-                        }
-
-                        if (s.item.dataScope && s.item.dataScope.fields.length == 0 && !s.item.parent.dataScope) {
-                            this.collectionCmds.push({
-                                cmd: "attach",
-                                input: s.item,
-                                data: s.item.dataScope.dataTable.id
-                            });
-                        }
-                    }
-                    break;
-                }
-                default:
-                    if (c instanceof Mark) {
-                        let m = {
-                            cmd: "mark",
-                            type: c.type,
-                            output: c,
-                            args: c.toJSON().args
-                        };
-                        this._inferMarkArgs(m, scene);
-                        this.glyphCmds.push(m);
-                    }
-                    break;
-            }
-        }
-
-        this._inferJoin();
-        this._inferArgs(scene);
-
-        for (let a in this.axes){
-            let json = this.axes[a].toJSON();
-            this.guideCmds.push({
-                cmd: json.type,
-                channel: json.channel,
-                field: json.field,
-                args: json.args
-            });
-        }
-
-        // console.log("collection commands");
-        // for (let c of this.collectionCmds)
-        //     console.log(c);
-        // console.log("glyphs", this.glyphCmds);
-        // console.log("guides", this.guideCmds);
-
-        this._generateFullSpec(scene);
-        return this.spec;
-    }
-
-    _inferJoin() {
-        for (let c of this.collectionCmds) {
-            if (c.cmd != "join") continue;
-            let itm = c.input, p = itm.parent;
-            switch (itm.type) {
-                case ItemType.Rect:
-                    if (p.layout && p.layout.type == LayoutType.Stack)
-                        c.cmd = "divide";
-                    else
-                        c.cmd = "repeat";
-                    break;                    
-                default:
-                    c.cmd = "repeat";
-                    break;
-            }
-        }
-    }
-
-    _inferArgs(scene) {
-        for (let c of this.collectionCmds) {
-            switch(c.cmd) {
-                case "mark":
-                    this._inferMarkArgs(c, scene);
-                    break;
-                case "divide":
-                    this._inferDivideArgs(c, scene);
-                    break;
-            }
-        }
-    }
-
-    _inferDivideArgs(c) {
-        c.args.orientation = c.output.layout.orientation;
-    }
-
-    _inferMarkArgs(c, scene) {
-        let itm = c.output, p = itm.parent;
-        let itmPeers = getPeers(itm, scene), parentPeers = getPeers(p, scene);
-        switch (itm.type) {
-            case ItemType.Rect:
-                if (p.layout && p.layout.type == LayoutType.Grid) {
-                    c.args.width = p.layout.cellBounds[0].width;
-                    c.args.height = p.layout.cellBounds[0].height;
-                } else if (p.layout && p.layout.type == LayoutType.Stack) {
-                    c.args.width = Math.max(...parentPeers.map(d => d.bounds.width));
-                    c.args.height = Math.max(...parentPeers.map(d => d.bounds.height));
-                } else {
-                    c.args.width = Math.max(...itmPeers.map(d => d.bounds.width));
-                    c.args.height = Math.max(...itmPeers.map(d => d.bounds.height));
-                }
-                c.args.left = Math.min(...itmPeers.map(d => d.bounds.left));
-                c.args.top = Math.min(...itmPeers.map(d => d.bounds.top));
-                break;
-            case ItemType.Line:
-                c.args.x1 = Math.min(...itmPeers.map(d => d.vertices[0].x));
-                c.args.y1 = Math.min(...itmPeers.map(d => d.vertices[0].y));
-                c.args.x2 = Math.min(...itmPeers.map(d => d.vertices[1].x));
-                c.args.y2 = Math.min(...itmPeers.map(d => d.vertices[1].y));
-                break;
-            case ItemType.Arc:
-                c.args.x = itm.x;
-                c.args.y = itm.y;
-                c.args.innerRadius = itm.innerRadius;
-                c.args.outerRadius = itm.outerRadius;
-                break;
-            default:
-                break;
-        }
-        for (let s in itm.styles) {
-            c.args[s] = itm.styles[s];
-        }
-    }
-
-    _analyze(itm, result) {
-        if (itm instanceof Glyph) {
-            for (let c of itm.children) 
-                this._analyze(c, result);    
-        } else if (itm instanceof Group) {
-            this._analyze(itm.firstChild, result);
-        }
-
-        let node = {type: itm.type, item: itm};
-        if (itm.dataScope)
-            node.fields = new Set(itm.dataScope.fields);
-        else
-            node.fields = new Set();
-        result.push(node);  
-    }
-
-    _generateFullSpec(scene) {
-        this.spec = [];
-        this.spec.push({
-            cmd: "scene",
-            args: {fillColor: scene.fillColor}
-        });
-
-        let tables = scene.getDataTables(); //, sourceTables = {};
-        let imports = {}, transforms = [];
-        for (let t in tables) {
-            let table = tables[t];
-            if (table.sourceDataTable) {
-                while (table.sourceDataTable) {
-                    transforms.push({
-                        cmd: "transform",
-                        type: table.transform.type,
-                        args: table.transform.args,
-                        input: table.sourceDataTable.id,
-                        output: table.id
-                    });
-                    table = table.sourceDataTable;
-                }
-            }
-            if (!(table.id in imports)) {
-                imports[table.id] = {
-                    cmd: "data",
-                    url: table.url,
-                    output: table.id
-                };
-            }
-        }
-
-        this.spec = this.spec.concat(Object.values(imports));
-        this.spec = this.spec.concat(transforms);
-
-        let sortChildren = [];
-
-        for (let c of this.collectionCmds) {  
-            let l;         
-            if (c.output && c.output.layout) {
-                l = {
-                    cmd: "layout",
-                    type: c.output.layout.type,
-                    input: c.output.id,
-                    args: c.output.layout.toJSON().args
-                };
-            }
-            this.spec.push(c);
-            if (c.output && c.output.childrenOrder) {
-                sortChildren.push({
-                    cmd: "sortChildren",
-                    args: c.output.childrenOrder,
-                    input: c.output.id
-                })
-            }
-            if (l)
-                this.spec.push(l);
-            
-            if (c.input && Array.isArray(c.input)) { //glyph
-                c.input = c.input.map(d => d.classId ? d.classId : d.id);
-            } else if (c.input)
-                c.input = c.input.classId ? c.input.classId : c.input.id;
-            if (c.output)
-                c.output = c.output.classId ? c.output.classId : c.output.id;
-        }
-
-        let scales = {}, encodings = [];
-        for (let classId in scene.encodings) {
-            for (let channel in scene.encodings[classId]) {
-                let enc = scene.encodings[classId][channel];
-                if (enc.scale && !(enc.scale.id in scales)) {
-					scales[enc.scale.id] = enc.scale.toJSON();
-				}
-                let args = enc.toJSON().args;
-                args.field = enc.field;
-                args.channel = enc.channel;
-                delete args.datatable;
-                encodings.push({
-                    cmd: "encode",
-                    input: getEncodingKey(enc.anyItem),
-                    scale: enc.scale.id,
-                    args: args
-                });
-            }
-        }
-
-        for (let s in scales) {
-            let o = scales[s];
-            o.cmd = "scale";
-            this.spec.push(o);
-        }
-
-        this.spec = this.spec.concat(encodings);
-        this.spec = this.spec.concat(sortChildren);
-
-        for (let c in scene.constraints) {
-            let constr = scene.constraints[c];
-            let o = {
-                cmd: "constraint",
-                type: constr.type,
-                args: {}
-            };
-            switch (constr.type) {
-                case ConstraintType.Affix:
-                    o.item = constr.item.classId ? constr.item.classId : constr.item.id;
-                    o.baseItem = constr.baseItem.classId ? constr.baseItem.classId : constr.baseItem.id;
-                    o.channel = constr.channel;
-                    o.args.itemAnchor = constr.itemAnchor;
-                    o.args.baseAnchor = constr.baseAnchor;
-                    o.args.offset = constr.offset;
-                    break;
-                case ConstraintType.Align:
-                    //TODO: need to actually do more to infer what items are being aligned
-                    o.items = constr.items.map(d => d.classId ? d.classId : d.id);
-                    o.anchor = constr.anchor;
-                    break;
-            }
-            this.spec.push(o);
-        }
-
-        for (let c of this.guideCmds) {
-            this.spec.push(c);
-        }
-
-        for (let c of this.glyphCmds) {
-            if (c.output)
-                c.output = c.output.classId ? c.output.classId : c.output.id;
-            this.spec.push(c);
-        }
-    }
-}