echarts-rails 0.1.0 → 0.1.2

data/vendor/assets/javascripts/extension/bmap.js

@@ -0,0 +1,369 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("echarts"));
+	else if(typeof define === 'function' && define.amd)
+		define(["echarts"], factory);
+	else if(typeof exports === 'object')
+		exports["bmap"] = factory(require("echarts"));
+	else
+		root["echarts"] = root["echarts"] || {}, root["echarts"]["bmap"] = factory(root["echarts"]);
+})(this, function(__WEBPACK_EXTERNAL_MODULE_1__) {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_RESULT__;/**
+	 * BMap component extension
+	 */
+	!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
+
+	    __webpack_require__(1).registerCoordinateSystem(
+	        'bmap', __webpack_require__(2)
+	    );
+	    __webpack_require__(3);
+	    __webpack_require__(4);
+
+	    // Action
+	    __webpack_require__(1).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'
+	    };
+	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+/***/ },
+/* 1 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_1__;
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
+
+	    var echarts = __webpack_require__(1);
+
+	    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]);
+	        // TODO pointToOverlayPixel is toooooooo slow, cache the transform
+	        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;
+	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+/***/ },
+/* 3 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
+
+	    function v2Equal(a, b) {
+	        return a && b && a[0] === b[0] && a[1] === b[1];
+	    }
+
+	    return __webpack_require__(1).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: [104.114129, 37.550339],
+
+	            zoom: 5,
+
+	            mapStyle: {},
+
+	            roam: false
+	        }
+	    });
+	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+/***/ },
+/* 4 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
+
+	    return __webpack_require__(1).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) {
+	                // FIXME May have blank tile when dragging if setMapStyle
+	                if (Object.keys(newMapStyle).length) {
+	                    bmap.setMapStyle(newMapStyle);
+	                }
+	                bMapModel.__mapStyle = JSON.parse(mapStyleStr);
+	            }
+
+	            rendering = false;
+	        }
+	    });
+	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+/***/ }
+/******/ ])
+});
+;

data/vendor/assets/javascripts/extension/dataTool.js

@@ -0,0 +1,405 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("echarts"));
+	else if(typeof define === 'function' && define.amd)
+		define(["echarts"], factory);
+	else if(typeof exports === 'object')
+		exports["dataTool"] = factory(require("echarts"));
+	else
+		root["echarts"] = root["echarts"] || {}, root["echarts"]["dataTool"] = factory(root["echarts"]);
+})(this, function(__WEBPACK_EXTERNAL_MODULE_1__) {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
+	    var echarts = __webpack_require__(1);
+	    echarts.dataTool = {
+	        version: '1.0.0',
+	        gexf: __webpack_require__(5),
+	        prepareBoxplotData: __webpack_require__(6)
+	    };
+	    return echarts.dataTool;
+	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+/***/ },
+/* 1 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_1__;
+
+/***/ },
+/* 2 */,
+/* 3 */,
+/* 4 */,
+/* 5 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_RESULT__;// GEXF File Parser
+	// http://gexf.net/1.2draft/gexf-12draft-primer.pdf
+	!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
+
+	    'use strict';
+	    var zrUtil = __webpack_require__(1).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
+	    };
+	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
+
+	    var quantile = __webpack_require__(7);
+	    var numberUtil = __webpack_require__(1).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
+	        };
+	    };
+
+	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_RESULT__;/**
+	 * 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.
+	 */
+	!(__WEBPACK_AMD_DEFINE_RESULT__ = 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;
+	    };
+
+	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+/***/ }
+/******/ ])
+});
+;