echarts 4.2.0-rc.2 → 4.2.1

package/lib/component/axis/AxisBuilder.js

@@ -46,6 +46,10 @@ var _vector = require("zrender/lib/core/vector");
 
 var v2ApplyTransform = _vector.applyTransform;
 
+var _axisHelper = require("../../coord/axisHelper");
+
+var shouldShowAllLabels = _axisHelper.shouldShowAllLabels;
+
 /*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
@@ -238,7 +242,8 @@ var builders = {
           symbol.attr({
             rotation: point.rotate,
             position: pos,
-            silent: true
+            silent: true,
+            z2: 11
           });
           this.group.add(symbol);
         }
@@ -438,9 +443,13 @@ function isSilent(axisModel) {
 }
 
 function fixMinMaxLabelShow(axisModel, labelEls, tickEls) {
-  // If min or max are user set, we need to check
+  if (shouldShowAllLabels(axisModel.axis)) {
+    return;
+  } // If min or max are user set, we need to check
   // If the tick on min(max) are overlap on their neighbour tick
   // If they are overlapped, we need to hide the min(max) tick label
+
+
   var showMinLabel = axisModel.get('axisLabel.showMinLabel');
   var showMaxLabel = axisModel.get('axisLabel.showMaxLabel'); // FIXME
   // Have not consider onBand yet, where tick els is more than label els.

package/lib/component/helper/MapDraw.js

@@ -300,6 +300,10 @@ MapDraw.prototype = {
 
         var textEl = new graphic.Text({
           position: region.center.slice(),
+          // FIXME
+          // label rotation is not support yet in geo or regions of series-map
+          // that has no data. The rotation will be effected by this `scale`.
+          // So needed to change to RectText?
           scale: [1 / scale[0], 1 / scale[1]],
           z2: 10,
           silent: true

package/lib/component/helper/RoamController.js

@@ -149,7 +149,7 @@ function RoamController(zr) {
 zrUtil.mixin(RoamController, Eventful);
 
 function mousedown(e) {
-  if (eventTool.notLeftMouse(e) || e.target && e.target.draggable) {
+  if (eventTool.isMiddleOrRightButtonOnMouseUpDown(e) || e.target && e.target.draggable) {
     return;
   }
 
@@ -165,7 +165,7 @@ function mousedown(e) {
 }
 
 function mousemove(e) {
-  if (eventTool.notLeftMouse(e) || !isAvailableBehavior('moveOnMouseMove', e, this._opt) || !this._dragging || e.gestureEvent === 'pinch' || interactionMutex.isTaken(this._zr, 'globalPan')) {
+  if (!this._dragging || !isAvailableBehavior('moveOnMouseMove', e, this._opt) || e.gestureEvent === 'pinch' || interactionMutex.isTaken(this._zr, 'globalPan')) {
     return;
   }
 
@@ -189,7 +189,7 @@ function mousemove(e) {
 }
 
 function mouseup(e) {
-  if (!eventTool.notLeftMouse(e)) {
+  if (!eventTool.isMiddleOrRightButtonOnMouseUpDown(e)) {
     this._dragging = false;
   }
 }

package/lib/component/legend/LegendView.js

@@ -79,6 +79,14 @@ var _default = echarts.extendComponentView({
      */
 
     this._backgroundEl;
+    /**
+     * If first rendering, `contentGroup.position` is [0, 0], which
+     * does not make sense and may cause unexepcted animation if adopted.
+     * @private
+     * @type {boolean}
+     */
+
+    this._isFirstRender = true;
   },
 
   /**
@@ -92,6 +100,8 @@ var _default = echarts.extendComponentView({
    * @override
    */
   render: function (legendModel, ecModel, api) {
+    var isFirstRender = this._isFirstRender;
+    this._isFirstRender = false;
     this.resetInner();
 
     if (!legendModel.get('show', true)) {
@@ -113,7 +123,7 @@ var _default = echarts.extendComponentView({
     };
     var padding = legendModel.get('padding');
     var maxSize = layoutUtil.getLayoutRect(positionInfo, viewportSize, padding);
-    var mainRect = this.layoutInner(legendModel, itemAlign, maxSize); // Place mainGroup, based on the calculated `mainRect`.
+    var mainRect = this.layoutInner(legendModel, itemAlign, maxSize, isFirstRender); // Place mainGroup, based on the calculated `mainRect`.
 
     var layoutRect = layoutUtil.getLayoutRect(zrUtil.defaults({
       width: mainRect.width,
@@ -300,6 +310,14 @@ var _default = echarts.extendComponentView({
     var contentRect = contentGroup.getBoundingRect();
     contentGroup.attr('position', [-contentRect.x, -contentRect.y]);
     return this.group.getBoundingRect();
+  },
+
+  /**
+   * @protected
+   */
+  remove: function () {
+    this.getContentGroup().removeAll();
+    this._isFirstRender = true;
   }
 });
 

package/lib/component/legend/ScrollableLegendView.js

@@ -105,7 +105,9 @@ var ScrollableLegendView = LegendView.extend({
     var me = this; // Render content items.
 
     ScrollableLegendView.superCall(this, 'renderInner', itemAlign, legendModel, ecModel, api);
-    var controllerGroup = this._controllerGroup;
+    var controllerGroup = this._controllerGroup; // FIXME: support be 'auto' adapt to size number text length,
+    // e.g., '3/12345' should not overlap with the control arrow button.
+
     var pageIconSize = legendModel.get('pageIconSize', true);
 
     if (!zrUtil.isArray(pageIconSize)) {
@@ -146,7 +148,7 @@ var ScrollableLegendView = LegendView.extend({
   /**
    * @override
    */
-  layoutInner: function (legendModel, itemAlign, maxSize) {
+  layoutInner: function (legendModel, itemAlign, maxSize, isFirstRender) {
     var contentGroup = this.getContentGroup();
     var containerGroup = this._containerGroup;
     var controllerGroup = this._controllerGroup;
@@ -162,8 +164,13 @@ var ScrollableLegendView = LegendView.extend({
     var controllerRect = controllerGroup.getBoundingRect();
     var showController = this._showController = contentRect[wh] > maxSize[wh];
     var contentPos = [-contentRect.x, -contentRect.y]; // Remain contentPos when scroll animation perfroming.
+    // If first rendering, `contentGroup.position` is [0, 0], which
+    // does not make sense and may cause unexepcted animation if adopted.
+
+    if (!isFirstRender) {
+      contentPos[orientIdx] = contentGroup.position[orientIdx];
+    } // Layout container group based on 0.
 
-    contentPos[orientIdx] = contentGroup.position[orientIdx]; // Layout container group based on 0.
 
     var containerPos = [0, 0];
     var controllerPos = [-controllerRect.x, -controllerRect.y];
@@ -278,95 +285,123 @@ var ScrollableLegendView = LegendView.extend({
    * }
    */
   _getPageInfo: function (legendModel) {
-    // Align left or top by the current dataIndex.
-    var currDataIndex = legendModel.get('scrollDataIndex', true);
+    var scrollDataIndex = legendModel.get('scrollDataIndex', true);
     var contentGroup = this.getContentGroup();
-    var contentRect = contentGroup.getBoundingRect();
     var containerRectSize = this._containerGroup.__rectSize;
     var orientIdx = legendModel.getOrient().index;
     var wh = WH[orientIdx];
-    var hw = WH[1 - orientIdx];
     var xy = XY[orientIdx];
-    var contentPos = contentGroup.position.slice();
-    var pageIndex;
-    var pagePrevDataIndex;
-    var pageNextDataIndex;
-    var targetItemGroup;
 
-    if (this._showController) {
-      contentGroup.eachChild(function (child) {
-        if (child.__legendDataIndex === currDataIndex) {
-          targetItemGroup = child;
-        }
-      });
-    } else {
-      targetItemGroup = contentGroup.childAt(0);
+    var targetItemIndex = this._findTargetItemIndex(scrollDataIndex);
+
+    var children = contentGroup.children();
+    var targetItem = children[targetItemIndex];
+    var itemCount = children.length;
+    var pCount = !itemCount ? 0 : 1;
+    var result = {
+      contentPosition: contentGroup.position.slice(),
+      pageCount: pCount,
+      pageIndex: pCount - 1,
+      pagePrevDataIndex: null,
+      pageNextDataIndex: null
+    };
+
+    if (!targetItem) {
+      return result;
     }
 
-    var pageCount = containerRectSize ? Math.ceil(contentRect[wh] / containerRectSize) : 0;
+    var targetItemInfo = getItemInfo(targetItem);
+    result.contentPosition[orientIdx] = -targetItemInfo.s; // Strategy:
+    // (1) Always align based on the left/top most item.
+    // (2) It is user-friendly that the last item shown in the
+    // current window is shown at the begining of next window.
+    // Otherwise if half of the last item is cut by the window,
+    // it will have no chance to display entirely.
+    // (3) Consider that item size probably be different, we
+    // have calculate pageIndex by size rather than item index,
+    // and we can not get page index directly by division.
+    // (4) The window is to narrow to contain more than
+    // one item, we should make sure that the page can be fliped.
+
+    for (var i = targetItemIndex + 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i <= itemCount; ++i) {
+      currItemInfo = getItemInfo(children[i]);
+
+      if ( // Half of the last item is out of the window.
+      !currItemInfo && winEndItemInfo.e > winStartItemInfo.s + containerRectSize || // If the current item does not intersect with the window, the new page
+      // can be started at the current item or the last item.
+      currItemInfo && !intersect(currItemInfo, winStartItemInfo.s)) {
+        if (winEndItemInfo.i > winStartItemInfo.i) {
+          winStartItemInfo = winEndItemInfo;
+        } else {
+          // e.g., when page size is smaller than item size.
+          winStartItemInfo = currItemInfo;
+        }
 
-    if (targetItemGroup) {
-      var itemRect = targetItemGroup.getBoundingRect();
-      var itemLoc = targetItemGroup.position[orientIdx] + itemRect[xy];
-      contentPos[orientIdx] = -itemLoc - contentRect[xy];
-      pageIndex = Math.floor(pageCount * (itemLoc + itemRect[xy] + containerRectSize / 2) / contentRect[wh]);
-      pageIndex = contentRect[wh] && pageCount ? Math.max(0, Math.min(pageCount - 1, pageIndex)) : -1;
-      var winRect = {
-        x: 0,
-        y: 0
-      };
-      winRect[wh] = containerRectSize;
-      winRect[hw] = contentRect[hw];
-      winRect[xy] = -contentPos[orientIdx] - contentRect[xy];
-      var startIdx;
-      var children = contentGroup.children();
-      contentGroup.eachChild(function (child, index) {
-        var itemRect = getItemRect(child);
+        if (winStartItemInfo) {
+          if (result.pageNextDataIndex == null) {
+            result.pageNextDataIndex = winStartItemInfo.i;
+          }
 
-        if (itemRect.intersect(winRect)) {
-          startIdx == null && (startIdx = index); // It is user-friendly that the last item shown in the
-          // current window is shown at the begining of next window.
+          ++result.pageCount;
+        }
+      }
+
+      winEndItemInfo = currItemInfo;
+    }
 
-          pageNextDataIndex = child.__legendDataIndex;
-        } // If the last item is shown entirely, no next page.
+    for (var i = targetItemIndex - 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i >= -1; --i) {
+      currItemInfo = getItemInfo(children[i]);
 
+      if ( // If the the end item does not intersect with the window started
+      // from the current item, a page can be settled.
+      (!currItemInfo || !intersect(winEndItemInfo, currItemInfo.s)) && // e.g., when page size is smaller than item size.
+      winStartItemInfo.i < winEndItemInfo.i) {
+        winEndItemInfo = winStartItemInfo;
 
-        if (index === children.length - 1 && itemRect[xy] + itemRect[wh] <= winRect[xy] + winRect[wh]) {
-          pageNextDataIndex = null;
+        if (result.pagePrevDataIndex == null) {
+          result.pagePrevDataIndex = winStartItemInfo.i;
         }
-      }); // Always align based on the left/top most item, so the left/top most
-      // item in the previous window is needed to be found here.
 
-      if (startIdx != null) {
-        var startItem = children[startIdx];
-        var startRect = getItemRect(startItem);
-        winRect[xy] = startRect[xy] + startRect[wh] - winRect[wh]; // If the first item is shown entirely, no previous page.
+        ++result.pageCount;
+        ++result.pageIndex;
+      }
 
-        if (startIdx <= 0 && startRect[xy] >= winRect[xy]) {
-          pagePrevDataIndex = null;
-        } else {
-          while (startIdx > 0 && getItemRect(children[startIdx - 1]).intersect(winRect)) {
-            startIdx--;
-          }
+      winStartItemInfo = currItemInfo;
+    }
 
-          pagePrevDataIndex = children[startIdx].__legendDataIndex;
-        }
+    return result;
+
+    function getItemInfo(el) {
+      if (el) {
+        var itemRect = el.getBoundingRect();
+        var start = itemRect[xy] + el.position[orientIdx];
+        return {
+          s: start,
+          e: start + itemRect[wh],
+          i: el.__legendDataIndex
+        };
       }
     }
 
-    return {
-      contentPosition: contentPos,
-      pageIndex: pageIndex,
-      pageCount: pageCount,
-      pagePrevDataIndex: pagePrevDataIndex,
-      pageNextDataIndex: pageNextDataIndex
-    };
+    function intersect(itemInfo, winStart) {
+      return itemInfo.e >= winStart && itemInfo.s <= winStart + containerRectSize;
+    }
+  },
+  _findTargetItemIndex: function (targetDataIndex) {
+    var index;
+    var contentGroup = this.getContentGroup();
 
-    function getItemRect(el) {
-      var itemRect = el.getBoundingRect().clone();
-      itemRect[xy] += el.position[orientIdx];
-      return itemRect;
+    if (this._showController) {
+      contentGroup.eachChild(function (child, idx) {
+        if (child.__legendDataIndex === targetDataIndex) {
+          index = idx;
+        }
+      });
+    } else {
+      index = 0;
     }
+
+    return index;
   }
 });
 var _default = ScrollableLegendView;

package/lib/coord/axisHelper.js

@@ -396,6 +396,27 @@ function rotateTextRect(textRect, rotate) {
   var rotatedRect = new BoundingRect(boundingBox.x, boundingBox.y, afterWidth, afterHeight);
   return rotatedRect;
 }
+/**
+ * @param {module:echarts/src/model/Model} model axisLabelModel or axisTickModel
+ * @return {number|String} Can be null|'auto'|number|function
+ */
+
+
+function getOptionCategoryInterval(model) {
+  var interval = model.get('interval');
+  return interval == null ? 'auto' : interval;
+}
+/**
+ * Set `categoryInterval` as 0 implicitly indicates that
+ * show all labels reguardless of overlap.
+ * @param {Object} axis axisModel.axis
+ * @return {boolean}
+ */
+
+
+function shouldShowAllLabels(axis) {
+  return axis.type === 'category' && getOptionCategoryInterval(axis.getLabelModel()) === 0;
+}
 
 exports.getScaleExtent = getScaleExtent;
 exports.niceScaleExtent = niceScaleExtent;
@@ -403,4 +424,6 @@ exports.createScaleByModel = createScaleByModel;
 exports.ifAxisCrossZero = ifAxisCrossZero;
 exports.makeLabelFormatter = makeLabelFormatter;
 exports.getAxisRawValue = getAxisRawValue;
-exports.estimateLabelUnionRect = estimateLabelUnionRect;
+exports.estimateLabelUnionRect = estimateLabelUnionRect;
+exports.getOptionCategoryInterval = getOptionCategoryInterval;
+exports.shouldShowAllLabels = shouldShowAllLabels;

package/lib/coord/axisTickLabelBuilder.js

@@ -29,6 +29,8 @@ var makeInner = _model.makeInner;
 var _axisHelper = require("./axisHelper");
 
 var makeLabelFormatter = _axisHelper.makeLabelFormatter;
+var getOptionCategoryInterval = _axisHelper.getOptionCategoryInterval;
+var shouldShowAllLabels = _axisHelper.shouldShowAllLabels;
 
 /*
 * Licensed to the Apache Software Foundation (ASF) under one
@@ -307,12 +309,11 @@ function makeLabelsByNumericCategoryInterval(axis, categoryInterval, onlyTick) {
   // do not need to perform this process.
 
 
-  var showMinMax = {
-    min: labelModel.get('showMinLabel'),
-    max: labelModel.get('showMaxLabel')
-  };
+  var showAllLabel = shouldShowAllLabels(axis);
+  var includeMinLabel = labelModel.get('showMinLabel') || showAllLabel;
+  var includeMaxLabel = labelModel.get('showMaxLabel') || showAllLabel;
 
-  if (showMinMax.min && startTick !== ordinalExtent[0]) {
+  if (includeMinLabel && startTick !== ordinalExtent[0]) {
     addItem(ordinalExtent[0]);
   } // Optimize: avoid generating large array by `ordinalScale.getTicks()`.
 
@@ -323,7 +324,7 @@ function makeLabelsByNumericCategoryInterval(axis, categoryInterval, onlyTick) {
     addItem(tickValue);
   }
 
-  if (showMinMax.max && tickValue !== ordinalExtent[1]) {
+  if (includeMaxLabel && tickValue !== ordinalExtent[1]) {
     addItem(ordinalExtent[1]);
   }
 
@@ -356,12 +357,6 @@ function makeLabelsByCustomizedCategoryInterval(axis, categoryInterval, onlyTick
     }
   });
   return result;
-} // Can be null|'auto'|number|function
-
-
-function getOptionCategoryInterval(model) {
-  var interval = model.get('interval');
-  return interval == null ? 'auto' : interval;
 }
 
 exports.createAxisLabels = createAxisLabels;

package/lib/coord/geo/Geo.js

@@ -67,7 +67,7 @@ function Geo(name, map, nameMap, invertLongitute) {
   this.map = map;
   var source = geoSourceManager.load(map, nameMap);
   this._nameCoordMap = source.nameCoordMap;
-  this._regionsMap = source.nameCoordMap;
+  this._regionsMap = source.regionsMap;
   this._invertLongitute = invertLongitute == null ? true : invertLongitute;
   /**
    * @readOnly

package/lib/data/List.js

@@ -65,7 +65,8 @@ var summarizeDimensions = _dimensionHelper.summarizeDimensions;
  * @module echarts/data/List
  */
 var isObject = zrUtil.isObject;
-var UNDEFINED = 'undefined'; // Use prefix to avoid index to be the same as otherIdList[idx],
+var UNDEFINED = 'undefined';
+var INDEX_NOT_FOUND = -1; // Use prefix to avoid index to be the same as otherIdList[idx],
 // which will cause weird udpate animation.
 
 var ID_PREFIX = 'e\0\0';
@@ -80,6 +81,7 @@ var dataCtors = {
 // different from the Ctor of typed array.
 
 var CtorUint32Array = typeof Uint32Array === UNDEFINED ? Array : Uint32Array;
+var CtorInt32Array = typeof Int32Array === UNDEFINED ? Array : Int32Array;
 var CtorUint16Array = typeof Uint16Array === UNDEFINED ? Array : Uint16Array;
 
 function getIndicesCtor(list) {
@@ -421,7 +423,8 @@ listProto.initData = function (data, nameList, dimValueGetter) {
 
   this.defaultDimValueGetter = defaultDimValueGetters[this._rawData.getSource().sourceFormat]; // Default dim value getter
 
-  this._dimValueGetter = dimValueGetter = dimValueGetter || this.defaultDimValueGetter; // Reset raw extent.
+  this._dimValueGetter = dimValueGetter = dimValueGetter || this.defaultDimValueGetter;
+  this._dimValueGetterArrayRows = defaultDimValueGetters.arrayRows; // Reset raw extent.
 
   this._rawExtent = {};
 
@@ -436,6 +439,10 @@ listProto.initData = function (data, nameList, dimValueGetter) {
 listProto.getProvider = function () {
   return this._rawData;
 };
+/**
+ * Caution: Can be only called on raw data (before `this._indices` created).
+ */
+
 
 listProto.appendData = function (data) {
   var rawData = this._rawData;
@@ -449,6 +456,77 @@ listProto.appendData = function (data) {
 
   this._initDataFromProvider(start, end);
 };
+/**
+ * Caution: Can be only called on raw data (before `this._indices` created).
+ * This method does not modify `rawData` (`dataProvider`), but only
+ * add values to storage.
+ *
+ * The final count will be increased by `Math.max(values.length, names.length)`.
+ *
+ * @param {Array.<Array.<*>>} values That is the SourceType: 'arrayRows', like
+ *        [
+ *            [12, 33, 44],
+ *            [NaN, 43, 1],
+ *            ['-', 'asdf', 0]
+ *        ]
+ *        Each item is exaclty cooresponding to a dimension.
+ * @param {Array.<string>} [names]
+ */
+
+
+listProto.appendValues = function (values, names) {
+  var chunkSize = this._chunkSize;
+  var storage = this._storage;
+  var dimensions = this.dimensions;
+  var dimLen = dimensions.length;
+  var rawExtent = this._rawExtent;
+  var start = this.count();
+  var end = start + Math.max(values.length, names ? names.length : 0);
+  var originalChunkCount = this._chunkCount;
+
+  for (var i = 0; i < dimLen; i++) {
+    var dim = dimensions[i];
+
+    if (!rawExtent[dim]) {
+      rawExtent[dim] = getInitialExtent();
+    }
+
+    if (!storage[dim]) {
+      storage[dim] = [];
+    }
+
+    prepareChunks(storage, this._dimensionInfos[dim], chunkSize, originalChunkCount, end);
+    this._chunkCount = storage[dim].length;
+  }
+
+  var emptyDataItem = new Array(dimLen);
+
+  for (var idx = start; idx < end; idx++) {
+    var sourceIdx = idx - start;
+    var chunkIndex = Math.floor(idx / chunkSize);
+    var chunkOffset = idx % chunkSize; // Store the data by dimensions
+
+    for (var k = 0; k < dimLen; k++) {
+      var dim = dimensions[k];
+
+      var val = this._dimValueGetterArrayRows(values[sourceIdx] || emptyDataItem, dim, sourceIdx, k);
+
+      storage[dim][chunkIndex][chunkOffset] = val;
+      var dimRawExtent = rawExtent[dim];
+      val < dimRawExtent[0] && (dimRawExtent[0] = val);
+      val > dimRawExtent[1] && (dimRawExtent[1] = val);
+    }
+
+    if (names) {
+      this._nameList[idx] = names[sourceIdx];
+    }
+  }
+
+  this._rawCount = this._count = end; // Reset data extent
+
+  this._extent = {};
+  prepareInvertedIndex(this);
+};
 
 listProto._initDataFromProvider = function (start, end) {
   // Optimize.
@@ -467,8 +545,7 @@ listProto._initDataFromProvider = function (start, end) {
   var rawExtent = this._rawExtent;
   var nameRepeatCount = this._nameRepeatCount = {};
   var nameDimIdx;
-  var chunkCount = this._chunkCount;
-  var lastChunkIndex = chunkCount - 1;
+  var originalChunkCount = this._chunkCount;
 
   for (var i = 0; i < dimLen; i++) {
     var dim = dimensions[i];
@@ -487,30 +564,11 @@ listProto._initDataFromProvider = function (start, end) {
       this._idDimIdx = i;
     }
 
-    var DataCtor = dataCtors[dimInfo.type];
-
     if (!storage[dim]) {
       storage[dim] = [];
     }
 
-    var resizeChunkArray = storage[dim][lastChunkIndex];
-
-    if (resizeChunkArray && resizeChunkArray.length < chunkSize) {
-      var newStore = new DataCtor(Math.min(end - lastChunkIndex * chunkSize, chunkSize)); // The cost of the copy is probably inconsiderable
-      // within the initial chunkSize.
-
-      for (var j = 0; j < resizeChunkArray.length; j++) {
-        newStore[j] = resizeChunkArray[j];
-      }
-
-      storage[dim][lastChunkIndex] = newStore;
-    } // Create new chunks.
-
-
-    for (var k = chunkCount * chunkSize; k < end; k += chunkSize) {
-      storage[dim].push(new DataCtor(Math.min(end - k, chunkSize)));
-    }
-
+    prepareChunks(storage, dimInfo, chunkSize, originalChunkCount, end);
     this._chunkCount = storage[dim].length;
   }
 
@@ -536,14 +594,8 @@ listProto._initDataFromProvider = function (start, end) {
 
       dimStorage[chunkOffset] = val;
       var dimRawExtent = rawExtent[dim];
-
-      if (val < dimRawExtent[0]) {
-        dimRawExtent[0] = val;
-      }
-
-      if (val > dimRawExtent[1]) {
-        dimRawExtent[1] = val;
-      }
+      val < dimRawExtent[0] && (dimRawExtent[0] = val);
+      val > dimRawExtent[1] && (dimRawExtent[1] = val);
     } // ??? FIXME not check by pure but sourceFormat?
     // TODO refactor these logic.
 
@@ -604,6 +656,29 @@ listProto._initDataFromProvider = function (start, end) {
   prepareInvertedIndex(this);
 };
 
+function prepareChunks(storage, dimInfo, chunkSize, chunkCount, end) {
+  var DataCtor = dataCtors[dimInfo.type];
+  var lastChunkIndex = chunkCount - 1;
+  var dim = dimInfo.name;
+  var resizeChunkArray = storage[dim][lastChunkIndex];
+
+  if (resizeChunkArray && resizeChunkArray.length < chunkSize) {
+    var newStore = new DataCtor(Math.min(end - lastChunkIndex * chunkSize, chunkSize)); // The cost of the copy is probably inconsiderable
+    // within the initial chunkSize.
+
+    for (var j = 0; j < resizeChunkArray.length; j++) {
+      newStore[j] = resizeChunkArray[j];
+    }
+
+    storage[dim][lastChunkIndex] = newStore;
+  } // Create new chunks.
+
+
+  for (var k = chunkCount * chunkSize; k < end; k += chunkSize) {
+    storage[dim].push(new DataCtor(Math.min(end - k, chunkSize)));
+  }
+}
+
 function prepareInvertedIndex(list) {
   var invertedIndicesMap = list._invertedIndicesMap;
   zrUtil.each(invertedIndicesMap, function (invertedIndices, dim) {
@@ -612,11 +687,11 @@ function prepareInvertedIndex(list) {
     var ordinalMeta = dimInfo.ordinalMeta;
 
     if (ordinalMeta) {
-      invertedIndices = invertedIndicesMap[dim] = new CtorUint32Array(ordinalMeta.categories.length); // The default value of TypedArray is 0. To avoid miss
-      // mapping to 0, we should set it as NaN.
+      invertedIndices = invertedIndicesMap[dim] = new CtorInt32Array(ordinalMeta.categories.length); // The default value of TypedArray is 0. To avoid miss
+      // mapping to 0, we should set it as INDEX_NOT_FOUND.
 
       for (var i = 0; i < invertedIndices.length; i++) {
-        invertedIndices[i] = NaN;
+        invertedIndices[i] = INDEX_NOT_FOUND;
       }
 
       for (var i = 0; i < list._count; i++) {
@@ -1008,7 +1083,7 @@ listProto.rawIndexOf = function (dim, value) {
   var rawIndex = invertedIndices[value];
 
   if (rawIndex == null || isNaN(rawIndex)) {
-    return -1;
+    return INDEX_NOT_FOUND;
   }
 
   return rawIndex;