@fmdevui/fm-dev 1.0.112 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/createSeriesData.mjs

@@ -0,0 +1,131 @@
+import { map, each, isFunction, curry, isArray } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import SeriesData from '../../data/SeriesData.mjs';
+import prepareSeriesDataSchema from '../../data/helper/createDimensions.mjs';
+import { getDimensionTypeByAxis } from '../../data/helper/dimensionHelper.mjs';
+import { getDataItemValue } from '../../util/model.mjs';
+import CoordinateSystemManager from '../../core/CoordinateSystem.mjs';
+import { getCoordSysInfoBySeries } from '../../model/referHelper.mjs';
+import { createSourceFromSeriesDataOption } from '../../data/Source.mjs';
+import { enableDataStack } from '../../data/helper/dataStackHelper.mjs';
+import { makeSeriesEncodeForAxisCoordSys } from '../../data/helper/sourceHelper.mjs';
+import { SOURCE_FORMAT_ORIGINAL } from '../../util/types.mjs';
+
+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) {
+    // Get dimensions from registered coordinate system
+    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;
+}
+/**
+ * Caution: there are side effects to `sourceManager` in this method.
+ * Should better only be called in `Series['getInitialData']`.
+ */
+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();
+    // Is series.data. not dataset.
+    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: 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: schema,
+    store: store
+  });
+  var data = new SeriesData(schema, seriesModel);
+  data.setCalculationInfo(stackCalculationInfo);
+  var dimValueGetter = firstCategoryDimIndex != null && isNeedCompleteOrdinalData(source)
+  /**
+   * This serves this case:
+   *  var echarts_option = {
+   *      xAxis: { data: ['a', 'b', 'c'] },
+   *      yAxis: {}
+   *      series: { data: [555, 666, 777] }
+   *  };
+   * The `series.data` is completed to:
+   *  [[0, 555], [1, 666], [2, 777]]
+   */ ? function (itemOpt, dimName, dataIndex, dimIndex) {
+    // Use dataIndex as ordinal value in categoryAxis
+    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 { createSeriesData as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/createSeriesDataSimply.mjs

@@ -0,0 +1,28 @@
+import prepareSeriesDataSchema from '../../data/helper/createDimensions.mjs';
+import SeriesData from '../../data/SeriesData.mjs';
+import { isArray, extend } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+/**
+ * [Usage]:
+ * (1)
+ * createListSimply(seriesModel, ['value']);
+ * (2)
+ * createListSimply(seriesModel, {
+ *     coordDimensions: ['value'],
+ *     dimensionsCount: 5
+ * });
+ */
+function createSeriesDataSimply(seriesModel, opt, nameList) {
+  opt = isArray(opt) && {
+    coordDimensions: opt
+  } || extend({
+    encodeDefine: seriesModel.getEncode()
+  }, opt);
+  var source = seriesModel.getSource();
+  var dimensions = prepareSeriesDataSchema(source, opt).dimensions;
+  var list = new SeriesData(dimensions, seriesModel);
+  list.initData(source, nameList);
+  return list;
+}
+
+export { createSeriesDataSimply as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/enableAriaDecalForTree.mjs

@@ -0,0 +1,18 @@
+import { getDecalFromPalette } from '../../model/mixin/palette.mjs';
+
+function enableAriaDecalForTree(seriesModel) {
+  var data = seriesModel.getData();
+  var tree = data.tree;
+  var decalPaletteScope = {};
+  tree.eachNode(function (node) {
+    // Use decal of level 1 node
+    var current = node;
+    while (current && current.depth > 1) {
+      current = current.parentNode;
+    }
+    var decal = getDecalFromPalette(seriesModel.ecModel, current.name || current.dataIndex + '', decalPaletteScope);
+    node.setVisual('decal', decal);
+  });
+}
+
+export { enableAriaDecalForTree as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/labelHelper.mjs

@@ -0,0 +1,37 @@
+import { retrieveRawValue } from '../../data/helper/dataProvider.mjs';
+import { isArray } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+/**
+ * @return label string. Not null/undefined
+ */
+function getDefaultLabel(data, dataIndex) {
+  var labelDims = data.mapDimensionsAll('defaultedLabel');
+  var len = labelDims.length;
+  // Simple optimization (in lots of cases, label dims length is 1)
+  if (len === 1) {
+    var rawVal = retrieveRawValue(data, dataIndex, labelDims[0]);
+    return rawVal != null ? rawVal + '' : null;
+  } else if (len) {
+    var vals = [];
+    for (var i = 0; i < labelDims.length; i++) {
+      vals.push(retrieveRawValue(data, dataIndex, labelDims[i]));
+    }
+    return vals.join(' ');
+  }
+}
+function getDefaultInterpolatedLabel(data, interpolatedValue) {
+  var labelDims = data.mapDimensionsAll('defaultedLabel');
+  if (!isArray(interpolatedValue)) {
+    return interpolatedValue + '';
+  }
+  var vals = [];
+  for (var i = 0; i < labelDims.length; i++) {
+    var dimIndex = data.getDimensionIndex(labelDims[i]);
+    if (dimIndex >= 0) {
+      vals.push(interpolatedValue[dimIndex]);
+    }
+  }
+  return vals.join(' ');
+}
+
+export { getDefaultInterpolatedLabel, getDefaultLabel };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/multipleGraphEdgeHelper.mjs

@@ -0,0 +1,185 @@
+import { isNumber, isArray } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+var KEY_DELIMITER = '-->';
+/**
+ * params handler
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @returns {*}
+ */
+var getAutoCurvenessParams = function (seriesModel) {
+  return seriesModel.get('autoCurveness') || null;
+};
+/**
+ * Generate a list of edge curvatures, 20 is the default
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param {number} appendLength
+ * @return  20 => [0, -0.2, 0.2, -0.4, 0.4, -0.6, 0.6, -0.8, 0.8, -1, 1, -1.2, 1.2, -1.4, 1.4, -1.6, 1.6, -1.8, 1.8, -2]
+ */
+var createCurveness = function (seriesModel, appendLength) {
+  var autoCurvenessParmas = getAutoCurvenessParams(seriesModel);
+  var length = 20;
+  var curvenessList = [];
+  // handler the function set
+  if (isNumber(autoCurvenessParmas)) {
+    length = autoCurvenessParmas;
+  } else if (isArray(autoCurvenessParmas)) {
+    seriesModel.__curvenessList = autoCurvenessParmas;
+    return;
+  }
+  // append length
+  if (appendLength > length) {
+    length = appendLength;
+  }
+  // make sure the length is even
+  var len = length % 2 ? length + 2 : length + 3;
+  curvenessList = [];
+  for (var i = 0; i < len; i++) {
+    curvenessList.push((i % 2 ? i + 1 : i) / 10 * (i % 2 ? -1 : 1));
+  }
+  seriesModel.__curvenessList = curvenessList;
+};
+/**
+ * Create different cache key data in the positive and negative directions, in order to set the curvature later
+ * @param {number|string|module:echarts/data/Graph.Node} n1
+ * @param {number|string|module:echarts/data/Graph.Node} n2
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @returns {string} key
+ */
+var getKeyOfEdges = function (n1, n2, seriesModel) {
+  var source = [n1.id, n1.dataIndex].join('.');
+  var target = [n2.id, n2.dataIndex].join('.');
+  return [seriesModel.uid, source, target].join(KEY_DELIMITER);
+};
+/**
+ * get opposite key
+ * @param {string} key
+ * @returns {string}
+ */
+var getOppositeKey = function (key) {
+  var keys = key.split(KEY_DELIMITER);
+  return [keys[0], keys[2], keys[1]].join(KEY_DELIMITER);
+};
+/**
+ * get edgeMap with key
+ * @param edge
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ */
+var getEdgeFromMap = function (edge, seriesModel) {
+  var key = getKeyOfEdges(edge.node1, edge.node2, seriesModel);
+  return seriesModel.__edgeMap[key];
+};
+/**
+ * calculate all cases total length
+ * @param edge
+ * @param seriesModel
+ * @returns {number}
+ */
+var getTotalLengthBetweenNodes = function (edge, seriesModel) {
+  var len = getEdgeMapLengthWithKey(getKeyOfEdges(edge.node1, edge.node2, seriesModel), seriesModel);
+  var lenV = getEdgeMapLengthWithKey(getKeyOfEdges(edge.node2, edge.node1, seriesModel), seriesModel);
+  return len + lenV;
+};
+/**
+ *
+ * @param key
+ */
+var getEdgeMapLengthWithKey = function (key, seriesModel) {
+  var edgeMap = seriesModel.__edgeMap;
+  return edgeMap[key] ? edgeMap[key].length : 0;
+};
+/**
+ * Count the number of edges between the same two points, used to obtain the curvature table and the parity of the edge
+ * @see /graph/GraphSeries.js@getInitialData
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ */
+function initCurvenessList(seriesModel) {
+  if (!getAutoCurvenessParams(seriesModel)) {
+    return;
+  }
+  seriesModel.__curvenessList = [];
+  seriesModel.__edgeMap = {};
+  // calc the array of curveness List
+  createCurveness(seriesModel);
+}
+/**
+ * set edgeMap with key
+ * @param {number|string|module:echarts/data/Graph.Node} n1
+ * @param {number|string|module:echarts/data/Graph.Node} n2
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param {number} index
+ */
+function createEdgeMapForCurveness(n1, n2, seriesModel, index) {
+  if (!getAutoCurvenessParams(seriesModel)) {
+    return;
+  }
+  var key = getKeyOfEdges(n1, n2, seriesModel);
+  var edgeMap = seriesModel.__edgeMap;
+  var oppositeEdges = edgeMap[getOppositeKey(key)];
+  // set direction
+  if (edgeMap[key] && !oppositeEdges) {
+    edgeMap[key].isForward = true;
+  } else if (oppositeEdges && edgeMap[key]) {
+    oppositeEdges.isForward = true;
+    edgeMap[key].isForward = false;
+  }
+  edgeMap[key] = edgeMap[key] || [];
+  edgeMap[key].push(index);
+}
+/**
+ * get curvature for edge
+ * @param edge
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param index
+ */
+function getCurvenessForEdge(edge, seriesModel, index, needReverse) {
+  var autoCurvenessParams = getAutoCurvenessParams(seriesModel);
+  var isArrayParam = isArray(autoCurvenessParams);
+  if (!autoCurvenessParams) {
+    return null;
+  }
+  var edgeArray = getEdgeFromMap(edge, seriesModel);
+  if (!edgeArray) {
+    return null;
+  }
+  var edgeIndex = -1;
+  for (var i = 0; i < edgeArray.length; i++) {
+    if (edgeArray[i] === index) {
+      edgeIndex = i;
+      break;
+    }
+  }
+  // if totalLen is Longer createCurveness
+  var totalLen = getTotalLengthBetweenNodes(edge, seriesModel);
+  createCurveness(seriesModel, totalLen);
+  edge.lineStyle = edge.lineStyle || {};
+  // if is opposite edge, must set curvenss to opposite number
+  var curKey = getKeyOfEdges(edge.node1, edge.node2, seriesModel);
+  var curvenessList = seriesModel.__curvenessList;
+  // if pass array no need parity
+  var parityCorrection = isArrayParam ? 0 : totalLen % 2 ? 0 : 1;
+  if (!edgeArray.isForward) {
+    // the opposite edge show outside
+    var oppositeKey = getOppositeKey(curKey);
+    var len = getEdgeMapLengthWithKey(oppositeKey, seriesModel);
+    var resValue = curvenessList[edgeIndex + len + parityCorrection];
+    // isNeedReverse, simple, force type need reverse the curveness in the junction of the forword and the opposite
+    if (needReverse) {
+      // set as array may make the parity handle with the len of opposite
+      if (isArrayParam) {
+        if (autoCurvenessParams && autoCurvenessParams[0] === 0) {
+          return (len + parityCorrection) % 2 ? resValue : -resValue;
+        } else {
+          return ((len % 2 ? 0 : 1) + parityCorrection) % 2 ? resValue : -resValue;
+        }
+      } else {
+        return (len + parityCorrection) % 2 ? resValue : -resValue;
+      }
+    } else {
+      return curvenessList[edgeIndex + len + parityCorrection];
+    }
+  } else {
+    return curvenessList[parityCorrection + edgeIndex];
+  }
+}
+
+export { createEdgeMapForCurveness, getCurvenessForEdge, initCurvenessList };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/sectorHelper.mjs

@@ -0,0 +1,22 @@
+import { isArray, map } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { parsePercent } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/contain/text.mjs';
+
+function getSectorCornerRadius(model, shape, zeroIfNull) {
+  var cornerRadius = model.get('borderRadius');
+  if (cornerRadius == null) {
+    return zeroIfNull ? {
+      cornerRadius: 0
+    } : null;
+  }
+  if (!isArray(cornerRadius)) {
+    cornerRadius = [cornerRadius, cornerRadius, cornerRadius, cornerRadius];
+  }
+  var dr = Math.abs(shape.r || 0 - shape.r0 || 0);
+  return {
+    cornerRadius: map(cornerRadius, function (cr) {
+      return parsePercent(cr, dr);
+    })
+  };
+}
+
+export { getSectorCornerRadius };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/treeHelper.mjs

@@ -0,0 +1,52 @@
+import { indexOf, isString } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+function retrieveTargetInfo(payload, validPayloadTypes, seriesModel) {
+  if (payload && indexOf(validPayloadTypes, payload.type) >= 0) {
+    var root = seriesModel.getData().tree.root;
+    var targetNode = payload.targetNode;
+    if (isString(targetNode)) {
+      targetNode = root.getNodeById(targetNode);
+    }
+    if (targetNode && root.contains(targetNode)) {
+      return {
+        node: targetNode
+      };
+    }
+    var targetNodeId = payload.targetNodeId;
+    if (targetNodeId != null && (targetNode = root.getNodeById(targetNodeId))) {
+      return {
+        node: targetNode
+      };
+    }
+  }
+}
+// Not includes the given node at the last item.
+function getPathToRoot(node) {
+  var path = [];
+  while (node) {
+    node = node.parentNode;
+    node && path.push(node);
+  }
+  return path.reverse();
+}
+function aboveViewRoot(viewRoot, node) {
+  var viewPath = getPathToRoot(viewRoot);
+  return indexOf(viewPath, node) >= 0;
+}
+// From root to the input node (the input node will be included).
+function wrapTreePathInfo(node, seriesModel) {
+  var treePathInfo = [];
+  while (node) {
+    var nodeDataIndex = node.dataIndex;
+    treePathInfo.push({
+      name: node.name,
+      dataIndex: nodeDataIndex,
+      value: seriesModel.getRawValue(nodeDataIndex)
+    });
+    node = node.parentNode;
+  }
+  treePathInfo.reverse();
+  return treePathInfo;
+}
+
+export { aboveViewRoot, getPathToRoot, retrieveTargetInfo, wrapTreePathInfo };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/whiskerBoxCommon.mjs

@@ -0,0 +1,104 @@
+import createSeriesDataSimply from './createSeriesDataSimply.mjs';
+import { each, isArray, extend, curry } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { getDimensionTypeByAxis } from '../../data/helper/dimensionHelper.mjs';
+import { makeSeriesEncodeForAxisCoordSys } from '../../data/helper/sourceHelper.mjs';
+
+var WhiskerBoxCommonMixin = /** @class */function () {
+  function WhiskerBoxCommonMixin() {}
+  /**
+   * @private
+   */
+  WhiskerBoxCommonMixin.prototype._hasEncodeRule = function (key) {
+    var encodeRules = this.getEncode();
+    return encodeRules && encodeRules.get(key) != null;
+  };
+  /**
+   * @override
+   */
+  WhiskerBoxCommonMixin.prototype.getInitialData = function (option, ecModel) {
+    // When both types of xAxis and yAxis are 'value', layout is
+    // needed to be specified by user. Otherwise, layout can be
+    // judged by which axis is category.
+    var ordinalMeta;
+    var xAxisModel = ecModel.getComponent('xAxis', this.get('xAxisIndex'));
+    var yAxisModel = ecModel.getComponent('yAxis', this.get('yAxisIndex'));
+    var xAxisType = xAxisModel.get('type');
+    var yAxisType = yAxisModel.get('type');
+    var addOrdinal;
+    // FIXME
+    // Consider time axis.
+    if (xAxisType === 'category') {
+      option.layout = 'horizontal';
+      ordinalMeta = xAxisModel.getOrdinalMeta();
+      addOrdinal = !this._hasEncodeRule('x');
+    } else if (yAxisType === 'category') {
+      option.layout = 'vertical';
+      ordinalMeta = yAxisModel.getOrdinalMeta();
+      addOrdinal = !this._hasEncodeRule('y');
+    } else {
+      option.layout = option.layout || 'horizontal';
+    }
+    var coordDims = ['x', 'y'];
+    var baseAxisDimIndex = option.layout === 'horizontal' ? 0 : 1;
+    var baseAxisDim = this._baseAxisDim = coordDims[baseAxisDimIndex];
+    var otherAxisDim = coordDims[1 - baseAxisDimIndex];
+    var axisModels = [xAxisModel, yAxisModel];
+    var baseAxisType = axisModels[baseAxisDimIndex].get('type');
+    var otherAxisType = axisModels[1 - baseAxisDimIndex].get('type');
+    var data = option.data;
+    // Clone a new data for next setOption({}) usage.
+    // Avoid modifying current data will affect further update.
+    if (data && addOrdinal) {
+      var newOptionData_1 = [];
+      each(data, function (item, index) {
+        var newItem;
+        if (isArray(item)) {
+          newItem = item.slice();
+          // Modify current using data.
+          item.unshift(index);
+        } else if (isArray(item.value)) {
+          newItem = extend({}, item);
+          newItem.value = newItem.value.slice();
+          // Modify current using data.
+          item.value.unshift(index);
+        } else {
+          newItem = item;
+        }
+        newOptionData_1.push(newItem);
+      });
+      option.data = newOptionData_1;
+    }
+    var defaultValueDimensions = this.defaultValueDimensions;
+    var coordDimensions = [{
+      name: baseAxisDim,
+      type: getDimensionTypeByAxis(baseAxisType),
+      ordinalMeta: ordinalMeta,
+      otherDims: {
+        tooltip: false,
+        itemName: 0
+      },
+      dimsDef: ['base']
+    }, {
+      name: otherAxisDim,
+      type: getDimensionTypeByAxis(otherAxisType),
+      dimsDef: defaultValueDimensions.slice()
+    }];
+    return createSeriesDataSimply(this, {
+      coordDimensions: coordDimensions,
+      dimensionsCount: defaultValueDimensions.length + 1,
+      encodeDefaulter: curry(makeSeriesEncodeForAxisCoordSys, coordDimensions, this)
+    });
+  };
+  /**
+   * If horizontal, base axis is x, otherwise y.
+   * @override
+   */
+  WhiskerBoxCommonMixin.prototype.getBaseAxis = function () {
+    var dim = this._baseAxisDim;
+    return this.ecModel.getComponent(dim + 'Axis', this.get(dim + 'AxisIndex')).axis;
+  };
+  return WhiskerBoxCommonMixin;
+}();
+;
+
+export { WhiskerBoxCommonMixin };