office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/layout/barPolar.js

@@ -0,0 +1,213 @@
+import { filter, each } from '../../../zrender/lib/core/util.js';
+import { parsePercent } from '../util/number.js';
+import { isDimensionStacked } from '../data/helper/dataStackHelper.js';
+
+function getSeriesStackId(seriesModel) {
+  return seriesModel.get('stack') || '__ec_stack_' + seriesModel.seriesIndex;
+}
+function getAxisKey(polar, axis) {
+  return axis.dim + polar.model.componentIndex;
+}
+function barLayoutPolar(seriesType, ecModel, api) {
+  var lastStackCoords = {};
+  var barWidthAndOffset = calRadialBar(filter(ecModel.getSeriesByType(seriesType), function (seriesModel) {
+    return !ecModel.isSeriesFiltered(seriesModel) && seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'polar';
+  }));
+  ecModel.eachSeriesByType(seriesType, function (seriesModel) {
+    // Check series coordinate, do layout for polar only
+    if (seriesModel.coordinateSystem.type !== 'polar') {
+      return;
+    }
+    var data = seriesModel.getData();
+    var polar = seriesModel.coordinateSystem;
+    var baseAxis = polar.getBaseAxis();
+    var axisKey = getAxisKey(polar, baseAxis);
+    var stackId = getSeriesStackId(seriesModel);
+    var columnLayoutInfo = barWidthAndOffset[axisKey][stackId];
+    var columnOffset = columnLayoutInfo.offset;
+    var columnWidth = columnLayoutInfo.width;
+    var valueAxis = polar.getOtherAxis(baseAxis);
+    var cx = seriesModel.coordinateSystem.cx;
+    var cy = seriesModel.coordinateSystem.cy;
+    var barMinHeight = seriesModel.get('barMinHeight') || 0;
+    var barMinAngle = seriesModel.get('barMinAngle') || 0;
+    lastStackCoords[stackId] = lastStackCoords[stackId] || [];
+    var valueDim = data.mapDimension(valueAxis.dim);
+    var baseDim = data.mapDimension(baseAxis.dim);
+    var stacked = isDimensionStacked(data, valueDim /* , baseDim */);
+    var clampLayout = baseAxis.dim !== 'radius' || !seriesModel.get('roundCap', true);
+    var valueAxisStart = valueAxis.dataToCoord(0);
+    for (var idx = 0, len = data.count(); idx < len; idx++) {
+      var value = data.get(valueDim, idx);
+      var baseValue = data.get(baseDim, idx);
+      var sign = value >= 0 ? 'p' : 'n';
+      var baseCoord = valueAxisStart;
+      // Because of the barMinHeight, we can not use the value in
+      // stackResultDimension directly.
+      // Only ordinal axis can be stacked.
+      if (stacked) {
+        if (!lastStackCoords[stackId][baseValue]) {
+          lastStackCoords[stackId][baseValue] = {
+            p: valueAxisStart,
+            n: valueAxisStart // Negative stack
+          };
+        }
+        // Should also consider #4243
+        baseCoord = lastStackCoords[stackId][baseValue][sign];
+      }
+      var r0 = void 0;
+      var r = void 0;
+      var startAngle = void 0;
+      var endAngle = void 0;
+      // radial sector
+      if (valueAxis.dim === 'radius') {
+        var radiusSpan = valueAxis.dataToCoord(value) - valueAxisStart;
+        var angle = baseAxis.dataToCoord(baseValue);
+        if (Math.abs(radiusSpan) < barMinHeight) {
+          radiusSpan = (radiusSpan < 0 ? -1 : 1) * barMinHeight;
+        }
+        r0 = baseCoord;
+        r = baseCoord + radiusSpan;
+        startAngle = angle - columnOffset;
+        endAngle = startAngle - columnWidth;
+        stacked && (lastStackCoords[stackId][baseValue][sign] = r);
+      }
+      // tangential sector
+      else {
+        var angleSpan = valueAxis.dataToCoord(value, clampLayout) - valueAxisStart;
+        var radius = baseAxis.dataToCoord(baseValue);
+        if (Math.abs(angleSpan) < barMinAngle) {
+          angleSpan = (angleSpan < 0 ? -1 : 1) * barMinAngle;
+        }
+        r0 = radius + columnOffset;
+        r = r0 + columnWidth;
+        startAngle = baseCoord;
+        endAngle = baseCoord + angleSpan;
+        // if the previous stack is at the end of the ring,
+        // add a round to differentiate it from origin
+        // let extent = angleAxis.getExtent();
+        // let stackCoord = angle;
+        // if (stackCoord === extent[0] && value > 0) {
+        //     stackCoord = extent[1];
+        // }
+        // else if (stackCoord === extent[1] && value < 0) {
+        //     stackCoord = extent[0];
+        // }
+        stacked && (lastStackCoords[stackId][baseValue][sign] = endAngle);
+      }
+      data.setItemLayout(idx, {
+        cx: cx,
+        cy: cy,
+        r0: r0,
+        r: r,
+        // Consider that positive angle is anti-clockwise,
+        // while positive radian of sector is clockwise
+        startAngle: -startAngle * Math.PI / 180,
+        endAngle: -endAngle * Math.PI / 180,
+        /**
+         * Keep the same logic with bar in catesion: use end value to
+         * control direction. Notice that if clockwise is true (by
+         * default), the sector will always draw clockwisely, no matter
+         * whether endAngle is greater or less than startAngle.
+         */
+        clockwise: startAngle >= endAngle
+      });
+    }
+  });
+}
+/**
+ * Calculate bar width and offset for radial bar charts
+ */
+function calRadialBar(barSeries) {
+  // Columns info on each category axis. Key is polar name
+  var columnsMap = {};
+  each(barSeries, function (seriesModel, idx) {
+    var data = seriesModel.getData();
+    var polar = seriesModel.coordinateSystem;
+    var baseAxis = polar.getBaseAxis();
+    var axisKey = getAxisKey(polar, baseAxis);
+    var axisExtent = baseAxis.getExtent();
+    var bandWidth = baseAxis.type === 'category' ? baseAxis.getBandWidth() : Math.abs(axisExtent[1] - axisExtent[0]) / data.count();
+    var columnsOnAxis = columnsMap[axisKey] || {
+      bandWidth: bandWidth,
+      remainedWidth: bandWidth,
+      autoWidthCount: 0,
+      categoryGap: '20%',
+      gap: '30%',
+      stacks: {}
+    };
+    var stacks = columnsOnAxis.stacks;
+    columnsMap[axisKey] = columnsOnAxis;
+    var stackId = getSeriesStackId(seriesModel);
+    if (!stacks[stackId]) {
+      columnsOnAxis.autoWidthCount++;
+    }
+    stacks[stackId] = stacks[stackId] || {
+      width: 0,
+      maxWidth: 0
+    };
+    var barWidth = parsePercent(seriesModel.get('barWidth'), bandWidth);
+    var barMaxWidth = parsePercent(seriesModel.get('barMaxWidth'), bandWidth);
+    var barGap = seriesModel.get('barGap');
+    var barCategoryGap = seriesModel.get('barCategoryGap');
+    if (barWidth && !stacks[stackId].width) {
+      barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
+      stacks[stackId].width = barWidth;
+      columnsOnAxis.remainedWidth -= barWidth;
+    }
+    barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+    barGap != null && (columnsOnAxis.gap = barGap);
+    barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap);
+  });
+  var result = {};
+  each(columnsMap, function (columnsOnAxis, coordSysName) {
+    result[coordSysName] = {};
+    var stacks = columnsOnAxis.stacks;
+    var bandWidth = columnsOnAxis.bandWidth;
+    var categoryGap = parsePercent(columnsOnAxis.categoryGap, bandWidth);
+    var barGapPercent = parsePercent(columnsOnAxis.gap, 1);
+    var remainedWidth = columnsOnAxis.remainedWidth;
+    var autoWidthCount = columnsOnAxis.autoWidthCount;
+    var autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+    autoWidth = Math.max(autoWidth, 0);
+    // Find if any auto calculated bar exceeded maxBarWidth
+    each(stacks, function (column, stack) {
+      var maxWidth = column.maxWidth;
+      if (maxWidth && maxWidth < autoWidth) {
+        maxWidth = Math.min(maxWidth, remainedWidth);
+        if (column.width) {
+          maxWidth = Math.min(maxWidth, column.width);
+        }
+        remainedWidth -= maxWidth;
+        column.width = maxWidth;
+        autoWidthCount--;
+      }
+    });
+    // Recalculate width again
+    autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+    autoWidth = Math.max(autoWidth, 0);
+    var widthSum = 0;
+    var lastColumn;
+    each(stacks, function (column, idx) {
+      if (!column.width) {
+        column.width = autoWidth;
+      }
+      lastColumn = column;
+      widthSum += column.width * (1 + barGapPercent);
+    });
+    if (lastColumn) {
+      widthSum -= lastColumn.width * barGapPercent;
+    }
+    var offset = -widthSum / 2;
+    each(stacks, function (column, stackId) {
+      result[coordSysName][stackId] = result[coordSysName][stackId] || {
+        offset: offset,
+        width: column.width
+      };
+      offset += column.width * (1 + barGapPercent);
+    });
+  });
+  return result;
+}
+
+export { barLayoutPolar as default };

package/esm/node_modules/echarts/lib/layout/points.js

@@ -0,0 +1,64 @@
+import { map } from '../../../zrender/lib/core/util.js';
+import createRenderPlanner from '../chart/helper/createRenderPlanner.js';
+import { isDimensionStacked } from '../data/helper/dataStackHelper.js';
+import { createFloat32Array } from '../util/vendor.js';
+
+function pointsLayout(seriesType, forceStoreInTypedArray) {
+  return {
+    seriesType: seriesType,
+    plan: createRenderPlanner(),
+    reset: function (seriesModel) {
+      var data = seriesModel.getData();
+      var coordSys = seriesModel.coordinateSystem;
+      var pipelineContext = seriesModel.pipelineContext;
+      var useTypedArray = forceStoreInTypedArray || pipelineContext.large;
+      if (!coordSys) {
+        return;
+      }
+      var dims = map(coordSys.dimensions, function (dim) {
+        return data.mapDimension(dim);
+      }).slice(0, 2);
+      var dimLen = dims.length;
+      var stackResultDim = data.getCalculationInfo('stackResultDimension');
+      if (isDimensionStacked(data, dims[0])) {
+        dims[0] = stackResultDim;
+      }
+      if (isDimensionStacked(data, dims[1])) {
+        dims[1] = stackResultDim;
+      }
+      var store = data.getStore();
+      var dimIdx0 = data.getDimensionIndex(dims[0]);
+      var dimIdx1 = data.getDimensionIndex(dims[1]);
+      return dimLen && {
+        progress: function (params, data) {
+          var segCount = params.end - params.start;
+          var points = useTypedArray && createFloat32Array(segCount * dimLen);
+          var tmpIn = [];
+          var tmpOut = [];
+          for (var i = params.start, offset = 0; i < params.end; i++) {
+            var point = void 0;
+            if (dimLen === 1) {
+              var x = store.get(dimIdx0, i);
+              // NOTE: Make sure the second parameter is null to use default strategy.
+              point = coordSys.dataToPoint(x, null, tmpOut);
+            } else {
+              tmpIn[0] = store.get(dimIdx0, i);
+              tmpIn[1] = store.get(dimIdx1, i);
+              // Let coordinate system to handle the NaN data.
+              point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+            }
+            if (useTypedArray) {
+              points[offset++] = point[0];
+              points[offset++] = point[1];
+            } else {
+              data.setItemLayout(i, point.slice());
+            }
+          }
+          useTypedArray && data.setLayout('points', points);
+        }
+      };
+    }
+  };
+}
+
+export { pointsLayout as default };

package/esm/node_modules/echarts/lib/legacy/dataSelectAction.js

@@ -0,0 +1,76 @@
+import { each, extend, isArray, isString } from '../../../zrender/lib/core/util.js';
+import { deprecateReplaceLog, deprecateLog } from '../util/log.js';
+import { queryDataIndex } from '../util/model.js';
+
+// Legacy data selection action.
+// Includes: pieSelect, pieUnSelect, pieToggleSelect, mapSelect, mapUnSelect, mapToggleSelect
+function createLegacyDataSelectAction(seriesType, ecRegisterAction) {
+  function getSeriesIndices(ecModel, payload) {
+    var seriesIndices = [];
+    ecModel.eachComponent({
+      mainType: 'series',
+      subType: seriesType,
+      query: payload
+    }, function (seriesModel) {
+      seriesIndices.push(seriesModel.seriesIndex);
+    });
+    return seriesIndices;
+  }
+  each([[seriesType + 'ToggleSelect', 'toggleSelect'], [seriesType + 'Select', 'select'], [seriesType + 'UnSelect', 'unselect']], function (eventsMap) {
+    ecRegisterAction(eventsMap[0], function (payload, ecModel, api) {
+      payload = extend({}, payload);
+      if (process.env.NODE_ENV !== 'production') {
+        deprecateReplaceLog(payload.type, eventsMap[1]);
+      }
+      api.dispatchAction(extend(payload, {
+        type: eventsMap[1],
+        seriesIndex: getSeriesIndices(ecModel, payload)
+      }));
+    });
+  });
+}
+function handleSeriesLegacySelectEvents(type, eventPostfix, ecIns, ecModel, payload) {
+  var legacyEventName = type + eventPostfix;
+  if (!ecIns.isSilent(legacyEventName)) {
+    if (process.env.NODE_ENV !== 'production') {
+      deprecateLog("event " + legacyEventName + " is deprecated.");
+    }
+    ecModel.eachComponent({
+      mainType: 'series',
+      subType: 'pie'
+    }, function (seriesModel) {
+      var seriesIndex = seriesModel.seriesIndex;
+      var selectedMap = seriesModel.option.selectedMap;
+      var selected = payload.selected;
+      for (var i = 0; i < selected.length; i++) {
+        if (selected[i].seriesIndex === seriesIndex) {
+          var data = seriesModel.getData();
+          var dataIndex = queryDataIndex(data, payload.fromActionPayload);
+          ecIns.trigger(legacyEventName, {
+            type: legacyEventName,
+            seriesId: seriesModel.id,
+            name: isArray(dataIndex) ? data.getName(dataIndex[0]) : data.getName(dataIndex),
+            selected: isString(selectedMap) ? selectedMap : extend({}, selectedMap)
+          });
+        }
+      }
+    });
+  }
+}
+function handleLegacySelectEvents(messageCenter, ecIns, api) {
+  messageCenter.on('selectchanged', function (params) {
+    var ecModel = api.getModel();
+    if (params.isFromClick) {
+      handleSeriesLegacySelectEvents('map', 'selectchanged', ecIns, ecModel, params);
+      handleSeriesLegacySelectEvents('pie', 'selectchanged', ecIns, ecModel, params);
+    } else if (params.fromAction === 'select') {
+      handleSeriesLegacySelectEvents('map', 'selected', ecIns, ecModel, params);
+      handleSeriesLegacySelectEvents('pie', 'selected', ecIns, ecModel, params);
+    } else if (params.fromAction === 'unselect') {
+      handleSeriesLegacySelectEvents('map', 'unselected', ecIns, ecModel, params);
+      handleSeriesLegacySelectEvents('pie', 'unselected', ecIns, ecModel, params);
+    }
+  });
+}
+
+export { createLegacyDataSelectAction, handleLegacySelectEvents };

package/esm/node_modules/echarts/lib/legacy/getTextRect.js

@@ -0,0 +1,20 @@
+import '../util/graphic.js';
+import ZRText from '../../../zrender/lib/graphic/Text.js';
+
+function getTextRect(text, font, align, verticalAlign, padding, rich, truncate, lineHeight) {
+  var textEl = new ZRText({
+    style: {
+      text: text,
+      font: font,
+      align: align,
+      verticalAlign: verticalAlign,
+      padding: padding,
+      rich: rich,
+      overflow: truncate ? 'truncate' : null,
+      lineHeight: lineHeight
+    }
+  });
+  return textEl.getBoundingRect();
+}
+
+export { getTextRect };

package/esm/node_modules/echarts/lib/loading/default.js

@@ -0,0 +1,124 @@
+import { defaults } from '../../../zrender/lib/core/util.js';
+import '../util/graphic.js';
+import Group from '../../../zrender/lib/graphic/Group.js';
+import Rect from '../../../zrender/lib/graphic/shape/Rect.js';
+import ZRText from '../../../zrender/lib/graphic/Text.js';
+import Arc from '../../../zrender/lib/graphic/shape/Arc.js';
+
+var PI = Math.PI;
+/**
+ * @param {module:echarts/ExtensionAPI} api
+ * @param {Object} [opts]
+ * @param {string} [opts.text]
+ * @param {string} [opts.color]
+ * @param {string} [opts.textColor]
+ * @return {module:zrender/Element}
+ */
+function defaultLoading(api, opts) {
+  opts = opts || {};
+  defaults(opts, {
+    text: 'loading',
+    textColor: '#000',
+    fontSize: 12,
+    fontWeight: 'normal',
+    fontStyle: 'normal',
+    fontFamily: 'sans-serif',
+    maskColor: 'rgba(255, 255, 255, 0.8)',
+    showSpinner: true,
+    color: '#5470c6',
+    spinnerRadius: 10,
+    lineWidth: 5,
+    zlevel: 0
+  });
+  var group = new Group();
+  var mask = new Rect({
+    style: {
+      fill: opts.maskColor
+    },
+    zlevel: opts.zlevel,
+    z: 10000
+  });
+  group.add(mask);
+  var textContent = new ZRText({
+    style: {
+      text: opts.text,
+      fill: opts.textColor,
+      fontSize: opts.fontSize,
+      fontWeight: opts.fontWeight,
+      fontStyle: opts.fontStyle,
+      fontFamily: opts.fontFamily
+    },
+    zlevel: opts.zlevel,
+    z: 10001
+  });
+  var labelRect = new Rect({
+    style: {
+      fill: 'none'
+    },
+    textContent: textContent,
+    textConfig: {
+      position: 'right',
+      distance: 10
+    },
+    zlevel: opts.zlevel,
+    z: 10001
+  });
+  group.add(labelRect);
+  var arc;
+  if (opts.showSpinner) {
+    arc = new Arc({
+      shape: {
+        startAngle: -PI / 2,
+        endAngle: -PI / 2 + 0.1,
+        r: opts.spinnerRadius
+      },
+      style: {
+        stroke: opts.color,
+        lineCap: 'round',
+        lineWidth: opts.lineWidth
+      },
+      zlevel: opts.zlevel,
+      z: 10001
+    });
+    arc.animateShape(true).when(1000, {
+      endAngle: PI * 3 / 2
+    }).start('circularInOut');
+    arc.animateShape(true).when(1000, {
+      startAngle: PI * 3 / 2
+    }).delay(300).start('circularInOut');
+    group.add(arc);
+  }
+  // Inject resize
+  group.resize = function () {
+    var textWidth = textContent.getBoundingRect().width;
+    var r = opts.showSpinner ? opts.spinnerRadius : 0;
+    // cx = (containerWidth - arcDiameter - textDistance - textWidth) / 2
+    // textDistance needs to be calculated when both animation and text exist
+    var cx = (api.getWidth() - r * 2 - (opts.showSpinner && textWidth ? 10 : 0) - textWidth) / 2 - (opts.showSpinner && textWidth ? 0 : 5 + textWidth / 2)
+    // only show the text
+    + (opts.showSpinner ? 0 : textWidth / 2)
+    // only show the spinner
+    + (textWidth ? 0 : r);
+    var cy = api.getHeight() / 2;
+    opts.showSpinner && arc.setShape({
+      cx: cx,
+      cy: cy
+    });
+    labelRect.setShape({
+      x: cx - r,
+      y: cy - r,
+      width: r * 2,
+      height: r * 2
+    });
+    mask.setShape({
+      x: 0,
+      y: 0,
+      width: api.getWidth(),
+      height: api.getHeight()
+    });
+  };
+  group.resize();
+  return group;
+}
+
+export { defaultLoading as default };

package/esm/node_modules/echarts/lib/model/Component.js

@@ -0,0 +1,193 @@
+import { __extends } from 'tslib';
+import { merge, each, map, indexOf } from '../../../zrender/lib/core/util.js';
+import Model from './Model.js';
+import { getUID, enableSubTypeDefaulter, enableTopologicalTravel } from '../util/component.js';
+import { isExtendedClass, mountExtend, enableClassManagement, parseClassType } from '../util/clazz.js';
+import { queryReferringComponents, makeInner } from '../util/model.js';
+import { fetchLayoutMode, getLayoutParams, mergeLayoutParam } from '../util/layout.js';
+
+var inner = makeInner();
+var ComponentModel = /** @class */function (_super) {
+  __extends(ComponentModel, _super);
+  function ComponentModel(option, parentModel, ecModel) {
+    var _this = _super.call(this, option, parentModel, ecModel) || this;
+    _this.uid = getUID('ec_cpt_model');
+    return _this;
+  }
+  ComponentModel.prototype.init = function (option, parentModel, ecModel) {
+    this.mergeDefaultAndTheme(option, ecModel);
+  };
+  ComponentModel.prototype.mergeDefaultAndTheme = function (option, ecModel) {
+    var layoutMode = fetchLayoutMode(this);
+    var inputPositionParams = layoutMode ? getLayoutParams(option) : {};
+    var themeModel = ecModel.getTheme();
+    merge(option, themeModel.get(this.mainType));
+    merge(option, this.getDefaultOption());
+    if (layoutMode) {
+      mergeLayoutParam(option, inputPositionParams, layoutMode);
+    }
+  };
+  ComponentModel.prototype.mergeOption = function (option, ecModel) {
+    merge(this.option, option, true);
+    var layoutMode = fetchLayoutMode(this);
+    if (layoutMode) {
+      mergeLayoutParam(this.option, option, layoutMode);
+    }
+  };
+  /**
+   * Called immediately after `init` or `mergeOption` of this instance called.
+   */
+  ComponentModel.prototype.optionUpdated = function (newCptOption, isInit) {};
+  /**
+   * [How to declare defaultOption]:
+   *
+   * (A) If using class declaration in typescript (since echarts 5):
+   * ```ts
+   * import {ComponentOption} from '../model/option.js';
+   * export interface XxxOption extends ComponentOption {
+   *     aaa: number
+   * }
+   * export class XxxModel extends Component {
+   *     static type = 'xxx';
+   *     static defaultOption: XxxOption = {
+   *         aaa: 123
+   *     }
+   * }
+   * Component.registerClass(XxxModel);
+   * ```
+   * ```ts
+   * import {inheritDefaultOption} from '../util/component.js';
+   * import {XxxModel, XxxOption} from './XxxModel.js';
+   * export interface XxxSubOption extends XxxOption {
+   *     bbb: number
+   * }
+   * class XxxSubModel extends XxxModel {
+   *     static defaultOption: XxxSubOption = inheritDefaultOption(XxxModel.defaultOption, {
+   *         bbb: 456
+   *     })
+   *     fn() {
+   *         let opt = this.getDefaultOption();
+   *         // opt is {aaa: 123, bbb: 456}
+   *     }
+   * }
+   * ```
+   *
+   * (B) If using class extend (previous approach in echarts 3 & 4):
+   * ```js
+   * let XxxComponent = Component.extend({
+   *     defaultOption: {
+   *         xx: 123
+   *     }
+   * })
+   * ```
+   * ```js
+   * let XxxSubComponent = XxxComponent.extend({
+   *     defaultOption: {
+   *         yy: 456
+   *     },
+   *     fn: function () {
+   *         let opt = this.getDefaultOption();
+   *         // opt is {xx: 123, yy: 456}
+   *     }
+   * })
+   * ```
+   */
+  ComponentModel.prototype.getDefaultOption = function () {
+    var ctor = this.constructor;
+    // If using class declaration, it is different to travel super class
+    // in legacy env and auto merge defaultOption. So if using class
+    // declaration, defaultOption should be merged manually.
+    if (!isExtendedClass(ctor)) {
+      // When using ts class, defaultOption must be declared as static.
+      return ctor.defaultOption;
+    }
+    // FIXME: remove this approach?
+    var fields = inner(this);
+    if (!fields.defaultOption) {
+      var optList = [];
+      var clz = ctor;
+      while (clz) {
+        var opt = clz.prototype.defaultOption;
+        opt && optList.push(opt);
+        clz = clz.superClass;
+      }
+      var defaultOption = {};
+      for (var i = optList.length - 1; i >= 0; i--) {
+        defaultOption = merge(defaultOption, optList[i], true);
+      }
+      fields.defaultOption = defaultOption;
+    }
+    return fields.defaultOption;
+  };
+  /**
+   * Notice: always force to input param `useDefault` in case that forget to consider it.
+   * The same behavior as `modelUtil.parseFinder`.
+   *
+   * @param useDefault In many cases like series refer axis and axis refer grid,
+   *        If axis index / axis id not specified, use the first target as default.
+   *        In other cases like dataZoom refer axis, if not specified, measn no refer.
+   */
+  ComponentModel.prototype.getReferringComponents = function (mainType, opt) {
+    var indexKey = mainType + 'Index';
+    var idKey = mainType + 'Id';
+    return queryReferringComponents(this.ecModel, mainType, {
+      index: this.get(indexKey, true),
+      id: this.get(idKey, true)
+    }, opt);
+  };
+  ComponentModel.prototype.getBoxLayoutParams = function () {
+    // Consider itself having box layout configs.
+    var boxLayoutModel = this;
+    return {
+      left: boxLayoutModel.get('left'),
+      top: boxLayoutModel.get('top'),
+      right: boxLayoutModel.get('right'),
+      bottom: boxLayoutModel.get('bottom'),
+      width: boxLayoutModel.get('width'),
+      height: boxLayoutModel.get('height')
+    };
+  };
+  /**
+   * Get key for zlevel.
+   * If developers don't configure zlevel. We will assign zlevel to series based on the key.
+   * For example, lines with trail effect and progressive series will in an individual zlevel.
+   */
+  ComponentModel.prototype.getZLevelKey = function () {
+    return '';
+  };
+  ComponentModel.prototype.setZLevel = function (zlevel) {
+    this.option.zlevel = zlevel;
+  };
+  ComponentModel.protoInitialize = function () {
+    var proto = ComponentModel.prototype;
+    proto.type = 'component';
+    proto.id = '';
+    proto.name = '';
+    proto.mainType = '';
+    proto.subType = '';
+    proto.componentIndex = 0;
+  }();
+  return ComponentModel;
+}(Model);
+mountExtend(ComponentModel, Model);
+enableClassManagement(ComponentModel);
+enableSubTypeDefaulter(ComponentModel);
+enableTopologicalTravel(ComponentModel, getDependencies);
+function getDependencies(componentType) {
+  var deps = [];
+  each(ComponentModel.getClassesByMainType(componentType), function (clz) {
+    deps = deps.concat(clz.dependencies || clz.prototype.dependencies || []);
+  });
+  // Ensure main type.
+  deps = map(deps, function (type) {
+    return parseClassType(type).main;
+  });
+  // Hack dataset for convenience.
+  if (componentType !== 'dataset' && indexOf(deps, 'dataset') <= 0) {
+    deps.unshift('dataset');
+  }
+  return deps;
+}
+var ComponentModel$1 = ComponentModel;
+
+export { ComponentModel$1 as default };