@ecan-bi/datav 1.1.15 → 1.1.17

package/lib/node_modules/echarts/lib/data/SeriesData.js

@@ -0,0 +1,666 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../zrender/lib/core/util.js");
+const Model = require("../model/Model.js");
+const DataDiffer = require("./DataDiffer.js");
+const dataProvider = require("./helper/dataProvider.js");
+const dimensionHelper = require("./helper/dimensionHelper.js");
+const SeriesDimensionDefine = require("./SeriesDimensionDefine.js");
+const types = require("../util/types.js");
+const model = require("../util/model.js");
+const innerStore = require("../util/innerStore.js");
+const Source = require("./Source.js");
+const DataStore = require("./DataStore.js");
+const SeriesDataSchema = require("./helper/SeriesDataSchema.js");
+var isObject = util.isObject;
+var map = util.map;
+var CtorInt32Array = typeof Int32Array === "undefined" ? Array : Int32Array;
+var ID_PREFIX = "e\0\0";
+var INDEX_NOT_FOUND = -1;
+var TRANSFERABLE_PROPERTIES = ["hasItemOption", "_nameList", "_idList", "_invertedIndicesMap", "_dimSummary", "userOutput", "_rawData", "_dimValueGetter", "_nameDimIdx", "_idDimIdx", "_nameRepeatCount"];
+var CLONE_PROPERTIES = ["_approximateExtent"];
+var prepareInvertedIndex;
+var getId;
+var getIdNameFromStore;
+var normalizeDimensions;
+var transferProperties;
+var cloneListForMapAndSample;
+var makeIdFromName;
+var SeriesData = (
+  /** @class */
+  function() {
+    function SeriesData2(dimensionsInput, hostModel) {
+      this.type = "list";
+      this._dimOmitted = false;
+      this._nameList = [];
+      this._idList = [];
+      this._visual = {};
+      this._layout = {};
+      this._itemVisuals = [];
+      this._itemLayouts = [];
+      this._graphicEls = [];
+      this._approximateExtent = {};
+      this._calculationInfo = {};
+      this.hasItemOption = false;
+      this.TRANSFERABLE_METHODS = ["cloneShallow", "downSample", "lttbDownSample", "map"];
+      this.CHANGABLE_METHODS = ["filterSelf", "selectRange"];
+      this.DOWNSAMPLE_METHODS = ["downSample", "lttbDownSample"];
+      var dimensions;
+      var assignStoreDimIdx = false;
+      if (SeriesDataSchema.isSeriesDataSchema(dimensionsInput)) {
+        dimensions = dimensionsInput.dimensions;
+        this._dimOmitted = dimensionsInput.isDimensionOmitted();
+        this._schema = dimensionsInput;
+      } else {
+        assignStoreDimIdx = true;
+        dimensions = dimensionsInput;
+      }
+      dimensions = dimensions || ["x", "y"];
+      var dimensionInfos = {};
+      var dimensionNames = [];
+      var invertedIndicesMap = {};
+      var needsHasOwn = false;
+      var emptyObj = {};
+      for (var i = 0; i < dimensions.length; i++) {
+        var dimInfoInput = dimensions[i];
+        var dimensionInfo = util.isString(dimInfoInput) ? new SeriesDimensionDefine.default({
+          name: dimInfoInput
+        }) : !(dimInfoInput instanceof SeriesDimensionDefine.default) ? new SeriesDimensionDefine.default(dimInfoInput) : dimInfoInput;
+        var dimensionName = dimensionInfo.name;
+        dimensionInfo.type = dimensionInfo.type || "float";
+        if (!dimensionInfo.coordDim) {
+          dimensionInfo.coordDim = dimensionName;
+          dimensionInfo.coordDimIndex = 0;
+        }
+        var otherDims = dimensionInfo.otherDims = dimensionInfo.otherDims || {};
+        dimensionNames.push(dimensionName);
+        dimensionInfos[dimensionName] = dimensionInfo;
+        if (emptyObj[dimensionName] != null) {
+          needsHasOwn = true;
+        }
+        if (dimensionInfo.createInvertedIndices) {
+          invertedIndicesMap[dimensionName] = [];
+        }
+        if (otherDims.itemName === 0) {
+          this._nameDimIdx = i;
+        }
+        if (otherDims.itemId === 0) {
+          this._idDimIdx = i;
+        }
+        if (process.env.NODE_ENV !== "production") {
+          util.assert(assignStoreDimIdx || dimensionInfo.storeDimIndex >= 0);
+        }
+        if (assignStoreDimIdx) {
+          dimensionInfo.storeDimIndex = i;
+        }
+      }
+      this.dimensions = dimensionNames;
+      this._dimInfos = dimensionInfos;
+      this._initGetDimensionInfo(needsHasOwn);
+      this.hostModel = hostModel;
+      this._invertedIndicesMap = invertedIndicesMap;
+      if (this._dimOmitted) {
+        var dimIdxToName_1 = this._dimIdxToName = util.createHashMap();
+        util.each(dimensionNames, function(dimName) {
+          dimIdxToName_1.set(dimensionInfos[dimName].storeDimIndex, dimName);
+        });
+      }
+    }
+    SeriesData2.prototype.getDimension = function(dim) {
+      var dimIdx = this._recognizeDimIndex(dim);
+      if (dimIdx == null) {
+        return dim;
+      }
+      dimIdx = dim;
+      if (!this._dimOmitted) {
+        return this.dimensions[dimIdx];
+      }
+      var dimName = this._dimIdxToName.get(dimIdx);
+      if (dimName != null) {
+        return dimName;
+      }
+      var sourceDimDef = this._schema.getSourceDimension(dimIdx);
+      if (sourceDimDef) {
+        return sourceDimDef.name;
+      }
+    };
+    SeriesData2.prototype.getDimensionIndex = function(dim) {
+      var dimIdx = this._recognizeDimIndex(dim);
+      if (dimIdx != null) {
+        return dimIdx;
+      }
+      if (dim == null) {
+        return -1;
+      }
+      var dimInfo = this._getDimInfo(dim);
+      return dimInfo ? dimInfo.storeDimIndex : this._dimOmitted ? this._schema.getSourceDimensionIndex(dim) : -1;
+    };
+    SeriesData2.prototype._recognizeDimIndex = function(dim) {
+      if (util.isNumber(dim) || dim != null && !isNaN(dim) && !this._getDimInfo(dim) && (!this._dimOmitted || this._schema.getSourceDimensionIndex(dim) < 0)) {
+        return +dim;
+      }
+    };
+    SeriesData2.prototype._getStoreDimIndex = function(dim) {
+      var dimIdx = this.getDimensionIndex(dim);
+      if (process.env.NODE_ENV !== "production") {
+        if (dimIdx == null) {
+          throw new Error("Unkown dimension " + dim);
+        }
+      }
+      return dimIdx;
+    };
+    SeriesData2.prototype.getDimensionInfo = function(dim) {
+      return this._getDimInfo(this.getDimension(dim));
+    };
+    SeriesData2.prototype._initGetDimensionInfo = function(needsHasOwn) {
+      var dimensionInfos = this._dimInfos;
+      this._getDimInfo = needsHasOwn ? function(dimName) {
+        return dimensionInfos.hasOwnProperty(dimName) ? dimensionInfos[dimName] : void 0;
+      } : function(dimName) {
+        return dimensionInfos[dimName];
+      };
+    };
+    SeriesData2.prototype.getDimensionsOnCoord = function() {
+      return this._dimSummary.dataDimsOnCoord.slice();
+    };
+    SeriesData2.prototype.mapDimension = function(coordDim, idx) {
+      var dimensionsSummary = this._dimSummary;
+      if (idx == null) {
+        return dimensionsSummary.encodeFirstDimNotExtra[coordDim];
+      }
+      var dims = dimensionsSummary.encode[coordDim];
+      return dims ? dims[idx] : null;
+    };
+    SeriesData2.prototype.mapDimensionsAll = function(coordDim) {
+      var dimensionsSummary = this._dimSummary;
+      var dims = dimensionsSummary.encode[coordDim];
+      return (dims || []).slice();
+    };
+    SeriesData2.prototype.getStore = function() {
+      return this._store;
+    };
+    SeriesData2.prototype.initData = function(data, nameList, dimValueGetter) {
+      var _this = this;
+      var store;
+      if (data instanceof DataStore.default) {
+        store = data;
+      }
+      if (!store) {
+        var dimensions = this.dimensions;
+        var provider = Source.isSourceInstance(data) || util.isArrayLike(data) ? new dataProvider.DefaultDataProvider(data, dimensions.length) : data;
+        store = new DataStore.default();
+        var dimensionInfos = map(dimensions, function(dimName) {
+          return {
+            type: _this._dimInfos[dimName].type,
+            property: dimName
+          };
+        });
+        store.initData(provider, dimensionInfos, dimValueGetter);
+      }
+      this._store = store;
+      this._nameList = (nameList || []).slice();
+      this._idList = [];
+      this._nameRepeatCount = {};
+      this._doInit(0, store.count());
+      this._dimSummary = dimensionHelper.summarizeDimensions(this, this._schema);
+      this.userOutput = this._dimSummary.userOutput;
+    };
+    SeriesData2.prototype.appendData = function(data) {
+      var range = this._store.appendData(data);
+      this._doInit(range[0], range[1]);
+    };
+    SeriesData2.prototype.appendValues = function(values, names) {
+      var _a = this._store.appendValues(values, names.length), start = _a.start, end = _a.end;
+      var shouldMakeIdFromName = this._shouldMakeIdFromName();
+      this._updateOrdinalMeta();
+      if (names) {
+        for (var idx = start; idx < end; idx++) {
+          var sourceIdx = idx - start;
+          this._nameList[idx] = names[sourceIdx];
+          if (shouldMakeIdFromName) {
+            makeIdFromName(this, idx);
+          }
+        }
+      }
+    };
+    SeriesData2.prototype._updateOrdinalMeta = function() {
+      var store = this._store;
+      var dimensions = this.dimensions;
+      for (var i = 0; i < dimensions.length; i++) {
+        var dimInfo = this._dimInfos[dimensions[i]];
+        if (dimInfo.ordinalMeta) {
+          store.collectOrdinalMeta(dimInfo.storeDimIndex, dimInfo.ordinalMeta);
+        }
+      }
+    };
+    SeriesData2.prototype._shouldMakeIdFromName = function() {
+      var provider = this._store.getProvider();
+      return this._idDimIdx == null && provider.getSource().sourceFormat !== types.SOURCE_FORMAT_TYPED_ARRAY && !provider.fillStorage;
+    };
+    SeriesData2.prototype._doInit = function(start, end) {
+      if (start >= end) {
+        return;
+      }
+      var store = this._store;
+      var provider = store.getProvider();
+      this._updateOrdinalMeta();
+      var nameList = this._nameList;
+      var idList = this._idList;
+      var sourceFormat = provider.getSource().sourceFormat;
+      var isFormatOriginal = sourceFormat === types.SOURCE_FORMAT_ORIGINAL;
+      if (isFormatOriginal && !provider.pure) {
+        var sharedDataItem = [];
+        for (var idx = start; idx < end; idx++) {
+          var dataItem = provider.getItem(idx, sharedDataItem);
+          if (!this.hasItemOption && model.isDataItemOption(dataItem)) {
+            this.hasItemOption = true;
+          }
+          if (dataItem) {
+            var itemName = dataItem.name;
+            if (nameList[idx] == null && itemName != null) {
+              nameList[idx] = model.convertOptionIdName(itemName, null);
+            }
+            var itemId = dataItem.id;
+            if (idList[idx] == null && itemId != null) {
+              idList[idx] = model.convertOptionIdName(itemId, null);
+            }
+          }
+        }
+      }
+      if (this._shouldMakeIdFromName()) {
+        for (var idx = start; idx < end; idx++) {
+          makeIdFromName(this, idx);
+        }
+      }
+      prepareInvertedIndex(this);
+    };
+    SeriesData2.prototype.getApproximateExtent = function(dim) {
+      return this._approximateExtent[dim] || this._store.getDataExtent(this._getStoreDimIndex(dim));
+    };
+    SeriesData2.prototype.setApproximateExtent = function(extent, dim) {
+      dim = this.getDimension(dim);
+      this._approximateExtent[dim] = extent.slice();
+    };
+    SeriesData2.prototype.getCalculationInfo = function(key) {
+      return this._calculationInfo[key];
+    };
+    SeriesData2.prototype.setCalculationInfo = function(key, value) {
+      isObject(key) ? util.extend(this._calculationInfo, key) : this._calculationInfo[key] = value;
+    };
+    SeriesData2.prototype.getName = function(idx) {
+      var rawIndex = this.getRawIndex(idx);
+      var name = this._nameList[rawIndex];
+      if (name == null && this._nameDimIdx != null) {
+        name = getIdNameFromStore(this, this._nameDimIdx, rawIndex);
+      }
+      if (name == null) {
+        name = "";
+      }
+      return name;
+    };
+    SeriesData2.prototype._getCategory = function(dimIdx, idx) {
+      var ordinal = this._store.get(dimIdx, idx);
+      var ordinalMeta = this._store.getOrdinalMeta(dimIdx);
+      if (ordinalMeta) {
+        return ordinalMeta.categories[ordinal];
+      }
+      return ordinal;
+    };
+    SeriesData2.prototype.getId = function(idx) {
+      return getId(this, this.getRawIndex(idx));
+    };
+    SeriesData2.prototype.count = function() {
+      return this._store.count();
+    };
+    SeriesData2.prototype.get = function(dim, idx) {
+      var store = this._store;
+      var dimInfo = this._dimInfos[dim];
+      if (dimInfo) {
+        return store.get(dimInfo.storeDimIndex, idx);
+      }
+    };
+    SeriesData2.prototype.getByRawIndex = function(dim, rawIdx) {
+      var store = this._store;
+      var dimInfo = this._dimInfos[dim];
+      if (dimInfo) {
+        return store.getByRawIndex(dimInfo.storeDimIndex, rawIdx);
+      }
+    };
+    SeriesData2.prototype.getIndices = function() {
+      return this._store.getIndices();
+    };
+    SeriesData2.prototype.getDataExtent = function(dim) {
+      return this._store.getDataExtent(this._getStoreDimIndex(dim));
+    };
+    SeriesData2.prototype.getSum = function(dim) {
+      return this._store.getSum(this._getStoreDimIndex(dim));
+    };
+    SeriesData2.prototype.getMedian = function(dim) {
+      return this._store.getMedian(this._getStoreDimIndex(dim));
+    };
+    SeriesData2.prototype.getValues = function(dimensions, idx) {
+      var _this = this;
+      var store = this._store;
+      return util.isArray(dimensions) ? store.getValues(map(dimensions, function(dim) {
+        return _this._getStoreDimIndex(dim);
+      }), idx) : store.getValues(dimensions);
+    };
+    SeriesData2.prototype.hasValue = function(idx) {
+      var dataDimIndicesOnCoord = this._dimSummary.dataDimIndicesOnCoord;
+      for (var i = 0, len = dataDimIndicesOnCoord.length; i < len; i++) {
+        if (isNaN(this._store.get(dataDimIndicesOnCoord[i], idx))) {
+          return false;
+        }
+      }
+      return true;
+    };
+    SeriesData2.prototype.indexOfName = function(name) {
+      for (var i = 0, len = this._store.count(); i < len; i++) {
+        if (this.getName(i) === name) {
+          return i;
+        }
+      }
+      return -1;
+    };
+    SeriesData2.prototype.getRawIndex = function(idx) {
+      return this._store.getRawIndex(idx);
+    };
+    SeriesData2.prototype.indexOfRawIndex = function(rawIndex) {
+      return this._store.indexOfRawIndex(rawIndex);
+    };
+    SeriesData2.prototype.rawIndexOf = function(dim, value) {
+      var invertedIndices = dim && this._invertedIndicesMap[dim];
+      if (process.env.NODE_ENV !== "production") {
+        if (!invertedIndices) {
+          throw new Error("Do not supported yet");
+        }
+      }
+      var rawIndex = invertedIndices[value];
+      if (rawIndex == null || isNaN(rawIndex)) {
+        return INDEX_NOT_FOUND;
+      }
+      return rawIndex;
+    };
+    SeriesData2.prototype.indicesOfNearest = function(dim, value, maxDistance) {
+      return this._store.indicesOfNearest(this._getStoreDimIndex(dim), value, maxDistance);
+    };
+    SeriesData2.prototype.each = function(dims, cb, ctx) {
+      if (util.isFunction(dims)) {
+        ctx = cb;
+        cb = dims;
+        dims = [];
+      }
+      var fCtx = ctx || this;
+      var dimIndices = map(normalizeDimensions(dims), this._getStoreDimIndex, this);
+      this._store.each(dimIndices, fCtx ? util.bind(cb, fCtx) : cb);
+    };
+    SeriesData2.prototype.filterSelf = function(dims, cb, ctx) {
+      if (util.isFunction(dims)) {
+        ctx = cb;
+        cb = dims;
+        dims = [];
+      }
+      var fCtx = ctx || this;
+      var dimIndices = map(normalizeDimensions(dims), this._getStoreDimIndex, this);
+      this._store = this._store.filter(dimIndices, fCtx ? util.bind(cb, fCtx) : cb);
+      return this;
+    };
+    SeriesData2.prototype.selectRange = function(range) {
+      var _this = this;
+      var innerRange = {};
+      var dims = util.keys(range);
+      util.each(dims, function(dim) {
+        var dimIdx = _this._getStoreDimIndex(dim);
+        innerRange[dimIdx] = range[dim];
+      });
+      this._store = this._store.selectRange(innerRange);
+      return this;
+    };
+    SeriesData2.prototype.mapArray = function(dims, cb, ctx) {
+      if (util.isFunction(dims)) {
+        ctx = cb;
+        cb = dims;
+        dims = [];
+      }
+      ctx = ctx || this;
+      var result = [];
+      this.each(dims, function() {
+        result.push(cb && cb.apply(this, arguments));
+      }, ctx);
+      return result;
+    };
+    SeriesData2.prototype.map = function(dims, cb, ctx, ctxCompat) {
+      var fCtx = ctx || ctxCompat || this;
+      var dimIndices = map(normalizeDimensions(dims), this._getStoreDimIndex, this);
+      var list = cloneListForMapAndSample(this);
+      list._store = this._store.map(dimIndices, fCtx ? util.bind(cb, fCtx) : cb);
+      return list;
+    };
+    SeriesData2.prototype.modify = function(dims, cb, ctx, ctxCompat) {
+      var _this = this;
+      var fCtx = ctx || ctxCompat || this;
+      if (process.env.NODE_ENV !== "production") {
+        util.each(normalizeDimensions(dims), function(dim) {
+          var dimInfo = _this.getDimensionInfo(dim);
+          if (!dimInfo.isCalculationCoord) {
+            console.error("Danger: only stack dimension can be modified");
+          }
+        });
+      }
+      var dimIndices = map(normalizeDimensions(dims), this._getStoreDimIndex, this);
+      this._store.modify(dimIndices, fCtx ? util.bind(cb, fCtx) : cb);
+    };
+    SeriesData2.prototype.downSample = function(dimension, rate, sampleValue, sampleIndex) {
+      var list = cloneListForMapAndSample(this);
+      list._store = this._store.downSample(this._getStoreDimIndex(dimension), rate, sampleValue, sampleIndex);
+      return list;
+    };
+    SeriesData2.prototype.lttbDownSample = function(valueDimension, rate) {
+      var list = cloneListForMapAndSample(this);
+      list._store = this._store.lttbDownSample(this._getStoreDimIndex(valueDimension), rate);
+      return list;
+    };
+    SeriesData2.prototype.getRawDataItem = function(idx) {
+      return this._store.getRawDataItem(idx);
+    };
+    SeriesData2.prototype.getItemModel = function(idx) {
+      var hostModel = this.hostModel;
+      var dataItem = this.getRawDataItem(idx);
+      return new Model.default(dataItem, hostModel, hostModel && hostModel.ecModel);
+    };
+    SeriesData2.prototype.diff = function(otherList) {
+      var thisList = this;
+      return new DataDiffer.default(otherList ? otherList.getStore().getIndices() : [], this.getStore().getIndices(), function(idx) {
+        return getId(otherList, idx);
+      }, function(idx) {
+        return getId(thisList, idx);
+      });
+    };
+    SeriesData2.prototype.getVisual = function(key) {
+      var visual = this._visual;
+      return visual && visual[key];
+    };
+    SeriesData2.prototype.setVisual = function(kvObj, val) {
+      this._visual = this._visual || {};
+      if (isObject(kvObj)) {
+        util.extend(this._visual, kvObj);
+      } else {
+        this._visual[kvObj] = val;
+      }
+    };
+    SeriesData2.prototype.getItemVisual = function(idx, key) {
+      var itemVisual = this._itemVisuals[idx];
+      var val = itemVisual && itemVisual[key];
+      if (val == null) {
+        return this.getVisual(key);
+      }
+      return val;
+    };
+    SeriesData2.prototype.hasItemVisual = function() {
+      return this._itemVisuals.length > 0;
+    };
+    SeriesData2.prototype.ensureUniqueItemVisual = function(idx, key) {
+      var itemVisuals = this._itemVisuals;
+      var itemVisual = itemVisuals[idx];
+      if (!itemVisual) {
+        itemVisual = itemVisuals[idx] = {};
+      }
+      var val = itemVisual[key];
+      if (val == null) {
+        val = this.getVisual(key);
+        if (util.isArray(val)) {
+          val = val.slice();
+        } else if (isObject(val)) {
+          val = util.extend({}, val);
+        }
+        itemVisual[key] = val;
+      }
+      return val;
+    };
+    SeriesData2.prototype.setItemVisual = function(idx, key, value) {
+      var itemVisual = this._itemVisuals[idx] || {};
+      this._itemVisuals[idx] = itemVisual;
+      if (isObject(key)) {
+        util.extend(itemVisual, key);
+      } else {
+        itemVisual[key] = value;
+      }
+    };
+    SeriesData2.prototype.clearAllVisual = function() {
+      this._visual = {};
+      this._itemVisuals = [];
+    };
+    SeriesData2.prototype.setLayout = function(key, val) {
+      isObject(key) ? util.extend(this._layout, key) : this._layout[key] = val;
+    };
+    SeriesData2.prototype.getLayout = function(key) {
+      return this._layout[key];
+    };
+    SeriesData2.prototype.getItemLayout = function(idx) {
+      return this._itemLayouts[idx];
+    };
+    SeriesData2.prototype.setItemLayout = function(idx, layout, merge) {
+      this._itemLayouts[idx] = merge ? util.extend(this._itemLayouts[idx] || {}, layout) : layout;
+    };
+    SeriesData2.prototype.clearItemLayouts = function() {
+      this._itemLayouts.length = 0;
+    };
+    SeriesData2.prototype.setItemGraphicEl = function(idx, el) {
+      var seriesIndex = this.hostModel && this.hostModel.seriesIndex;
+      innerStore.setCommonECData(seriesIndex, this.dataType, idx, el);
+      this._graphicEls[idx] = el;
+    };
+    SeriesData2.prototype.getItemGraphicEl = function(idx) {
+      return this._graphicEls[idx];
+    };
+    SeriesData2.prototype.eachItemGraphicEl = function(cb, context) {
+      util.each(this._graphicEls, function(el, idx) {
+        if (el) {
+          cb && cb.call(context, el, idx);
+        }
+      });
+    };
+    SeriesData2.prototype.cloneShallow = function(list) {
+      if (!list) {
+        list = new SeriesData2(this._schema ? this._schema : map(this.dimensions, this._getDimInfo, this), this.hostModel);
+      }
+      transferProperties(list, this);
+      list._store = this._store;
+      return list;
+    };
+    SeriesData2.prototype.wrapMethod = function(methodName, injectFunction) {
+      var originalMethod = this[methodName];
+      if (!util.isFunction(originalMethod)) {
+        return;
+      }
+      this.__wrappedMethods = this.__wrappedMethods || [];
+      this.__wrappedMethods.push(methodName);
+      this[methodName] = function() {
+        var res = originalMethod.apply(this, arguments);
+        return injectFunction.apply(this, [res].concat(util.slice(arguments)));
+      };
+    };
+    SeriesData2.internalField = function() {
+      prepareInvertedIndex = function(data) {
+        var invertedIndicesMap = data._invertedIndicesMap;
+        util.each(invertedIndicesMap, function(invertedIndices, dim) {
+          var dimInfo = data._dimInfos[dim];
+          var ordinalMeta = dimInfo.ordinalMeta;
+          var store = data._store;
+          if (ordinalMeta) {
+            invertedIndices = invertedIndicesMap[dim] = new CtorInt32Array(ordinalMeta.categories.length);
+            for (var i = 0; i < invertedIndices.length; i++) {
+              invertedIndices[i] = INDEX_NOT_FOUND;
+            }
+            for (var i = 0; i < store.count(); i++) {
+              invertedIndices[store.get(dimInfo.storeDimIndex, i)] = i;
+            }
+          }
+        });
+      };
+      getIdNameFromStore = function(data, dimIdx, idx) {
+        return model.convertOptionIdName(data._getCategory(dimIdx, idx), null);
+      };
+      getId = function(data, rawIndex) {
+        var id = data._idList[rawIndex];
+        if (id == null && data._idDimIdx != null) {
+          id = getIdNameFromStore(data, data._idDimIdx, rawIndex);
+        }
+        if (id == null) {
+          id = ID_PREFIX + rawIndex;
+        }
+        return id;
+      };
+      normalizeDimensions = function(dimensions) {
+        if (!util.isArray(dimensions)) {
+          dimensions = dimensions != null ? [dimensions] : [];
+        }
+        return dimensions;
+      };
+      cloneListForMapAndSample = function(original) {
+        var list = new SeriesData2(original._schema ? original._schema : map(original.dimensions, original._getDimInfo, original), original.hostModel);
+        transferProperties(list, original);
+        return list;
+      };
+      transferProperties = function(target, source) {
+        util.each(TRANSFERABLE_PROPERTIES.concat(source.__wrappedMethods || []), function(propName) {
+          if (source.hasOwnProperty(propName)) {
+            target[propName] = source[propName];
+          }
+        });
+        target.__wrappedMethods = source.__wrappedMethods;
+        util.each(CLONE_PROPERTIES, function(propName) {
+          target[propName] = util.clone(source[propName]);
+        });
+        target._calculationInfo = util.extend({}, source._calculationInfo);
+      };
+      makeIdFromName = function(data, idx) {
+        var nameList = data._nameList;
+        var idList = data._idList;
+        var nameDimIdx = data._nameDimIdx;
+        var idDimIdx = data._idDimIdx;
+        var name = nameList[idx];
+        var id = idList[idx];
+        if (name == null && nameDimIdx != null) {
+          nameList[idx] = name = getIdNameFromStore(data, nameDimIdx, idx);
+        }
+        if (id == null && idDimIdx != null) {
+          idList[idx] = id = getIdNameFromStore(data, idDimIdx, idx);
+        }
+        if (id == null && name != null) {
+          var nameRepeatCount = data._nameRepeatCount;
+          var nmCnt = nameRepeatCount[name] = (nameRepeatCount[name] || 0) + 1;
+          id = name;
+          if (nmCnt > 1) {
+            id += "__ec__" + nmCnt;
+          }
+          idList[idx] = id;
+        }
+      };
+    }();
+    return SeriesData2;
+  }()
+);
+const SeriesData$1 = SeriesData;
+exports.default = SeriesData$1;
+//# sourceMappingURL=SeriesData.js.map