x-print-designer 0.3.0 → 0.3.2

package/dist/core-BbvNjmfU.js

@@ -0,0 +1,233 @@
+import { getStackedDimension, enableDataStack, isDimensionStacked, createScaleByModel, niceScaleExtent, createTextStyle as createTextStyle$1, Model, AxisModelCommonMixin, createSymbol, enableHoverEmphasis, getECData, getLayoutRect, MAX_SAFE_INTEGER, asc, getPercentWithPrecision, getPixelPrecision, getPrecision, getPrecisionSafe, isNumeric, isRadianAroundZero, linearMap, nice, numericToNumber, parseDate, parsePercent, quantile, quantity, quantityExponent, reformIntervals, remRadian, round, format as format$1, roundTime, Arc, BezierCurve, Circle, Ellipse, IncrementalDisplayable, Line, LinearGradient, Polygon, Polyline, RadialGradient, Ring, Sector, clipPointsByRect, clipRectByRect, createIcon, extendPath, extendShape, getShapeClass, getTransform, initProps, makeImage, makePath, mergePath, registerShape, resizePath, updateProps, addCommas, capitalFirst, formatTime, formatTpl, getTooltipMarker, normalizeCssArray, toCamelCase, ChartView, ComponentModel, ComponentView, SeriesModel } from "./Axis-NtNlSRsM.js";
+import { Axis, SeriesData, PRIORITY, connect, dataTool, dependencies, disConnect, disconnect, dispose, getCoordinateSystemDimensions, getInstanceByDom, getInstanceById, getMap, init, parseGeoJSON, parseGeoJSON as parseGeoJSON2, registerAction, registerCoordinateSystem, registerCustomSeries, registerLayout, registerLoading, registerLocale, registerMap, registerPostInit, registerPostUpdate, registerPreprocessor, registerProcessor, registerTheme, registerTransform, registerUpdateLifecycle, registerVisual, setCanvasCreator, throttle, use, version } from "./Axis-NtNlSRsM.js";
+import { ZRText, mixin, BoundingRect, CompoundPath, Group, ZRImage, Rect, encodeHTML, truncateText, bind, clone, curry, defaults, each, extend, filter, indexOf, inherits, isArray, isFunction, isObject, isString, map, merge, reduce } from "./graphic-BEFAeatd.js";
+import { color, env, brushSingle, matrix, setPlatformAPI, vector, util, zrender } from "./graphic-BEFAeatd.js";
+import { createSeriesData, createDimensions } from "./createSeriesData-DGiG-J3b.js";
+function getTextRect(text, font, align, verticalAlign, padding, rich, truncate, lineHeight) {
+  var textEl = new ZRText({
+    style: {
+      text,
+      font,
+      align,
+      verticalAlign,
+      padding,
+      rich,
+      overflow: truncate ? "truncate" : null,
+      lineHeight
+    }
+  });
+  return textEl.getBoundingRect();
+}
+function createList(seriesModel) {
+  return createSeriesData(null, seriesModel);
+}
+var dataStack = {
+  isDimensionStacked,
+  enableDataStack,
+  getStackedDimension
+};
+function createScale(dataExtent, option) {
+  var axisModel = option;
+  if (!(option instanceof Model)) {
+    axisModel = new Model(option);
+  }
+  var scale = createScaleByModel(axisModel);
+  scale.setExtent(dataExtent[0], dataExtent[1]);
+  niceScaleExtent(scale, axisModel);
+  return scale;
+}
+function mixinAxisModelCommonMethods(Model2) {
+  mixin(Model2, AxisModelCommonMixin);
+}
+function createTextStyle(textStyleModel, opts) {
+  opts = opts || {};
+  return createTextStyle$1(textStyleModel, null, null, opts.state !== "normal");
+}
+const helper = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createDimensions,
+  createList,
+  createScale,
+  createSymbol,
+  createTextStyle,
+  dataStack,
+  enableHoverEmphasis,
+  getECData,
+  getLayoutRect,
+  mixinAxisModelCommonMethods
+}, Symbol.toStringTag, { value: "Module" }));
+const number = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MAX_SAFE_INTEGER,
+  asc,
+  getPercentWithPrecision,
+  getPixelPrecision,
+  getPrecision,
+  getPrecisionSafe,
+  isNumeric,
+  isRadianAroundZero,
+  linearMap,
+  nice,
+  numericToNumber,
+  parseDate,
+  parsePercent,
+  quantile,
+  quantity,
+  quantityExponent,
+  reformIntervals,
+  remRadian,
+  round
+}, Symbol.toStringTag, { value: "Module" }));
+const time = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  format: format$1,
+  parse: parseDate,
+  roundTime
+}, Symbol.toStringTag, { value: "Module" }));
+const graphic = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Arc,
+  BezierCurve,
+  BoundingRect,
+  Circle,
+  CompoundPath,
+  Ellipse,
+  Group,
+  Image: ZRImage,
+  IncrementalDisplayable,
+  Line,
+  LinearGradient,
+  Polygon,
+  Polyline,
+  RadialGradient,
+  Rect,
+  Ring,
+  Sector,
+  Text: ZRText,
+  clipPointsByRect,
+  clipRectByRect,
+  createIcon,
+  extendPath,
+  extendShape,
+  getShapeClass,
+  getTransform,
+  initProps,
+  makeImage,
+  makePath,
+  mergePath,
+  registerShape,
+  resizePath,
+  updateProps
+}, Symbol.toStringTag, { value: "Module" }));
+const format = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addCommas,
+  capitalFirst,
+  encodeHTML,
+  formatTime,
+  formatTpl,
+  getTextRect,
+  getTooltipMarker,
+  normalizeCssArray,
+  toCamelCase,
+  truncateText
+}, Symbol.toStringTag, { value: "Module" }));
+const util2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  bind,
+  clone,
+  curry,
+  defaults,
+  each,
+  extend,
+  filter,
+  indexOf,
+  inherits,
+  isArray,
+  isFunction,
+  isObject,
+  isString,
+  map,
+  merge,
+  reduce
+}, Symbol.toStringTag, { value: "Module" }));
+function extendComponentModel(proto) {
+  var Model2 = ComponentModel.extend(proto);
+  ComponentModel.registerClass(Model2);
+  return Model2;
+}
+function extendComponentView(proto) {
+  var View = ComponentView.extend(proto);
+  ComponentView.registerClass(View);
+  return View;
+}
+function extendSeriesModel(proto) {
+  var Model2 = SeriesModel.extend(proto);
+  SeriesModel.registerClass(Model2);
+  return Model2;
+}
+function extendChartView(proto) {
+  var View = ChartView.extend(proto);
+  ChartView.registerClass(View);
+  return View;
+}
+export {
+  Axis,
+  ChartView,
+  ComponentModel,
+  ComponentView,
+  SeriesData as List,
+  Model,
+  PRIORITY,
+  SeriesModel,
+  color,
+  connect,
+  dataTool,
+  dependencies,
+  disConnect,
+  disconnect,
+  dispose,
+  env,
+  extendChartView,
+  extendComponentModel,
+  extendComponentView,
+  extendSeriesModel,
+  format,
+  getCoordinateSystemDimensions,
+  getInstanceByDom,
+  getInstanceById,
+  getMap,
+  graphic,
+  helper,
+  init,
+  brushSingle as innerDrawElementOnCanvas,
+  matrix,
+  number,
+  parseGeoJSON,
+  parseGeoJSON2 as parseGeoJson,
+  registerAction,
+  registerCoordinateSystem,
+  registerCustomSeries,
+  registerLayout,
+  registerLoading,
+  registerLocale,
+  registerMap,
+  registerPostInit,
+  registerPostUpdate,
+  registerPreprocessor,
+  registerProcessor,
+  registerTheme,
+  registerTransform,
+  registerUpdateLifecycle,
+  registerVisual,
+  setCanvasCreator,
+  setPlatformAPI,
+  throttle,
+  time,
+  use,
+  util2 as util,
+  vector,
+  version,
+  util as zrUtil,
+  zrender
+};

package/dist/createSeriesData-DGiG-J3b.js

@@ -0,0 +1,434 @@
+import { createHashMap, isString, each, extend, defaults, isObject, retrieve, isFunction, curry, map, isArray } from "./graphic-BEFAeatd.js";
+import { isSourceInstance, createSourceFromSeriesDataOption, shouldOmitUnusedDimensions, ensureSourceDimNameMap, createDimNameMap, CtorInt32Array, normalizeToArray, VISUAL_DIMENSIONS, guessOrdinal, BE_ORDINAL, SeriesDataSchema, SeriesDimensionDefine, SINGLE_REFERRING, SOURCE_FORMAT_ORIGINAL, makeSeriesEncodeForAxisCoordSys, enableDataStack, SeriesData, CoordinateSystemManager, getDimensionTypeByAxis, getDataItemValue } from "./Axis-NtNlSRsM.js";
+function createDimensions(source, opt) {
+  return prepareSeriesDataSchema(source, opt).dimensions;
+}
+function prepareSeriesDataSchema(source, opt) {
+  if (!isSourceInstance(source)) {
+    source = createSourceFromSeriesDataOption(source);
+  }
+  opt = opt || {};
+  var sysDims = opt.coordDimensions || [];
+  var dimsDef = opt.dimensionsDefine || source.dimensionsDefine || [];
+  var coordDimNameMap = createHashMap();
+  var resultList = [];
+  var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimensionsCount);
+  var omitUnusedDimensions = opt.canOmitUnusedDimensions && shouldOmitUnusedDimensions(dimCount);
+  var isUsingSourceDimensionsDef = dimsDef === source.dimensionsDefine;
+  var dataDimNameMap = isUsingSourceDimensionsDef ? ensureSourceDimNameMap(source) : createDimNameMap(dimsDef);
+  var encodeDef = opt.encodeDefine;
+  if (!encodeDef && opt.encodeDefaulter) {
+    encodeDef = opt.encodeDefaulter(source, dimCount);
+  }
+  var encodeDefMap = createHashMap(encodeDef);
+  var indicesMap = new CtorInt32Array(dimCount);
+  for (var i = 0; i < indicesMap.length; i++) {
+    indicesMap[i] = -1;
+  }
+  function getResultItem(dimIdx) {
+    var idx = indicesMap[dimIdx];
+    if (idx < 0) {
+      var dimDefItemRaw = dimsDef[dimIdx];
+      var dimDefItem = isObject(dimDefItemRaw) ? dimDefItemRaw : {
+        name: dimDefItemRaw
+      };
+      var resultItem2 = new SeriesDimensionDefine();
+      var userDimName = dimDefItem.name;
+      if (userDimName != null && dataDimNameMap.get(userDimName) != null) {
+        resultItem2.name = resultItem2.displayName = userDimName;
+      }
+      dimDefItem.type != null && (resultItem2.type = dimDefItem.type);
+      dimDefItem.displayName != null && (resultItem2.displayName = dimDefItem.displayName);
+      var newIdx = resultList.length;
+      indicesMap[dimIdx] = newIdx;
+      resultItem2.storeDimIndex = dimIdx;
+      resultList.push(resultItem2);
+      return resultItem2;
+    }
+    return resultList[idx];
+  }
+  if (!omitUnusedDimensions) {
+    for (var i = 0; i < dimCount; i++) {
+      getResultItem(i);
+    }
+  }
+  encodeDefMap.each(function(dataDimsRaw, coordDim2) {
+    var dataDims = normalizeToArray(dataDimsRaw).slice();
+    if (dataDims.length === 1 && !isString(dataDims[0]) && dataDims[0] < 0) {
+      encodeDefMap.set(coordDim2, false);
+      return;
+    }
+    var validDataDims = encodeDefMap.set(coordDim2, []);
+    each(dataDims, function(resultDimIdxOrName, idx) {
+      var resultDimIdx2 = isString(resultDimIdxOrName) ? dataDimNameMap.get(resultDimIdxOrName) : resultDimIdxOrName;
+      if (resultDimIdx2 != null && resultDimIdx2 < dimCount) {
+        validDataDims[idx] = resultDimIdx2;
+        applyDim(getResultItem(resultDimIdx2), coordDim2, idx);
+      }
+    });
+  });
+  var availDimIdx = 0;
+  each(sysDims, function(sysDimItemRaw) {
+    var coordDim2;
+    var sysDimItemDimsDef;
+    var sysDimItemOtherDims;
+    var sysDimItem;
+    if (isString(sysDimItemRaw)) {
+      coordDim2 = sysDimItemRaw;
+      sysDimItem = {};
+    } else {
+      sysDimItem = sysDimItemRaw;
+      coordDim2 = sysDimItem.name;
+      var ordinalMeta = sysDimItem.ordinalMeta;
+      sysDimItem.ordinalMeta = null;
+      sysDimItem = extend({}, sysDimItem);
+      sysDimItem.ordinalMeta = ordinalMeta;
+      sysDimItemDimsDef = sysDimItem.dimsDef;
+      sysDimItemOtherDims = sysDimItem.otherDims;
+      sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;
+    }
+    var dataDims = encodeDefMap.get(coordDim2);
+    if (dataDims === false) {
+      return;
+    }
+    dataDims = normalizeToArray(dataDims);
+    if (!dataDims.length) {
+      for (var i2 = 0; i2 < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i2++) {
+        while (availDimIdx < dimCount && getResultItem(availDimIdx).coordDim != null) {
+          availDimIdx++;
+        }
+        availDimIdx < dimCount && dataDims.push(availDimIdx++);
+      }
+    }
+    each(dataDims, function(resultDimIdx2, coordDimIndex) {
+      var resultItem2 = getResultItem(resultDimIdx2);
+      if (isUsingSourceDimensionsDef && sysDimItem.type != null) {
+        resultItem2.type = sysDimItem.type;
+      }
+      applyDim(defaults(resultItem2, sysDimItem), coordDim2, coordDimIndex);
+      if (resultItem2.name == null && sysDimItemDimsDef) {
+        var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];
+        !isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {
+          name: sysDimItemDimsDefItem
+        });
+        resultItem2.name = resultItem2.displayName = sysDimItemDimsDefItem.name;
+        resultItem2.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;
+      }
+      sysDimItemOtherDims && defaults(resultItem2.otherDims, sysDimItemOtherDims);
+    });
+  });
+  function applyDim(resultItem2, coordDim2, coordDimIndex) {
+    if (VISUAL_DIMENSIONS.get(coordDim2) != null) {
+      resultItem2.otherDims[coordDim2] = coordDimIndex;
+    } else {
+      resultItem2.coordDim = coordDim2;
+      resultItem2.coordDimIndex = coordDimIndex;
+      coordDimNameMap.set(coordDim2, true);
+    }
+  }
+  var generateCoord = opt.generateCoord;
+  var generateCoordCount = opt.generateCoordCount;
+  var fromZero = generateCoordCount != null;
+  generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;
+  var extra = generateCoord || "value";
+  function ifNoNameFillWithCoordName(resultItem2) {
+    if (resultItem2.name == null) {
+      resultItem2.name = resultItem2.coordDim;
+    }
+  }
+  if (!omitUnusedDimensions) {
+    for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
+      var resultItem = getResultItem(resultDimIdx);
+      var coordDim = resultItem.coordDim;
+      if (coordDim == null) {
+        resultItem.coordDim = genCoordDimName(extra, coordDimNameMap, fromZero);
+        resultItem.coordDimIndex = 0;
+        if (!generateCoord || generateCoordCount <= 0) {
+          resultItem.isExtraCoord = true;
+        }
+        generateCoordCount--;
+      }
+      ifNoNameFillWithCoordName(resultItem);
+      if (resultItem.type == null && (guessOrdinal(source, resultDimIdx) === BE_ORDINAL.Must || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {
+        resultItem.type = "ordinal";
+      }
+    }
+  } else {
+    each(resultList, function(resultItem2) {
+      ifNoNameFillWithCoordName(resultItem2);
+    });
+    resultList.sort(function(item0, item1) {
+      return item0.storeDimIndex - item1.storeDimIndex;
+    });
+  }
+  removeDuplication(resultList);
+  return new SeriesDataSchema({
+    source,
+    dimensions: resultList,
+    fullDimensionCount: dimCount,
+    dimensionOmitted: omitUnusedDimensions
+  });
+}
+function removeDuplication(result) {
+  var duplicationMap = createHashMap();
+  for (var i = 0; i < result.length; i++) {
+    var dim = result[i];
+    var dimOriginalName = dim.name;
+    var count = duplicationMap.get(dimOriginalName) || 0;
+    if (count > 0) {
+      dim.name = dimOriginalName + (count - 1);
+    }
+    count++;
+    duplicationMap.set(dimOriginalName, count);
+  }
+}
+function getDimCount(source, sysDims, dimsDef, optDimCount) {
+  var dimCount = Math.max(source.dimensionsDetectedCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);
+  each(sysDims, function(sysDimItem) {
+    var sysDimItemDimsDef;
+    if (isObject(sysDimItem) && (sysDimItemDimsDef = sysDimItem.dimsDef)) {
+      dimCount = Math.max(dimCount, sysDimItemDimsDef.length);
+    }
+  });
+  return dimCount;
+}
+function genCoordDimName(name, map2, fromZero) {
+  if (fromZero || map2.hasKey(name)) {
+    var i = 0;
+    while (map2.hasKey(name + i)) {
+      i++;
+    }
+    name += i;
+  }
+  map2.set(name, true);
+  return name;
+}
+var CoordSysInfo = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function CoordSysInfo2(coordSysName) {
+      this.coordSysDims = [];
+      this.axisMap = createHashMap();
+      this.categoryAxisMap = createHashMap();
+      this.coordSysName = coordSysName;
+    }
+    return CoordSysInfo2;
+  })()
+);
+function getCoordSysInfoBySeries(seriesModel) {
+  var coordSysName = seriesModel.get("coordinateSystem");
+  var result = new CoordSysInfo(coordSysName);
+  var fetch = fetchers[coordSysName];
+  if (fetch) {
+    fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);
+    return result;
+  }
+}
+var fetchers = {
+  cartesian2d: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var xAxisModel = seriesModel.getReferringComponents("xAxis", SINGLE_REFERRING).models[0];
+    var yAxisModel = seriesModel.getReferringComponents("yAxis", SINGLE_REFERRING).models[0];
+    if (process.env.NODE_ENV !== "production") {
+      if (!xAxisModel) {
+        throw new Error('xAxis "' + retrieve(seriesModel.get("xAxisIndex"), seriesModel.get("xAxisId"), 0) + '" not found');
+      }
+      if (!yAxisModel) {
+        throw new Error('yAxis "' + retrieve(seriesModel.get("xAxisIndex"), seriesModel.get("yAxisId"), 0) + '" not found');
+      }
+    }
+    result.coordSysDims = ["x", "y"];
+    axisMap.set("x", xAxisModel);
+    axisMap.set("y", yAxisModel);
+    if (isCategory(xAxisModel)) {
+      categoryAxisMap.set("x", xAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+    if (isCategory(yAxisModel)) {
+      categoryAxisMap.set("y", yAxisModel);
+      result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
+    }
+  },
+  singleAxis: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var singleAxisModel = seriesModel.getReferringComponents("singleAxis", SINGLE_REFERRING).models[0];
+    if (process.env.NODE_ENV !== "production") {
+      if (!singleAxisModel) {
+        throw new Error("singleAxis should be specified.");
+      }
+    }
+    result.coordSysDims = ["single"];
+    axisMap.set("single", singleAxisModel);
+    if (isCategory(singleAxisModel)) {
+      categoryAxisMap.set("single", singleAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+  },
+  polar: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var polarModel = seriesModel.getReferringComponents("polar", SINGLE_REFERRING).models[0];
+    var radiusAxisModel = polarModel.findAxisModel("radiusAxis");
+    var angleAxisModel = polarModel.findAxisModel("angleAxis");
+    if (process.env.NODE_ENV !== "production") {
+      if (!angleAxisModel) {
+        throw new Error("angleAxis option not found");
+      }
+      if (!radiusAxisModel) {
+        throw new Error("radiusAxis option not found");
+      }
+    }
+    result.coordSysDims = ["radius", "angle"];
+    axisMap.set("radius", radiusAxisModel);
+    axisMap.set("angle", angleAxisModel);
+    if (isCategory(radiusAxisModel)) {
+      categoryAxisMap.set("radius", radiusAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+    if (isCategory(angleAxisModel)) {
+      categoryAxisMap.set("angle", angleAxisModel);
+      result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
+    }
+  },
+  geo: function(seriesModel, result, axisMap, categoryAxisMap) {
+    result.coordSysDims = ["lng", "lat"];
+  },
+  parallel: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var ecModel = seriesModel.ecModel;
+    var parallelModel = ecModel.getComponent("parallel", seriesModel.get("parallelIndex"));
+    var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice();
+    each(parallelModel.parallelAxisIndex, function(axisIndex, index) {
+      var axisModel = ecModel.getComponent("parallelAxis", axisIndex);
+      var axisDim = coordSysDims[index];
+      axisMap.set(axisDim, axisModel);
+      if (isCategory(axisModel)) {
+        categoryAxisMap.set(axisDim, axisModel);
+        if (result.firstCategoryDimIndex == null) {
+          result.firstCategoryDimIndex = index;
+        }
+      }
+    });
+  },
+  matrix: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var matrixModel = seriesModel.getReferringComponents("matrix", SINGLE_REFERRING).models[0];
+    if (process.env.NODE_ENV !== "production") {
+      if (!matrixModel) {
+        throw new Error("matrix coordinate system should be specified.");
+      }
+    }
+    result.coordSysDims = ["x", "y"];
+    var xModel = matrixModel.getDimensionModel("x");
+    var yModel = matrixModel.getDimensionModel("y");
+    axisMap.set("x", xModel);
+    axisMap.set("y", yModel);
+    categoryAxisMap.set("x", xModel);
+    categoryAxisMap.set("y", yModel);
+  }
+};
+function isCategory(axisModel) {
+  return axisModel.get("type") === "category";
+}
+function getCoordSysDimDefs(seriesModel, coordSysInfo) {
+  var coordSysName = seriesModel.get("coordinateSystem");
+  var registeredCoordSys = CoordinateSystemManager.get(coordSysName);
+  var coordSysDimDefs;
+  if (coordSysInfo && coordSysInfo.coordSysDims) {
+    coordSysDimDefs = map(coordSysInfo.coordSysDims, function(dim) {
+      var dimInfo = {
+        name: dim
+      };
+      var axisModel = coordSysInfo.axisMap.get(dim);
+      if (axisModel) {
+        var axisType = axisModel.get("type");
+        dimInfo.type = getDimensionTypeByAxis(axisType);
+      }
+      return dimInfo;
+    });
+  }
+  if (!coordSysDimDefs) {
+    coordSysDimDefs = registeredCoordSys && (registeredCoordSys.getDimensionsInfo ? registeredCoordSys.getDimensionsInfo() : registeredCoordSys.dimensions.slice()) || ["x", "y"];
+  }
+  return coordSysDimDefs;
+}
+function injectOrdinalMeta(dimInfoList, createInvertedIndices, coordSysInfo) {
+  var firstCategoryDimIndex;
+  var hasNameEncode;
+  coordSysInfo && each(dimInfoList, function(dimInfo, dimIndex) {
+    var coordDim = dimInfo.coordDim;
+    var categoryAxisModel = coordSysInfo.categoryAxisMap.get(coordDim);
+    if (categoryAxisModel) {
+      if (firstCategoryDimIndex == null) {
+        firstCategoryDimIndex = dimIndex;
+      }
+      dimInfo.ordinalMeta = categoryAxisModel.getOrdinalMeta();
+      if (createInvertedIndices) {
+        dimInfo.createInvertedIndices = true;
+      }
+    }
+    if (dimInfo.otherDims.itemName != null) {
+      hasNameEncode = true;
+    }
+  });
+  if (!hasNameEncode && firstCategoryDimIndex != null) {
+    dimInfoList[firstCategoryDimIndex].otherDims.itemName = 0;
+  }
+  return firstCategoryDimIndex;
+}
+function createSeriesData(sourceRaw, seriesModel, opt) {
+  opt = opt || {};
+  var sourceManager = seriesModel.getSourceManager();
+  var source;
+  var isOriginalSource = false;
+  if (sourceRaw) {
+    isOriginalSource = true;
+    source = createSourceFromSeriesDataOption(sourceRaw);
+  } else {
+    source = sourceManager.getSource();
+    isOriginalSource = source.sourceFormat === SOURCE_FORMAT_ORIGINAL;
+  }
+  var coordSysInfo = getCoordSysInfoBySeries(seriesModel);
+  var coordSysDimDefs = getCoordSysDimDefs(seriesModel, coordSysInfo);
+  var useEncodeDefaulter = opt.useEncodeDefaulter;
+  var encodeDefaulter = isFunction(useEncodeDefaulter) ? useEncodeDefaulter : useEncodeDefaulter ? curry(makeSeriesEncodeForAxisCoordSys, coordSysDimDefs, seriesModel) : null;
+  var createDimensionOptions = {
+    coordDimensions: coordSysDimDefs,
+    generateCoord: opt.generateCoord,
+    encodeDefine: seriesModel.getEncode(),
+    encodeDefaulter,
+    canOmitUnusedDimensions: !isOriginalSource
+  };
+  var schema = prepareSeriesDataSchema(source, createDimensionOptions);
+  var firstCategoryDimIndex = injectOrdinalMeta(schema.dimensions, opt.createInvertedIndices, coordSysInfo);
+  var store = !isOriginalSource ? sourceManager.getSharedDataStore(schema) : null;
+  var stackCalculationInfo = enableDataStack(seriesModel, {
+    schema,
+    store
+  });
+  var data = new SeriesData(schema, seriesModel);
+  data.setCalculationInfo(stackCalculationInfo);
+  var dimValueGetter = firstCategoryDimIndex != null && isNeedCompleteOrdinalData(source) ? function(itemOpt, dimName, dataIndex, dimIndex) {
+    return dimIndex === firstCategoryDimIndex ? dataIndex : this.defaultDimValueGetter(itemOpt, dimName, dataIndex, dimIndex);
+  } : null;
+  data.hasItemOption = false;
+  data.initData(
+    // Try to reuse the data store in sourceManager if using dataset.
+    isOriginalSource ? source : store,
+    null,
+    dimValueGetter
+  );
+  return data;
+}
+function isNeedCompleteOrdinalData(source) {
+  if (source.sourceFormat === SOURCE_FORMAT_ORIGINAL) {
+    var sampleItem = firstDataNotNull(source.data || []);
+    return !isArray(getDataItemValue(sampleItem));
+  }
+}
+function firstDataNotNull(arr) {
+  var i = 0;
+  while (i < arr.length && arr[i] == null) {
+    i++;
+  }
+  return arr[i];
+}
+export {
+  createDimensions,
+  createSeriesData,
+  prepareSeriesDataSchema
+};