Start again

vendors/echarts/extension/bmap/BMapCoordSys.js

@@ -0,0 +1,135 @@
+define(function (require) {
+
+    var echarts = require('echarts');
+
+    function BMapCoordSys(bmap, api) {
+        this._bmap = bmap;
+        this.dimensions = ['lng', 'lat'];
+        this._mapOffset = [0, 0];
+
+        this._api = api;
+    }
+
+    BMapCoordSys.prototype.dimensions = ['lng', 'lat'];
+
+    BMapCoordSys.prototype.setMapOffset = function (mapOffset) {
+        this._mapOffset = mapOffset;
+    };
+
+    BMapCoordSys.prototype.getBMap = function () {
+        return this._bmap;
+    };
+
+    BMapCoordSys.prototype.dataToPoint = function (data) {
+        var point = new BMap.Point(data[0], data[1]);
+        var px = this._bmap.pointToOverlayPixel(point);
+        var mapOffset = this._mapOffset;
+        return [px.x - mapOffset[0], px.y - mapOffset[1]];
+    };
+
+    BMapCoordSys.prototype.pointToData = function (pt) {
+        var mapOffset = this._mapOffset;
+        var pt = this._bmap.overlayPixelToPoint({
+            x: pt[0] + mapOffset[0],
+            y: pt[1] + mapOffset[1]
+        });
+        return [pt.lng, pt.lat];
+    };
+
+    BMapCoordSys.prototype.getViewRect = function () {
+        var api = this._api;
+        return new echarts.graphic.BoundingRect(0, 0, api.getWidth(), api.getHeight());
+    };
+
+    BMapCoordSys.prototype.getRoamTransform = function () {
+        return echarts.matrix.create();
+    };
+
+    var Overlay;
+
+    // For deciding which dimensions to use when creating list data
+    BMapCoordSys.dimensions = BMapCoordSys.prototype.dimensions;
+
+    function createOverlayCtor() {
+        function Overlay(root) {
+            this._root = root;
+        }
+
+        Overlay.prototype = new BMap.Overlay();
+        /**
+         * 初始化
+         *
+         * @param {BMap.Map} map
+         * @override
+         */
+        Overlay.prototype.initialize = function (map) {
+            map.getPanes().labelPane.appendChild(this._root);
+            return this._root;
+        };
+        /**
+         * @override
+         */
+        Overlay.prototype.draw = function () {};
+
+        return Overlay;
+    }
+
+    BMapCoordSys.create = function (ecModel, api) {
+        var bmapCoordSys;
+        var root = api.getDom();
+
+        // TODO Dispose
+        ecModel.eachComponent('bmap', function (bmapModel) {
+            var viewportRoot = api.getZr().painter.getViewportRoot();
+            if (typeof BMap === 'undefined') {
+                throw new Error('BMap api is not loaded');
+            }
+            Overlay = Overlay || createOverlayCtor();
+            if (bmapCoordSys) {
+                throw new Error('Only one bmap component can exist');
+            }
+            if (!bmapModel.__bmap) {
+                // Not support IE8
+                var bmapRoot = root.querySelector('.ec-extension-bmap');
+                if (bmapRoot) {
+                    // Reset viewport left and top, which will be changed
+                    // in moving handler in BMapView
+                    viewportRoot.style.left = '0px';
+                    viewportRoot.style.top = '0px';
+                    root.removeChild(bmapRoot);
+                }
+                bmapRoot = document.createElement('div');
+                bmapRoot.style.cssText = 'width:100%;height:100%';
+                // Not support IE8
+                bmapRoot.classList.add('ec-extension-bmap');
+                root.appendChild(bmapRoot);
+                var bmap = bmapModel.__bmap = new BMap.Map(bmapRoot);
+
+                var overlay = new Overlay(viewportRoot);
+                bmap.addOverlay(overlay);
+            }
+            var bmap = bmapModel.__bmap;
+
+            // Set bmap options
+            // centerAndZoom before layout and render
+            var center = bmapModel.get('center');
+            var zoom = bmapModel.get('zoom');
+            if (center && zoom) {
+                var pt = new BMap.Point(center[0], center[1]);
+                bmap.centerAndZoom(pt, zoom);
+            }
+
+            bmapCoordSys = new BMapCoordSys(bmap, api);
+            bmapCoordSys.setMapOffset(bmapModel.__mapOffset || [0, 0]);
+            bmapModel.coordinateSystem = bmapCoordSys;
+        });
+
+        ecModel.eachSeries(function (seriesModel) {
+            if (seriesModel.get('coordinateSystem') === 'bmap') {
+                seriesModel.coordinateSystem = bmapCoordSys;
+            }
+        });
+    };
+
+    return BMapCoordSys;
+});

vendors/echarts/extension/bmap/BMapModel.js

@@ -0,0 +1,35 @@
+define(function (require) {
+
+    function v2Equal(a, b) {
+        return a && b && a[0] === b[0] && a[1] === b[1];
+    }
+
+    return require('echarts').extendComponentModel({
+        type: 'bmap',
+
+        getBMap: function () {
+            // __bmap is injected when creating BMapCoordSys
+            return this.__bmap;
+        },
+
+        setCenterAndZoom: function (center, zoom) {
+            this.option.center = center;
+            this.option.zoom = zoom;
+        },
+
+        centerOrZoomChanged: function (center, zoom) {
+            var option = this.option;
+            return !(v2Equal(center, option.center) && zoom === option.zoom);
+        },
+
+        defaultOption: {
+            center: null,
+
+            zoom: 1,
+
+            mapStyle: {},
+
+            roam: false
+        }
+    });
+});

vendors/echarts/extension/bmap/BMapView.js

@@ -0,0 +1,84 @@
+define(function (require) {
+
+    return require('echarts').extendComponentView({
+        type: 'bmap',
+
+        render: function (bMapModel, ecModel, api) {
+            var rendering = true;
+
+            var bmap = bMapModel.getBMap();
+            var viewportRoot = api.getZr().painter.getViewportRoot();
+            var coordSys = bMapModel.coordinateSystem;
+            var moveHandler = function (type, target) {
+                if (rendering) {
+                    return;
+                }
+                var offsetEl = viewportRoot.parentNode.parentNode.parentNode;
+                var mapOffset = [
+                    -parseInt(offsetEl.style.left, 10) || 0,
+                    -parseInt(offsetEl.style.top, 10) || 0
+                ];
+                viewportRoot.style.left = mapOffset[0] + 'px';
+                viewportRoot.style.top = mapOffset[1] + 'px';
+
+                coordSys.setMapOffset(mapOffset);
+                bMapModel.__mapOffset = mapOffset;
+
+                api.dispatchAction({
+                    type: 'bmapRoam'
+                });
+            };
+
+            function zoomEndHandler() {
+                if (rendering) {
+                    return;
+                }
+                api.dispatchAction({
+                    type: 'bmapRoam'
+                });
+            }
+
+            bmap.removeEventListener('moving', this._oldMoveHandler);
+            // FIXME
+            // Moveend may be triggered by centerAndZoom method when creating coordSys next time
+            // bmap.removeEventListener('moveend', this._oldMoveHandler);
+            bmap.removeEventListener('zoomend', this._oldZoomEndHandler);
+            bmap.addEventListener('moving', moveHandler);
+            // bmap.addEventListener('moveend', moveHandler);
+            bmap.addEventListener('zoomend', zoomEndHandler);
+
+            this._oldMoveHandler = moveHandler;
+            this._oldZoomEndHandler = zoomEndHandler;
+
+            var roam = bMapModel.get('roam');
+            if (roam && roam !== 'scale') {
+                bmap.enableDragging();
+            }
+            else {
+                bmap.disableDragging();
+            }
+            if (roam && roam !== 'move') {
+                bmap.enableScrollWheelZoom();
+                bmap.enableDoubleClickZoom();
+                bmap.enablePinchToZoom();
+            }
+            else {
+                bmap.disableScrollWheelZoom();
+                bmap.disableDoubleClickZoom();
+                bmap.disablePinchToZoom();
+            }
+
+            var originalStyle = bMapModel.__mapStyle;
+
+            var newMapStyle = bMapModel.get('mapStyle') || {};
+            // FIXME, Not use JSON methods
+            var mapStyleStr = JSON.stringify(newMapStyle);
+            if (JSON.stringify(originalStyle) !== mapStyleStr) {
+                bmap.setMapStyle(newMapStyle);
+                bMapModel.__mapStyle = JSON.parse(mapStyleStr);
+            }
+
+            rendering = false;
+        }
+    });
+});

vendors/echarts/extension/bmap/bmap.js

@@ -0,0 +1,28 @@
+/**
+ * BMap component extension
+ */
+define(function (require) {
+
+    require('echarts').registerCoordinateSystem(
+        'bmap', require('./BMapCoordSys')
+    );
+    require('./BMapModel');
+    require('./BMapView');
+
+    // Action
+    require('echarts').registerAction({
+        type: 'bmapRoam',
+        event: 'bmapRoam',
+        update: 'updateLayout'
+    }, function (payload, ecModel) {
+        ecModel.eachComponent('bmap', function (bMapModel) {
+            var bmap = bMapModel.getBMap();
+            var center = bmap.getCenter();
+            bMapModel.setCenterAndZoom([center.lng, center.lat], bmap.getZoom());
+        });
+    });
+
+    return {
+        version: '1.0.0'
+    };
+});

vendors/echarts/extension/dataTool/gexf.js

@@ -0,0 +1,204 @@
+// GEXF File Parser
+// http://gexf.net/1.2draft/gexf-12draft-primer.pdf
+define(function (require) {
+
+    'use strict';
+    var zrUtil = require('echarts').util;
+
+    function parse(xml) {
+        var doc;
+        if (typeof xml === 'string') {
+            var parser = new DOMParser();
+            doc = parser.parseFromString(xml, 'text/xml');
+        }
+        else {
+            doc = xml;
+        }
+        if (!doc || doc.getElementsByTagName('parsererror').length) {
+            return null;
+        }
+
+        var gexfRoot = getChildByTagName(doc, 'gexf');
+
+        if (!gexfRoot) {
+            return null;
+        }
+
+        var graphRoot = getChildByTagName(gexfRoot, 'graph');
+
+        var attributes = parseAttributes(getChildByTagName(graphRoot, 'attributes'));
+        var attributesMap = {};
+        for (var i = 0; i < attributes.length; i++) {
+            attributesMap[attributes[i].id] = attributes[i];
+        }
+
+        return {
+            nodes: parseNodes(getChildByTagName(graphRoot, 'nodes'), attributesMap),
+            links: parseEdges(getChildByTagName(graphRoot, 'edges'))
+        };
+    }
+
+    function parseAttributes(parent) {
+        return parent ? zrUtil.map(getChildrenByTagName(parent, 'attribute'), function (attribDom) {
+            return {
+                id: getAttr(attribDom, 'id'),
+                title: getAttr(attribDom, 'title'),
+                type: getAttr(attribDom, 'type')
+            };
+        }) : [];
+    }
+
+    function parseNodes(parent, attributesMap) {
+        return parent ? zrUtil.map(getChildrenByTagName(parent, 'node'), function (nodeDom) {
+
+            var id = getAttr(nodeDom, 'id');
+            var label = getAttr(nodeDom, 'label');
+
+            var node = {
+                id: id,
+                name: label,
+                itemStyle: {
+                    normal: {}
+                }
+            };
+
+            var vizSizeDom = getChildByTagName(nodeDom, 'viz:size');
+            var vizPosDom = getChildByTagName(nodeDom, 'viz:position');
+            var vizColorDom = getChildByTagName(nodeDom, 'viz:color');
+            // var vizShapeDom = getChildByTagName(nodeDom, 'viz:shape');
+
+            var attvaluesDom = getChildByTagName(nodeDom, 'attvalues');
+
+            if (vizSizeDom) {
+                node.symbolSize = parseFloat(getAttr(vizSizeDom, 'value'));
+            }
+            if (vizPosDom) {
+                node.x = parseFloat(getAttr(vizPosDom, 'x'));
+                node.y = parseFloat(getAttr(vizPosDom, 'y'));
+                // z
+            }
+            if (vizColorDom) {
+                node.itemStyle.normal.color = 'rgb(' +[
+                    getAttr(vizColorDom, 'r') | 0,
+                    getAttr(vizColorDom, 'g') | 0,
+                    getAttr(vizColorDom, 'b') | 0
+                ].join(',') + ')';
+            }
+            // if (vizShapeDom) {
+                // node.shape = getAttr(vizShapeDom, 'shape');
+            // }
+            if (attvaluesDom) {
+                var attvalueDomList = getChildrenByTagName(attvaluesDom, 'attvalue');
+
+                node.attributes = {};
+
+                for (var j = 0; j < attvalueDomList.length; j++) {
+                    var attvalueDom = attvalueDomList[j];
+                    var attId = getAttr(attvalueDom, 'for');
+                    var attValue = getAttr(attvalueDom, 'value');
+                    var attribute = attributesMap[attId];
+
+                    if (attribute) {
+                        switch (attribute.type) {
+                            case 'integer':
+                            case 'long':
+                                attValue = parseInt(attValue, 10);
+                                break;
+                            case 'float':
+                            case 'double':
+                                attValue = parseFloat(attValue);
+                                break;
+                            case 'boolean':
+                                attValue = attValue.toLowerCase() == 'true';
+                                break;
+                            default:
+                        }
+                        node.attributes[attId] = attValue;
+                    }
+                }
+            }
+
+            return node;
+        }) : [];
+    }
+
+    function parseEdges(parent) {
+        return parent ? zrUtil.map(getChildrenByTagName(parent, 'edge'), function (edgeDom) {
+            var id = getAttr(edgeDom, 'id');
+            var label = getAttr(edgeDom, 'label');
+
+            var sourceId = getAttr(edgeDom, 'source');
+            var targetId = getAttr(edgeDom, 'target');
+
+            var edge = {
+                id: id,
+                name: label,
+                source: sourceId,
+                target: targetId,
+                lineStyle: {
+                    normal: {}
+                }
+            };
+
+            var lineStyle = edge.lineStyle.normal;
+
+            var vizThicknessDom = getChildByTagName(edgeDom, 'viz:thickness');
+            var vizColorDom = getChildByTagName(edgeDom, 'viz:color');
+            // var vizShapeDom = getChildByTagName(edgeDom, 'viz:shape');
+
+            if (vizThicknessDom) {
+                lineStyle.width = parseFloat(vizThicknessDom.getAttribute('value'));
+            }
+            if (vizColorDom) {
+                lineStyle.color = 'rgb(' + [
+                    getAttr(vizColorDom, 'r') | 0,
+                    getAttr(vizColorDom, 'g') | 0,
+                    getAttr(vizColorDom, 'b') | 0
+                ].join(',') + ')';
+            }
+            // if (vizShapeDom) {
+            //     edge.shape = vizShapeDom.getAttribute('shape');
+            // }
+
+            return edge;
+        }) : [];
+    }
+
+    function getAttr(el, attrName) {
+        return el.getAttribute(attrName);
+    }
+
+    function getChildByTagName (parent, tagName) {
+        var node = parent.firstChild;
+
+        while (node) {
+            if (
+                node.nodeType != 1 ||
+                node.nodeName.toLowerCase() != tagName.toLowerCase()
+            ) {
+                node = node.nextSibling;
+            } else {
+                return node;
+            }
+        }
+
+        return null;
+    }
+
+    function getChildrenByTagName (parent, tagName) {
+        var node = parent.firstChild;
+        var children = [];
+        while (node) {
+            if (node.nodeName.toLowerCase() == tagName.toLowerCase()) {
+                children.push(node);
+            }
+            node = node.nextSibling;
+        }
+
+        return children;
+    }
+
+    return {
+        parse: parse
+    };
+});

vendors/echarts/extension/dataTool/index.js

@@ -0,0 +1,9 @@
+define(function (require) {
+    var echarts = require('echarts');
+    echarts.dataTool = {
+        version: '1.0.0',
+        gexf: require('./gexf'),
+        prepareBoxplotData: require('./prepareBoxplotData')
+    };
+    return echarts.dataTool;
+});

vendors/echarts/extension/dataTool/prepareBoxplotData.js

@@ -0,0 +1,63 @@
+define(function (require) {
+
+    var quantile = require('./quantile');
+    var numberUtil = require('echarts').number;
+
+    /**
+     * Helper method for preparing data.
+     * @param {Array.<number>} rawData like
+     *        [
+     *            [12,232,443], (raw data set for the first box)
+     *            [3843,5545,1232], (raw datat set for the second box)
+     *            ...
+     *        ]
+     * @param {Object} [opt]
+     *
+     * @param {(number|string)} [opt.boundIQR=1.5] Data less than min bound is outlier.
+     *                          default 1.5, means Q1 - 1.5 * (Q3 - Q1).
+     *                          If pass 'none', min bound will not be used.
+     * @param {(number|string)} [opt.layout='horizontal']
+     *                          Box plot layout, can be 'horizontal' or 'vertical'
+     */
+    return function (rawData, opt) {
+        opt = opt || [];
+        var boxData = [];
+        var outliers = [];
+        var axisData = [];
+        var boundIQR = opt.boundIQR;
+
+        for (var i = 0; i < rawData.length; i++) {
+            axisData.push(i + '');
+            var ascList = numberUtil.asc(rawData[i].slice());
+
+            var Q1 = quantile(ascList, 0.25);
+            var Q2 = quantile(ascList, 0.5);
+            var Q3 = quantile(ascList, 0.75);
+            var IQR = Q3 - Q1;
+
+            var low = boundIQR === 'none'
+                ? ascList[0]
+                : Q1 - (boundIQR == null ? 1.5 : boundIQR) * IQR;
+            var high = boundIQR === 'none'
+                ? ascList[ascList.length - 1]
+                : Q3 + (boundIQR == null ? 1.5 : boundIQR) * IQR;
+
+            boxData.push([low, Q1, Q2, Q3, high]);
+
+            for (var j = 0; j < ascList.length; j++) {
+                var dataItem = ascList[j];
+                if (dataItem < low || dataItem > high) {
+                    var outlier = [i, dataItem];
+                    opt.layout === 'vertical' && outlier.reverse();
+                    outliers.push(outlier);
+                }
+            }
+        }
+        return {
+            boxData: boxData,
+            outliers: outliers,
+            axisData: axisData
+        };
+    };
+
+});

vendors/echarts/extension/dataTool/quantile.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2010-2015, Michael Bostock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * The name Michael Bostock may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL MICHAEL BOSTOCK BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+define(function (require) {
+
+    /**
+     * @see <https://github.com/mbostock/d3/blob/master/src/arrays/quantile.js>
+     * @see <http://en.wikipedia.org/wiki/Quantile>
+     * @param {Array.<number>} ascArr
+     */
+    return function(ascArr, p) {
+        var H = (ascArr.length - 1) * p + 1,
+            h = Math.floor(H),
+            v = +ascArr[h - 1],
+            e = H - h;
+        return e ? v + e * (ascArr[h] - v) : v;
+    };
+
+});

vendors/echarts/extension/echarts.js

@@ -0,0 +1 @@
+define('echarts', [], function () {return echarts;});

vendors/echarts/extension/webpack.config.js

@@ -0,0 +1,17 @@
+var PROD = process.argv.indexOf('-p') >= 0;
+
+module.exports = {
+    entry: {
+        'bmap': __dirname + '/../extension/bmap/bmap.js',
+        'dataTool': __dirname + '/../extension/dataTool'
+    },
+    output: {
+        libraryTarget: 'umd',
+        library: ['echarts', '[name]'],
+        path: __dirname + '/../dist/extension',
+        filename: PROD ? '[name].min.js' : '[name].js'
+    },
+    externals: {
+        'echarts': 'echarts'
+    }
+};