{"version":3,"sources":["webpack:///./node_modules/echarts/lib/scale/Ordinal.js","webpack:///./node_modules/echarts/lib/scale/Time.js","webpack:///./node_modules/echarts/lib/scale/Interval.js","webpack:///./node_modules/echarts/lib/scale/Log.js","webpack:///./node_modules/echarts/lib/scale/helper.js","webpack:///./node_modules/echarts/lib/processor/dataStack.js","webpack:///./node_modules/echarts/lib/scale/Scale.js"],"names":["zrUtil","Scale","OrdinalMeta","scaleProto","prototype","OrdinalScale","extend","type","init","ordinalMeta","extent","isArray","categories","this","_ordinalMeta","_extent","length","parse","val","getOrdinal","Math","round","contain","rank","call","normalize","scale","getTicks","ticks","push","getLabel","n","isBlank","count","unionExtentFromData","data","dim","unionExtent","getApproximateExtent","getOrdinalMeta","niceTicks","noop","niceExtent","create","_default","module","exports","numberUtil","formatUtil","scaleHelper","IntervalScale","intervalScaleProto","mathCeil","ceil","mathFloor","floor","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_DAY","bisect","a","x","lo","hi","mid","TimeScale","stepLvl","_stepLvl","date","Date","formatTime","getSetting","opt","Infinity","d","getFullYear","getMonth","getDate","splitNumber","minInterval","maxInterval","interval","_interval","fixMin","fixMax","approxTickNum","span","approxInterval","scaleLevelsLen","scaleLevels","idx","level","min","yearSpan","yearStep","nice","timezoneOffset","getTimezoneOffset","fixExtent","_niceExtent","parseDate","each","methodName","model","useUTC","ecModel","get","helper","roundNumber","_intervalPrecision","setExtent","start","end","thisExtent","isNaN","parseFloat","other","getInterval","setInterval","slice","getIntervalPrecision","expandToNicedExtent","niceTickExtent","intervalPrecision","safeLimit","tick","lastNiceTick","getMinorTicks","minorTicks","getExtent","i","nextTick","prevTick","minorTicksGroup","minorInterval","minorTick","precision","getPrecisionSafe","addCommas","isFinite","reverse","result","intervalScaleNiceTicks","expandSize","roundingErrorFix","mathPow","pow","mathLog","log","LogScale","base","$constructor","apply","arguments","_originalScale","originalScale","originalExtent","map","powVal","__fixMin","fixRoundingError","__fixMax","quantity","err","abs","originalVal","clamp","max","_util","createHashMap","stackInfoMap","eachSeries","seriesModel","stack","stackInfoList","set","getData","stackInfo","stackResultDimension","getCalculationInfo","stackedOverDimension","stackedDimension","stackedByDimension","isStackedByIndex","setCalculationInfo","calculateStack","targetStackInfo","idxInStack","resultVal","resultNaN","NaN","dims","targetData","newData","v0","v1","dataIndex","byValue","stackedDataRawIndex","sum","getRawIndex","stackedOver","j","rawIndexOf","getByRawIndex","hostModel","setData","clazzUtil","setting","_setting","name","_isBlank","setBlank","enableClassExtend","enableClassManagement","registerWhenExtend"],"mappings":"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","file":"js/chunk-e3ca463a.e361839f.js","sourcesContent":["\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = require(\"zrender/lib/core/util\");\n\nvar Scale = require(\"./Scale\");\n\nvar OrdinalMeta = require(\"../data/OrdinalMeta\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Linear continuous scale\n * @module echarts/coord/scale/Ordinal\n *\n * http://en.wikipedia.org/wiki/Level_of_measurement\n */\n// FIXME only one data\nvar scaleProto = Scale.prototype;\nvar OrdinalScale = Scale.extend({\n type: 'ordinal',\n\n /**\n * @param {module:echarts/data/OrdianlMeta|Array.} ordinalMeta\n */\n init: function (ordinalMeta, extent) {\n // Caution: Should not use instanceof, consider ec-extensions using\n // import approach to get OrdinalMeta class.\n if (!ordinalMeta || zrUtil.isArray(ordinalMeta)) {\n ordinalMeta = new OrdinalMeta({\n categories: ordinalMeta\n });\n }\n\n this._ordinalMeta = ordinalMeta;\n this._extent = extent || [0, ordinalMeta.categories.length - 1];\n },\n parse: function (val) {\n return typeof val === 'string' ? this._ordinalMeta.getOrdinal(val) // val might be float.\n : Math.round(val);\n },\n contain: function (rank) {\n rank = this.parse(rank);\n return scaleProto.contain.call(this, rank) && this._ordinalMeta.categories[rank] != null;\n },\n\n /**\n * Normalize given rank or name to linear [0, 1]\n * @param {number|string} [val]\n * @return {number}\n */\n normalize: function (val) {\n return scaleProto.normalize.call(this, this.parse(val));\n },\n scale: function (val) {\n return Math.round(scaleProto.scale.call(this, val));\n },\n\n /**\n * @return {Array}\n */\n getTicks: function () {\n var ticks = [];\n var extent = this._extent;\n var rank = extent[0];\n\n while (rank <= extent[1]) {\n ticks.push(rank);\n rank++;\n }\n\n return ticks;\n },\n\n /**\n * Get item on rank n\n * @param {number} n\n * @return {string}\n */\n getLabel: function (n) {\n if (!this.isBlank()) {\n // Note that if no data, ordinalMeta.categories is an empty array.\n return this._ordinalMeta.categories[n];\n }\n },\n\n /**\n * @return {number}\n */\n count: function () {\n return this._extent[1] - this._extent[0] + 1;\n },\n\n /**\n * @override\n */\n unionExtentFromData: function (data, dim) {\n this.unionExtent(data.getApproximateExtent(dim));\n },\n getOrdinalMeta: function () {\n return this._ordinalMeta;\n },\n niceTicks: zrUtil.noop,\n niceExtent: zrUtil.noop\n});\n/**\n * @return {module:echarts/scale/Time}\n */\n\nOrdinalScale.create = function () {\n return new OrdinalScale();\n};\n\nvar _default = OrdinalScale;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = require(\"zrender/lib/core/util\");\n\nvar numberUtil = require(\"../util/number\");\n\nvar formatUtil = require(\"../util/format\");\n\nvar scaleHelper = require(\"./helper\");\n\nvar IntervalScale = require(\"./Interval\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/*\n* A third-party license is embeded for some of the code in this file:\n* The \"scaleLevels\" was originally copied from \"d3.js\" with some\n* modifications made for this project.\n* (See more details in the comment on the definition of \"scaleLevels\" below.)\n* The use of the source code of this file is also subject to the terms\n* and consitions of the license of \"d3.js\" (BSD-3Clause, see\n* ).\n*/\n// [About UTC and local time zone]:\n// In most cases, `number.parseDate` will treat input data string as local time\n// (except time zone is specified in time string). And `format.formateTime` returns\n// local time by default. option.useUTC is false by default. This design have\n// concidered these common case:\n// (1) Time that is persistent in server is in UTC, but it is needed to be diplayed\n// in local time by default.\n// (2) By default, the input data string (e.g., '2011-01-02') should be displayed\n// as its original time, without any time difference.\nvar intervalScaleProto = IntervalScale.prototype;\nvar mathCeil = Math.ceil;\nvar mathFloor = Math.floor;\nvar ONE_SECOND = 1000;\nvar ONE_MINUTE = ONE_SECOND * 60;\nvar ONE_HOUR = ONE_MINUTE * 60;\nvar ONE_DAY = ONE_HOUR * 24; // FIXME 公用？\n\nvar bisect = function (a, x, lo, hi) {\n while (lo < hi) {\n var mid = lo + hi >>> 1;\n\n if (a[mid][1] < x) {\n lo = mid + 1;\n } else {\n hi = mid;\n }\n }\n\n return lo;\n};\n/**\n * @alias module:echarts/coord/scale/Time\n * @constructor\n */\n\n\nvar TimeScale = IntervalScale.extend({\n type: 'time',\n\n /**\n * @override\n */\n getLabel: function (val) {\n var stepLvl = this._stepLvl;\n var date = new Date(val);\n return formatUtil.formatTime(stepLvl[0], date, this.getSetting('useUTC'));\n },\n\n /**\n * @override\n */\n niceExtent: function (opt) {\n var extent = this._extent; // If extent start and end are same, expand them\n\n if (extent[0] === extent[1]) {\n // Expand extent\n extent[0] -= ONE_DAY;\n extent[1] += ONE_DAY;\n } // If there are no data and extent are [Infinity, -Infinity]\n\n\n if (extent[1] === -Infinity && extent[0] === Infinity) {\n var d = new Date();\n extent[1] = +new Date(d.getFullYear(), d.getMonth(), d.getDate());\n extent[0] = extent[1] - ONE_DAY;\n }\n\n this.niceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval); // var extent = this._extent;\n\n var interval = this._interval;\n\n if (!opt.fixMin) {\n extent[0] = numberUtil.round(mathFloor(extent[0] / interval) * interval);\n }\n\n if (!opt.fixMax) {\n extent[1] = numberUtil.round(mathCeil(extent[1] / interval) * interval);\n }\n },\n\n /**\n * @override\n */\n niceTicks: function (approxTickNum, minInterval, maxInterval) {\n approxTickNum = approxTickNum || 10;\n var extent = this._extent;\n var span = extent[1] - extent[0];\n var approxInterval = span / approxTickNum;\n\n if (minInterval != null && approxInterval < minInterval) {\n approxInterval = minInterval;\n }\n\n if (maxInterval != null && approxInterval > maxInterval) {\n approxInterval = maxInterval;\n }\n\n var scaleLevelsLen = scaleLevels.length;\n var idx = bisect(scaleLevels, approxInterval, 0, scaleLevelsLen);\n var level = scaleLevels[Math.min(idx, scaleLevelsLen - 1)];\n var interval = level[1]; // Same with interval scale if span is much larger than 1 year\n\n if (level[0] === 'year') {\n var yearSpan = span / interval; // From \"Nice Numbers for Graph Labels\" of Graphic Gems\n // var niceYearSpan = numberUtil.nice(yearSpan, false);\n\n var yearStep = numberUtil.nice(yearSpan / approxTickNum, true);\n interval *= yearStep;\n }\n\n var timezoneOffset = this.getSetting('useUTC') ? 0 : new Date(+extent[0] || +extent[1]).getTimezoneOffset() * 60 * 1000;\n var niceExtent = [Math.round(mathCeil((extent[0] - timezoneOffset) / interval) * interval + timezoneOffset), Math.round(mathFloor((extent[1] - timezoneOffset) / interval) * interval + timezoneOffset)];\n scaleHelper.fixExtent(niceExtent, extent);\n this._stepLvl = level; // Interval will be used in getTicks\n\n this._interval = interval;\n this._niceExtent = niceExtent;\n },\n parse: function (val) {\n // val might be float.\n return +numberUtil.parseDate(val);\n }\n});\nzrUtil.each(['contain', 'normalize'], function (methodName) {\n TimeScale.prototype[methodName] = function (val) {\n return intervalScaleProto[methodName].call(this, this.parse(val));\n };\n});\n/**\n * This implementation was originally copied from \"d3.js\"\n * \n * with some modifications made for this program.\n * See the license statement at the head of this file.\n */\n\nvar scaleLevels = [// Format interval\n['hh:mm:ss', ONE_SECOND], // 1s\n['hh:mm:ss', ONE_SECOND * 5], // 5s\n['hh:mm:ss', ONE_SECOND * 10], // 10s\n['hh:mm:ss', ONE_SECOND * 15], // 15s\n['hh:mm:ss', ONE_SECOND * 30], // 30s\n['hh:mm\\nMM-dd', ONE_MINUTE], // 1m\n['hh:mm\\nMM-dd', ONE_MINUTE * 5], // 5m\n['hh:mm\\nMM-dd', ONE_MINUTE * 10], // 10m\n['hh:mm\\nMM-dd', ONE_MINUTE * 15], // 15m\n['hh:mm\\nMM-dd', ONE_MINUTE * 30], // 30m\n['hh:mm\\nMM-dd', ONE_HOUR], // 1h\n['hh:mm\\nMM-dd', ONE_HOUR * 2], // 2h\n['hh:mm\\nMM-dd', ONE_HOUR * 6], // 6h\n['hh:mm\\nMM-dd', ONE_HOUR * 12], // 12h\n['MM-dd\\nyyyy', ONE_DAY], // 1d\n['MM-dd\\nyyyy', ONE_DAY * 2], // 2d\n['MM-dd\\nyyyy', ONE_DAY * 3], // 3d\n['MM-dd\\nyyyy', ONE_DAY * 4], // 4d\n['MM-dd\\nyyyy', ONE_DAY * 5], // 5d\n['MM-dd\\nyyyy', ONE_DAY * 6], // 6d\n['week', ONE_DAY * 7], // 7d\n['MM-dd\\nyyyy', ONE_DAY * 10], // 10d\n['week', ONE_DAY * 14], // 2w\n['week', ONE_DAY * 21], // 3w\n['month', ONE_DAY * 31], // 1M\n['week', ONE_DAY * 42], // 6w\n['month', ONE_DAY * 62], // 2M\n['week', ONE_DAY * 70], // 10w\n['quarter', ONE_DAY * 95], // 3M\n['month', ONE_DAY * 31 * 4], // 4M\n['month', ONE_DAY * 31 * 5], // 5M\n['half-year', ONE_DAY * 380 / 2], // 6M\n['month', ONE_DAY * 31 * 8], // 8M\n['month', ONE_DAY * 31 * 10], // 10M\n['year', ONE_DAY * 380] // 1Y\n];\n/**\n * @param {module:echarts/model/Model}\n * @return {module:echarts/scale/Time}\n */\n\nTimeScale.create = function (model) {\n return new TimeScale({\n useUTC: model.ecModel.get('useUTC')\n });\n};\n\nvar _default = TimeScale;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar numberUtil = require(\"../util/number\");\n\nvar formatUtil = require(\"../util/format\");\n\nvar Scale = require(\"./Scale\");\n\nvar helper = require(\"./helper\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Interval scale\n * @module echarts/scale/Interval\n */\nvar roundNumber = numberUtil.round;\n/**\n * @alias module:echarts/coord/scale/Interval\n * @constructor\n */\n\nvar IntervalScale = Scale.extend({\n type: 'interval',\n _interval: 0,\n _intervalPrecision: 2,\n setExtent: function (start, end) {\n var thisExtent = this._extent; //start,end may be a Number like '25',so...\n\n if (!isNaN(start)) {\n thisExtent[0] = parseFloat(start);\n }\n\n if (!isNaN(end)) {\n thisExtent[1] = parseFloat(end);\n }\n },\n unionExtent: function (other) {\n var extent = this._extent;\n other[0] < extent[0] && (extent[0] = other[0]);\n other[1] > extent[1] && (extent[1] = other[1]); // unionExtent may called by it's sub classes\n\n IntervalScale.prototype.setExtent.call(this, extent[0], extent[1]);\n },\n\n /**\n * Get interval\n */\n getInterval: function () {\n return this._interval;\n },\n\n /**\n * Set interval\n */\n setInterval: function (interval) {\n this._interval = interval; // Dropped auto calculated niceExtent and use user setted extent\n // We assume user wan't to set both interval, min, max to get a better result\n\n this._niceExtent = this._extent.slice();\n this._intervalPrecision = helper.getIntervalPrecision(interval);\n },\n\n /**\n * @param {boolean} [expandToNicedExtent=false] If expand the ticks to niced extent.\n * @return {Array.}\n */\n getTicks: function (expandToNicedExtent) {\n var interval = this._interval;\n var extent = this._extent;\n var niceTickExtent = this._niceExtent;\n var intervalPrecision = this._intervalPrecision;\n var ticks = []; // If interval is 0, return [];\n\n if (!interval) {\n return ticks;\n } // Consider this case: using dataZoom toolbox, zoom and zoom.\n\n\n var safeLimit = 10000;\n\n if (extent[0] < niceTickExtent[0]) {\n if (expandToNicedExtent) {\n ticks.push(roundNumber(niceTickExtent[0] - interval, intervalPrecision));\n } else {\n ticks.push(extent[0]);\n }\n }\n\n var tick = niceTickExtent[0];\n\n while (tick <= niceTickExtent[1]) {\n ticks.push(tick); // Avoid rounding error\n\n tick = roundNumber(tick + interval, intervalPrecision);\n\n if (tick === ticks[ticks.length - 1]) {\n // Consider out of safe float point, e.g.,\n // -3711126.9907707 + 2e-10 === -3711126.9907707\n break;\n }\n\n if (ticks.length > safeLimit) {\n return [];\n }\n } // Consider this case: the last item of ticks is smaller\n // than niceTickExtent[1] and niceTickExtent[1] === extent[1].\n\n\n var lastNiceTick = ticks.length ? ticks[ticks.length - 1] : niceTickExtent[1];\n\n if (extent[1] > lastNiceTick) {\n if (expandToNicedExtent) {\n ticks.push(roundNumber(lastNiceTick + interval, intervalPrecision));\n } else {\n ticks.push(extent[1]);\n }\n }\n\n return ticks;\n },\n\n /**\n * @param {number} [splitNumber=5]\n * @return {Array.>}\n */\n getMinorTicks: function (splitNumber) {\n var ticks = this.getTicks(true);\n var minorTicks = [];\n var extent = this.getExtent();\n\n for (var i = 1; i < ticks.length; i++) {\n var nextTick = ticks[i];\n var prevTick = ticks[i - 1];\n var count = 0;\n var minorTicksGroup = [];\n var interval = nextTick - prevTick;\n var minorInterval = interval / splitNumber;\n\n while (count < splitNumber - 1) {\n var minorTick = numberUtil.round(prevTick + (count + 1) * minorInterval); // For the first and last interval. The count may be less than splitNumber.\n\n if (minorTick > extent[0] && minorTick < extent[1]) {\n minorTicksGroup.push(minorTick);\n }\n\n count++;\n }\n\n minorTicks.push(minorTicksGroup);\n }\n\n return minorTicks;\n },\n\n /**\n * @param {number} data\n * @param {Object} [opt]\n * @param {number|string} [opt.precision] If 'auto', use nice presision.\n * @param {boolean} [opt.pad] returns 1.50 but not 1.5 if precision is 2.\n * @return {string}\n */\n getLabel: function (data, opt) {\n if (data == null) {\n return '';\n }\n\n var precision = opt && opt.precision;\n\n if (precision == null) {\n precision = numberUtil.getPrecisionSafe(data) || 0;\n } else if (precision === 'auto') {\n // Should be more precise then tick.\n precision = this._intervalPrecision;\n } // (1) If `precision` is set, 12.005 should be display as '12.00500'.\n // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'.\n\n\n data = roundNumber(data, precision, true);\n return formatUtil.addCommas(data);\n },\n\n /**\n * Update interval and extent of intervals for nice ticks\n *\n * @param {number} [splitNumber = 5] Desired number of ticks\n * @param {number} [minInterval]\n * @param {number} [maxInterval]\n */\n niceTicks: function (splitNumber, minInterval, maxInterval) {\n splitNumber = splitNumber || 5;\n var extent = this._extent;\n var span = extent[1] - extent[0];\n\n if (!isFinite(span)) {\n return;\n } // User may set axis min 0 and data are all negative\n // FIXME If it needs to reverse ?\n\n\n if (span < 0) {\n span = -span;\n extent.reverse();\n }\n\n var result = helper.intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval);\n this._intervalPrecision = result.intervalPrecision;\n this._interval = result.interval;\n this._niceExtent = result.niceTickExtent;\n },\n\n /**\n * Nice extent.\n * @param {Object} opt\n * @param {number} [opt.splitNumber = 5] Given approx tick number\n * @param {boolean} [opt.fixMin=false]\n * @param {boolean} [opt.fixMax=false]\n * @param {boolean} [opt.minInterval]\n * @param {boolean} [opt.maxInterval]\n */\n niceExtent: function (opt) {\n var extent = this._extent; // If extent start and end are same, expand them\n\n if (extent[0] === extent[1]) {\n if (extent[0] !== 0) {\n // Expand extent\n var expandSize = extent[0]; // In the fowllowing case\n // Axis has been fixed max 100\n // Plus data are all 100 and axis extent are [100, 100].\n // Extend to the both side will cause expanded max is larger than fixed max.\n // So only expand to the smaller side.\n\n if (!opt.fixMax) {\n extent[1] += expandSize / 2;\n extent[0] -= expandSize / 2;\n } else {\n extent[0] -= expandSize / 2;\n }\n } else {\n extent[1] = 1;\n }\n }\n\n var span = extent[1] - extent[0]; // If there are no data and extent are [Infinity, -Infinity]\n\n if (!isFinite(span)) {\n extent[0] = 0;\n extent[1] = 1;\n }\n\n this.niceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval); // var extent = this._extent;\n\n var interval = this._interval;\n\n if (!opt.fixMin) {\n extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);\n }\n\n if (!opt.fixMax) {\n extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);\n }\n }\n});\n/**\n * @return {module:echarts/scale/Time}\n */\n\nIntervalScale.create = function () {\n return new IntervalScale();\n};\n\nvar _default = IntervalScale;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = require(\"zrender/lib/core/util\");\n\nvar Scale = require(\"./Scale\");\n\nvar numberUtil = require(\"../util/number\");\n\nvar IntervalScale = require(\"./Interval\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Log scale\n * @module echarts/scale/Log\n */\n// Use some method of IntervalScale\nvar scaleProto = Scale.prototype;\nvar intervalScaleProto = IntervalScale.prototype;\nvar getPrecisionSafe = numberUtil.getPrecisionSafe;\nvar roundingErrorFix = numberUtil.round;\nvar mathFloor = Math.floor;\nvar mathCeil = Math.ceil;\nvar mathPow = Math.pow;\nvar mathLog = Math.log;\nvar LogScale = Scale.extend({\n type: 'log',\n base: 10,\n $constructor: function () {\n Scale.apply(this, arguments);\n this._originalScale = new IntervalScale();\n },\n\n /**\n * @param {boolean} [expandToNicedExtent=false] If expand the ticks to niced extent.\n * @return {Array.}\n */\n getTicks: function (expandToNicedExtent) {\n var originalScale = this._originalScale;\n var extent = this._extent;\n var originalExtent = originalScale.getExtent();\n return zrUtil.map(intervalScaleProto.getTicks.call(this, expandToNicedExtent), function (val) {\n var powVal = numberUtil.round(mathPow(this.base, val)); // Fix #4158\n\n powVal = val === extent[0] && originalScale.__fixMin ? fixRoundingError(powVal, originalExtent[0]) : powVal;\n powVal = val === extent[1] && originalScale.__fixMax ? fixRoundingError(powVal, originalExtent[1]) : powVal;\n return powVal;\n }, this);\n },\n\n /**\n * @param {number} splitNumber\n * @return {Array.>}\n */\n getMinorTicks: intervalScaleProto.getMinorTicks,\n\n /**\n * @param {number} val\n * @return {string}\n */\n getLabel: intervalScaleProto.getLabel,\n\n /**\n * @param {number} val\n * @return {number}\n */\n scale: function (val) {\n val = scaleProto.scale.call(this, val);\n return mathPow(this.base, val);\n },\n\n /**\n * @param {number} start\n * @param {number} end\n */\n setExtent: function (start, end) {\n var base = this.base;\n start = mathLog(start) / mathLog(base);\n end = mathLog(end) / mathLog(base);\n intervalScaleProto.setExtent.call(this, start, end);\n },\n\n /**\n * @return {number} end\n */\n getExtent: function () {\n var base = this.base;\n var extent = scaleProto.getExtent.call(this);\n extent[0] = mathPow(base, extent[0]);\n extent[1] = mathPow(base, extent[1]); // Fix #4158\n\n var originalScale = this._originalScale;\n var originalExtent = originalScale.getExtent();\n originalScale.__fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));\n originalScale.__fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));\n return extent;\n },\n\n /**\n * @param {Array.} extent\n */\n unionExtent: function (extent) {\n this._originalScale.unionExtent(extent);\n\n var base = this.base;\n extent[0] = mathLog(extent[0]) / mathLog(base);\n extent[1] = mathLog(extent[1]) / mathLog(base);\n scaleProto.unionExtent.call(this, extent);\n },\n\n /**\n * @override\n */\n unionExtentFromData: function (data, dim) {\n // TODO\n // filter value that <= 0\n this.unionExtent(data.getApproximateExtent(dim));\n },\n\n /**\n * Update interval and extent of intervals for nice ticks\n * @param {number} [approxTickNum = 10] Given approx tick number\n */\n niceTicks: function (approxTickNum) {\n approxTickNum = approxTickNum || 10;\n var extent = this._extent;\n var span = extent[1] - extent[0];\n\n if (span === Infinity || span <= 0) {\n return;\n }\n\n var interval = numberUtil.quantity(span);\n var err = approxTickNum / span * interval; // Filter ticks to get closer to the desired count.\n\n if (err <= 0.5) {\n interval *= 10;\n } // Interval should be integer\n\n\n while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {\n interval *= 10;\n }\n\n var niceExtent = [numberUtil.round(mathCeil(extent[0] / interval) * interval), numberUtil.round(mathFloor(extent[1] / interval) * interval)];\n this._interval = interval;\n this._niceExtent = niceExtent;\n },\n\n /**\n * Nice extent.\n * @override\n */\n niceExtent: function (opt) {\n intervalScaleProto.niceExtent.call(this, opt);\n var originalScale = this._originalScale;\n originalScale.__fixMin = opt.fixMin;\n originalScale.__fixMax = opt.fixMax;\n }\n});\nzrUtil.each(['contain', 'normalize'], function (methodName) {\n LogScale.prototype[methodName] = function (val) {\n val = mathLog(val) / mathLog(this.base);\n return scaleProto[methodName].call(this, val);\n };\n});\n\nLogScale.create = function () {\n return new LogScale();\n};\n\nfunction fixRoundingError(val, originalVal) {\n return roundingErrorFix(val, getPrecisionSafe(originalVal));\n}\n\nvar _default = LogScale;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar numberUtil = require(\"../util/number\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * For testable.\n */\nvar roundNumber = numberUtil.round;\n/**\n * @param {Array.} extent Both extent[0] and extent[1] should be valid number.\n * Should be extent[0] < extent[1].\n * @param {number} splitNumber splitNumber should be >= 1.\n * @param {number} [minInterval]\n * @param {number} [maxInterval]\n * @return {Object} {interval, intervalPrecision, niceTickExtent}\n */\n\nfunction intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval) {\n var result = {};\n var span = extent[1] - extent[0];\n var interval = result.interval = numberUtil.nice(span / splitNumber, true);\n\n if (minInterval != null && interval < minInterval) {\n interval = result.interval = minInterval;\n }\n\n if (maxInterval != null && interval > maxInterval) {\n interval = result.interval = maxInterval;\n } // Tow more digital for tick.\n\n\n var precision = result.intervalPrecision = getIntervalPrecision(interval); // Niced extent inside original extent\n\n var niceTickExtent = result.niceTickExtent = [roundNumber(Math.ceil(extent[0] / interval) * interval, precision), roundNumber(Math.floor(extent[1] / interval) * interval, precision)];\n fixExtent(niceTickExtent, extent);\n return result;\n}\n/**\n * @param {number} interval\n * @return {number} interval precision\n */\n\n\nfunction getIntervalPrecision(interval) {\n // Tow more digital for tick.\n return numberUtil.getPrecisionSafe(interval) + 2;\n}\n\nfunction clamp(niceTickExtent, idx, extent) {\n niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]);\n} // In some cases (e.g., splitNumber is 1), niceTickExtent may be out of extent.\n\n\nfunction fixExtent(niceTickExtent, extent) {\n !isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]);\n !isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]);\n clamp(niceTickExtent, 0, extent);\n clamp(niceTickExtent, 1, extent);\n\n if (niceTickExtent[0] > niceTickExtent[1]) {\n niceTickExtent[0] = niceTickExtent[1];\n }\n}\n\nexports.intervalScaleNiceTicks = intervalScaleNiceTicks;\nexports.getIntervalPrecision = getIntervalPrecision;\nexports.fixExtent = fixExtent;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar each = _util.each;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// (1) [Caution]: the logic is correct based on the premises:\n// data processing stage is blocked in stream.\n// See \n// (2) Only register once when import repeatly.\n// Should be executed after series filtered and before stack calculation.\nfunction _default(ecModel) {\n var stackInfoMap = createHashMap();\n ecModel.eachSeries(function (seriesModel) {\n var stack = seriesModel.get('stack'); // Compatibal: when `stack` is set as '', do not stack.\n\n if (stack) {\n var stackInfoList = stackInfoMap.get(stack) || stackInfoMap.set(stack, []);\n var data = seriesModel.getData();\n var stackInfo = {\n // Used for calculate axis extent automatically.\n stackResultDimension: data.getCalculationInfo('stackResultDimension'),\n stackedOverDimension: data.getCalculationInfo('stackedOverDimension'),\n stackedDimension: data.getCalculationInfo('stackedDimension'),\n stackedByDimension: data.getCalculationInfo('stackedByDimension'),\n isStackedByIndex: data.getCalculationInfo('isStackedByIndex'),\n data: data,\n seriesModel: seriesModel\n }; // If stacked on axis that do not support data stack.\n\n if (!stackInfo.stackedDimension || !(stackInfo.isStackedByIndex || stackInfo.stackedByDimension)) {\n return;\n }\n\n stackInfoList.length && data.setCalculationInfo('stackedOnSeries', stackInfoList[stackInfoList.length - 1].seriesModel);\n stackInfoList.push(stackInfo);\n }\n });\n stackInfoMap.each(calculateStack);\n}\n\nfunction calculateStack(stackInfoList) {\n each(stackInfoList, function (targetStackInfo, idxInStack) {\n var resultVal = [];\n var resultNaN = [NaN, NaN];\n var dims = [targetStackInfo.stackResultDimension, targetStackInfo.stackedOverDimension];\n var targetData = targetStackInfo.data;\n var isStackedByIndex = targetStackInfo.isStackedByIndex; // Should not write on raw data, because stack series model list changes\n // depending on legend selection.\n\n var newData = targetData.map(dims, function (v0, v1, dataIndex) {\n var sum = targetData.get(targetStackInfo.stackedDimension, dataIndex); // Consider `connectNulls` of line area, if value is NaN, stackedOver\n // should also be NaN, to draw a appropriate belt area.\n\n if (isNaN(sum)) {\n return resultNaN;\n }\n\n var byValue;\n var stackedDataRawIndex;\n\n if (isStackedByIndex) {\n stackedDataRawIndex = targetData.getRawIndex(dataIndex);\n } else {\n byValue = targetData.get(targetStackInfo.stackedByDimension, dataIndex);\n } // If stackOver is NaN, chart view will render point on value start.\n\n\n var stackedOver = NaN;\n\n for (var j = idxInStack - 1; j >= 0; j--) {\n var stackInfo = stackInfoList[j]; // Has been optimized by inverted indices on `stackedByDimension`.\n\n if (!isStackedByIndex) {\n stackedDataRawIndex = stackInfo.data.rawIndexOf(stackInfo.stackedByDimension, byValue);\n }\n\n if (stackedDataRawIndex >= 0) {\n var val = stackInfo.data.getByRawIndex(stackInfo.stackResultDimension, stackedDataRawIndex); // Considering positive stack, negative stack and empty data\n\n if (sum >= 0 && val > 0 || // Positive stack\n sum <= 0 && val < 0 // Negative stack\n ) {\n sum += val;\n stackedOver = val;\n break;\n }\n }\n }\n\n resultVal[0] = sum;\n resultVal[1] = stackedOver;\n return resultVal;\n });\n targetData.hostModel.setData(newData); // Update for consequent calculation\n\n targetStackInfo.data = newData;\n });\n}\n\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar clazzUtil = require(\"../util/clazz\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements. See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership. The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied. See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * // Scale class management\n * @module echarts/scale/Scale\n */\n\n/**\n * @param {Object} [setting]\n */\nfunction Scale(setting) {\n this._setting = setting || {};\n /**\n * Extent\n * @type {Array.}\n * @protected\n */\n\n this._extent = [Infinity, -Infinity];\n /**\n * Step is calculated in adjustExtent\n * @type {Array.}\n * @protected\n */\n\n this._interval = 0;\n this.init && this.init.apply(this, arguments);\n}\n/**\n * Parse input val to valid inner number.\n * @param {*} val\n * @return {number}\n */\n\n\nScale.prototype.parse = function (val) {\n // Notice: This would be a trap here, If the implementation\n // of this method depends on extent, and this method is used\n // before extent set (like in dataZoom), it would be wrong.\n // Nevertheless, parse does not depend on extent generally.\n return val;\n};\n\nScale.prototype.getSetting = function (name) {\n return this._setting[name];\n};\n\nScale.prototype.contain = function (val) {\n var extent = this._extent;\n return val >= extent[0] && val <= extent[1];\n};\n/**\n * Normalize value to linear [0, 1], return 0.5 if extent span is 0\n * @param {number} val\n * @return {number}\n */\n\n\nScale.prototype.normalize = function (val) {\n var extent = this._extent;\n\n if (extent[1] === extent[0]) {\n return 0.5;\n }\n\n return (val - extent[0]) / (extent[1] - extent[0]);\n};\n/**\n * Scale normalized value\n * @param {number} val\n * @return {number}\n */\n\n\nScale.prototype.scale = function (val) {\n var extent = this._extent;\n return val * (extent[1] - extent[0]) + extent[0];\n};\n/**\n * Set extent from data\n * @param {Array.} other\n */\n\n\nScale.prototype.unionExtent = function (other) {\n var extent = this._extent;\n other[0] < extent[0] && (extent[0] = other[0]);\n other[1] > extent[1] && (extent[1] = other[1]); // not setExtent because in log axis it may transformed to power\n // this.setExtent(extent[0], extent[1]);\n};\n/**\n * Set extent from data\n * @param {module:echarts/data/List} data\n * @param {string} dim\n */\n\n\nScale.prototype.unionExtentFromData = function (data, dim) {\n this.unionExtent(data.getApproximateExtent(dim));\n};\n/**\n * Get extent\n * @return {Array.}\n */\n\n\nScale.prototype.getExtent = function () {\n return this._extent.slice();\n};\n/**\n * Set extent\n * @param {number} start\n * @param {number} end\n */\n\n\nScale.prototype.setExtent = function (start, end) {\n var thisExtent = this._extent;\n\n if (!isNaN(start)) {\n thisExtent[0] = start;\n }\n\n if (!isNaN(end)) {\n thisExtent[1] = end;\n }\n};\n/**\n * When axis extent depends on data and no data exists,\n * axis ticks should not be drawn, which is named 'blank'.\n */\n\n\nScale.prototype.isBlank = function () {\n return this._isBlank;\n},\n/**\n * When axis extent depends on data and no data exists,\n * axis ticks should not be drawn, which is named 'blank'.\n */\nScale.prototype.setBlank = function (isBlank) {\n this._isBlank = isBlank;\n};\n/**\n * @abstract\n * @param {*} tick\n * @return {string} label of the tick.\n */\n\nScale.prototype.getLabel = null;\nclazzUtil.enableClassExtend(Scale);\nclazzUtil.enableClassManagement(Scale, {\n registerWhenExtend: true\n});\nvar _default = Scale;\nmodule.exports = _default;"],"sourceRoot":""}