{"version":3,"sources":["../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/dataProvider.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/dataValueHelper.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/createDimensions.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/dimensionHelper.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/SeriesDataSchema.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/sourceManager.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/extension.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/transform.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/linkSeriesData.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/export/api/helper.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/export/api.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/export/core.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/dataStackHelper.js","../node_modules/@dhi/react-components/node_modules/echarts/lib/data/helper/sourceHelper.js"],"names":["_a","_b","_c","providerMethods","mountMethods","DefaultDataProvider","sourceParam","dimSize","source","isSourceInstance","createSourceFromSeriesDataOption","this","_source","data","_data","sourceFormat","SOURCE_FORMAT_TYPED_ARRAY","_offset","_dimSize","prototype","getSource","count","getItem","idx","out","appendData","newData","clean","protoInitialize","proto","pure","persistent","internalField","provider","seriesLayoutBy","startIndex","dimsDef","dimensionsDefine","methods","getMethodMapKey","extend","getItemForTypedArray","countForTypedArray","fillStorage","fillStorageForTypedArray","rawItemGetter","getRawSourceItemGetter","bind","rawCounter","getRawSourceDataCounter","offset","i","start","end","storage","extent","dim","dimExtent","min","Infinity","max","arr","val","length","appendDataSimply","push","SOURCE_FORMAT_ARRAY_ROWS","SERIES_LAYOUT_BY_COLUMN","SERIES_LAYOUT_BY_ROW","Error","SOURCE_FORMAT_OBJECT_ROWS","SOURCE_FORMAT_KEYED_COLUMNS","each","newCol","key","oldCol","SOURCE_FORMAT_ORIGINAL","getItemSimply","rawData","rawSourceItemGetterMap","item","row","process","col","name","countSimply","rawSourceDataCounterMap","Math","getRawValueSimply","dataItem","dimIndex","property","rawSourceValueGetterMap","value","getDataItemValue","Array","getRawSourceValueGetter","retrieveRawValue","dataIndex","getRawDataItem","store","getStore","getDimensionIndex","getDimensionProperty","result","parseDataValue","opt","dimType","type","parseDate","NaN","valueParserMap","createHashMap","parseFloat","trim","getRawValueParser","get","ORDER_COMPARISON_OP_MAP","lt","lval","rval","lte","gt","gte","FilterOrderComparator","op","throwError","_opFn","_rvalFloat","numericToNumber","evaluate","SortOrderComparator","order","incomparable","isDesc","_resultLT","_incomparable","lvalTypeof","rvalTypeof","lvalFloat","rvalFloat","lvalNotNumeric","isNaN","rvalNotNumeric","lvalIsStr","rvalIsStr","FilterEqualityComparator","isEq","_rval","_isEQ","_rvalTypeof","eqResult","createFilterComparator","hasOwn","createDimensions","prepareSeriesDataSchema","dimensions","sysDims","coordDimensions","coordDimNameMap","resultList","dimCount","optDimCount","dimensionsDetectedCount","sysDimItem","sysDimItemDimsDef","isObject","getDimCount","dimensionsCount","omitUnusedDimensions","canOmitUnusedDimensions","shouldOmitUnusedDimensions","isUsingSourceDimensionsDef","dataDimNameMap","ensureSourceDimNameMap","createDimNameMap","encodeDef","encodeDefine","encodeDefaulter","encodeDefMap","indicesMap","CtorInt32Array","getResultItem","dimIdx","dimDefItemRaw","dimDefItem","resultItem","SeriesDimensionDefine","userDimName","displayName","newIdx","storeDimIndex","dataDimsRaw","coordDim","dataDims","normalizeToArray","slice","isString","set","validDataDims","resultDimIdxOrName","resultDimIdx","applyDim","availDimIdx","coordDimIndex","VISUAL_DIMENSIONS","otherDims","sysDimItemRaw","sysDimItemOtherDims","ordinalMeta","defaults","sysDimItemDimsDefItem","defaultTooltip","generateCoord","generateCoordCount","fromZero","extra","ifNoNameFillWithCoordName","sort","item0","item1","genCoordDimName","isExtraCoord","guessOrdinal","BE_ORDINAL","Must","itemName","seriesName","duplicationMap","dimOriginalName","removeDuplication","SeriesDataSchema","fullDimensionCount","dimensionOmitted","map","mapData","hasOwnProperty","DimensionUserOuput","encode","dimRequest","_encode","_schema","fullDimensions","_getFullDimensionNames","_cachedDimNames","makeOutputDimensionNames","summarizeDimensions","schema","summary","notExtraCoordDimMap","defaultedLabel","defaultedTooltip","userOutputEncode","dimName","dimItem","getDimensionInfo","getOrCreateEncodeArr","v","otherDim","encodeArr","dataDimsOnCoord","encodeFirstDimNotExtra","dimArr","concat","dataDimIndicesOnCoord","encodeLabel","label","encodeTooltip","tooltip","userOutput","getDimensionTypeByAxis","axisType","inner","makeInner","dimTypeShort","float","int","ordinal","number","time","_dimOmitted","_fullDimCount","_updateDimOmitted","isDimensionOmitted","_dimNameMap","getSourceDimensionIndex","retrieve2","getSourceDimension","makeStoreSchema","willRetrieveDataByName","shouldRetrieveDataByName","makeHashStrict","dimHash","dims","fullDimIdx","seriesDimIdx","seriesDimDef","sourceDimDef","isCalculationCoord","replace","uid","hash","join","name_1","appendCalculationDimension","dimDef","isSeriesDataSchema","innerSource","dimNameMap","SourceManager","sourceHost","_sourceList","_storeList","_upstreamSignList","_versionSignBase","_dirty","_sourceHost","dirty","_setLocalSource","sourceList","upstreamSignList","_getVersionSign","prepareSource","_isDirty","_createSource","resultSourceList","upSourceMgrList","_getUpstreamSourceManagers","hasUpstream","isSeries","seriesModel","upSource","upSourceMgr","isTypedArray","newMetaRawOption","_getSourceMetaRawOption","upMetaRawOption","metaRawOption","sourceHeader","createSource","datasetModel","_applyTransform","sourceData","upMgrList","transformOption","fromTransformResult","doThrow","upSourceList","upMgr","applyDataTransform","datasetIndex","componentIndex","cloneSourceShallow","upSrcMgr","sourceIndex","getSharedDataStore","seriesDimRequest","_innerGetDataStore","storeDims","seriesSource","sourceReadKey","storeList","cachedStoreMap","cachedStore","DataStore","initData","querySeriesUpstreamDatasetModel","getSourceManager","queryDatasetUpstreamDatasetModels","model","disableTransformOptionMerge","option","transform","setAsPrimitive","mainType","errMsg","extensions","extensionRegisters","registerPreprocessor","registerProcessor","registerPostInit","registerPostUpdate","registerUpdateLifecycle","registerAction","registerCoordinateSystem","registerLayout","registerVisual","registerTransform","registerLoading","registerMap","PRIORITY","ComponentModel","ComponentView","SeriesModel","ChartView","registerComponentModel","ComponentModelClass","registerClass","registerComponentView","ComponentViewClass","registerSeriesModel","SeriesModelClass","registerChartView","ChartViewClass","registerSubTypeDefaulter","componentType","defaulter","registerPainter","painterType","PainterCtor","use","ext","isArray","singleExt","indexOf","isFunction","install","ExternalSource","getRawData","cloneRawData","cloneAllDimensionInfo","retrieveValue","retrieveValueFromItem","convertValue","rawVal","dimInfo","upstream","isSupportedSourceFormat","len","dimsByName","clone","externalTransformMap","registerExternalTransform","externalTransform","typeParsed","split","isBuiltIn","__isBuiltIn","rawTransOption","infoForPrint","pipedTransOption","pipeLen","applySingleDataTransform","transOption","pipeIndex","transType","extUpSourceList","internalSource","extSource","sourceHeaderCount","dimDefExt","index","rawValueGetter","rawItem","createExternalSource","upstreamList","config","resultIndex","resultMetaRawOption","detectSourceFormat","firstUpSource","transferInjection","res","mainData","datas","dataType","linkAll","linkSingle","changeInjection","struct","update","cloneShallowInjection","cloneShallow","getLinkedData","getLinkedDataAll","keys","structAttr","datasAttr","linkSeriesData","main","TRANSFERABLE_METHODS","methodName","wrapMethod","curry","CHANGABLE_METHODS","assert","createList","createSeriesData","dataStack","isDimensionStacked","enableDataStack","getStackedDimension","createScale","dataExtent","axisModel","Model","scale","axisHelper","setExtent","mixinAxisModelCommonMethods","zrUtil","AxisModelCommonMixin","createTextStyle","textStyleModel","opts","innerCreateTextStyle","state","extendComponentModel","extendComponentView","View","extendSeriesModel","extendChartView","installLabelLayout","dimensionsInput","dimensionDefineList","byIndex","stackedCoordDimension","isLegacyDimensionsInput","stackedByDimInfo","stackedDimInfo","stackResultDimension","stackedOverDimension","mayStack","dimensionInfo","id","createInvertedIndices","stackedDimCoordDim_1","stackedDimType","stackedDimCoordIndex_1","stackedOverDimensionDefine","stackResultDimensionDefine","ensureCalculationDimension","stackedDimension","stackedByDimension","isStackedByIndex","stackedDim","getCalculationInfo","targetDim","Might","Not","innerGlobalModel","resetSourceDefaulter","ecModel","datasetMap","makeSeriesEncodeForAxisCoordSys","baseCategoryDimIndex","categoryWayValueDimStart","encodeItemName","encodeSeriesName","coordDimInfoLoose","coordDimIdx","coordDimInfo","getDataDimCountOnCoordDim","datasetRecord","categoryWayDim","valueWayDim","pushDim","dimIdxArr","idxFrom","idxCount","coordDimName","makeSeriesEncodeForNameBased","potentialNameDimIndex","idxResult","idxRes0","idxRes1","guessRecords","guessResult","doGuessOrdinal","isPureNumber","n","fulfilled","nameDimIndex","queryReferringComponents","SINGLE_REFERRING","models","dataArrayRows","sample","detectValue","dataObjectRows","dataKeyedColumns","dataOriginal","beStr","isFinite"],"mappings":"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","file":"static/js/45.f44fec97.chunk.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\n\n/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nvar _a, _b, _c; // TODO\n// ??? refactor? check the outer usage of data provider.\n// merge with defaultDimValueGetter?\n\n\nimport { isTypedArray, extend, assert, each, isObject, bind } from 'zrender/lib/core/util';\nimport { getDataItemValue } from '../../util/model';\nimport { createSourceFromSeriesDataOption, isSourceInstance } from '../Source';\nimport { SOURCE_FORMAT_ORIGINAL, SOURCE_FORMAT_OBJECT_ROWS, SOURCE_FORMAT_KEYED_COLUMNS, SOURCE_FORMAT_TYPED_ARRAY, SOURCE_FORMAT_ARRAY_ROWS, SERIES_LAYOUT_BY_COLUMN, SERIES_LAYOUT_BY_ROW } from '../../util/types';\nvar providerMethods;\nvar mountMethods;\n/**\n * If normal array used, mutable chunk size is supported.\n * If typed array used, chunk size must be fixed.\n */\n\nvar DefaultDataProvider =\n/** @class */\nfunction () {\n  function DefaultDataProvider(sourceParam, dimSize) {\n    // let source: Source;\n    var source = !isSourceInstance(sourceParam) ? createSourceFromSeriesDataOption(sourceParam) : sourceParam; // declare source is Source;\n\n    this._source = source;\n    var data = this._data = source.data; // Typed array. TODO IE10+?\n\n    if (source.sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (dimSize == null) {\n          throw new Error('Typed array data must specify dimension size');\n        }\n      }\n\n      this._offset = 0;\n      this._dimSize = dimSize;\n      this._data = data;\n    }\n\n    mountMethods(this, data, source);\n  }\n\n  DefaultDataProvider.prototype.getSource = function () {\n    return this._source;\n  };\n\n  DefaultDataProvider.prototype.count = function () {\n    return 0;\n  };\n\n  DefaultDataProvider.prototype.getItem = function (idx, out) {\n    return;\n  };\n\n  DefaultDataProvider.prototype.appendData = function (newData) {};\n\n  DefaultDataProvider.prototype.clean = function () {};\n\n  DefaultDataProvider.protoInitialize = function () {\n    // PENDING: To avoid potential incompat (e.g., prototype\n    // is visited somewhere), still init them on prototype.\n    var proto = DefaultDataProvider.prototype;\n    proto.pure = false;\n    proto.persistent = true;\n  }();\n\n  DefaultDataProvider.internalField = function () {\n    var _a;\n\n    mountMethods = function (provider, data, source) {\n      var sourceFormat = source.sourceFormat;\n      var seriesLayoutBy = source.seriesLayoutBy;\n      var startIndex = source.startIndex;\n      var dimsDef = source.dimensionsDefine;\n      var methods = providerMethods[getMethodMapKey(sourceFormat, seriesLayoutBy)];\n\n      if (process.env.NODE_ENV !== 'production') {\n        assert(methods, 'Invalide sourceFormat: ' + sourceFormat);\n      }\n\n      extend(provider, methods);\n\n      if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {\n        provider.getItem = getItemForTypedArray;\n        provider.count = countForTypedArray;\n        provider.fillStorage = fillStorageForTypedArray;\n      } else {\n        var rawItemGetter = getRawSourceItemGetter(sourceFormat, seriesLayoutBy);\n        provider.getItem = bind(rawItemGetter, null, data, startIndex, dimsDef);\n        var rawCounter = getRawSourceDataCounter(sourceFormat, seriesLayoutBy);\n        provider.count = bind(rawCounter, null, data, startIndex, dimsDef);\n      }\n    };\n\n    var getItemForTypedArray = function (idx, out) {\n      idx = idx - this._offset;\n      out = out || [];\n      var data = this._data;\n      var dimSize = this._dimSize;\n      var offset = dimSize * idx;\n\n      for (var i = 0; i < dimSize; i++) {\n        out[i] = data[offset + i];\n      }\n\n      return out;\n    };\n\n    var fillStorageForTypedArray = function (start, end, storage, extent) {\n      var data = this._data;\n      var dimSize = this._dimSize;\n\n      for (var dim = 0; dim < dimSize; dim++) {\n        var dimExtent = extent[dim];\n        var min = dimExtent[0] == null ? Infinity : dimExtent[0];\n        var max = dimExtent[1] == null ? -Infinity : dimExtent[1];\n        var count = end - start;\n        var arr = storage[dim];\n\n        for (var i = 0; i < count; i++) {\n          // appendData with TypedArray will always do replace in provider.\n          var val = data[i * dimSize + dim];\n          arr[start + i] = val;\n          val < min && (min = val);\n          val > max && (max = val);\n        }\n\n        dimExtent[0] = min;\n        dimExtent[1] = max;\n      }\n    };\n\n    var countForTypedArray = function () {\n      return this._data ? this._data.length / this._dimSize : 0;\n    };\n\n    providerMethods = (_a = {}, _a[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_COLUMN] = {\n      pure: true,\n      appendData: appendDataSimply\n    }, _a[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_ROW] = {\n      pure: true,\n      appendData: function () {\n        throw new Error('Do not support appendData when set seriesLayoutBy: \"row\".');\n      }\n    }, _a[SOURCE_FORMAT_OBJECT_ROWS] = {\n      pure: true,\n      appendData: appendDataSimply\n    }, _a[SOURCE_FORMAT_KEYED_COLUMNS] = {\n      pure: true,\n      appendData: function (newData) {\n        var data = this._data;\n        each(newData, function (newCol, key) {\n          var oldCol = data[key] || (data[key] = []);\n\n          for (var i = 0; i < (newCol || []).length; i++) {\n            oldCol.push(newCol[i]);\n          }\n        });\n      }\n    }, _a[SOURCE_FORMAT_ORIGINAL] = {\n      appendData: appendDataSimply\n    }, _a[SOURCE_FORMAT_TYPED_ARRAY] = {\n      persistent: false,\n      pure: true,\n      appendData: function (newData) {\n        if (process.env.NODE_ENV !== 'production') {\n          assert(isTypedArray(newData), 'Added data must be TypedArray if data in initialization is TypedArray');\n        }\n\n        this._data = newData;\n      },\n      // Clean self if data is already used.\n      clean: function () {\n        // PENDING\n        this._offset += this.count();\n        this._data = null;\n      }\n    }, _a);\n\n    function appendDataSimply(newData) {\n      for (var i = 0; i < newData.length; i++) {\n        this._data.push(newData[i]);\n      }\n    }\n  }();\n\n  return DefaultDataProvider;\n}();\n\nexport { DefaultDataProvider };\n\nvar getItemSimply = function (rawData, startIndex, dimsDef, idx) {\n  return rawData[idx];\n};\n\nvar rawSourceItemGetterMap = (_a = {}, _a[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_COLUMN] = function (rawData, startIndex, dimsDef, idx) {\n  return rawData[idx + startIndex];\n}, _a[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_ROW] = function (rawData, startIndex, dimsDef, idx, out) {\n  idx += startIndex;\n  var item = out || [];\n  var data = rawData;\n\n  for (var i = 0; i < data.length; i++) {\n    var row = data[i];\n    item[i] = row ? row[idx] : null;\n  }\n\n  return item;\n}, _a[SOURCE_FORMAT_OBJECT_ROWS] = getItemSimply, _a[SOURCE_FORMAT_KEYED_COLUMNS] = function (rawData, startIndex, dimsDef, idx, out) {\n  var item = out || [];\n\n  for (var i = 0; i < dimsDef.length; i++) {\n    var dimName = dimsDef[i].name;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (dimName == null) {\n        throw new Error();\n      }\n    }\n\n    var col = rawData[dimName];\n    item[i] = col ? col[idx] : null;\n  }\n\n  return item;\n}, _a[SOURCE_FORMAT_ORIGINAL] = getItemSimply, _a);\nexport function getRawSourceItemGetter(sourceFormat, seriesLayoutBy) {\n  var method = rawSourceItemGetterMap[getMethodMapKey(sourceFormat, seriesLayoutBy)];\n\n  if (process.env.NODE_ENV !== 'production') {\n    assert(method, 'Do not support get item on \"' + sourceFormat + '\", \"' + seriesLayoutBy + '\".');\n  }\n\n  return method;\n}\n\nvar countSimply = function (rawData, startIndex, dimsDef) {\n  return rawData.length;\n};\n\nvar rawSourceDataCounterMap = (_b = {}, _b[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_COLUMN] = function (rawData, startIndex, dimsDef) {\n  return Math.max(0, rawData.length - startIndex);\n}, _b[SOURCE_FORMAT_ARRAY_ROWS + '_' + SERIES_LAYOUT_BY_ROW] = function (rawData, startIndex, dimsDef) {\n  var row = rawData[0];\n  return row ? Math.max(0, row.length - startIndex) : 0;\n}, _b[SOURCE_FORMAT_OBJECT_ROWS] = countSimply, _b[SOURCE_FORMAT_KEYED_COLUMNS] = function (rawData, startIndex, dimsDef) {\n  var dimName = dimsDef[0].name;\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (dimName == null) {\n      throw new Error();\n    }\n  }\n\n  var col = rawData[dimName];\n  return col ? col.length : 0;\n}, _b[SOURCE_FORMAT_ORIGINAL] = countSimply, _b);\nexport function getRawSourceDataCounter(sourceFormat, seriesLayoutBy) {\n  var method = rawSourceDataCounterMap[getMethodMapKey(sourceFormat, seriesLayoutBy)];\n\n  if (process.env.NODE_ENV !== 'production') {\n    assert(method, 'Do not suppport count on \"' + sourceFormat + '\", \"' + seriesLayoutBy + '\".');\n  }\n\n  return method;\n}\n\nvar getRawValueSimply = function (dataItem, dimIndex, property) {\n  return dataItem[dimIndex];\n};\n\nvar rawSourceValueGetterMap = (_c = {}, _c[SOURCE_FORMAT_ARRAY_ROWS] = getRawValueSimply, _c[SOURCE_FORMAT_OBJECT_ROWS] = function (dataItem, dimIndex, property) {\n  return dataItem[property];\n}, _c[SOURCE_FORMAT_KEYED_COLUMNS] = getRawValueSimply, _c[SOURCE_FORMAT_ORIGINAL] = function (dataItem, dimIndex, property) {\n  // FIXME: In some case (markpoint in geo (geo-map.html)),\n  // dataItem is {coord: [...]}\n  var value = getDataItemValue(dataItem);\n  return !(value instanceof Array) ? value : value[dimIndex];\n}, _c[SOURCE_FORMAT_TYPED_ARRAY] = getRawValueSimply, _c);\nexport function getRawSourceValueGetter(sourceFormat) {\n  var method = rawSourceValueGetterMap[sourceFormat];\n\n  if (process.env.NODE_ENV !== 'production') {\n    assert(method, 'Do not suppport get value on \"' + sourceFormat + '\".');\n  }\n\n  return method;\n}\n\nfunction getMethodMapKey(sourceFormat, seriesLayoutBy) {\n  return sourceFormat === SOURCE_FORMAT_ARRAY_ROWS ? sourceFormat + '_' + seriesLayoutBy : sourceFormat;\n} // ??? FIXME can these logic be more neat: getRawValue, getRawDataItem,\n// Consider persistent.\n// Caution: why use raw value to display on label or tooltip?\n// A reason is to avoid format. For example time value we do not know\n// how to format is expected. More over, if stack is used, calculated\n// value may be 0.91000000001, which have brings trouble to display.\n// TODO: consider how to treat null/undefined/NaN when display?\n\n\nexport function retrieveRawValue(data, dataIndex, // If dimIndex is null/undefined, return OptionDataItem.\n// Otherwise, return OptionDataValue.\ndim) {\n  if (!data) {\n    return;\n  } // Consider data may be not persistent.\n\n\n  var dataItem = data.getRawDataItem(dataIndex);\n\n  if (dataItem == null) {\n    return;\n  }\n\n  var store = data.getStore();\n  var sourceFormat = store.getSource().sourceFormat;\n\n  if (dim != null) {\n    var dimIndex = data.getDimensionIndex(dim);\n    var property = store.getDimensionProperty(dimIndex);\n    return getRawSourceValueGetter(sourceFormat)(dataItem, dimIndex, property);\n  } else {\n    var result = dataItem;\n\n    if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n      result = getDataItemValue(dataItem);\n    }\n\n    return result;\n  }\n}\n/**\n * Compatible with some cases (in pie, map) like:\n * data: [{name: 'xx', value: 5, selected: true}, ...]\n * where only sourceFormat is 'original' and 'objectRows' supported.\n *\n * // TODO\n * Supported detail options in data item when using 'arrayRows'.\n *\n * @param data\n * @param dataIndex\n * @param attr like 'selected'\n */\n\nexport function retrieveRawAttr(data, dataIndex, attr) {\n  if (!data) {\n    return;\n  }\n\n  var sourceFormat = data.getStore().getSource().sourceFormat;\n\n  if (sourceFormat !== SOURCE_FORMAT_ORIGINAL && sourceFormat !== SOURCE_FORMAT_OBJECT_ROWS) {\n    return;\n  }\n\n  var dataItem = data.getRawDataItem(dataIndex);\n\n  if (sourceFormat === SOURCE_FORMAT_ORIGINAL && !isObject(dataItem)) {\n    dataItem = null;\n  }\n\n  if (dataItem) {\n    return dataItem[attr];\n  }\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { parseDate, numericToNumber } from '../../util/number';\nimport { createHashMap, trim, hasOwn } from 'zrender/lib/core/util';\nimport { throwError } from '../../util/log';\n/**\n * Convert raw the value in to inner value in List.\n *\n * [Performance sensitive]\n *\n * [Caution]: this is the key logic of user value parser.\n * For backward compatibiliy, do not modify it until have to!\n */\n\nexport function parseDataValue(value, // For high performance, do not omit the second param.\nopt) {\n  // Performance sensitive.\n  var dimType = opt && opt.type;\n\n  if (dimType === 'ordinal') {\n    // If given value is a category string\n    return value;\n  }\n\n  if (dimType === 'time' // spead up when using timestamp\n  && typeof value !== 'number' && value != null && value !== '-') {\n    value = +parseDate(value);\n  } // dimType defaults 'number'.\n  // If dimType is not ordinal and value is null or undefined or NaN or '-',\n  // parse to NaN.\n  // number-like string (like ' 123 ') can be converted to a number.\n  // where null/undefined or other string will be converted to NaN.\n\n\n  return value == null || value === '' ? NaN // If string (like '-'), using '+' parse to NaN\n  // If object, also parse to NaN\n  : +value;\n}\n;\nvar valueParserMap = createHashMap({\n  'number': function (val) {\n    // Do not use `numericToNumber` here. We have by defualt `numericToNumber`.\n    // Here the number parser can have loose rule:\n    // enable to cut suffix: \"120px\" => 120, \"14%\" => 14.\n    return parseFloat(val);\n  },\n  'time': function (val) {\n    // return timestamp.\n    return +parseDate(val);\n  },\n  'trim': function (val) {\n    return typeof val === 'string' ? trim(val) : val;\n  }\n});\nexport function getRawValueParser(type) {\n  return valueParserMap.get(type);\n}\nvar ORDER_COMPARISON_OP_MAP = {\n  lt: function (lval, rval) {\n    return lval < rval;\n  },\n  lte: function (lval, rval) {\n    return lval <= rval;\n  },\n  gt: function (lval, rval) {\n    return lval > rval;\n  },\n  gte: function (lval, rval) {\n    return lval >= rval;\n  }\n};\n\nvar FilterOrderComparator =\n/** @class */\nfunction () {\n  function FilterOrderComparator(op, rval) {\n    if (typeof rval !== 'number') {\n      var errMsg = '';\n\n      if (process.env.NODE_ENV !== 'production') {\n        errMsg = 'rvalue of \"<\", \">\", \"<=\", \">=\" can only be number in filter.';\n      }\n\n      throwError(errMsg);\n    }\n\n    this._opFn = ORDER_COMPARISON_OP_MAP[op];\n    this._rvalFloat = numericToNumber(rval);\n  } // Performance sensitive.\n\n\n  FilterOrderComparator.prototype.evaluate = function (lval) {\n    // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.\n    return typeof lval === 'number' ? this._opFn(lval, this._rvalFloat) : this._opFn(numericToNumber(lval), this._rvalFloat);\n  };\n\n  return FilterOrderComparator;\n}();\n\nvar SortOrderComparator =\n/** @class */\nfunction () {\n  /**\n   * @param order by defualt: 'asc'\n   * @param incomparable by defualt: Always on the tail.\n   *        That is, if 'asc' => 'max', if 'desc' => 'min'\n   *        See the definition of \"incomparable\" in [SORT_COMPARISON_RULE]\n   */\n  function SortOrderComparator(order, incomparable) {\n    var isDesc = order === 'desc';\n    this._resultLT = isDesc ? 1 : -1;\n\n    if (incomparable == null) {\n      incomparable = isDesc ? 'min' : 'max';\n    }\n\n    this._incomparable = incomparable === 'min' ? -Infinity : Infinity;\n  } // See [SORT_COMPARISON_RULE].\n  // Performance sensitive.\n\n\n  SortOrderComparator.prototype.evaluate = function (lval, rval) {\n    // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.\n    var lvalTypeof = typeof lval;\n    var rvalTypeof = typeof rval;\n    var lvalFloat = lvalTypeof === 'number' ? lval : numericToNumber(lval);\n    var rvalFloat = rvalTypeof === 'number' ? rval : numericToNumber(rval);\n    var lvalNotNumeric = isNaN(lvalFloat);\n    var rvalNotNumeric = isNaN(rvalFloat);\n\n    if (lvalNotNumeric) {\n      lvalFloat = this._incomparable;\n    }\n\n    if (rvalNotNumeric) {\n      rvalFloat = this._incomparable;\n    }\n\n    if (lvalNotNumeric && rvalNotNumeric) {\n      var lvalIsStr = lvalTypeof === 'string';\n      var rvalIsStr = rvalTypeof === 'string';\n\n      if (lvalIsStr) {\n        lvalFloat = rvalIsStr ? lval : 0;\n      }\n\n      if (rvalIsStr) {\n        rvalFloat = lvalIsStr ? rval : 0;\n      }\n    }\n\n    return lvalFloat < rvalFloat ? this._resultLT : lvalFloat > rvalFloat ? -this._resultLT : 0;\n  };\n\n  return SortOrderComparator;\n}();\n\nexport { SortOrderComparator };\n\nvar FilterEqualityComparator =\n/** @class */\nfunction () {\n  function FilterEqualityComparator(isEq, rval) {\n    this._rval = rval;\n    this._isEQ = isEq;\n    this._rvalTypeof = typeof rval;\n    this._rvalFloat = numericToNumber(rval);\n  } // Performance sensitive.\n\n\n  FilterEqualityComparator.prototype.evaluate = function (lval) {\n    var eqResult = lval === this._rval;\n\n    if (!eqResult) {\n      var lvalTypeof = typeof lval;\n\n      if (lvalTypeof !== this._rvalTypeof && (lvalTypeof === 'number' || this._rvalTypeof === 'number')) {\n        eqResult = numericToNumber(lval) === this._rvalFloat;\n      }\n    }\n\n    return this._isEQ ? eqResult : !eqResult;\n  };\n\n  return FilterEqualityComparator;\n}();\n/**\n * [FILTER_COMPARISON_RULE]\n * `lt`|`lte`|`gt`|`gte`:\n * + rval must be a number. And lval will be converted to number (`numericToNumber`) to compare.\n * `eq`:\n * + If same type, compare with `===`.\n * + If there is one number, convert to number (`numericToNumber`) to compare.\n * + Else return `false`.\n * `ne`:\n * + Not `eq`.\n *\n *\n * [SORT_COMPARISON_RULE]\n * All the values are grouped into three categories:\n * + \"numeric\" (number and numeric string)\n * + \"non-numeric-string\" (string that excluding numeric string)\n * + \"others\"\n * \"numeric\" vs \"numeric\": values are ordered by number order.\n * \"non-numeric-string\" vs \"non-numeric-string\": values are ordered by ES spec (#sec-abstract-relational-comparison).\n * \"others\" vs \"others\": do not change order (always return 0).\n * \"numeric\" vs \"non-numeric-string\": \"non-numeric-string\" is treated as \"incomparable\".\n * \"number\" vs \"others\": \"others\" is treated as \"incomparable\".\n * \"non-numeric-string\" vs \"others\": \"others\" is treated as \"incomparable\".\n * \"incomparable\" will be seen as -Infinity or Infinity (depends on the settings).\n * MEMO:\n *   non-numeric string sort make sence when need to put the items with the same tag together.\n *   But if we support string sort, we still need to avoid the misleading like `'2' > '12'`,\n *   So we treat \"numeric-string\" sorted by number order rather than string comparison.\n *\n *\n * [CHECK_LIST_OF_THE_RULE_DESIGN]\n * + Do not support string comparison until required. And also need to\n *   void the misleading of \"2\" > \"12\".\n * + Should avoid the misleading case:\n *   `\" 22 \" gte \"22\"` is `true` but `\" 22 \" eq \"22\"` is `false`.\n * + JS bad case should be avoided: null <= 0, [] <= 0, ' ' <= 0, ...\n * + Only \"numeric\" can be converted to comparable number, otherwise converted to NaN.\n *   See `util/number.ts#numericToNumber`.\n *\n * @return If `op` is not `RelationalOperator`, return null;\n */\n\n\nexport function createFilterComparator(op, rval) {\n  return op === 'eq' || op === 'ne' ? new FilterEqualityComparator(op === 'eq', rval) : hasOwn(ORDER_COMPARISON_OP_MAP, op) ? new FilterOrderComparator(op, rval) : null;\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { VISUAL_DIMENSIONS } from '../../util/types';\nimport SeriesDimensionDefine from '../SeriesDimensionDefine';\nimport { createHashMap, defaults, each, extend, isObject, isString } from 'zrender/lib/core/util';\nimport { createSourceFromSeriesDataOption, isSourceInstance } from '../Source';\nimport { CtorInt32Array } from '../DataStore';\nimport { normalizeToArray } from '../../util/model';\nimport { BE_ORDINAL, guessOrdinal } from './sourceHelper';\nimport { createDimNameMap, ensureSourceDimNameMap, SeriesDataSchema, shouldOmitUnusedDimensions } from './SeriesDataSchema';\n/**\n * For outside usage compat (like echarts-gl are using it).\n */\n\nexport function createDimensions(source, opt) {\n  return prepareSeriesDataSchema(source, opt).dimensions;\n}\n/**\n * This method builds the relationship between:\n * + \"what the coord sys or series requires (see `coordDimensions`)\",\n * + \"what the user defines (in `encode` and `dimensions`, see `opt.dimensionsDefine` and `opt.encodeDefine`)\"\n * + \"what the data source provids (see `source`)\".\n *\n * Some guess strategy will be adapted if user does not define something.\n * If no 'value' dimension specified, the first no-named dimension will be\n * named as 'value'.\n *\n * @return The results are always sorted by `storeDimIndex` asc.\n */\n\nexport default function prepareSeriesDataSchema( // TODO: TYPE completeDimensions type\nsource, opt) {\n  if (!isSourceInstance(source)) {\n    source = createSourceFromSeriesDataOption(source);\n  }\n\n  opt = opt || {};\n  var sysDims = opt.coordDimensions || [];\n  var dimsDef = opt.dimensionsDefine || source.dimensionsDefine || [];\n  var coordDimNameMap = createHashMap();\n  var resultList = [];\n  var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimensionsCount); // Try to ignore unsed dimensions if sharing a high dimension datastore\n  // 30 is an experience value.\n\n  var omitUnusedDimensions = opt.canOmitUnusedDimensions && shouldOmitUnusedDimensions(dimCount);\n  var isUsingSourceDimensionsDef = dimsDef === source.dimensionsDefine;\n  var dataDimNameMap = isUsingSourceDimensionsDef ? ensureSourceDimNameMap(source) : createDimNameMap(dimsDef);\n  var encodeDef = opt.encodeDefine;\n\n  if (!encodeDef && opt.encodeDefaulter) {\n    encodeDef = opt.encodeDefaulter(source, dimCount);\n  }\n\n  var encodeDefMap = createHashMap(encodeDef);\n  var indicesMap = new CtorInt32Array(dimCount);\n\n  for (var i = 0; i < indicesMap.length; i++) {\n    indicesMap[i] = -1;\n  }\n\n  function getResultItem(dimIdx) {\n    var idx = indicesMap[dimIdx];\n\n    if (idx < 0) {\n      var dimDefItemRaw = dimsDef[dimIdx];\n      var dimDefItem = isObject(dimDefItemRaw) ? dimDefItemRaw : {\n        name: dimDefItemRaw\n      };\n      var resultItem = new SeriesDimensionDefine();\n      var userDimName = dimDefItem.name;\n\n      if (userDimName != null && dataDimNameMap.get(userDimName) != null) {\n        // Only if `series.dimensions` is defined in option\n        // displayName, will be set, and dimension will be diplayed vertically in\n        // tooltip by default.\n        resultItem.name = resultItem.displayName = userDimName;\n      }\n\n      dimDefItem.type != null && (resultItem.type = dimDefItem.type);\n      dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName);\n      var newIdx = resultList.length;\n      indicesMap[dimIdx] = newIdx;\n      resultItem.storeDimIndex = dimIdx;\n      resultList.push(resultItem);\n      return resultItem;\n    }\n\n    return resultList[idx];\n  }\n\n  if (!omitUnusedDimensions) {\n    for (var i = 0; i < dimCount; i++) {\n      getResultItem(i);\n    }\n  } // Set `coordDim` and `coordDimIndex` by `encodeDefMap` and normalize `encodeDefMap`.\n\n\n  encodeDefMap.each(function (dataDimsRaw, coordDim) {\n    var dataDims = normalizeToArray(dataDimsRaw).slice(); // Note: It is allowed that `dataDims.length` is `0`, e.g., options is\n    // `{encode: {x: -1, y: 1}}`. Should not filter anything in\n    // this case.\n\n    if (dataDims.length === 1 && !isString(dataDims[0]) && dataDims[0] < 0) {\n      encodeDefMap.set(coordDim, false);\n      return;\n    }\n\n    var validDataDims = encodeDefMap.set(coordDim, []);\n    each(dataDims, function (resultDimIdxOrName, idx) {\n      // The input resultDimIdx can be dim name or index.\n      var resultDimIdx = isString(resultDimIdxOrName) ? dataDimNameMap.get(resultDimIdxOrName) : resultDimIdxOrName;\n\n      if (resultDimIdx != null && resultDimIdx < dimCount) {\n        validDataDims[idx] = resultDimIdx;\n        applyDim(getResultItem(resultDimIdx), coordDim, idx);\n      }\n    });\n  }); // Apply templetes and default order from `sysDims`.\n\n  var availDimIdx = 0;\n  each(sysDims, function (sysDimItemRaw) {\n    var coordDim;\n    var sysDimItemDimsDef;\n    var sysDimItemOtherDims;\n    var sysDimItem;\n\n    if (isString(sysDimItemRaw)) {\n      coordDim = sysDimItemRaw;\n      sysDimItem = {};\n    } else {\n      sysDimItem = sysDimItemRaw;\n      coordDim = sysDimItem.name;\n      var ordinalMeta = sysDimItem.ordinalMeta;\n      sysDimItem.ordinalMeta = null;\n      sysDimItem = extend({}, sysDimItem);\n      sysDimItem.ordinalMeta = ordinalMeta; // `coordDimIndex` should not be set directly.\n\n      sysDimItemDimsDef = sysDimItem.dimsDef;\n      sysDimItemOtherDims = sysDimItem.otherDims;\n      sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;\n    }\n\n    var dataDims = encodeDefMap.get(coordDim); // negative resultDimIdx means no need to mapping.\n\n    if (dataDims === false) {\n      return;\n    }\n\n    dataDims = normalizeToArray(dataDims); // dimensions provides default dim sequences.\n\n    if (!dataDims.length) {\n      for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {\n        while (availDimIdx < dimCount && getResultItem(availDimIdx).coordDim != null) {\n          availDimIdx++;\n        }\n\n        availDimIdx < dimCount && dataDims.push(availDimIdx++);\n      }\n    } // Apply templates.\n\n\n    each(dataDims, function (resultDimIdx, coordDimIndex) {\n      var resultItem = getResultItem(resultDimIdx); // Coordinate system has a higher priority on dim type than source.\n\n      if (isUsingSourceDimensionsDef && sysDimItem.type != null) {\n        resultItem.type = sysDimItem.type;\n      }\n\n      applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);\n\n      if (resultItem.name == null && sysDimItemDimsDef) {\n        var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];\n        !isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {\n          name: sysDimItemDimsDefItem\n        });\n        resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name;\n        resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;\n      } // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}\n\n\n      sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);\n    });\n  });\n\n  function applyDim(resultItem, coordDim, coordDimIndex) {\n    if (VISUAL_DIMENSIONS.get(coordDim) != null) {\n      resultItem.otherDims[coordDim] = coordDimIndex;\n    } else {\n      resultItem.coordDim = coordDim;\n      resultItem.coordDimIndex = coordDimIndex;\n      coordDimNameMap.set(coordDim, true);\n    }\n  } // Make sure the first extra dim is 'value'.\n\n\n  var generateCoord = opt.generateCoord;\n  var generateCoordCount = opt.generateCoordCount;\n  var fromZero = generateCoordCount != null;\n  generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;\n  var extra = generateCoord || 'value';\n\n  function ifNoNameFillWithCoordName(resultItem) {\n    if (resultItem.name == null) {\n      // Duplication will be removed in the next step.\n      resultItem.name = resultItem.coordDim;\n    }\n  } // Set dim `name` and other `coordDim` and other props.\n\n\n  if (!omitUnusedDimensions) {\n    for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {\n      var resultItem = getResultItem(resultDimIdx);\n      var coordDim = resultItem.coordDim;\n\n      if (coordDim == null) {\n        // TODO no need to generate coordDim for isExtraCoord?\n        resultItem.coordDim = genCoordDimName(extra, coordDimNameMap, fromZero);\n        resultItem.coordDimIndex = 0; // Series specified generateCoord is using out.\n\n        if (!generateCoord || generateCoordCount <= 0) {\n          resultItem.isExtraCoord = true;\n        }\n\n        generateCoordCount--;\n      }\n\n      ifNoNameFillWithCoordName(resultItem);\n\n      if (resultItem.type == null && (guessOrdinal(source, resultDimIdx) === BE_ORDINAL.Must // Consider the case:\n      // {\n      //    dataset: {source: [\n      //        ['2001', 123],\n      //        ['2002', 456],\n      //        ...\n      //        ['The others', 987],\n      //    ]},\n      //    series: {type: 'pie'}\n      // }\n      // The first colum should better be treated as a \"ordinal\" although it\n      // might not able to be detected as an \"ordinal\" by `guessOrdinal`.\n      || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {\n        resultItem.type = 'ordinal';\n      }\n    }\n  } else {\n    each(resultList, function (resultItem) {\n      // PENDING: guessOrdinal or let user specify type: 'ordinal' manually?\n      ifNoNameFillWithCoordName(resultItem);\n    }); // Sort dimensions: there are some rule that use the last dim as label,\n    // and for some latter travel process easier.\n\n    resultList.sort(function (item0, item1) {\n      return item0.storeDimIndex - item1.storeDimIndex;\n    });\n  }\n\n  removeDuplication(resultList);\n  return new SeriesDataSchema({\n    source: source,\n    dimensions: resultList,\n    fullDimensionCount: dimCount,\n    dimensionOmitted: omitUnusedDimensions\n  });\n}\n\nfunction removeDuplication(result) {\n  var duplicationMap = createHashMap();\n\n  for (var i = 0; i < result.length; i++) {\n    var dim = result[i];\n    var dimOriginalName = dim.name;\n    var count = duplicationMap.get(dimOriginalName) || 0;\n\n    if (count > 0) {\n      // Starts from 0.\n      dim.name = dimOriginalName + (count - 1);\n    }\n\n    count++;\n    duplicationMap.set(dimOriginalName, count);\n  }\n} // ??? TODO\n// Originally detect dimCount by data[0]. Should we\n// optimize it to only by sysDims and dimensions and encode.\n// So only necessary dims will be initialized.\n// But\n// (1) custom series should be considered. where other dims\n// may be visited.\n// (2) sometimes user need to calcualte bubble size or use visualMap\n// on other dimensions besides coordSys needed.\n// So, dims that is not used by system, should be shared in data store?\n\n\nfunction getDimCount(source, sysDims, dimsDef, optDimCount) {\n  // Note that the result dimCount should not small than columns count\n  // of data, otherwise `dataDimNameMap` checking will be incorrect.\n  var dimCount = Math.max(source.dimensionsDetectedCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);\n  each(sysDims, function (sysDimItem) {\n    var sysDimItemDimsDef;\n\n    if (isObject(sysDimItem) && (sysDimItemDimsDef = sysDimItem.dimsDef)) {\n      dimCount = Math.max(dimCount, sysDimItemDimsDef.length);\n    }\n  });\n  return dimCount;\n}\n\nfunction genCoordDimName(name, map, fromZero) {\n  var mapData = map.data;\n\n  if (fromZero || mapData.hasOwnProperty(name)) {\n    var i = 0;\n\n    while (mapData.hasOwnProperty(name + i)) {\n      i++;\n    }\n\n    name += i;\n  }\n\n  map.set(name, true);\n  return name;\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { each, createHashMap, assert, map } from 'zrender/lib/core/util';\nimport { VISUAL_DIMENSIONS } from '../../util/types';\n\nvar DimensionUserOuput =\n/** @class */\nfunction () {\n  function DimensionUserOuput(encode, dimRequest) {\n    this._encode = encode;\n    this._schema = dimRequest;\n  }\n\n  DimensionUserOuput.prototype.get = function () {\n    return {\n      // Do not generate full dimension name until fist used.\n      fullDimensions: this._getFullDimensionNames(),\n      encode: this._encode\n    };\n  };\n  /**\n   * Get all data store dimension names.\n   * Theoretically a series data store is defined both by series and used dataset (if any).\n   * If some dimensions are omitted for performance reason in `this.dimensions`,\n   * the dimension name may not be auto-generated if user does not specify a dimension name.\n   * In this case, the dimension name is `null`/`undefined`.\n   */\n\n\n  DimensionUserOuput.prototype._getFullDimensionNames = function () {\n    if (!this._cachedDimNames) {\n      this._cachedDimNames = this._schema ? this._schema.makeOutputDimensionNames() : [];\n    }\n\n    return this._cachedDimNames;\n  };\n\n  return DimensionUserOuput;\n}();\n\n;\nexport function summarizeDimensions(data, schema) {\n  var summary = {};\n  var encode = summary.encode = {};\n  var notExtraCoordDimMap = createHashMap();\n  var defaultedLabel = [];\n  var defaultedTooltip = [];\n  var userOutputEncode = {};\n  each(data.dimensions, function (dimName) {\n    var dimItem = data.getDimensionInfo(dimName);\n    var coordDim = dimItem.coordDim;\n\n    if (coordDim) {\n      if (process.env.NODE_ENV !== 'production') {\n        assert(VISUAL_DIMENSIONS.get(coordDim) == null);\n      }\n\n      var coordDimIndex = dimItem.coordDimIndex;\n      getOrCreateEncodeArr(encode, coordDim)[coordDimIndex] = dimName;\n\n      if (!dimItem.isExtraCoord) {\n        notExtraCoordDimMap.set(coordDim, 1); // Use the last coord dim (and label friendly) as default label,\n        // because when dataset is used, it is hard to guess which dimension\n        // can be value dimension. If both show x, y on label is not look good,\n        // and conventionally y axis is focused more.\n\n        if (mayLabelDimType(dimItem.type)) {\n          defaultedLabel[0] = dimName;\n        } // User output encode do not contain generated coords.\n        // And it only has index. User can use index to retrieve value from the raw item array.\n\n\n        getOrCreateEncodeArr(userOutputEncode, coordDim)[coordDimIndex] = data.getDimensionIndex(dimItem.name);\n      }\n\n      if (dimItem.defaultTooltip) {\n        defaultedTooltip.push(dimName);\n      }\n    }\n\n    VISUAL_DIMENSIONS.each(function (v, otherDim) {\n      var encodeArr = getOrCreateEncodeArr(encode, otherDim);\n      var dimIndex = dimItem.otherDims[otherDim];\n\n      if (dimIndex != null && dimIndex !== false) {\n        encodeArr[dimIndex] = dimItem.name;\n      }\n    });\n  });\n  var dataDimsOnCoord = [];\n  var encodeFirstDimNotExtra = {};\n  notExtraCoordDimMap.each(function (v, coordDim) {\n    var dimArr = encode[coordDim];\n    encodeFirstDimNotExtra[coordDim] = dimArr[0]; // Not necessary to remove duplicate, because a data\n    // dim canot on more than one coordDim.\n\n    dataDimsOnCoord = dataDimsOnCoord.concat(dimArr);\n  });\n  summary.dataDimsOnCoord = dataDimsOnCoord;\n  summary.dataDimIndicesOnCoord = map(dataDimsOnCoord, function (dimName) {\n    return data.getDimensionInfo(dimName).storeDimIndex;\n  });\n  summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra;\n  var encodeLabel = encode.label; // FIXME `encode.label` is not recommanded, because formatter can not be set\n  // in this way. Use label.formatter instead. May be remove this approach someday.\n\n  if (encodeLabel && encodeLabel.length) {\n    defaultedLabel = encodeLabel.slice();\n  }\n\n  var encodeTooltip = encode.tooltip;\n\n  if (encodeTooltip && encodeTooltip.length) {\n    defaultedTooltip = encodeTooltip.slice();\n  } else if (!defaultedTooltip.length) {\n    defaultedTooltip = defaultedLabel.slice();\n  }\n\n  encode.defaultedLabel = defaultedLabel;\n  encode.defaultedTooltip = defaultedTooltip;\n  summary.userOutput = new DimensionUserOuput(userOutputEncode, schema);\n  return summary;\n}\n\nfunction getOrCreateEncodeArr(encode, dim) {\n  if (!encode.hasOwnProperty(dim)) {\n    encode[dim] = [];\n  }\n\n  return encode[dim];\n} // FIXME:TS should be type `AxisType`\n\n\nexport function getDimensionTypeByAxis(axisType) {\n  return axisType === 'category' ? 'ordinal' : axisType === 'time' ? 'time' : 'float';\n}\n\nfunction mayLabelDimType(dimType) {\n  // In most cases, ordinal and time do not suitable for label.\n  // Ordinal info can be displayed on axis. Time is too long.\n  return !(dimType === 'ordinal' || dimType === 'time');\n} // function findTheLastDimMayLabel(data) {\n//     // Get last value dim\n//     let dimensions = data.dimensions.slice();\n//     let valueType;\n//     let valueDim;\n//     while (dimensions.length && (\n//         valueDim = dimensions.pop(),\n//         valueType = data.getDimensionInfo(valueDim).type,\n//         valueType === 'ordinal' || valueType === 'time'\n//     )) {} // jshint ignore:line\n//     return valueDim;\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { createHashMap, isObject, retrieve2 } from 'zrender/lib/core/util';\nimport { makeInner } from '../../util/model';\nimport { shouldRetrieveDataByName } from '../Source';\nvar inner = makeInner();\nvar dimTypeShort = {\n  float: 'f',\n  int: 'i',\n  ordinal: 'o',\n  number: 'n',\n  time: 't'\n};\n/**\n * Represents the dimension requirement of a series.\n *\n * NOTICE:\n * When there are too many dimensions in dataset and many series, only the used dimensions\n * (i.e., used by coord sys and declared in `series.encode`) are add to `dimensionDefineList`.\n * But users may query data by other unused dimension names.\n * In this case, users can only query data if and only if they have defined dimension names\n * via ec option, so we provide `getDimensionIndexFromSource`, which only query them from\n * `source` dimensions.\n */\n\nvar SeriesDataSchema =\n/** @class */\nfunction () {\n  function SeriesDataSchema(opt) {\n    this.dimensions = opt.dimensions;\n    this._dimOmitted = opt.dimensionOmitted;\n    this.source = opt.source;\n    this._fullDimCount = opt.fullDimensionCount;\n\n    this._updateDimOmitted(opt.dimensionOmitted);\n  }\n\n  SeriesDataSchema.prototype.isDimensionOmitted = function () {\n    return this._dimOmitted;\n  };\n\n  SeriesDataSchema.prototype._updateDimOmitted = function (dimensionOmitted) {\n    this._dimOmitted = dimensionOmitted;\n\n    if (!dimensionOmitted) {\n      return;\n    }\n\n    if (!this._dimNameMap) {\n      this._dimNameMap = ensureSourceDimNameMap(this.source);\n    }\n  };\n  /**\n   * @caution Can only be used when `dimensionOmitted: true`.\n   *\n   * Get index by user defined dimension name (i.e., not internal generate name).\n   * That is, get index from `dimensionsDefine`.\n   * If no `dimensionsDefine`, or no name get, return -1.\n   */\n\n\n  SeriesDataSchema.prototype.getSourceDimensionIndex = function (dimName) {\n    return retrieve2(this._dimNameMap.get(dimName), -1);\n  };\n  /**\n   * @caution Can only be used when `dimensionOmitted: true`.\n   *\n   * Notice: may return `null`/`undefined` if user not specify dimension names.\n   */\n\n\n  SeriesDataSchema.prototype.getSourceDimension = function (dimIndex) {\n    var dimensionsDefine = this.source.dimensionsDefine;\n\n    if (dimensionsDefine) {\n      return dimensionsDefine[dimIndex];\n    }\n  };\n\n  SeriesDataSchema.prototype.makeStoreSchema = function () {\n    var dimCount = this._fullDimCount;\n    var willRetrieveDataByName = shouldRetrieveDataByName(this.source);\n    var makeHashStrict = !shouldOmitUnusedDimensions(dimCount); // If source don't have dimensions or series don't omit unsed dimensions.\n    // Generate from seriesDimList directly\n\n    var dimHash = '';\n    var dims = [];\n\n    for (var fullDimIdx = 0, seriesDimIdx = 0; fullDimIdx < dimCount; fullDimIdx++) {\n      var property = void 0;\n      var type = void 0;\n      var ordinalMeta = void 0;\n      var seriesDimDef = this.dimensions[seriesDimIdx]; // The list has been sorted by `storeDimIndex` asc.\n\n      if (seriesDimDef && seriesDimDef.storeDimIndex === fullDimIdx) {\n        property = willRetrieveDataByName ? seriesDimDef.name : null;\n        type = seriesDimDef.type;\n        ordinalMeta = seriesDimDef.ordinalMeta;\n        seriesDimIdx++;\n      } else {\n        var sourceDimDef = this.getSourceDimension(fullDimIdx);\n\n        if (sourceDimDef) {\n          property = willRetrieveDataByName ? sourceDimDef.name : null;\n          type = sourceDimDef.type;\n        }\n      }\n\n      dims.push({\n        property: property,\n        type: type,\n        ordinalMeta: ordinalMeta\n      }); // If retrieving data by index,\n      //   use <index, type, ordinalMeta> to determine whether data can be shared.\n      //   (Becuase in this case there might be no dimension name defined in dataset, but indices always exists).\n      //   (indices are always 0, 1, 2, ..., so we can ignore them to shorten the hash).\n      // Otherwise if retrieving data by property name (like `data: [{aa: 123, bb: 765}, ...]`),\n      //   use <property, type, ordinalMeta> in hash.\n\n      if (willRetrieveDataByName && property != null // For data stack, we have make sure each series has its own dim on this store.\n      // So we do not add property to hash to make sure they can share this store.\n      && (!seriesDimDef || !seriesDimDef.isCalculationCoord)) {\n        dimHash += makeHashStrict // Use escape character '`' in case that property name contains '$'.\n        ? property.replace(/\\`/g, '`1').replace(/\\$/g, '`2') // For better performance, when there are large dimensions, tolerant this defects that hardly meet.\n        : property;\n      }\n\n      dimHash += '$';\n      dimHash += dimTypeShort[type] || 'f';\n\n      if (ordinalMeta) {\n        dimHash += ordinalMeta.uid;\n      }\n\n      dimHash += '$';\n    } // Source from endpoint(usually series) will be read differently\n    // when seriesLayoutBy or startIndex(which is affected by sourceHeader) are different.\n    // So we use this three props as key.\n\n\n    var source = this.source;\n    var hash = [source.seriesLayoutBy, source.startIndex, dimHash].join('$$');\n    return {\n      dimensions: dims,\n      hash: hash\n    };\n  };\n\n  SeriesDataSchema.prototype.makeOutputDimensionNames = function () {\n    var result = [];\n\n    for (var fullDimIdx = 0, seriesDimIdx = 0; fullDimIdx < this._fullDimCount; fullDimIdx++) {\n      var name_1 = void 0;\n      var seriesDimDef = this.dimensions[seriesDimIdx]; // The list has been sorted by `storeDimIndex` asc.\n\n      if (seriesDimDef && seriesDimDef.storeDimIndex === fullDimIdx) {\n        if (!seriesDimDef.isCalculationCoord) {\n          name_1 = seriesDimDef.name;\n        }\n\n        seriesDimIdx++;\n      } else {\n        var sourceDimDef = this.getSourceDimension(fullDimIdx);\n\n        if (sourceDimDef) {\n          name_1 = sourceDimDef.name;\n        }\n      }\n\n      result.push(name_1);\n    }\n\n    return result;\n  };\n\n  SeriesDataSchema.prototype.appendCalculationDimension = function (dimDef) {\n    this.dimensions.push(dimDef);\n    dimDef.isCalculationCoord = true;\n    this._fullDimCount++; // If append dimension on a data store, consider the store\n    // might be shared by different series, series dimensions not\n    // really map to store dimensions.\n\n    this._updateDimOmitted(true);\n  };\n\n  return SeriesDataSchema;\n}();\n\nexport { SeriesDataSchema };\nexport function isSeriesDataSchema(schema) {\n  return schema instanceof SeriesDataSchema;\n}\nexport function createDimNameMap(dimsDef) {\n  var dataDimNameMap = createHashMap();\n\n  for (var i = 0; i < (dimsDef || []).length; i++) {\n    var dimDefItemRaw = dimsDef[i];\n    var userDimName = isObject(dimDefItemRaw) ? dimDefItemRaw.name : dimDefItemRaw;\n\n    if (userDimName != null && dataDimNameMap.get(userDimName) == null) {\n      dataDimNameMap.set(userDimName, i);\n    }\n  }\n\n  return dataDimNameMap;\n}\nexport function ensureSourceDimNameMap(source) {\n  var innerSource = inner(source);\n  return innerSource.dimNameMap || (innerSource.dimNameMap = createDimNameMap(source.dimensionsDefine));\n}\nexport function shouldOmitUnusedDimensions(dimCount) {\n  return dimCount > 30;\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { setAsPrimitive, map, isTypedArray, assert, each, retrieve2 } from 'zrender/lib/core/util';\nimport { createSource, cloneSourceShallow } from '../Source';\nimport { SOURCE_FORMAT_TYPED_ARRAY, SOURCE_FORMAT_ORIGINAL } from '../../util/types';\nimport { querySeriesUpstreamDatasetModel, queryDatasetUpstreamDatasetModels } from './sourceHelper';\nimport { applyDataTransform } from './transform';\nimport DataStore from '../DataStore';\nimport { DefaultDataProvider } from './dataProvider';\n/**\n * [REQUIREMENT_MEMO]:\n * (0) `metaRawOption` means `dimensions`/`sourceHeader`/`seriesLayoutBy` in raw option.\n * (1) Keep support the feature: `metaRawOption` can be specified both on `series` and\n * `root-dataset`. Them on `series` has higher priority.\n * (2) Do not support to set `metaRawOption` on a `non-root-dataset`, because it might\n * confuse users: whether those props indicate how to visit the upstream source or visit\n * the transform result source, and some transforms has nothing to do with these props,\n * and some transforms might have multiple upstream.\n * (3) Transforms should specify `metaRawOption` in each output, just like they can be\n * declared in `root-dataset`.\n * (4) At present only support visit source in `SERIES_LAYOUT_BY_COLUMN` in transforms.\n * That is for reducing complexity in transfroms.\n * PENDING: Whether to provide transposition transform?\n *\n * [IMPLEMENTAION_MEMO]:\n * \"sourceVisitConfig\" are calculated from `metaRawOption` and `data`.\n * They will not be calculated until `source` is about to be visited (to prevent from\n * duplicate calcuation). `source` is visited only in series and input to transforms.\n *\n * [DIMENSION_INHERIT_RULE]:\n * By default the dimensions are inherited from ancestors, unless a transform return\n * a new dimensions definition.\n * Consider the case:\n * ```js\n * dataset: [{\n *     source: [ ['Product', 'Sales', 'Prise'], ['Cookies', 321, 44.21], ...]\n * }, {\n *     transform: { type: 'filter', ... }\n * }]\n * dataset: [{\n *     dimension: ['Product', 'Sales', 'Prise'],\n *     source: [ ['Cookies', 321, 44.21], ...]\n * }, {\n *     transform: { type: 'filter', ... }\n * }]\n * ```\n * The two types of option should have the same behavior after transform.\n *\n *\n * [SCENARIO]:\n * (1) Provide source data directly:\n * ```js\n * series: {\n *     encode: {...},\n *     dimensions: [...]\n *     seriesLayoutBy: 'row',\n *     data: [[...]]\n * }\n * ```\n * (2) Series refer to dataset.\n * ```js\n * series: [{\n *     encode: {...}\n *     // Ignore datasetIndex means `datasetIndex: 0`\n *     // and the dimensions defination in dataset is used\n * }, {\n *     encode: {...},\n *     seriesLayoutBy: 'column',\n *     datasetIndex: 1\n * }]\n * ```\n * (3) dataset transform\n * ```js\n * dataset: [{\n *     source: [...]\n * }, {\n *     source: [...]\n * }, {\n *     // By default from 0.\n *     transform: { type: 'filter', config: {...} }\n * }, {\n *     // Piped.\n *     transform: [\n *         { type: 'filter', config: {...} },\n *         { type: 'sort', config: {...} }\n *     ]\n * }, {\n *     id: 'regressionData',\n *     fromDatasetIndex: 1,\n *     // Third-party transform\n *     transform: { type: 'ecStat:regression', config: {...} }\n * }, {\n *     // retrieve the extra result.\n *     id: 'regressionFormula',\n *     fromDatasetId: 'regressionData',\n *     fromTransformResult: 1\n * }]\n * ```\n */\n\nvar SourceManager =\n/** @class */\nfunction () {\n  function SourceManager(sourceHost) {\n    // Cached source. Do not repeat calculating if not dirty.\n    this._sourceList = [];\n    this._storeList = []; // version sign of each upstream source manager.\n\n    this._upstreamSignList = [];\n    this._versionSignBase = 0;\n    this._dirty = true;\n    this._sourceHost = sourceHost;\n  }\n  /**\n   * Mark dirty.\n   */\n\n\n  SourceManager.prototype.dirty = function () {\n    this._setLocalSource([], []);\n\n    this._storeList = [];\n    this._dirty = true;\n  };\n\n  SourceManager.prototype._setLocalSource = function (sourceList, upstreamSignList) {\n    this._sourceList = sourceList;\n    this._upstreamSignList = upstreamSignList;\n    this._versionSignBase++;\n\n    if (this._versionSignBase > 9e10) {\n      this._versionSignBase = 0;\n    }\n  };\n  /**\n   * For detecting whether the upstream source is dirty, so that\n   * the local cached source (in `_sourceList`) should be discarded.\n   */\n\n\n  SourceManager.prototype._getVersionSign = function () {\n    return this._sourceHost.uid + '_' + this._versionSignBase;\n  };\n  /**\n   * Always return a source instance. Otherwise throw error.\n   */\n\n\n  SourceManager.prototype.prepareSource = function () {\n    // For the case that call `setOption` multiple time but no data changed,\n    // cache the result source to prevent from repeating transform.\n    if (this._isDirty()) {\n      this._createSource();\n\n      this._dirty = false;\n    }\n  };\n\n  SourceManager.prototype._createSource = function () {\n    this._setLocalSource([], []);\n\n    var sourceHost = this._sourceHost;\n\n    var upSourceMgrList = this._getUpstreamSourceManagers();\n\n    var hasUpstream = !!upSourceMgrList.length;\n    var resultSourceList;\n    var upstreamSignList;\n\n    if (isSeries(sourceHost)) {\n      var seriesModel = sourceHost;\n      var data = void 0;\n      var sourceFormat = void 0;\n      var upSource = void 0; // Has upstream dataset\n\n      if (hasUpstream) {\n        var upSourceMgr = upSourceMgrList[0];\n        upSourceMgr.prepareSource();\n        upSource = upSourceMgr.getSource();\n        data = upSource.data;\n        sourceFormat = upSource.sourceFormat;\n        upstreamSignList = [upSourceMgr._getVersionSign()];\n      } // Series data is from own.\n      else {\n          data = seriesModel.get('data', true);\n          sourceFormat = isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL;\n          upstreamSignList = [];\n        } // See [REQUIREMENT_MEMO], merge settings on series and parent dataset if it is root.\n\n\n      var newMetaRawOption = this._getSourceMetaRawOption() || {};\n      var upMetaRawOption = upSource && upSource.metaRawOption || {};\n      var seriesLayoutBy = retrieve2(newMetaRawOption.seriesLayoutBy, upMetaRawOption.seriesLayoutBy) || null;\n      var sourceHeader = retrieve2(newMetaRawOption.sourceHeader, upMetaRawOption.sourceHeader) || null; // Note here we should not use `upSource.dimensionsDefine`. Consider the case:\n      // `upSource.dimensionsDefine` is detected by `seriesLayoutBy: 'column'`,\n      // but series need `seriesLayoutBy: 'row'`.\n\n      var dimensions = retrieve2(newMetaRawOption.dimensions, upMetaRawOption.dimensions); // We share source with dataset as much as possible\n      // to avoid extra memroy cost of high dimensional data.\n\n      var needsCreateSource = seriesLayoutBy !== upMetaRawOption.seriesLayoutBy || !!sourceHeader !== !!upMetaRawOption.sourceHeader || dimensions;\n      resultSourceList = needsCreateSource ? [createSource(data, {\n        seriesLayoutBy: seriesLayoutBy,\n        sourceHeader: sourceHeader,\n        dimensions: dimensions\n      }, sourceFormat)] : [];\n    } else {\n      var datasetModel = sourceHost; // Has upstream dataset.\n\n      if (hasUpstream) {\n        var result = this._applyTransform(upSourceMgrList);\n\n        resultSourceList = result.sourceList;\n        upstreamSignList = result.upstreamSignList;\n      } // Is root dataset.\n      else {\n          var sourceData = datasetModel.get('source', true);\n          resultSourceList = [createSource(sourceData, this._getSourceMetaRawOption(), null)];\n          upstreamSignList = [];\n        }\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      assert(resultSourceList && upstreamSignList);\n    }\n\n    this._setLocalSource(resultSourceList, upstreamSignList);\n  };\n\n  SourceManager.prototype._applyTransform = function (upMgrList) {\n    var datasetModel = this._sourceHost;\n    var transformOption = datasetModel.get('transform', true);\n    var fromTransformResult = datasetModel.get('fromTransformResult', true);\n\n    if (process.env.NODE_ENV !== 'production') {\n      assert(fromTransformResult != null || transformOption != null);\n    }\n\n    if (fromTransformResult != null) {\n      var errMsg = '';\n\n      if (upMgrList.length !== 1) {\n        if (process.env.NODE_ENV !== 'production') {\n          errMsg = 'When using `fromTransformResult`, there should be only one upstream dataset';\n        }\n\n        doThrow(errMsg);\n      }\n    }\n\n    var sourceList;\n    var upSourceList = [];\n    var upstreamSignList = [];\n    each(upMgrList, function (upMgr) {\n      upMgr.prepareSource();\n      var upSource = upMgr.getSource(fromTransformResult || 0);\n      var errMsg = '';\n\n      if (fromTransformResult != null && !upSource) {\n        if (process.env.NODE_ENV !== 'production') {\n          errMsg = 'Can not retrieve result by `fromTransformResult`: ' + fromTransformResult;\n        }\n\n        doThrow(errMsg);\n      }\n\n      upSourceList.push(upSource);\n      upstreamSignList.push(upMgr._getVersionSign());\n    });\n\n    if (transformOption) {\n      sourceList = applyDataTransform(transformOption, upSourceList, {\n        datasetIndex: datasetModel.componentIndex\n      });\n    } else if (fromTransformResult != null) {\n      sourceList = [cloneSourceShallow(upSourceList[0])];\n    }\n\n    return {\n      sourceList: sourceList,\n      upstreamSignList: upstreamSignList\n    };\n  };\n\n  SourceManager.prototype._isDirty = function () {\n    if (this._dirty) {\n      return true;\n    } // All sourceList is from the some upsteam.\n\n\n    var upSourceMgrList = this._getUpstreamSourceManagers();\n\n    for (var i = 0; i < upSourceMgrList.length; i++) {\n      var upSrcMgr = upSourceMgrList[i];\n\n      if ( // Consider the case that there is ancestor diry, call it recursively.\n      // The performance is probably not an issue because usually the chain is not long.\n      upSrcMgr._isDirty() || this._upstreamSignList[i] !== upSrcMgr._getVersionSign()) {\n        return true;\n      }\n    }\n  };\n  /**\n   * @param sourceIndex By defualt 0, means \"main source\".\n   *                    Most cases there is only one source.\n   */\n\n\n  SourceManager.prototype.getSource = function (sourceIndex) {\n    sourceIndex = sourceIndex || 0;\n    var source = this._sourceList[sourceIndex];\n\n    if (!source) {\n      // Series may share source instance with dataset.\n      var upSourceMgrList = this._getUpstreamSourceManagers();\n\n      return upSourceMgrList[0] && upSourceMgrList[0].getSource(sourceIndex);\n    }\n\n    return source;\n  };\n  /**\n   *\n   * Get a data store which can be shared across series.\n   * Only available for series.\n   *\n   * @param seriesDimRequest Dimensions that are generated in series.\n   *        Should have been sorted by `storeDimIndex` asc.\n   */\n\n\n  SourceManager.prototype.getSharedDataStore = function (seriesDimRequest) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert(isSeries(this._sourceHost), 'Can only call getDataStore on series source manager.');\n    }\n\n    var schema = seriesDimRequest.makeStoreSchema();\n    return this._innerGetDataStore(schema.dimensions, seriesDimRequest.source, schema.hash);\n  };\n\n  SourceManager.prototype._innerGetDataStore = function (storeDims, seriesSource, sourceReadKey) {\n    // TODO Can use other sourceIndex?\n    var sourceIndex = 0;\n    var storeList = this._storeList;\n    var cachedStoreMap = storeList[sourceIndex];\n\n    if (!cachedStoreMap) {\n      cachedStoreMap = storeList[sourceIndex] = {};\n    }\n\n    var cachedStore = cachedStoreMap[sourceReadKey];\n\n    if (!cachedStore) {\n      var upSourceMgr = this._getUpstreamSourceManagers()[0];\n\n      if (isSeries(this._sourceHost) && upSourceMgr) {\n        cachedStore = upSourceMgr._innerGetDataStore(storeDims, seriesSource, sourceReadKey);\n      } else {\n        cachedStore = new DataStore(); // Always create store from source of series.\n\n        cachedStore.initData(new DefaultDataProvider(seriesSource, storeDims.length), storeDims);\n      }\n\n      cachedStoreMap[sourceReadKey] = cachedStore;\n    }\n\n    return cachedStore;\n  };\n  /**\n   * PEDING: Is it fast enough?\n   * If no upstream, return empty array.\n   */\n\n\n  SourceManager.prototype._getUpstreamSourceManagers = function () {\n    // Always get the relationship from the raw option.\n    // Do not cache the link of the dependency graph, so that\n    // no need to update them when change happen.\n    var sourceHost = this._sourceHost;\n\n    if (isSeries(sourceHost)) {\n      var datasetModel = querySeriesUpstreamDatasetModel(sourceHost);\n      return !datasetModel ? [] : [datasetModel.getSourceManager()];\n    } else {\n      return map(queryDatasetUpstreamDatasetModels(sourceHost), function (datasetModel) {\n        return datasetModel.getSourceManager();\n      });\n    }\n  };\n\n  SourceManager.prototype._getSourceMetaRawOption = function () {\n    var sourceHost = this._sourceHost;\n    var seriesLayoutBy;\n    var sourceHeader;\n    var dimensions;\n\n    if (isSeries(sourceHost)) {\n      seriesLayoutBy = sourceHost.get('seriesLayoutBy', true);\n      sourceHeader = sourceHost.get('sourceHeader', true);\n      dimensions = sourceHost.get('dimensions', true);\n    } // See [REQUIREMENT_MEMO], `non-root-dataset` do not support them.\n    else if (!this._getUpstreamSourceManagers().length) {\n        var model = sourceHost;\n        seriesLayoutBy = model.get('seriesLayoutBy', true);\n        sourceHeader = model.get('sourceHeader', true);\n        dimensions = model.get('dimensions', true);\n      }\n\n    return {\n      seriesLayoutBy: seriesLayoutBy,\n      sourceHeader: sourceHeader,\n      dimensions: dimensions\n    };\n  };\n\n  return SourceManager;\n}();\n\nexport { SourceManager }; // Call this method after `super.init` and `super.mergeOption` to\n// disable the transform merge, but do not disable transfrom clone from rawOption.\n\nexport function disableTransformOptionMerge(datasetModel) {\n  var transformOption = datasetModel.option.transform;\n  transformOption && setAsPrimitive(datasetModel.option.transform);\n}\n\nfunction isSeries(sourceHost) {\n  // Avoid circular dependency with Series.ts\n  return sourceHost.mainType === 'series';\n}\n\nfunction doThrow(errMsg) {\n  throw new Error(errMsg);\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { registerPreprocessor, registerProcessor, registerPostInit, registerPostUpdate, registerAction, registerCoordinateSystem, registerLayout, registerVisual, registerTransform, registerLoading, registerMap, registerUpdateLifecycle, PRIORITY } from './core/echarts';\nimport ComponentView from './view/Component';\nimport ChartView from './view/Chart';\nimport ComponentModel from './model/Component';\nimport SeriesModel from './model/Series';\nimport { isFunction, indexOf, isArray, each } from 'zrender/lib/core/util';\nimport { registerPainter } from 'zrender/lib/zrender';\nvar extensions = [];\nvar extensionRegisters = {\n  registerPreprocessor: registerPreprocessor,\n  registerProcessor: registerProcessor,\n  registerPostInit: registerPostInit,\n  registerPostUpdate: registerPostUpdate,\n  registerUpdateLifecycle: registerUpdateLifecycle,\n  registerAction: registerAction,\n  registerCoordinateSystem: registerCoordinateSystem,\n  registerLayout: registerLayout,\n  registerVisual: registerVisual,\n  registerTransform: registerTransform,\n  registerLoading: registerLoading,\n  registerMap: registerMap,\n  PRIORITY: PRIORITY,\n  ComponentModel: ComponentModel,\n  ComponentView: ComponentView,\n  SeriesModel: SeriesModel,\n  ChartView: ChartView,\n  // TODO Use ComponentModel and SeriesModel instead of Constructor\n  registerComponentModel: function (ComponentModelClass) {\n    ComponentModel.registerClass(ComponentModelClass);\n  },\n  registerComponentView: function (ComponentViewClass) {\n    ComponentView.registerClass(ComponentViewClass);\n  },\n  registerSeriesModel: function (SeriesModelClass) {\n    SeriesModel.registerClass(SeriesModelClass);\n  },\n  registerChartView: function (ChartViewClass) {\n    ChartView.registerClass(ChartViewClass);\n  },\n  registerSubTypeDefaulter: function (componentType, defaulter) {\n    ComponentModel.registerSubTypeDefaulter(componentType, defaulter);\n  },\n  registerPainter: function (painterType, PainterCtor) {\n    registerPainter(painterType, PainterCtor);\n  }\n};\nexport function use(ext) {\n  if (isArray(ext)) {\n    // use([ChartLine, ChartBar]);\n    each(ext, function (singleExt) {\n      use(singleExt);\n    });\n    return;\n  }\n\n  if (indexOf(extensions, ext) >= 0) {\n    return;\n  }\n\n  extensions.push(ext);\n\n  if (isFunction(ext)) {\n    ext = {\n      install: ext\n    };\n  }\n\n  ext.install(extensionRegisters);\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { SERIES_LAYOUT_BY_COLUMN, SOURCE_FORMAT_OBJECT_ROWS, SOURCE_FORMAT_ARRAY_ROWS } from '../../util/types';\nimport { normalizeToArray } from '../../util/model';\nimport { createHashMap, bind, each, hasOwn, map, clone, isObject, extend } from 'zrender/lib/core/util';\nimport { getRawSourceItemGetter, getRawSourceDataCounter, getRawSourceValueGetter } from './dataProvider';\nimport { parseDataValue } from './dataValueHelper';\nimport { consoleLog, makePrintable, throwError } from '../../util/log';\nimport { createSource, detectSourceFormat } from '../Source';\n/**\n * TODO: disable writable.\n * This structure will be exposed to users.\n */\n\nvar ExternalSource =\n/** @class */\nfunction () {\n  function ExternalSource() {}\n\n  ExternalSource.prototype.getRawData = function () {\n    // Only built-in transform available.\n    throw new Error('not supported');\n  };\n\n  ExternalSource.prototype.getRawDataItem = function (dataIndex) {\n    // Only built-in transform available.\n    throw new Error('not supported');\n  };\n\n  ExternalSource.prototype.cloneRawData = function () {\n    return;\n  };\n  /**\n   * @return If dimension not found, return null/undefined.\n   */\n\n\n  ExternalSource.prototype.getDimensionInfo = function (dim) {\n    return;\n  };\n  /**\n   * dimensions defined if and only if either:\n   * (a) dataset.dimensions are declared.\n   * (b) dataset data include dimensions definitions in data (detected or via specified `sourceHeader`).\n   * If dimensions are defined, `dimensionInfoAll` is corresponding to\n   * the defined dimensions.\n   * Otherwise, `dimensionInfoAll` is determined by data columns.\n   * @return Always return an array (even empty array).\n   */\n\n\n  ExternalSource.prototype.cloneAllDimensionInfo = function () {\n    return;\n  };\n\n  ExternalSource.prototype.count = function () {\n    return;\n  };\n  /**\n   * Only support by dimension index.\n   * No need to support by dimension name in transform function,\n   * becuase transform function is not case-specific, no need to use name literally.\n   */\n\n\n  ExternalSource.prototype.retrieveValue = function (dataIndex, dimIndex) {\n    return;\n  };\n\n  ExternalSource.prototype.retrieveValueFromItem = function (dataItem, dimIndex) {\n    return;\n  };\n\n  ExternalSource.prototype.convertValue = function (rawVal, dimInfo) {\n    return parseDataValue(rawVal, dimInfo);\n  };\n\n  return ExternalSource;\n}();\n\nexport { ExternalSource };\n\nfunction createExternalSource(internalSource, externalTransform) {\n  var extSource = new ExternalSource();\n  var data = internalSource.data;\n  var sourceFormat = extSource.sourceFormat = internalSource.sourceFormat;\n  var sourceHeaderCount = internalSource.startIndex;\n  var errMsg = '';\n\n  if (internalSource.seriesLayoutBy !== SERIES_LAYOUT_BY_COLUMN) {\n    // For the logic simplicity in transformer, only 'culumn' is\n    // supported in data transform. Otherwise, the `dimensionsDefine`\n    // might be detected by 'row', which probably confuses users.\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = '`seriesLayoutBy` of upstream dataset can only be \"column\" in data transform.';\n    }\n\n    throwError(errMsg);\n  } // [MEMO]\n  // Create a new dimensions structure for exposing.\n  // Do not expose all dimension info to users directly.\n  // Becuase the dimension is probably auto detected from data and not might reliable.\n  // Should not lead the transformers to think that is relialbe and return it.\n  // See [DIMENSION_INHERIT_RULE] in `sourceManager.ts`.\n\n\n  var dimensions = [];\n  var dimsByName = {};\n  var dimsDef = internalSource.dimensionsDefine;\n\n  if (dimsDef) {\n    each(dimsDef, function (dimDef, idx) {\n      var name = dimDef.name;\n      var dimDefExt = {\n        index: idx,\n        name: name,\n        displayName: dimDef.displayName\n      };\n      dimensions.push(dimDefExt); // Users probably not sepcify dimension name. For simplicity, data transform\n      // do not generate dimension name.\n\n      if (name != null) {\n        // Dimension name should not be duplicated.\n        // For simplicity, data transform forbid name duplication, do not generate\n        // new name like module `completeDimensions.ts` did, but just tell users.\n        var errMsg_1 = '';\n\n        if (hasOwn(dimsByName, name)) {\n          if (process.env.NODE_ENV !== 'production') {\n            errMsg_1 = 'dimension name \"' + name + '\" duplicated.';\n          }\n\n          throwError(errMsg_1);\n        }\n\n        dimsByName[name] = dimDefExt;\n      }\n    });\n  } // If dimension definitions are not defined and can not be detected.\n  // e.g., pure data `[[11, 22], ...]`.\n  else {\n      for (var i = 0; i < internalSource.dimensionsDetectedCount || 0; i++) {\n        // Do not generete name or anything others. The consequence process in\n        // `transform` or `series` probably have there own name generation strategry.\n        dimensions.push({\n          index: i\n        });\n      }\n    } // Implement public methods:\n\n\n  var rawItemGetter = getRawSourceItemGetter(sourceFormat, SERIES_LAYOUT_BY_COLUMN);\n\n  if (externalTransform.__isBuiltIn) {\n    extSource.getRawDataItem = function (dataIndex) {\n      return rawItemGetter(data, sourceHeaderCount, dimensions, dataIndex);\n    };\n\n    extSource.getRawData = bind(getRawData, null, internalSource);\n  }\n\n  extSource.cloneRawData = bind(cloneRawData, null, internalSource);\n  var rawCounter = getRawSourceDataCounter(sourceFormat, SERIES_LAYOUT_BY_COLUMN);\n  extSource.count = bind(rawCounter, null, data, sourceHeaderCount, dimensions);\n  var rawValueGetter = getRawSourceValueGetter(sourceFormat);\n\n  extSource.retrieveValue = function (dataIndex, dimIndex) {\n    var rawItem = rawItemGetter(data, sourceHeaderCount, dimensions, dataIndex);\n    return retrieveValueFromItem(rawItem, dimIndex);\n  };\n\n  var retrieveValueFromItem = extSource.retrieveValueFromItem = function (dataItem, dimIndex) {\n    if (dataItem == null) {\n      return;\n    }\n\n    var dimDef = dimensions[dimIndex]; // When `dimIndex` is `null`, `rawValueGetter` return the whole item.\n\n    if (dimDef) {\n      return rawValueGetter(dataItem, dimIndex, dimDef.name);\n    }\n  };\n\n  extSource.getDimensionInfo = bind(getDimensionInfo, null, dimensions, dimsByName);\n  extSource.cloneAllDimensionInfo = bind(cloneAllDimensionInfo, null, dimensions);\n  return extSource;\n}\n\nfunction getRawData(upstream) {\n  var sourceFormat = upstream.sourceFormat;\n\n  if (!isSupportedSourceFormat(sourceFormat)) {\n    var errMsg = '';\n\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = '`getRawData` is not supported in source format ' + sourceFormat;\n    }\n\n    throwError(errMsg);\n  }\n\n  return upstream.data;\n}\n\nfunction cloneRawData(upstream) {\n  var sourceFormat = upstream.sourceFormat;\n  var data = upstream.data;\n\n  if (!isSupportedSourceFormat(sourceFormat)) {\n    var errMsg = '';\n\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = '`cloneRawData` is not supported in source format ' + sourceFormat;\n    }\n\n    throwError(errMsg);\n  }\n\n  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n    var result = [];\n\n    for (var i = 0, len = data.length; i < len; i++) {\n      // Not strictly clone for performance\n      result.push(data[i].slice());\n    }\n\n    return result;\n  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n    var result = [];\n\n    for (var i = 0, len = data.length; i < len; i++) {\n      // Not strictly clone for performance\n      result.push(extend({}, data[i]));\n    }\n\n    return result;\n  }\n}\n\nfunction getDimensionInfo(dimensions, dimsByName, dim) {\n  if (dim == null) {\n    return;\n  } // Keep the same logic as `List::getDimension` did.\n\n\n  if (typeof dim === 'number' // If being a number-like string but not being defined a dimension name.\n  || !isNaN(dim) && !hasOwn(dimsByName, dim)) {\n    return dimensions[dim];\n  } else if (hasOwn(dimsByName, dim)) {\n    return dimsByName[dim];\n  }\n}\n\nfunction cloneAllDimensionInfo(dimensions) {\n  return clone(dimensions);\n}\n\nvar externalTransformMap = createHashMap();\nexport function registerExternalTransform(externalTransform) {\n  externalTransform = clone(externalTransform);\n  var type = externalTransform.type;\n  var errMsg = '';\n\n  if (!type) {\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = 'Must have a `type` when `registerTransform`.';\n    }\n\n    throwError(errMsg);\n  }\n\n  var typeParsed = type.split(':');\n\n  if (typeParsed.length !== 2) {\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = 'Name must include namespace like \"ns:regression\".';\n    }\n\n    throwError(errMsg);\n  } // Namespace 'echarts:xxx' is official namespace, where the transforms should\n  // be called directly via 'xxx' rather than 'echarts:xxx'.\n\n\n  var isBuiltIn = false;\n\n  if (typeParsed[0] === 'echarts') {\n    type = typeParsed[1];\n    isBuiltIn = true;\n  }\n\n  externalTransform.__isBuiltIn = isBuiltIn;\n  externalTransformMap.set(type, externalTransform);\n}\nexport function applyDataTransform(rawTransOption, sourceList, infoForPrint) {\n  var pipedTransOption = normalizeToArray(rawTransOption);\n  var pipeLen = pipedTransOption.length;\n  var errMsg = '';\n\n  if (!pipeLen) {\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = 'If `transform` declared, it should at least contain one transform.';\n    }\n\n    throwError(errMsg);\n  }\n\n  for (var i = 0, len = pipeLen; i < len; i++) {\n    var transOption = pipedTransOption[i];\n    sourceList = applySingleDataTransform(transOption, sourceList, infoForPrint, pipeLen === 1 ? null : i); // piped transform only support single input, except the fist one.\n    // piped transform only support single output, except the last one.\n\n    if (i !== len - 1) {\n      sourceList.length = Math.max(sourceList.length, 1);\n    }\n  }\n\n  return sourceList;\n}\n\nfunction applySingleDataTransform(transOption, upSourceList, infoForPrint, // If `pipeIndex` is null/undefined, no piped transform.\npipeIndex) {\n  var errMsg = '';\n\n  if (!upSourceList.length) {\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = 'Must have at least one upstream dataset.';\n    }\n\n    throwError(errMsg);\n  }\n\n  if (!isObject(transOption)) {\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = 'transform declaration must be an object rather than ' + typeof transOption + '.';\n    }\n\n    throwError(errMsg);\n  }\n\n  var transType = transOption.type;\n  var externalTransform = externalTransformMap.get(transType);\n\n  if (!externalTransform) {\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = 'Can not find transform on type \"' + transType + '\".';\n    }\n\n    throwError(errMsg);\n  } // Prepare source\n\n\n  var extUpSourceList = map(upSourceList, function (upSource) {\n    return createExternalSource(upSource, externalTransform);\n  });\n  var resultList = normalizeToArray(externalTransform.transform({\n    upstream: extUpSourceList[0],\n    upstreamList: extUpSourceList,\n    config: clone(transOption.config)\n  }));\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (transOption.print) {\n      var printStrArr = map(resultList, function (extSource) {\n        var pipeIndexStr = pipeIndex != null ? ' === pipe index: ' + pipeIndex : '';\n        return ['=== dataset index: ' + infoForPrint.datasetIndex + pipeIndexStr + ' ===', '- transform result data:', makePrintable(extSource.data), '- transform result dimensions:', makePrintable(extSource.dimensions)].join('\\n');\n      }).join('\\n');\n      consoleLog(printStrArr);\n    }\n  }\n\n  return map(resultList, function (result, resultIndex) {\n    var errMsg = '';\n\n    if (!isObject(result)) {\n      if (process.env.NODE_ENV !== 'production') {\n        errMsg = 'A transform should not return some empty results.';\n      }\n\n      throwError(errMsg);\n    }\n\n    if (!result.data) {\n      if (process.env.NODE_ENV !== 'production') {\n        errMsg = 'Transform result data should be not be null or undefined';\n      }\n\n      throwError(errMsg);\n    }\n\n    var sourceFormat = detectSourceFormat(result.data);\n\n    if (!isSupportedSourceFormat(sourceFormat)) {\n      if (process.env.NODE_ENV !== 'production') {\n        errMsg = 'Transform result data should be array rows or object rows.';\n      }\n\n      throwError(errMsg);\n    }\n\n    var resultMetaRawOption;\n    var firstUpSource = upSourceList[0];\n    /**\n     * Intuitively, the end users known the content of the original `dataset.source`,\n     * calucating the transform result in mind.\n     * Suppose the original `dataset.source` is:\n     * ```js\n     * [\n     *     ['product', '2012', '2013', '2014', '2015'],\n     *     ['AAA', 41.1, 30.4, 65.1, 53.3],\n     *     ['BBB', 86.5, 92.1, 85.7, 83.1],\n     *     ['CCC', 24.1, 67.2, 79.5, 86.4]\n     * ]\n     * ```\n     * The dimension info have to be detected from the source data.\n     * Some of the transformers (like filter, sort) will follow the dimension info\n     * of upstream, while others use new dimensions (like aggregate).\n     * Transformer can output a field `dimensions` to define the its own output dimensions.\n     * We also allow transformers to ignore the output `dimensions` field, and\n     * inherit the upstream dimensions definition. It can reduce the burden of handling\n     * dimensions in transformers.\n     *\n     * See also [DIMENSION_INHERIT_RULE] in `sourceManager.ts`.\n     */\n\n    if (firstUpSource && resultIndex === 0 // If transformer returns `dimensions`, it means that the transformer has different\n    // dimensions definitions. We do not inherit anything from upstream.\n    && !result.dimensions) {\n      var startIndex = firstUpSource.startIndex; // We copy the header of upstream to the result becuase:\n      // (1) The returned data always does not contain header line and can not be used\n      // as dimension-detection. In this case we can not use \"detected dimensions\" of\n      // upstream directly, because it might be detected based on different `seriesLayoutBy`.\n      // (2) We should support that the series read the upstream source in `seriesLayoutBy: 'row'`.\n      // So the original detected header should be add to the result, otherwise they can not be read.\n\n      if (startIndex) {\n        result.data = firstUpSource.data.slice(0, startIndex).concat(result.data);\n      }\n\n      resultMetaRawOption = {\n        seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN,\n        sourceHeader: startIndex,\n        dimensions: firstUpSource.metaRawOption.dimensions\n      };\n    } else {\n      resultMetaRawOption = {\n        seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN,\n        sourceHeader: 0,\n        dimensions: result.dimensions\n      };\n    }\n\n    return createSource(result.data, resultMetaRawOption, null);\n  });\n}\n\nfunction isSupportedSourceFormat(sourceFormat) {\n  return sourceFormat === SOURCE_FORMAT_ARRAY_ROWS || sourceFormat === SOURCE_FORMAT_OBJECT_ROWS;\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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 * Link lists and struct (graph or tree)\n */\nimport { curry, each, assert, extend, map, keys } from 'zrender/lib/core/util';\nimport { makeInner } from '../../util/model';\nvar inner = makeInner();\n\nfunction linkSeriesData(opt) {\n  var mainData = opt.mainData;\n  var datas = opt.datas;\n\n  if (!datas) {\n    datas = {\n      main: mainData\n    };\n    opt.datasAttr = {\n      main: 'data'\n    };\n  }\n\n  opt.datas = opt.mainData = null;\n  linkAll(mainData, datas, opt); // Porxy data original methods.\n\n  each(datas, function (data) {\n    each(mainData.TRANSFERABLE_METHODS, function (methodName) {\n      data.wrapMethod(methodName, curry(transferInjection, opt));\n    });\n  }); // Beyond transfer, additional features should be added to `cloneShallow`.\n\n  mainData.wrapMethod('cloneShallow', curry(cloneShallowInjection, opt)); // Only mainData trigger change, because struct.update may trigger\n  // another changable methods, which may bring about dead lock.\n\n  each(mainData.CHANGABLE_METHODS, function (methodName) {\n    mainData.wrapMethod(methodName, curry(changeInjection, opt));\n  }); // Make sure datas contains mainData.\n\n  assert(datas[mainData.dataType] === mainData);\n}\n\nfunction transferInjection(opt, res) {\n  if (isMainData(this)) {\n    // Transfer datas to new main data.\n    var datas = extend({}, inner(this).datas);\n    datas[this.dataType] = res;\n    linkAll(res, datas, opt);\n  } else {\n    // Modify the reference in main data to point newData.\n    linkSingle(res, this.dataType, inner(this).mainData, opt);\n  }\n\n  return res;\n}\n\nfunction changeInjection(opt, res) {\n  opt.struct && opt.struct.update();\n  return res;\n}\n\nfunction cloneShallowInjection(opt, res) {\n  // cloneShallow, which brings about some fragilities, may be inappropriate\n  // to be exposed as an API. So for implementation simplicity we can make\n  // the restriction that cloneShallow of not-mainData should not be invoked\n  // outside, but only be invoked here.\n  each(inner(res).datas, function (data, dataType) {\n    data !== res && linkSingle(data.cloneShallow(), dataType, res, opt);\n  });\n  return res;\n}\n/**\n * Supplement method to List.\n *\n * @public\n * @param [dataType] If not specified, return mainData.\n */\n\n\nfunction getLinkedData(dataType) {\n  var mainData = inner(this).mainData;\n  return dataType == null || mainData == null ? mainData : inner(mainData).datas[dataType];\n}\n/**\n * Get list of all linked data\n */\n\n\nfunction getLinkedDataAll() {\n  var mainData = inner(this).mainData;\n  return mainData == null ? [{\n    data: mainData\n  }] : map(keys(inner(mainData).datas), function (type) {\n    return {\n      type: type,\n      data: inner(mainData).datas[type]\n    };\n  });\n}\n\nfunction isMainData(data) {\n  return inner(data).mainData === data;\n}\n\nfunction linkAll(mainData, datas, opt) {\n  inner(mainData).datas = {};\n  each(datas, function (data, dataType) {\n    linkSingle(data, dataType, mainData, opt);\n  });\n}\n\nfunction linkSingle(data, dataType, mainData, opt) {\n  inner(mainData).datas[dataType] = data;\n  inner(data).mainData = mainData;\n  data.dataType = dataType;\n\n  if (opt.struct) {\n    data[opt.structAttr] = opt.struct;\n    opt.struct[opt.datasAttr[dataType]] = data;\n  } // Supplement method.\n\n\n  data.getLinkedData = getLinkedData;\n  data.getLinkedDataAll = getLinkedDataAll;\n}\n\nexport default linkSeriesData;","\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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 * This module exposes helper functions for developing extensions.\n */\nimport * as zrUtil from 'zrender/lib/core/util';\nimport createSeriesData from '../../chart/helper/createSeriesData'; // import createGraphFromNodeEdge from './chart/helper/createGraphFromNodeEdge';\n\nimport * as axisHelper from '../../coord/axisHelper';\nimport { AxisModelCommonMixin } from '../../coord/axisModelCommonMixin';\nimport Model from '../../model/Model';\nimport { getLayoutRect } from '../../util/layout';\nimport { enableDataStack, isDimensionStacked, getStackedDimension } from '../../data/helper/dataStackHelper';\nimport { getECData } from '../../util/innerStore';\nimport { createTextStyle as innerCreateTextStyle } from '../../label/labelStyle';\n/**\n * Create a muti dimension List structure from seriesModel.\n */\n\nexport function createList(seriesModel) {\n  return createSeriesData(null, seriesModel);\n} // export function createGraph(seriesModel) {\n//     let nodes = seriesModel.get('data');\n//     let links = seriesModel.get('links');\n//     return createGraphFromNodeEdge(nodes, links, seriesModel);\n// }\n\nexport { getLayoutRect };\nexport { createDimensions } from '../../data/helper/createDimensions';\nexport var dataStack = {\n  isDimensionStacked: isDimensionStacked,\n  enableDataStack: enableDataStack,\n  getStackedDimension: getStackedDimension\n};\n/**\n * Create a symbol element with given symbol configuration: shape, x, y, width, height, color\n * @param {string} symbolDesc\n * @param {number} x\n * @param {number} y\n * @param {number} w\n * @param {number} h\n * @param {string} color\n */\n\nexport { createSymbol } from '../../util/symbol';\n/**\n * Create scale\n * @param {Array.<number>} dataExtent\n * @param {Object|module:echarts/Model} option If `optoin.type`\n *        is secified, it can only be `'value'` currently.\n */\n\nexport function createScale(dataExtent, option) {\n  var axisModel = option;\n\n  if (!(option instanceof Model)) {\n    axisModel = new Model(option); // FIXME\n    // Currently AxisModelCommonMixin has nothing to do with the\n    // the requirements of `axisHelper.createScaleByModel`. For\n    // example the method `getCategories` and `getOrdinalMeta`\n    // are required for `'category'` axis, and ecModel are required\n    // for `'time'` axis. But occationally echarts-gl happened\n    // to only use `'value'` axis.\n    // zrUtil.mixin(axisModel, AxisModelCommonMixin);\n  }\n\n  var scale = axisHelper.createScaleByModel(axisModel);\n  scale.setExtent(dataExtent[0], dataExtent[1]);\n  axisHelper.niceScaleExtent(scale, axisModel);\n  return scale;\n}\n/**\n * Mixin common methods to axis model,\n *\n * Inlcude methods\n * `getFormattedLabels() => Array.<string>`\n * `getCategories() => Array.<string>`\n * `getMin(origin: boolean) => number`\n * `getMax(origin: boolean) => number`\n * `getNeedCrossZero() => boolean`\n */\n\nexport function mixinAxisModelCommonMethods(Model) {\n  zrUtil.mixin(Model, AxisModelCommonMixin);\n}\nexport { getECData };\nexport { enableHoverEmphasis } from '../../util/states';\nexport function createTextStyle(textStyleModel, opts) {\n  opts = opts || {};\n  return innerCreateTextStyle(textStyleModel, null, null, opts.state !== 'normal');\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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// These APIs are for more advanced usages\n// For example extend charts and components, creating graphic elements, formatting.\nimport ComponentModel from '../model/Component';\nimport ComponentView from '../view/Component';\nimport SeriesModel from '../model/Series';\nimport ChartView from '../view/Chart';\nimport SeriesData from '../data/SeriesData';\nimport * as zrender_1 from 'zrender/lib/zrender';\nexport { zrender_1 as zrender };\nimport * as matrix_1 from 'zrender/lib/core/matrix';\nexport { matrix_1 as matrix };\nimport * as vector_1 from 'zrender/lib/core/vector';\nexport { vector_1 as vector };\nimport * as zrUtil_1 from 'zrender/lib/core/util';\nexport { zrUtil_1 as zrUtil };\nimport * as color_1 from 'zrender/lib/tool/color';\nexport { color_1 as color };\nexport { throttle } from '../util/throttle';\nimport * as helper_1 from './api/helper';\nexport { helper_1 as helper };\nexport { use } from '../extension'; //////////////// Helper Methods /////////////////////\n\nexport { default as parseGeoJSON } from '../coord/geo/parseGeoJson';\nexport { default as parseGeoJson } from '../coord/geo/parseGeoJson';\nimport * as number_1 from './api/number';\nexport { number_1 as number };\nimport * as time_1 from './api/time';\nexport { time_1 as time };\nimport * as graphic_1 from './api/graphic';\nexport { graphic_1 as graphic };\nimport * as format_1 from './api/format';\nexport { format_1 as format };\nimport * as util_1 from './api/util';\nexport { util_1 as util };\nexport { default as env } from 'zrender/lib/core/env'; //////////////// Export for Exension Usage ////////////////\n// export {SeriesData};\n\nexport { SeriesData as List }; // TODO: Compatitable with exists echarts-gl code\n\nexport { default as Model } from '../model/Model';\nexport { default as Axis } from '../coord/Axis';\nexport { ComponentModel, ComponentView, SeriesModel, ChartView }; // Only for GL\n\nexport { brushSingle as innerDrawElementOnCanvas } from 'zrender/lib/canvas/graphic'; //////////////// Deprecated Extension Methods ////////////////\n// Should use `ComponentModel.extend` or `class XXXX extend ComponentModel` to create class.\n// Then use `registerComponentModel` in `install` parameter when `use` this extension. For example:\n// class Bar3DModel extends ComponentModel {}\n// export function install(registers) { regsiters.registerComponentModel(Bar3DModel); }\n// echarts.use(install);\n\nexport function extendComponentModel(proto) {\n  var Model = ComponentModel.extend(proto);\n  ComponentModel.registerClass(Model);\n  return Model;\n}\nexport function extendComponentView(proto) {\n  var View = ComponentView.extend(proto);\n  ComponentView.registerClass(View);\n  return View;\n}\nexport function extendSeriesModel(proto) {\n  var Model = SeriesModel.extend(proto);\n  SeriesModel.registerClass(Model);\n  return Model;\n}\nexport function extendChartView(proto) {\n  var View = ChartView.extend(proto);\n  ChartView.registerClass(View);\n  return View;\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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// Core API from echarts/src/echarts\nexport * from '../core/echarts';\nexport * from './api';\nimport { use } from '../extension'; // Import label layout by default.\n// TODO remove\n\nimport { installLabelLayout } from '../label/installLabelLayout';\nuse(installLabelLayout);","\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { each, isString } from 'zrender/lib/core/util';\nimport { isSeriesDataSchema } from './SeriesDataSchema';\n/**\n * Note that it is too complicated to support 3d stack by value\n * (have to create two-dimension inverted index), so in 3d case\n * we just support that stacked by index.\n *\n * @param seriesModel\n * @param dimensionsInput The same as the input of <module:echarts/data/SeriesData>.\n *        The input will be modified.\n * @param opt\n * @param opt.stackedCoordDimension Specify a coord dimension if needed.\n * @param opt.byIndex=false\n * @return calculationInfo\n * {\n *     stackedDimension: string\n *     stackedByDimension: string\n *     isStackedByIndex: boolean\n *     stackedOverDimension: string\n *     stackResultDimension: string\n * }\n */\n\nexport function enableDataStack(seriesModel, dimensionsInput, opt) {\n  opt = opt || {};\n  var byIndex = opt.byIndex;\n  var stackedCoordDimension = opt.stackedCoordDimension;\n  var dimensionDefineList;\n  var schema;\n  var store;\n\n  if (isLegacyDimensionsInput(dimensionsInput)) {\n    dimensionDefineList = dimensionsInput;\n  } else {\n    schema = dimensionsInput.schema;\n    dimensionDefineList = schema.dimensions;\n    store = dimensionsInput.store;\n  } // Compatibal: when `stack` is set as '', do not stack.\n\n\n  var mayStack = !!(seriesModel && seriesModel.get('stack'));\n  var stackedByDimInfo;\n  var stackedDimInfo;\n  var stackResultDimension;\n  var stackedOverDimension;\n  each(dimensionDefineList, function (dimensionInfo, index) {\n    if (isString(dimensionInfo)) {\n      dimensionDefineList[index] = dimensionInfo = {\n        name: dimensionInfo\n      };\n    }\n\n    if (mayStack && !dimensionInfo.isExtraCoord) {\n      // Find the first ordinal dimension as the stackedByDimInfo.\n      if (!byIndex && !stackedByDimInfo && dimensionInfo.ordinalMeta) {\n        stackedByDimInfo = dimensionInfo;\n      } // Find the first stackable dimension as the stackedDimInfo.\n\n\n      if (!stackedDimInfo && dimensionInfo.type !== 'ordinal' && dimensionInfo.type !== 'time' && (!stackedCoordDimension || stackedCoordDimension === dimensionInfo.coordDim)) {\n        stackedDimInfo = dimensionInfo;\n      }\n    }\n  });\n\n  if (stackedDimInfo && !byIndex && !stackedByDimInfo) {\n    // Compatible with previous design, value axis (time axis) only stack by index.\n    // It may make sense if the user provides elaborately constructed data.\n    byIndex = true;\n  } // Add stack dimension, they can be both calculated by coordinate system in `unionExtent`.\n  // That put stack logic in List is for using conveniently in echarts extensions, but it\n  // might not be a good way.\n\n\n  if (stackedDimInfo) {\n    // Use a weird name that not duplicated with other names.\n    // Also need to use seriesModel.id as postfix because different\n    // series may share same data store. The stack dimension needs to be distinguished.\n    stackResultDimension = '__\\0ecstackresult_' + seriesModel.id;\n    stackedOverDimension = '__\\0ecstackedover_' + seriesModel.id; // Create inverted index to fast query index by value.\n\n    if (stackedByDimInfo) {\n      stackedByDimInfo.createInvertedIndices = true;\n    }\n\n    var stackedDimCoordDim_1 = stackedDimInfo.coordDim;\n    var stackedDimType = stackedDimInfo.type;\n    var stackedDimCoordIndex_1 = 0;\n    each(dimensionDefineList, function (dimensionInfo) {\n      if (dimensionInfo.coordDim === stackedDimCoordDim_1) {\n        stackedDimCoordIndex_1++;\n      }\n    });\n    var stackedOverDimensionDefine = {\n      name: stackResultDimension,\n      coordDim: stackedDimCoordDim_1,\n      coordDimIndex: stackedDimCoordIndex_1,\n      type: stackedDimType,\n      isExtraCoord: true,\n      isCalculationCoord: true,\n      storeDimIndex: dimensionDefineList.length\n    };\n    var stackResultDimensionDefine = {\n      name: stackedOverDimension,\n      // This dimension contains stack base (generally, 0), so do not set it as\n      // `stackedDimCoordDim` to avoid extent calculation, consider log scale.\n      coordDim: stackedOverDimension,\n      coordDimIndex: stackedDimCoordIndex_1 + 1,\n      type: stackedDimType,\n      isExtraCoord: true,\n      isCalculationCoord: true,\n      storeDimIndex: dimensionDefineList.length + 1\n    };\n\n    if (schema) {\n      if (store) {\n        stackedOverDimensionDefine.storeDimIndex = store.ensureCalculationDimension(stackedOverDimension, stackedDimType);\n        stackResultDimensionDefine.storeDimIndex = store.ensureCalculationDimension(stackResultDimension, stackedDimType);\n      }\n\n      schema.appendCalculationDimension(stackedOverDimensionDefine);\n      schema.appendCalculationDimension(stackResultDimensionDefine);\n    } else {\n      dimensionDefineList.push(stackedOverDimensionDefine);\n      dimensionDefineList.push(stackResultDimensionDefine);\n    }\n  }\n\n  return {\n    stackedDimension: stackedDimInfo && stackedDimInfo.name,\n    stackedByDimension: stackedByDimInfo && stackedByDimInfo.name,\n    isStackedByIndex: byIndex,\n    stackedOverDimension: stackedOverDimension,\n    stackResultDimension: stackResultDimension\n  };\n}\n\nfunction isLegacyDimensionsInput(dimensionsInput) {\n  return !isSeriesDataSchema(dimensionsInput.schema);\n}\n\nexport function isDimensionStacked(data, stackedDim) {\n  // Each single series only maps to one pair of axis. So we do not need to\n  // check stackByDim, whatever stacked by a dimension or stacked by index.\n  return !!stackedDim && stackedDim === data.getCalculationInfo('stackedDimension');\n}\nexport function getStackedDimension(data, targetDim) {\n  return isDimensionStacked(data, targetDim) ? data.getCalculationInfo('stackResultDimension') : targetDim;\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/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\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*/\nimport { makeInner, getDataItemValue, queryReferringComponents, SINGLE_REFERRING } from '../../util/model';\nimport { createHashMap, each, isArray, isString, isObject, isTypedArray } from 'zrender/lib/core/util';\nimport { SOURCE_FORMAT_ORIGINAL, SOURCE_FORMAT_ARRAY_ROWS, SOURCE_FORMAT_OBJECT_ROWS, SERIES_LAYOUT_BY_ROW, SOURCE_FORMAT_KEYED_COLUMNS } from '../../util/types'; // The result of `guessOrdinal`.\n\nexport var BE_ORDINAL = {\n  Must: 1,\n  Might: 2,\n  Not: 3 // Other cases\n\n};\nvar innerGlobalModel = makeInner();\n/**\n * MUST be called before mergeOption of all series.\n */\n\nexport function resetSourceDefaulter(ecModel) {\n  // `datasetMap` is used to make default encode.\n  innerGlobalModel(ecModel).datasetMap = createHashMap();\n}\n/**\n * [The strategy of the arrengment of data dimensions for dataset]:\n * \"value way\": all axes are non-category axes. So series one by one take\n *     several (the number is coordSysDims.length) dimensions from dataset.\n *     The result of data arrengment of data dimensions like:\n *     | ser0_x | ser0_y | ser1_x | ser1_y | ser2_x | ser2_y |\n * \"category way\": at least one axis is category axis. So the the first data\n *     dimension is always mapped to the first category axis and shared by\n *     all of the series. The other data dimensions are taken by series like\n *     \"value way\" does.\n *     The result of data arrengment of data dimensions like:\n *     | ser_shared_x | ser0_y | ser1_y | ser2_y |\n *\n * @return encode Never be `null/undefined`.\n */\n\nexport function makeSeriesEncodeForAxisCoordSys(coordDimensions, seriesModel, source) {\n  var encode = {};\n  var datasetModel = querySeriesUpstreamDatasetModel(seriesModel); // Currently only make default when using dataset, util more reqirements occur.\n\n  if (!datasetModel || !coordDimensions) {\n    return encode;\n  }\n\n  var encodeItemName = [];\n  var encodeSeriesName = [];\n  var ecModel = seriesModel.ecModel;\n  var datasetMap = innerGlobalModel(ecModel).datasetMap;\n  var key = datasetModel.uid + '_' + source.seriesLayoutBy;\n  var baseCategoryDimIndex;\n  var categoryWayValueDimStart;\n  coordDimensions = coordDimensions.slice();\n  each(coordDimensions, function (coordDimInfoLoose, coordDimIdx) {\n    var coordDimInfo = isObject(coordDimInfoLoose) ? coordDimInfoLoose : coordDimensions[coordDimIdx] = {\n      name: coordDimInfoLoose\n    };\n\n    if (coordDimInfo.type === 'ordinal' && baseCategoryDimIndex == null) {\n      baseCategoryDimIndex = coordDimIdx;\n      categoryWayValueDimStart = getDataDimCountOnCoordDim(coordDimInfo);\n    }\n\n    encode[coordDimInfo.name] = [];\n  });\n  var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {\n    categoryWayDim: categoryWayValueDimStart,\n    valueWayDim: 0\n  }); // TODO\n  // Auto detect first time axis and do arrangement.\n\n  each(coordDimensions, function (coordDimInfo, coordDimIdx) {\n    var coordDimName = coordDimInfo.name;\n    var count = getDataDimCountOnCoordDim(coordDimInfo); // In value way.\n\n    if (baseCategoryDimIndex == null) {\n      var start = datasetRecord.valueWayDim;\n      pushDim(encode[coordDimName], start, count);\n      pushDim(encodeSeriesName, start, count);\n      datasetRecord.valueWayDim += count; // ??? TODO give a better default series name rule?\n      // especially when encode x y specified.\n      // consider: when mutiple series share one dimension\n      // category axis, series name should better use\n      // the other dimsion name. On the other hand, use\n      // both dimensions name.\n    } // In category way, the first category axis.\n    else if (baseCategoryDimIndex === coordDimIdx) {\n        pushDim(encode[coordDimName], 0, count);\n        pushDim(encodeItemName, 0, count);\n      } // In category way, the other axis.\n      else {\n          var start = datasetRecord.categoryWayDim;\n          pushDim(encode[coordDimName], start, count);\n          pushDim(encodeSeriesName, start, count);\n          datasetRecord.categoryWayDim += count;\n        }\n  });\n\n  function pushDim(dimIdxArr, idxFrom, idxCount) {\n    for (var i = 0; i < idxCount; i++) {\n      dimIdxArr.push(idxFrom + i);\n    }\n  }\n\n  function getDataDimCountOnCoordDim(coordDimInfo) {\n    var dimsDef = coordDimInfo.dimsDef;\n    return dimsDef ? dimsDef.length : 1;\n  }\n\n  encodeItemName.length && (encode.itemName = encodeItemName);\n  encodeSeriesName.length && (encode.seriesName = encodeSeriesName);\n  return encode;\n}\n/**\n * Work for data like [{name: ..., value: ...}, ...].\n *\n * @return encode Never be `null/undefined`.\n */\n\nexport function makeSeriesEncodeForNameBased(seriesModel, source, dimCount) {\n  var encode = {};\n  var datasetModel = querySeriesUpstreamDatasetModel(seriesModel); // Currently only make default when using dataset, util more reqirements occur.\n\n  if (!datasetModel) {\n    return encode;\n  }\n\n  var sourceFormat = source.sourceFormat;\n  var dimensionsDefine = source.dimensionsDefine;\n  var potentialNameDimIndex;\n\n  if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    each(dimensionsDefine, function (dim, idx) {\n      if ((isObject(dim) ? dim.name : dim) === 'name') {\n        potentialNameDimIndex = idx;\n      }\n    });\n  }\n\n  var idxResult = function () {\n    var idxRes0 = {};\n    var idxRes1 = {};\n    var guessRecords = []; // 5 is an experience value.\n\n    for (var i = 0, len = Math.min(5, dimCount); i < len; i++) {\n      var guessResult = doGuessOrdinal(source.data, sourceFormat, source.seriesLayoutBy, dimensionsDefine, source.startIndex, i);\n      guessRecords.push(guessResult);\n      var isPureNumber = guessResult === BE_ORDINAL.Not; // [Strategy of idxRes0]: find the first BE_ORDINAL.Not as the value dim,\n      // and then find a name dim with the priority:\n      // \"BE_ORDINAL.Might|BE_ORDINAL.Must\" > \"other dim\" > \"the value dim itself\".\n\n      if (isPureNumber && idxRes0.v == null && i !== potentialNameDimIndex) {\n        idxRes0.v = i;\n      }\n\n      if (idxRes0.n == null || idxRes0.n === idxRes0.v || !isPureNumber && guessRecords[idxRes0.n] === BE_ORDINAL.Not) {\n        idxRes0.n = i;\n      }\n\n      if (fulfilled(idxRes0) && guessRecords[idxRes0.n] !== BE_ORDINAL.Not) {\n        return idxRes0;\n      } // [Strategy of idxRes1]: if idxRes0 not satisfied (that is, no BE_ORDINAL.Not),\n      // find the first BE_ORDINAL.Might as the value dim,\n      // and then find a name dim with the priority:\n      // \"other dim\" > \"the value dim itself\".\n      // That is for backward compat: number-like (e.g., `'3'`, `'55'`) can be\n      // treated as number.\n\n\n      if (!isPureNumber) {\n        if (guessResult === BE_ORDINAL.Might && idxRes1.v == null && i !== potentialNameDimIndex) {\n          idxRes1.v = i;\n        }\n\n        if (idxRes1.n == null || idxRes1.n === idxRes1.v) {\n          idxRes1.n = i;\n        }\n      }\n    }\n\n    function fulfilled(idxResult) {\n      return idxResult.v != null && idxResult.n != null;\n    }\n\n    return fulfilled(idxRes0) ? idxRes0 : fulfilled(idxRes1) ? idxRes1 : null;\n  }();\n\n  if (idxResult) {\n    encode.value = [idxResult.v]; // `potentialNameDimIndex` has highest priority.\n\n    var nameDimIndex = potentialNameDimIndex != null ? potentialNameDimIndex : idxResult.n; // By default, label use itemName in charts.\n    // So we dont set encodeLabel here.\n\n    encode.itemName = [nameDimIndex];\n    encode.seriesName = [nameDimIndex];\n  }\n\n  return encode;\n}\n/**\n * @return If return null/undefined, indicate that should not use datasetModel.\n */\n\nexport function querySeriesUpstreamDatasetModel(seriesModel) {\n  // Caution: consider the scenario:\n  // A dataset is declared and a series is not expected to use the dataset,\n  // and at the beginning `setOption({series: { noData })` (just prepare other\n  // option but no data), then `setOption({series: {data: [...]}); In this case,\n  // the user should set an empty array to avoid that dataset is used by default.\n  var thisData = seriesModel.get('data', true);\n\n  if (!thisData) {\n    return queryReferringComponents(seriesModel.ecModel, 'dataset', {\n      index: seriesModel.get('datasetIndex', true),\n      id: seriesModel.get('datasetId', true)\n    }, SINGLE_REFERRING).models[0];\n  }\n}\n/**\n * @return Always return an array event empty.\n */\n\nexport function queryDatasetUpstreamDatasetModels(datasetModel) {\n  // Only these attributes declared, we by defualt reference to `datasetIndex: 0`.\n  // Otherwise, no reference.\n  if (!datasetModel.get('transform', true) && !datasetModel.get('fromTransformResult', true)) {\n    return [];\n  }\n\n  return queryReferringComponents(datasetModel.ecModel, 'dataset', {\n    index: datasetModel.get('fromDatasetIndex', true),\n    id: datasetModel.get('fromDatasetId', true)\n  }, SINGLE_REFERRING).models;\n}\n/**\n * The rule should not be complex, otherwise user might not\n * be able to known where the data is wrong.\n * The code is ugly, but how to make it neat?\n */\n\nexport function guessOrdinal(source, dimIndex) {\n  return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);\n} // dimIndex may be overflow source data.\n// return {BE_ORDINAL}\n\nfunction doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {\n  var result; // Experience value.\n\n  var maxLoop = 5;\n\n  if (isTypedArray(data)) {\n    return BE_ORDINAL.Not;\n  } // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine\n  // always exists in source.\n\n\n  var dimName;\n  var dimType;\n\n  if (dimensionsDefine) {\n    var dimDefItem = dimensionsDefine[dimIndex];\n\n    if (isObject(dimDefItem)) {\n      dimName = dimDefItem.name;\n      dimType = dimDefItem.type;\n    } else if (isString(dimDefItem)) {\n      dimName = dimDefItem;\n    }\n  }\n\n  if (dimType != null) {\n    return dimType === 'ordinal' ? BE_ORDINAL.Must : BE_ORDINAL.Not;\n  }\n\n  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n    var dataArrayRows = data;\n\n    if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n      var sample = dataArrayRows[dimIndex];\n\n      for (var i = 0; i < (sample || []).length && i < maxLoop; i++) {\n        if ((result = detectValue(sample[startIndex + i])) != null) {\n          return result;\n        }\n      }\n    } else {\n      for (var i = 0; i < dataArrayRows.length && i < maxLoop; i++) {\n        var row = dataArrayRows[startIndex + i];\n\n        if (row && (result = detectValue(row[dimIndex])) != null) {\n          return result;\n        }\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n    var dataObjectRows = data;\n\n    if (!dimName) {\n      return BE_ORDINAL.Not;\n    }\n\n    for (var i = 0; i < dataObjectRows.length && i < maxLoop; i++) {\n      var item = dataObjectRows[i];\n\n      if (item && (result = detectValue(item[dimName])) != null) {\n        return result;\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    var dataKeyedColumns = data;\n\n    if (!dimName) {\n      return BE_ORDINAL.Not;\n    }\n\n    var sample = dataKeyedColumns[dimName];\n\n    if (!sample || isTypedArray(sample)) {\n      return BE_ORDINAL.Not;\n    }\n\n    for (var i = 0; i < sample.length && i < maxLoop; i++) {\n      if ((result = detectValue(sample[i])) != null) {\n        return result;\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n    var dataOriginal = data;\n\n    for (var i = 0; i < dataOriginal.length && i < maxLoop; i++) {\n      var item = dataOriginal[i];\n      var val = getDataItemValue(item);\n\n      if (!isArray(val)) {\n        return BE_ORDINAL.Not;\n      }\n\n      if ((result = detectValue(val[dimIndex])) != null) {\n        return result;\n      }\n    }\n  }\n\n  function detectValue(val) {\n    var beStr = isString(val); // Consider usage convenience, '1', '2' will be treated as \"number\".\n    // `isFinit('')` get `true`.\n\n    if (val != null && isFinite(val) && val !== '') {\n      return beStr ? BE_ORDINAL.Might : BE_ORDINAL.Not;\n    } else if (beStr && val !== '-') {\n      return BE_ORDINAL.Must;\n    }\n  }\n\n  return BE_ORDINAL.Not;\n}"],"sourceRoot":""}