office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/chart/candlestick/CandlestickView.js

@@ -0,0 +1,291 @@
+import { __extends } from 'tslib';
+import { map } from '../../../../zrender/lib/core/util.js';
+import ChartView from '../../view/Chart.js';
+import { traverseElements } from '../../util/graphic.js';
+import { setStatesStylesFromModel } from '../../util/states.js';
+import Path from '../../../../zrender/lib/graphic/Path.js';
+import { createClipPath } from '../helper/createClipPathFromCoordSys.js';
+import { initProps, updateProps, saveOldStyle } from '../../animation/basicTransition.js';
+
+var SKIP_PROPS = ['color', 'borderColor'];
+var CandlestickView = /** @class */function (_super) {
+  __extends(CandlestickView, _super);
+  function CandlestickView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = CandlestickView.type;
+    return _this;
+  }
+  CandlestickView.prototype.render = function (seriesModel, ecModel, api) {
+    // If there is clipPath created in large mode. Remove it.
+    this.group.removeClipPath();
+    // Clear previously rendered progressive elements.
+    this._progressiveEls = null;
+    this._updateDrawMode(seriesModel);
+    this._isLargeDraw ? this._renderLarge(seriesModel) : this._renderNormal(seriesModel);
+  };
+  CandlestickView.prototype.incrementalPrepareRender = function (seriesModel, ecModel, api) {
+    this._clear();
+    this._updateDrawMode(seriesModel);
+  };
+  CandlestickView.prototype.incrementalRender = function (params, seriesModel, ecModel, api) {
+    this._progressiveEls = [];
+    this._isLargeDraw ? this._incrementalRenderLarge(params, seriesModel) : this._incrementalRenderNormal(params, seriesModel);
+  };
+  CandlestickView.prototype.eachRendered = function (cb) {
+    traverseElements(this._progressiveEls || this.group, cb);
+  };
+  CandlestickView.prototype._updateDrawMode = function (seriesModel) {
+    var isLargeDraw = seriesModel.pipelineContext.large;
+    if (this._isLargeDraw == null || isLargeDraw !== this._isLargeDraw) {
+      this._isLargeDraw = isLargeDraw;
+      this._clear();
+    }
+  };
+  CandlestickView.prototype._renderNormal = function (seriesModel) {
+    var data = seriesModel.getData();
+    var oldData = this._data;
+    var group = this.group;
+    var isSimpleBox = data.getLayout('isSimpleBox');
+    var needsClip = seriesModel.get('clip', true);
+    var coord = seriesModel.coordinateSystem;
+    var clipArea = coord.getArea && coord.getArea();
+    // There is no old data only when first rendering or switching from
+    // stream mode to normal mode, where previous elements should be removed.
+    if (!this._data) {
+      group.removeAll();
+    }
+    data.diff(oldData).add(function (newIdx) {
+      if (data.hasValue(newIdx)) {
+        var itemLayout = data.getItemLayout(newIdx);
+        if (needsClip && isNormalBoxClipped(clipArea, itemLayout)) {
+          return;
+        }
+        var el = createNormalBox(itemLayout, newIdx, true);
+        initProps(el, {
+          shape: {
+            points: itemLayout.ends
+          }
+        }, seriesModel, newIdx);
+        setBoxCommon(el, data, newIdx, isSimpleBox);
+        group.add(el);
+        data.setItemGraphicEl(newIdx, el);
+      }
+    }).update(function (newIdx, oldIdx) {
+      var el = oldData.getItemGraphicEl(oldIdx);
+      // Empty data
+      if (!data.hasValue(newIdx)) {
+        group.remove(el);
+        return;
+      }
+      var itemLayout = data.getItemLayout(newIdx);
+      if (needsClip && isNormalBoxClipped(clipArea, itemLayout)) {
+        group.remove(el);
+        return;
+      }
+      if (!el) {
+        el = createNormalBox(itemLayout);
+      } else {
+        updateProps(el, {
+          shape: {
+            points: itemLayout.ends
+          }
+        }, seriesModel, newIdx);
+        saveOldStyle(el);
+      }
+      setBoxCommon(el, data, newIdx, isSimpleBox);
+      group.add(el);
+      data.setItemGraphicEl(newIdx, el);
+    }).remove(function (oldIdx) {
+      var el = oldData.getItemGraphicEl(oldIdx);
+      el && group.remove(el);
+    }).execute();
+    this._data = data;
+  };
+  CandlestickView.prototype._renderLarge = function (seriesModel) {
+    this._clear();
+    createLarge(seriesModel, this.group);
+    var clipPath = seriesModel.get('clip', true) ? createClipPath(seriesModel.coordinateSystem, false, seriesModel) : null;
+    if (clipPath) {
+      this.group.setClipPath(clipPath);
+    } else {
+      this.group.removeClipPath();
+    }
+  };
+  CandlestickView.prototype._incrementalRenderNormal = function (params, seriesModel) {
+    var data = seriesModel.getData();
+    var isSimpleBox = data.getLayout('isSimpleBox');
+    var dataIndex;
+    while ((dataIndex = params.next()) != null) {
+      var itemLayout = data.getItemLayout(dataIndex);
+      var el = createNormalBox(itemLayout);
+      setBoxCommon(el, data, dataIndex, isSimpleBox);
+      el.incremental = true;
+      this.group.add(el);
+      this._progressiveEls.push(el);
+    }
+  };
+  CandlestickView.prototype._incrementalRenderLarge = function (params, seriesModel) {
+    createLarge(seriesModel, this.group, this._progressiveEls, true);
+  };
+  CandlestickView.prototype.remove = function (ecModel) {
+    this._clear();
+  };
+  CandlestickView.prototype._clear = function () {
+    this.group.removeAll();
+    this._data = null;
+  };
+  CandlestickView.type = 'candlestick';
+  return CandlestickView;
+}(ChartView);
+var NormalBoxPathShape = /** @class */function () {
+  function NormalBoxPathShape() {}
+  return NormalBoxPathShape;
+}();
+var NormalBoxPath = /** @class */function (_super) {
+  __extends(NormalBoxPath, _super);
+  function NormalBoxPath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this.type = 'normalCandlestickBox';
+    return _this;
+  }
+  NormalBoxPath.prototype.getDefaultShape = function () {
+    return new NormalBoxPathShape();
+  };
+  NormalBoxPath.prototype.buildPath = function (ctx, shape) {
+    var ends = shape.points;
+    if (this.__simpleBox) {
+      ctx.moveTo(ends[4][0], ends[4][1]);
+      ctx.lineTo(ends[6][0], ends[6][1]);
+    } else {
+      ctx.moveTo(ends[0][0], ends[0][1]);
+      ctx.lineTo(ends[1][0], ends[1][1]);
+      ctx.lineTo(ends[2][0], ends[2][1]);
+      ctx.lineTo(ends[3][0], ends[3][1]);
+      ctx.closePath();
+      ctx.moveTo(ends[4][0], ends[4][1]);
+      ctx.lineTo(ends[5][0], ends[5][1]);
+      ctx.moveTo(ends[6][0], ends[6][1]);
+      ctx.lineTo(ends[7][0], ends[7][1]);
+    }
+  };
+  return NormalBoxPath;
+}(Path);
+function createNormalBox(itemLayout, dataIndex, isInit) {
+  var ends = itemLayout.ends;
+  return new NormalBoxPath({
+    shape: {
+      points: isInit ? transInit(ends, itemLayout) : ends
+    },
+    z2: 100
+  });
+}
+function isNormalBoxClipped(clipArea, itemLayout) {
+  var clipped = true;
+  for (var i = 0; i < itemLayout.ends.length; i++) {
+    // If any point are in the region.
+    if (clipArea.contain(itemLayout.ends[i][0], itemLayout.ends[i][1])) {
+      clipped = false;
+      break;
+    }
+  }
+  return clipped;
+}
+function setBoxCommon(el, data, dataIndex, isSimpleBox) {
+  var itemModel = data.getItemModel(dataIndex);
+  el.useStyle(data.getItemVisual(dataIndex, 'style'));
+  el.style.strokeNoScale = true;
+  el.__simpleBox = isSimpleBox;
+  setStatesStylesFromModel(el, itemModel);
+}
+function transInit(points, itemLayout) {
+  return map(points, function (point) {
+    point = point.slice();
+    point[1] = itemLayout.initBaseline;
+    return point;
+  });
+}
+var LargeBoxPathShape = /** @class */function () {
+  function LargeBoxPathShape() {}
+  return LargeBoxPathShape;
+}();
+var LargeBoxPath = /** @class */function (_super) {
+  __extends(LargeBoxPath, _super);
+  function LargeBoxPath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this.type = 'largeCandlestickBox';
+    return _this;
+  }
+  LargeBoxPath.prototype.getDefaultShape = function () {
+    return new LargeBoxPathShape();
+  };
+  LargeBoxPath.prototype.buildPath = function (ctx, shape) {
+    // Drawing lines is more efficient than drawing
+    // a whole line or drawing rects.
+    var points = shape.points;
+    for (var i = 0; i < points.length;) {
+      if (this.__sign === points[i++]) {
+        var x = points[i++];
+        ctx.moveTo(x, points[i++]);
+        ctx.lineTo(x, points[i++]);
+      } else {
+        i += 3;
+      }
+    }
+  };
+  return LargeBoxPath;
+}(Path);
+function createLarge(seriesModel, group, progressiveEls, incremental) {
+  var data = seriesModel.getData();
+  var largePoints = data.getLayout('largePoints');
+  var elP = new LargeBoxPath({
+    shape: {
+      points: largePoints
+    },
+    __sign: 1,
+    ignoreCoarsePointer: true
+  });
+  group.add(elP);
+  var elN = new LargeBoxPath({
+    shape: {
+      points: largePoints
+    },
+    __sign: -1,
+    ignoreCoarsePointer: true
+  });
+  group.add(elN);
+  var elDoji = new LargeBoxPath({
+    shape: {
+      points: largePoints
+    },
+    __sign: 0,
+    ignoreCoarsePointer: true
+  });
+  group.add(elDoji);
+  setLargeStyle(1, elP, seriesModel);
+  setLargeStyle(-1, elN, seriesModel);
+  setLargeStyle(0, elDoji, seriesModel);
+  if (incremental) {
+    elP.incremental = true;
+    elN.incremental = true;
+  }
+  if (progressiveEls) {
+    progressiveEls.push(elP, elN);
+  }
+}
+function setLargeStyle(sign, el, seriesModel, data) {
+  // TODO put in visual?
+  var borderColor = seriesModel.get(['itemStyle', sign > 0 ? 'borderColor' : 'borderColor0'])
+  // Use color for border color by default.
+  || seriesModel.get(['itemStyle', sign > 0 ? 'color' : 'color0']);
+  if (sign === 0) {
+    borderColor = seriesModel.get(['itemStyle', 'borderColorDoji']);
+  }
+  // Color must be excluded.
+  // Because symbol provide setColor individually to set fill and stroke
+  var itemStyle = seriesModel.getModel('itemStyle').getItemStyle(SKIP_PROPS);
+  el.useStyle(itemStyle);
+  el.style.fill = null;
+  el.style.stroke = borderColor;
+}
+
+export { CandlestickView as default };

package/esm/node_modules/echarts/lib/chart/candlestick/candlestickLayout.js

@@ -0,0 +1,163 @@
+import { subPixelOptimize } from '../../util/graphic.js';
+import createRenderPlanner from '../helper/createRenderPlanner.js';
+import { parsePercent } from '../../util/number.js';
+import { map, retrieve2 } from '../../../../zrender/lib/core/util.js';
+import { createFloat32Array } from '../../util/vendor.js';
+
+var candlestickLayout = {
+  seriesType: 'candlestick',
+  plan: createRenderPlanner(),
+  reset: function (seriesModel) {
+    var coordSys = seriesModel.coordinateSystem;
+    var data = seriesModel.getData();
+    var candleWidth = calculateCandleWidth(seriesModel, data);
+    var cDimIdx = 0;
+    var vDimIdx = 1;
+    var coordDims = ['x', 'y'];
+    var cDimI = data.getDimensionIndex(data.mapDimension(coordDims[cDimIdx]));
+    var vDimsI = map(data.mapDimensionsAll(coordDims[vDimIdx]), data.getDimensionIndex, data);
+    var openDimI = vDimsI[0];
+    var closeDimI = vDimsI[1];
+    var lowestDimI = vDimsI[2];
+    var highestDimI = vDimsI[3];
+    data.setLayout({
+      candleWidth: candleWidth,
+      // The value is experimented visually.
+      isSimpleBox: candleWidth <= 1.3
+    });
+    if (cDimI < 0 || vDimsI.length < 4) {
+      return;
+    }
+    return {
+      progress: seriesModel.pipelineContext.large ? largeProgress : normalProgress
+    };
+    function normalProgress(params, data) {
+      var dataIndex;
+      var store = data.getStore();
+      while ((dataIndex = params.next()) != null) {
+        var axisDimVal = store.get(cDimI, dataIndex);
+        var openVal = store.get(openDimI, dataIndex);
+        var closeVal = store.get(closeDimI, dataIndex);
+        var lowestVal = store.get(lowestDimI, dataIndex);
+        var highestVal = store.get(highestDimI, dataIndex);
+        var ocLow = Math.min(openVal, closeVal);
+        var ocHigh = Math.max(openVal, closeVal);
+        var ocLowPoint = getPoint(ocLow, axisDimVal);
+        var ocHighPoint = getPoint(ocHigh, axisDimVal);
+        var lowestPoint = getPoint(lowestVal, axisDimVal);
+        var highestPoint = getPoint(highestVal, axisDimVal);
+        var ends = [];
+        addBodyEnd(ends, ocHighPoint, 0);
+        addBodyEnd(ends, ocLowPoint, 1);
+        ends.push(subPixelOptimizePoint(highestPoint), subPixelOptimizePoint(ocHighPoint), subPixelOptimizePoint(lowestPoint), subPixelOptimizePoint(ocLowPoint));
+        var itemModel = data.getItemModel(dataIndex);
+        var hasDojiColor = !!itemModel.get(['itemStyle', 'borderColorDoji']);
+        data.setItemLayout(dataIndex, {
+          sign: getSign(store, dataIndex, openVal, closeVal, closeDimI, hasDojiColor),
+          initBaseline: openVal > closeVal ? ocHighPoint[vDimIdx] : ocLowPoint[vDimIdx],
+          ends: ends,
+          brushRect: makeBrushRect(lowestVal, highestVal, axisDimVal)
+        });
+      }
+      function getPoint(val, axisDimVal) {
+        var p = [];
+        p[cDimIdx] = axisDimVal;
+        p[vDimIdx] = val;
+        return isNaN(axisDimVal) || isNaN(val) ? [NaN, NaN] : coordSys.dataToPoint(p);
+      }
+      function addBodyEnd(ends, point, start) {
+        var point1 = point.slice();
+        var point2 = point.slice();
+        point1[cDimIdx] = subPixelOptimize(point1[cDimIdx] + candleWidth / 2, 1, false);
+        point2[cDimIdx] = subPixelOptimize(point2[cDimIdx] - candleWidth / 2, 1, true);
+        start ? ends.push(point1, point2) : ends.push(point2, point1);
+      }
+      function makeBrushRect(lowestVal, highestVal, axisDimVal) {
+        var pmin = getPoint(lowestVal, axisDimVal);
+        var pmax = getPoint(highestVal, axisDimVal);
+        pmin[cDimIdx] -= candleWidth / 2;
+        pmax[cDimIdx] -= candleWidth / 2;
+        return {
+          x: pmin[0],
+          y: pmin[1],
+          width: candleWidth ,
+          height: pmax[1] - pmin[1] 
+        };
+      }
+      function subPixelOptimizePoint(point) {
+        point[cDimIdx] = subPixelOptimize(point[cDimIdx], 1);
+        return point;
+      }
+    }
+    function largeProgress(params, data) {
+      // Structure: [sign, x, yhigh, ylow, sign, x, yhigh, ylow, ...]
+      var points = createFloat32Array(params.count * 4);
+      var offset = 0;
+      var point;
+      var tmpIn = [];
+      var tmpOut = [];
+      var dataIndex;
+      var store = data.getStore();
+      var hasDojiColor = !!seriesModel.get(['itemStyle', 'borderColorDoji']);
+      while ((dataIndex = params.next()) != null) {
+        var axisDimVal = store.get(cDimI, dataIndex);
+        var openVal = store.get(openDimI, dataIndex);
+        var closeVal = store.get(closeDimI, dataIndex);
+        var lowestVal = store.get(lowestDimI, dataIndex);
+        var highestVal = store.get(highestDimI, dataIndex);
+        if (isNaN(axisDimVal) || isNaN(lowestVal) || isNaN(highestVal)) {
+          points[offset++] = NaN;
+          offset += 3;
+          continue;
+        }
+        points[offset++] = getSign(store, dataIndex, openVal, closeVal, closeDimI, hasDojiColor);
+        tmpIn[cDimIdx] = axisDimVal;
+        tmpIn[vDimIdx] = lowestVal;
+        point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+        points[offset++] = point ? point[0] : NaN;
+        points[offset++] = point ? point[1] : NaN;
+        tmpIn[vDimIdx] = highestVal;
+        point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+        points[offset++] = point ? point[1] : NaN;
+      }
+      data.setLayout('largePoints', points);
+    }
+  }
+};
+/**
+ * Get the sign of a single data.
+ *
+ * @returns 0 for doji with hasDojiColor: true,
+ *          1 for positive,
+ *          -1 for negative.
+ */
+function getSign(store, dataIndex, openVal, closeVal, closeDimI, hasDojiColor) {
+  var sign;
+  if (openVal > closeVal) {
+    sign = -1;
+  } else if (openVal < closeVal) {
+    sign = 1;
+  } else {
+    sign = hasDojiColor
+    // When doji color is set, use it instead of color/color0.
+    ? 0 : dataIndex > 0
+    // If close === open, compare with close of last record
+    ? store.get(closeDimI, dataIndex - 1) <= closeVal ? 1 : -1
+    // No record of previous, set to be positive
+    : 1;
+  }
+  return sign;
+}
+function calculateCandleWidth(seriesModel, data) {
+  var baseAxis = seriesModel.getBaseAxis();
+  var extent;
+  var bandWidth = baseAxis.type === 'category' ? baseAxis.getBandWidth() : (extent = baseAxis.getExtent(), Math.abs(extent[1] - extent[0]) / data.count());
+  var barMaxWidth = parsePercent(retrieve2(seriesModel.get('barMaxWidth'), bandWidth), bandWidth);
+  var barMinWidth = parsePercent(retrieve2(seriesModel.get('barMinWidth'), 1), bandWidth);
+  var barWidth = seriesModel.get('barWidth');
+  return barWidth != null ? parsePercent(barWidth, bandWidth)
+  // Put max outer to ensure bar visible in spite of overlap.
+  : Math.max(Math.min(bandWidth / 2, barMaxWidth), barMinWidth);
+}
+
+export { candlestickLayout as default };

package/esm/node_modules/echarts/lib/chart/candlestick/candlestickVisual.js

@@ -0,0 +1,43 @@
+import createRenderPlanner from '../helper/createRenderPlanner.js';
+import { extend } from '../../../../zrender/lib/core/util.js';
+
+var positiveBorderColorQuery = ['itemStyle', 'borderColor'];
+var negativeBorderColorQuery = ['itemStyle', 'borderColor0'];
+var dojiBorderColorQuery = ['itemStyle', 'borderColorDoji'];
+var positiveColorQuery = ['itemStyle', 'color'];
+var negativeColorQuery = ['itemStyle', 'color0'];
+var candlestickVisual = {
+  seriesType: 'candlestick',
+  plan: createRenderPlanner(),
+  // For legend.
+  performRawSeries: true,
+  reset: function (seriesModel, ecModel) {
+    function getColor(sign, model) {
+      return model.get(sign > 0 ? positiveColorQuery : negativeColorQuery);
+    }
+    function getBorderColor(sign, model) {
+      return model.get(sign === 0 ? dojiBorderColorQuery : sign > 0 ? positiveBorderColorQuery : negativeBorderColorQuery);
+    }
+    // Only visible series has each data be visual encoded
+    if (ecModel.isSeriesFiltered(seriesModel)) {
+      return;
+    }
+    var isLargeRender = seriesModel.pipelineContext.large;
+    return !isLargeRender && {
+      progress: function (params, data) {
+        var dataIndex;
+        while ((dataIndex = params.next()) != null) {
+          var itemModel = data.getItemModel(dataIndex);
+          var sign = data.getItemLayout(dataIndex).sign;
+          var style = itemModel.getItemStyle();
+          style.fill = getColor(sign, itemModel);
+          style.stroke = getBorderColor(sign, itemModel) || style.fill;
+          var existsStyle = data.ensureUniqueItemVisual(dataIndex, 'style');
+          extend(existsStyle, style);
+        }
+      }
+    };
+  }
+};
+
+export { candlestickVisual as default };

package/esm/node_modules/echarts/lib/chart/candlestick/install.js

@@ -0,0 +1,15 @@
+import CandlestickView from './CandlestickView.js';
+import CandlestickSeriesModel from './CandlestickSeries.js';
+import candlestickPreprocessor from './preprocessor.js';
+import candlestickVisual from './candlestickVisual.js';
+import candlestickLayout from './candlestickLayout.js';
+
+function install(registers) {
+  registers.registerChartView(CandlestickView);
+  registers.registerSeriesModel(CandlestickSeriesModel);
+  registers.registerPreprocessor(candlestickPreprocessor);
+  registers.registerVisual(candlestickVisual);
+  registers.registerLayout(candlestickLayout);
+}
+
+export { install };

package/esm/node_modules/echarts/lib/chart/candlestick/preprocessor.js

@@ -0,0 +1,15 @@
+import { isArray, each, isObject } from '../../../../zrender/lib/core/util.js';
+
+function candlestickPreprocessor(option) {
+  if (!option || !isArray(option.series)) {
+    return;
+  }
+  // Translate 'k' to 'candlestick'.
+  each(option.series, function (seriesItem) {
+    if (isObject(seriesItem) && seriesItem.type === 'k') {
+      seriesItem.type = 'candlestick';
+    }
+  });
+}
+
+export { candlestickPreprocessor as default };

package/esm/node_modules/echarts/lib/chart/custom/CustomSeries.js

@@ -0,0 +1,64 @@
+import { __extends } from 'tslib';
+import createSeriesData from '../helper/createSeriesData.js';
+import { makeInner } from '../../util/model.js';
+import SeriesModel from '../../model/Series.js';
+
+// Also compat with ec4, where
+// `visual('color') visual('borderColor')` is supported.
+var STYLE_VISUAL_TYPE = {
+  color: 'fill',
+  borderColor: 'stroke'
+};
+var NON_STYLE_VISUAL_PROPS = {
+  symbol: 1,
+  symbolSize: 1,
+  symbolKeepAspect: 1,
+  legendIcon: 1,
+  visualMeta: 1,
+  liftZ: 1,
+  decal: 1
+};
+var customInnerStore = makeInner();
+var CustomSeriesModel = /** @class */function (_super) {
+  __extends(CustomSeriesModel, _super);
+  function CustomSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = CustomSeriesModel.type;
+    return _this;
+  }
+  CustomSeriesModel.prototype.optionUpdated = function () {
+    this.currentZLevel = this.get('zlevel', true);
+    this.currentZ = this.get('z', true);
+  };
+  CustomSeriesModel.prototype.getInitialData = function (option, ecModel) {
+    return createSeriesData(null, this);
+  };
+  CustomSeriesModel.prototype.getDataParams = function (dataIndex, dataType, el) {
+    var params = _super.prototype.getDataParams.call(this, dataIndex, dataType);
+    el && (params.info = customInnerStore(el).info);
+    return params;
+  };
+  CustomSeriesModel.type = 'series.custom';
+  CustomSeriesModel.dependencies = ['grid', 'polar', 'geo', 'singleAxis', 'calendar'];
+  CustomSeriesModel.defaultOption = {
+    coordinateSystem: 'cartesian2d',
+    // zlevel: 0,
+    z: 2,
+    legendHoverLink: true,
+    // Custom series will not clip by default.
+    // Some case will use custom series to draw label
+    // For example https://echarts.apache.org/examples/en/editor.html?c=custom-gantt-flight
+    clip: false
+    // Cartesian coordinate system
+    // xAxisIndex: 0,
+    // yAxisIndex: 0,
+    // Polar coordinate system
+    // polarIndex: 0,
+    // Geo coordinate system
+    // geoIndex: 0,
+  };
+
+  return CustomSeriesModel;
+}(SeriesModel);
+
+export { NON_STYLE_VISUAL_PROPS, STYLE_VISUAL_TYPE, customInnerStore, CustomSeriesModel as default };