echarts 4.5.0 → 4.9.0

package/lib/data/helper/completeDimensions.js

@@ -35,6 +35,7 @@ var normalizeToArray = _model.normalizeToArray;
 var _sourceHelper = require("./sourceHelper");
 
 var guessOrdinal = _sourceHelper.guessOrdinal;
+var BE_ORDINAL = _sourceHelper.BE_ORDINAL;
 
 var Source = require("../Source");
 
@@ -42,6 +43,8 @@ var _dimensionHelper = require("./dimensionHelper");
 
 var OTHER_DIMENSIONS = _dimensionHelper.OTHER_DIMENSIONS;
 
+var DataDimensionInfo = require("../DataDimensionInfo");
+
 /*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
@@ -69,8 +72,12 @@ var OTHER_DIMENSIONS = _dimensionHelper.OTHER_DIMENSIONS;
 /**
  * @see {module:echarts/test/ut/spec/data/completeDimensions}
  *
- * Complete the dimensions array, by user defined `dimension` and `encode`,
- * and guessing from the data structure.
+ * This method builds the relationship between:
+ * + "what the coord sys or series requires (see `sysDims`)",
+ * + "what the user defines (in `encode` and `dimensions`, see `opt.dimsDef` and `opt.encodeDef`)"
+ * + "what the data source provids (see `source`)".
+ *
+ * Some guess strategy will be adapted if user does not define something.
  * If no 'value' dimension specified, the first no-named dimension will be
  * named as 'value'.
  *
@@ -86,32 +93,20 @@ var OTHER_DIMENSIONS = _dimensionHelper.OTHER_DIMENSIONS;
  * @param {Array.<Object|string>} [opt.dimsDef] option.series.dimensions User defined dimensions
  *      For example: ['asdf', {name, type}, ...].
  * @param {Object|HashMap} [opt.encodeDef] option.series.encode {x: 2, y: [3, 1], tooltip: [1, 2], label: 3}
+ * @param {Function} [opt.encodeDefaulter] Called if no `opt.encodeDef` exists.
+ *      If not specified, auto find the next available data dim.
+ *      param source {module:data/Source}
+ *      param dimCount {number}
+ *      return {Object} encode Never be `null/undefined`.
  * @param {string} [opt.generateCoord] Generate coord dim with the given name.
- *                 If not specified, extra dim names will be:
- *                 'value', 'value0', 'value1', ...
+ *      If not specified, extra dim names will be:
+ *      'value', 'value0', 'value1', ...
  * @param {number} [opt.generateCoordCount] By default, the generated dim name is `generateCoord`.
- *                 If `generateCoordCount` specified, the generated dim names will be:
- *                 `generateCoord` + 0, `generateCoord` + 1, ...
- *                 can be Infinity, indicate that use all of the remain columns.
+ *      If `generateCoordCount` specified, the generated dim names will be:
+ *      `generateCoord` + 0, `generateCoord` + 1, ...
+ *      can be Infinity, indicate that use all of the remain columns.
  * @param {number} [opt.dimCount] If not specified, guess by the first data item.
- * @param {number} [opt.encodeDefaulter] If not specified, auto find the next available data dim.
- * @return {Array.<Object>} [{
- *      name: string mandatory,
- *      displayName: string, the origin name in dimsDef, see source helper.
- *                 If displayName given, the tooltip will displayed vertically.
- *      coordDim: string mandatory,
- *      coordDimIndex: number mandatory,
- *      type: string optional,
- *      otherDims: { never null/undefined
- *          tooltip: number optional,
- *          label: number optional,
- *          itemName: number optional,
- *          seriesName: number optional,
- *      },
- *      isExtraCoord: boolean true if coord is generated
- *          (not specified in encode and not series specified)
- *      other props ...
- * }]
+ * @return {Array.<module:data/DataDimensionInfo>}
  */
 function completeDimensions(sysDims, source, opt) {
   if (!Source.isInstance(source)) {
@@ -121,7 +116,6 @@ function completeDimensions(sysDims, source, opt) {
   opt = opt || {};
   sysDims = (sysDims || []).slice();
   var dimsDef = (opt.dimsDef || []).slice();
-  var encodeDef = createHashMap(opt.encodeDef);
   var dataDimNameMap = createHashMap();
   var coordDimNameMap = createHashMap(); // var valueCandidate;
 
@@ -133,9 +127,7 @@ function completeDimensions(sysDims, source, opt) {
       name: dimsDef[i]
     });
     var userDimName = dimDefItem.name;
-    var resultItem = result[i] = {
-      otherDims: {}
-    }; // Name will be applied later for avoiding duplication.
+    var resultItem = result[i] = new DataDimensionInfo(); // Name will be applied later for avoiding duplication.
 
     if (userDimName != null && dataDimNameMap.get(userDimName) == null) {
       // Only if `series.dimensions` is defined in option
@@ -147,8 +139,15 @@ function completeDimensions(sysDims, source, opt) {
 
     dimDefItem.type != null && (resultItem.type = dimDefItem.type);
     dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName);
-  } // Set `coordDim` and `coordDimIndex` by `encodeDef` and normalize `encodeDef`.
+  }
+
+  var encodeDef = opt.encodeDef;
+
+  if (!encodeDef && opt.encodeDefaulter) {
+    encodeDef = opt.encodeDefaulter(source, dimCount);
+  }
 
+  encodeDef = createHashMap(encodeDef); // Set `coordDim` and `coordDimIndex` by `encodeDef` and normalize `encodeDef`.
 
   encodeDef.each(function (dataDims, coordDim) {
     dataDims = normalizeToArray(dataDims).slice(); // Note: It is allowed that `dataDims.length` is `0`, e.g., options is
@@ -249,7 +248,7 @@ function completeDimensions(sysDims, source, opt) {
   var extra = generateCoord || 'value'; // Set dim `name` and other `coordDim` and other props.
 
   for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
-    var resultItem = result[resultDimIdx] = result[resultDimIdx] || {};
+    var resultItem = result[resultDimIdx] = result[resultDimIdx] || new DataDimensionInfo();
     var coordDim = resultItem.coordDim;
 
     if (coordDim == null) {
@@ -265,7 +264,19 @@ function completeDimensions(sysDims, source, opt) {
 
     resultItem.name == null && (resultItem.name = genName(resultItem.coordDim, dataDimNameMap));
 
-    if (resultItem.type == null && guessOrdinal(source, resultDimIdx, resultItem.name)) {
+    if (resultItem.type == null && (guessOrdinal(source, resultDimIdx, resultItem.name) === BE_ORDINAL.Must // Consider the case:
+    // {
+    //    dataset: {source: [
+    //        ['2001', 123],
+    //        ['2002', 456],
+    //        ...
+    //        ['The others', 987],
+    //    ]},
+    //    series: {type: 'pie'}
+    // }
+    // The first colum should better be treated as a "ordinal" although it
+    // might not able to be detected as an "ordinal" by `guessOrdinal`.
+    || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {
       resultItem.type = 'ordinal';
     }
   }

package/lib/data/helper/createDimensions.js

@@ -53,6 +53,7 @@ var completeDimensions = require("./completeDimensions");
  * @param {string} [opt.generateCoordCount]
  * @param {Array.<string|Object>} [opt.dimensionsDefine=source.dimensionsDefine] Overwrite source define.
  * @param {Object|HashMap} [opt.encodeDefine=source.encodeDefine] Overwrite source define.
+ * @param {Function} [opt.encodeDefaulter] Make default encode if user not specified.
  * @return {Array.<Object>} dimensionsInfo
  */
 function _default(source, opt) {
@@ -61,6 +62,7 @@ function _default(source, opt) {
     dimsDef: opt.dimensionsDefine || source.dimensionsDefine,
     encodeDef: opt.encodeDefine || source.encodeDefine,
     dimCount: opt.dimensionsCount,
+    encodeDefaulter: opt.encodeDefaulter,
     generateCoord: opt.generateCoord,
     generateCoordCount: opt.generateCoordCount
   });

package/lib/data/helper/sourceHelper.js

@@ -27,10 +27,6 @@ var _model = require("../../util/model");
 var makeInner = _model.makeInner;
 var getDataItemValue = _model.getDataItemValue;
 
-var _referHelper = require("../../model/referHelper");
-
-var getCoordSysDefineBySeries = _referHelper.getCoordSysDefineBySeries;
-
 var _util = require("zrender/lib/core/util");
 
 var createHashMap = _util.createHashMap;
@@ -74,6 +70,15 @@ var SERIES_LAYOUT_BY_ROW = _sourceType.SERIES_LAYOUT_BY_ROW;
 * specific language governing permissions and limitations
 * under the License.
 */
+// The result of `guessOrdinal`.
+var BE_ORDINAL = {
+  Must: 1,
+  // Encounter string but not '-' and not number-like.
+  Might: 2,
+  // Encounter string but number-like.
+  Not: 3 // Other cases
+
+};
 var inner = makeInner();
 /**
  * @see {module:echarts/data/Source}
@@ -196,14 +201,7 @@ function prepareSource(seriesModel) {
     dimensionsDefine = dimensionsDefine || datasetOption.dimensions;
   }
 
-  var completeResult = completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine); // Note: dataset option does not have `encode`.
-
-  var encodeDefine = seriesOption.encode;
-
-  if (!encodeDefine && datasetModel) {
-    encodeDefine = makeDefaultEncode(seriesModel, datasetModel, data, sourceFormat, seriesLayoutBy, completeResult);
-  }
-
+  var completeResult = completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine);
   inner(seriesModel).source = new Source({
     data: data,
     fromDataset: fromDataset,
@@ -212,7 +210,8 @@ function prepareSource(seriesModel) {
     dimensionsDefine: completeResult.dimensionsDefine,
     startIndex: completeResult.startIndex,
     dimensionsDetectCount: completeResult.dimensionsDetectCount,
-    encodeDefine: encodeDefine
+    // Note: dataset option does not have `encode`.
+    encodeDefine: seriesOption.encode
   });
 } // return {startIndex, dimensionsDefine, dimensionsCount}
 
@@ -226,7 +225,6 @@ function completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader,
 
   var dimensionsDetectCount;
   var startIndex;
-  var findPotentialName;
 
   if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {
     // Rule: Most of the first line are string: it is header.
@@ -260,12 +258,10 @@ function completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader,
   } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {
     if (!dimensionsDefine) {
       dimensionsDefine = objectRowsCollectDimensions(data);
-      findPotentialName = true;
     }
   } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
     if (!dimensionsDefine) {
       dimensionsDefine = [];
-      findPotentialName = true;
       each(data, function (colArr, key) {
         dimensionsDefine.push(key);
       });
@@ -275,22 +271,10 @@ function completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader,
     dimensionsDetectCount = isArray(value0) && value0.length || 1;
   } else if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {}
 
-  var potentialNameDimIndex;
-
-  if (findPotentialName) {
-    each(dimensionsDefine, function (dim, idx) {
-      if ((isObject(dim) ? dim.name : dim) === 'name') {
-        potentialNameDimIndex = idx;
-      }
-    });
-  }
-
   return {
     startIndex: startIndex,
     dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine),
-    dimensionsDetectCount: dimensionsDetectCount,
-    potentialNameDimIndex: potentialNameDimIndex // TODO: potentialIdDimIdx
-
+    dimensionsDetectCount: dimensionsDetectCount
   };
 } // Consider dimensions defined like ['A', 'price', 'B', 'price', 'C', 'price'],
 // which is reasonable. But dimension name is duplicated.
@@ -370,91 +354,191 @@ function objectRowsCollectDimensions(data) {
     });
     return dimensions;
   }
-} // ??? TODO merge to completedimensions, where also has
-// default encode making logic. And the default rule
-// should depends on series? consider 'map'.
+}
+/**
+ * [The strategy of the arrengment of data dimensions for dataset]:
+ * "value way": all axes are non-category axes. So series one by one take
+ *     several (the number is coordSysDims.length) dimensions from dataset.
+ *     The result of data arrengment of data dimensions like:
+ *     | ser0_x | ser0_y | ser1_x | ser1_y | ser2_x | ser2_y |
+ * "category way": at least one axis is category axis. So the the first data
+ *     dimension is always mapped to the first category axis and shared by
+ *     all of the series. The other data dimensions are taken by series like
+ *     "value way" does.
+ *     The result of data arrengment of data dimensions like:
+ *     | ser_shared_x | ser0_y | ser1_y | ser2_y |
+ *
+ * @param {Array.<Object|string>} coordDimensions [{name: <string>, type: <string>, dimsDef: <Array>}, ...]
+ * @param {module:model/Series} seriesModel
+ * @param {module:data/Source} source
+ * @return {Object} encode Never be `null/undefined`.
+ */
 
 
-function makeDefaultEncode(seriesModel, datasetModel, data, sourceFormat, seriesLayoutBy, completeResult) {
-  var coordSysDefine = getCoordSysDefineBySeries(seriesModel);
-  var encode = {}; // var encodeTooltip = [];
-  // var encodeLabel = [];
+function makeSeriesEncodeForAxisCoordSys(coordDimensions, seriesModel, source) {
+  var encode = {};
+  var datasetModel = getDatasetModel(seriesModel); // Currently only make default when using dataset, util more reqirements occur.
+
+  if (!datasetModel || !coordDimensions) {
+    return encode;
+  }
 
   var encodeItemName = [];
   var encodeSeriesName = [];
-  var seriesType = seriesModel.subType; // ??? TODO refactor: provide by series itself.
-  // Consider the case: 'map' series is based on geo coordSys,
-  // 'graph', 'heatmap' can be based on cartesian. But can not
-  // give default rule simply here.
-
-  var nSeriesMap = createHashMap(['pie', 'map', 'funnel']);
-  var cSeriesMap = createHashMap(['line', 'bar', 'pictorialBar', 'scatter', 'effectScatter', 'candlestick', 'boxplot']); // Usually in this case series will use the first data
-  // dimension as the "value" dimension, or other default
-  // processes respectively.
-
-  if (coordSysDefine && cSeriesMap.get(seriesType) != null) {
-    var ecModel = seriesModel.ecModel;
-    var datasetMap = inner(ecModel).datasetMap;
-    var key = datasetModel.uid + '_' + seriesLayoutBy;
-    var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {
-      categoryWayDim: 1,
-      valueWayDim: 0
-    }); // TODO
-    // Auto detect first time axis and do arrangement.
-
-    each(coordSysDefine.coordSysDims, function (coordDim) {
-      // In value way.
-      if (coordSysDefine.firstCategoryDimIndex == null) {
-        var dataDim = datasetRecord.valueWayDim++;
-        encode[coordDim] = dataDim; // ??? TODO give a better default series name rule?
-        // especially when encode x y specified.
-        // consider: when mutiple series share one dimension
-        // category axis, series name should better use
-        // the other dimsion name. On the other hand, use
-        // both dimensions name.
-
-        encodeSeriesName.push(dataDim); // encodeTooltip.push(dataDim);
-        // encodeLabel.push(dataDim);
-      } // In category way, category axis.
-      else if (coordSysDefine.categoryAxisMap.get(coordDim)) {
-          encode[coordDim] = 0;
-          encodeItemName.push(0);
-        } // In category way, non-category axis.
-        else {
-            var dataDim = datasetRecord.categoryWayDim++;
-            encode[coordDim] = dataDim; // encodeTooltip.push(dataDim);
-            // encodeLabel.push(dataDim);
-
-            encodeSeriesName.push(dataDim);
-          }
+  var ecModel = seriesModel.ecModel;
+  var datasetMap = inner(ecModel).datasetMap;
+  var key = datasetModel.uid + '_' + source.seriesLayoutBy;
+  var baseCategoryDimIndex;
+  var categoryWayValueDimStart;
+  coordDimensions = coordDimensions.slice();
+  each(coordDimensions, function (coordDimInfo, coordDimIdx) {
+    !isObject(coordDimInfo) && (coordDimensions[coordDimIdx] = {
+      name: coordDimInfo
     });
-  } // Do not make a complex rule! Hard to code maintain and not necessary.
-  // ??? TODO refactor: provide by series itself.
-  // [{name: ..., value: ...}, ...] like:
-  else if (nSeriesMap.get(seriesType) != null) {
-      // Find the first not ordinal. (5 is an experience value)
-      var firstNotOrdinal;
-
-      for (var i = 0; i < 5 && firstNotOrdinal == null; i++) {
-        if (!doGuessOrdinal(data, sourceFormat, seriesLayoutBy, completeResult.dimensionsDefine, completeResult.startIndex, i)) {
-          firstNotOrdinal = i;
+
+    if (coordDimInfo.type === 'ordinal' && baseCategoryDimIndex == null) {
+      baseCategoryDimIndex = coordDimIdx;
+      categoryWayValueDimStart = getDataDimCountOnCoordDim(coordDimensions[coordDimIdx]);
+    }
+
+    encode[coordDimInfo.name] = [];
+  });
+  var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {
+    categoryWayDim: categoryWayValueDimStart,
+    valueWayDim: 0
+  }); // TODO
+  // Auto detect first time axis and do arrangement.
+
+  each(coordDimensions, function (coordDimInfo, coordDimIdx) {
+    var coordDimName = coordDimInfo.name;
+    var count = getDataDimCountOnCoordDim(coordDimInfo); // In value way.
+
+    if (baseCategoryDimIndex == null) {
+      var start = datasetRecord.valueWayDim;
+      pushDim(encode[coordDimName], start, count);
+      pushDim(encodeSeriesName, start, count);
+      datasetRecord.valueWayDim += count; // ??? TODO give a better default series name rule?
+      // especially when encode x y specified.
+      // consider: when mutiple series share one dimension
+      // category axis, series name should better use
+      // the other dimsion name. On the other hand, use
+      // both dimensions name.
+    } // In category way, the first category axis.
+    else if (baseCategoryDimIndex === coordDimIdx) {
+        pushDim(encode[coordDimName], 0, count);
+        pushDim(encodeItemName, 0, count);
+      } // In category way, the other axis.
+      else {
+          var start = datasetRecord.categoryWayDim;
+          pushDim(encode[coordDimName], start, count);
+          pushDim(encodeSeriesName, start, count);
+          datasetRecord.categoryWayDim += count;
         }
+  });
+
+  function pushDim(dimIdxArr, idxFrom, idxCount) {
+    for (var i = 0; i < idxCount; i++) {
+      dimIdxArr.push(idxFrom + i);
+    }
+  }
+
+  function getDataDimCountOnCoordDim(coordDimInfo) {
+    var dimsDef = coordDimInfo.dimsDef;
+    return dimsDef ? dimsDef.length : 1;
+  }
+
+  encodeItemName.length && (encode.itemName = encodeItemName);
+  encodeSeriesName.length && (encode.seriesName = encodeSeriesName);
+  return encode;
+}
+/**
+ * Work for data like [{name: ..., value: ...}, ...].
+ *
+ * @param {module:model/Series} seriesModel
+ * @param {module:data/Source} source
+ * @return {Object} encode Never be `null/undefined`.
+ */
+
+
+function makeSeriesEncodeForNameBased(seriesModel, source, dimCount) {
+  var encode = {};
+  var datasetModel = getDatasetModel(seriesModel); // Currently only make default when using dataset, util more reqirements occur.
+
+  if (!datasetModel) {
+    return encode;
+  }
+
+  var sourceFormat = source.sourceFormat;
+  var dimensionsDefine = source.dimensionsDefine;
+  var potentialNameDimIndex;
+
+  if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
+    each(dimensionsDefine, function (dim, idx) {
+      if ((isObject(dim) ? dim.name : dim) === 'name') {
+        potentialNameDimIndex = idx;
       }
+    });
+  } // idxResult: {v, n}.
+
+
+  var idxResult = function () {
+    var idxRes0 = {};
+    var idxRes1 = {};
+    var guessRecords = []; // 5 is an experience value.
 
-      if (firstNotOrdinal != null) {
-        encode.value = firstNotOrdinal;
-        var nameDimIndex = completeResult.potentialNameDimIndex || Math.max(firstNotOrdinal - 1, 0); // By default, label use itemName in charts.
-        // So we dont set encodeLabel here.
+    for (var i = 0, len = Math.min(5, dimCount); i < len; i++) {
+      var guessResult = doGuessOrdinal(source.data, sourceFormat, source.seriesLayoutBy, dimensionsDefine, source.startIndex, i);
+      guessRecords.push(guessResult);
+      var isPureNumber = guessResult === BE_ORDINAL.Not; // [Strategy of idxRes0]: find the first BE_ORDINAL.Not as the value dim,
+      // and then find a name dim with the priority:
+      // "BE_ORDINAL.Might|BE_ORDINAL.Must" > "other dim" > "the value dim itself".
 
-        encodeSeriesName.push(nameDimIndex);
-        encodeItemName.push(nameDimIndex); // encodeTooltip.push(firstNotOrdinal);
+      if (isPureNumber && idxRes0.v == null && i !== potentialNameDimIndex) {
+        idxRes0.v = i;
       }
-    } // encodeTooltip.length && (encode.tooltip = encodeTooltip);
-  // encodeLabel.length && (encode.label = encodeLabel);
 
+      if (idxRes0.n == null || idxRes0.n === idxRes0.v || !isPureNumber && guessRecords[idxRes0.n] === BE_ORDINAL.Not) {
+        idxRes0.n = i;
+      }
+
+      if (fulfilled(idxRes0) && guessRecords[idxRes0.n] !== BE_ORDINAL.Not) {
+        return idxRes0;
+      } // [Strategy of idxRes1]: if idxRes0 not satisfied (that is, no BE_ORDINAL.Not),
+      // find the first BE_ORDINAL.Might as the value dim,
+      // and then find a name dim with the priority:
+      // "other dim" > "the value dim itself".
+      // That is for backward compat: number-like (e.g., `'3'`, `'55'`) can be
+      // treated as number.
+
+
+      if (!isPureNumber) {
+        if (guessResult === BE_ORDINAL.Might && idxRes1.v == null && i !== potentialNameDimIndex) {
+          idxRes1.v = i;
+        }
+
+        if (idxRes1.n == null || idxRes1.n === idxRes1.v) {
+          idxRes1.n = i;
+        }
+      }
+    }
+
+    function fulfilled(idxResult) {
+      return idxResult.v != null && idxResult.n != null;
+    }
+
+    return fulfilled(idxRes0) ? idxRes0 : fulfilled(idxRes1) ? idxRes1 : null;
+  }();
+
+  if (idxResult) {
+    encode.value = idxResult.v; // `potentialNameDimIndex` has highest priority.
+
+    var nameDimIndex = potentialNameDimIndex != null ? potentialNameDimIndex : idxResult.n; // By default, label use itemName in charts.
+    // So we dont set encodeLabel here.
+
+    encode.itemName = [nameDimIndex];
+    encode.seriesName = [nameDimIndex];
+  }
 
-  encodeItemName.length && (encode.itemName = encodeItemName);
-  encodeSeriesName.length && (encode.seriesName = encodeSeriesName);
   return encode;
 }
 /**
@@ -482,13 +566,14 @@ function getDatasetModel(seriesModel) {
  *
  * @param {module:echars/data/Source} source
  * @param {number} dimIndex
- * @return {boolean} Whether ordinal.
+ * @return {BE_ORDINAL} guess result.
  */
 
 
 function guessOrdinal(source, dimIndex) {
   return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);
 } // dimIndex may be overflow source data.
+// return {BE_ORDINAL}
 
 
 function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {
@@ -497,16 +582,27 @@ function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, st
   var maxLoop = 5;
 
   if (isTypedArray(data)) {
-    return false;
+    return BE_ORDINAL.Not;
   } // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine
   // always exists in source.
 
 
   var dimName;
+  var dimType;
 
   if (dimensionsDefine) {
-    dimName = dimensionsDefine[dimIndex];
-    dimName = isObject(dimName) ? dimName.name : dimName;
+    var dimDefItem = dimensionsDefine[dimIndex];
+
+    if (isObject(dimDefItem)) {
+      dimName = dimDefItem.name;
+      dimType = dimDefItem.type;
+    } else if (isString(dimDefItem)) {
+      dimName = dimDefItem;
+    }
+  }
+
+  if (dimType != null) {
+    return dimType === 'ordinal' ? BE_ORDINAL.Must : BE_ORDINAL.Not;
   }
 
   if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {
@@ -529,7 +625,7 @@ function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, st
     }
   } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {
     if (!dimName) {
-      return;
+      return BE_ORDINAL.Not;
     }
 
     for (var i = 0; i < data.length && i < maxLoop; i++) {
@@ -541,13 +637,13 @@ function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, st
     }
   } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
     if (!dimName) {
-      return;
+      return BE_ORDINAL.Not;
     }
 
     var sample = data[dimName];
 
     if (!sample || isTypedArray(sample)) {
-      return false;
+      return BE_ORDINAL.Not;
     }
 
     for (var i = 0; i < sample.length && i < maxLoop; i++) {
@@ -561,7 +657,7 @@ function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, st
       var val = getDataItemValue(item);
 
       if (!isArray(val)) {
-        return false;
+        return BE_ORDINAL.Not;
       }
 
       if ((result = detectValue(val[dimIndex])) != null) {
@@ -571,20 +667,24 @@ function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, st
   }
 
   function detectValue(val) {
-    // Consider usage convenience, '1', '2' will be treated as "number".
+    var beStr = isString(val); // Consider usage convenience, '1', '2' will be treated as "number".
     // `isFinit('')` get `true`.
+
     if (val != null && isFinite(val) && val !== '') {
-      return false;
-    } else if (isString(val) && val !== '-') {
-      return true;
+      return beStr ? BE_ORDINAL.Might : BE_ORDINAL.Not;
+    } else if (beStr && val !== '-') {
+      return BE_ORDINAL.Must;
     }
   }
 
-  return false;
+  return BE_ORDINAL.Not;
 }
 
+exports.BE_ORDINAL = BE_ORDINAL;
 exports.detectSourceFormat = detectSourceFormat;
 exports.getSource = getSource;
 exports.resetSourceDefaulter = resetSourceDefaulter;
 exports.prepareSource = prepareSource;
+exports.makeSeriesEncodeForAxisCoordSys = makeSeriesEncodeForAxisCoordSys;
+exports.makeSeriesEncodeForNameBased = makeSeriesEncodeForNameBased;
 exports.guessOrdinal = guessOrdinal;