office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/component/legend/ScrollableLegendView.js

@@ -0,0 +1,365 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+var graphic = require('../../util/graphic.js');
+var layout = require('../../util/layout.js');
+var LegendView = require('./LegendView.js');
+var Text = require('../../../../zrender/lib/graphic/Text.js');
+var Rect = require('../../../../zrender/lib/graphic/shape/Rect.js');
+var basicTransition = require('../../animation/basicTransition.js');
+var Group$1 = require('../../../../zrender/lib/graphic/Group.js');
+
+var Group = Group$1["default"];
+var WH = ['width', 'height'];
+var XY = ['x', 'y'];
+var ScrollableLegendView = /** @class */function (_super) {
+  tslib.__extends(ScrollableLegendView, _super);
+  function ScrollableLegendView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ScrollableLegendView.type;
+    _this.newlineDisabled = true;
+    _this._currentIndex = 0;
+    return _this;
+  }
+  ScrollableLegendView.prototype.init = function () {
+    _super.prototype.init.call(this);
+    this.group.add(this._containerGroup = new Group());
+    this._containerGroup.add(this.getContentGroup());
+    this.group.add(this._controllerGroup = new Group());
+  };
+  /**
+   * @override
+   */
+  ScrollableLegendView.prototype.resetInner = function () {
+    _super.prototype.resetInner.call(this);
+    this._controllerGroup.removeAll();
+    this._containerGroup.removeClipPath();
+    this._containerGroup.__rectSize = null;
+  };
+  /**
+   * @override
+   */
+  ScrollableLegendView.prototype.renderInner = function (itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition) {
+    var self = this;
+    // Render content items.
+    _super.prototype.renderInner.call(this, itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition);
+    var controllerGroup = this._controllerGroup;
+    // FIXME: support be 'auto' adapt to size number text length,
+    // e.g., '3/12345' should not overlap with the control arrow button.
+    var pageIconSize = legendModel.get('pageIconSize', true);
+    var pageIconSizeArr = util.isArray(pageIconSize) ? pageIconSize : [pageIconSize, pageIconSize];
+    createPageButton('pagePrev', 0);
+    var pageTextStyleModel = legendModel.getModel('pageTextStyle');
+    controllerGroup.add(new Text["default"]({
+      name: 'pageText',
+      style: {
+        // Placeholder to calculate a proper layout.
+        text: 'xx/xx',
+        fill: pageTextStyleModel.getTextColor(),
+        font: pageTextStyleModel.getFont(),
+        verticalAlign: 'middle',
+        align: 'center'
+      },
+      silent: true
+    }));
+    createPageButton('pageNext', 1);
+    function createPageButton(name, iconIdx) {
+      var pageDataIndexName = name + 'DataIndex';
+      var icon = graphic.createIcon(legendModel.get('pageIcons', true)[legendModel.getOrient().name][iconIdx], {
+        // Buttons will be created in each render, so we do not need
+        // to worry about avoiding using legendModel kept in scope.
+        onclick: util.bind(self._pageGo, self, pageDataIndexName, legendModel, api)
+      }, {
+        x: -pageIconSizeArr[0] / 2,
+        y: -pageIconSizeArr[1] / 2,
+        width: pageIconSizeArr[0],
+        height: pageIconSizeArr[1]
+      });
+      icon.name = name;
+      controllerGroup.add(icon);
+    }
+  };
+  /**
+   * @override
+   */
+  ScrollableLegendView.prototype.layoutInner = function (legendModel, itemAlign, maxSize, isFirstRender, selector, selectorPosition) {
+    var selectorGroup = this.getSelectorGroup();
+    var orientIdx = legendModel.getOrient().index;
+    var wh = WH[orientIdx];
+    var xy = XY[orientIdx];
+    var hw = WH[1 - orientIdx];
+    var yx = XY[1 - orientIdx];
+    selector && layout.box(
+    // Buttons in selectorGroup always layout horizontally
+    'horizontal', selectorGroup, legendModel.get('selectorItemGap', true));
+    var selectorButtonGap = legendModel.get('selectorButtonGap', true);
+    var selectorRect = selectorGroup.getBoundingRect();
+    var selectorPos = [-selectorRect.x, -selectorRect.y];
+    var processMaxSize = util.clone(maxSize);
+    selector && (processMaxSize[wh] = maxSize[wh] - selectorRect[wh] - selectorButtonGap);
+    var mainRect = this._layoutContentAndController(legendModel, isFirstRender, processMaxSize, orientIdx, wh, hw, yx, xy);
+    if (selector) {
+      if (selectorPosition === 'end') {
+        selectorPos[orientIdx] += mainRect[wh] + selectorButtonGap;
+      } else {
+        var offset = selectorRect[wh] + selectorButtonGap;
+        selectorPos[orientIdx] -= offset;
+        mainRect[xy] -= offset;
+      }
+      mainRect[wh] += selectorRect[wh] + selectorButtonGap;
+      selectorPos[1 - orientIdx] += mainRect[yx] + mainRect[hw] / 2 - selectorRect[hw] / 2;
+      mainRect[hw] = Math.max(mainRect[hw], selectorRect[hw]);
+      mainRect[yx] = Math.min(mainRect[yx], selectorRect[yx] + selectorPos[1 - orientIdx]);
+      selectorGroup.x = selectorPos[0];
+      selectorGroup.y = selectorPos[1];
+      selectorGroup.markRedraw();
+    }
+    return mainRect;
+  };
+  ScrollableLegendView.prototype._layoutContentAndController = function (legendModel, isFirstRender, maxSize, orientIdx, wh, hw, yx, xy) {
+    var contentGroup = this.getContentGroup();
+    var containerGroup = this._containerGroup;
+    var controllerGroup = this._controllerGroup;
+    // Place items in contentGroup.
+    layout.box(legendModel.get('orient'), contentGroup, legendModel.get('itemGap'), !orientIdx ? null : maxSize.width, orientIdx ? null : maxSize.height);
+    layout.box(
+    // Buttons in controller are layout always horizontally.
+    'horizontal', controllerGroup, legendModel.get('pageButtonItemGap', true));
+    var contentRect = contentGroup.getBoundingRect();
+    var controllerRect = controllerGroup.getBoundingRect();
+    var showController = this._showController = contentRect[wh] > maxSize[wh];
+    // In case that the inner elements of contentGroup layout do not based on [0, 0]
+    var contentPos = [-contentRect.x, -contentRect.y];
+    // Remain contentPos when scroll animation perfroming.
+    // If first rendering, `contentGroup.position` is [0, 0], which
+    // does not make sense and may cause unexepcted animation if adopted.
+    if (!isFirstRender) {
+      contentPos[orientIdx] = contentGroup[xy];
+    }
+    // Layout container group based on 0.
+    var containerPos = [0, 0];
+    var controllerPos = [-controllerRect.x, -controllerRect.y];
+    var pageButtonGap = util.retrieve2(legendModel.get('pageButtonGap', true), legendModel.get('itemGap', true));
+    // Place containerGroup and controllerGroup and contentGroup.
+    if (showController) {
+      var pageButtonPosition = legendModel.get('pageButtonPosition', true);
+      // controller is on the right / bottom.
+      if (pageButtonPosition === 'end') {
+        controllerPos[orientIdx] += maxSize[wh] - controllerRect[wh];
+      }
+      // controller is on the left / top.
+      else {
+        containerPos[orientIdx] += controllerRect[wh] + pageButtonGap;
+      }
+    }
+    // Always align controller to content as 'middle'.
+    controllerPos[1 - orientIdx] += contentRect[hw] / 2 - controllerRect[hw] / 2;
+    contentGroup.setPosition(contentPos);
+    containerGroup.setPosition(containerPos);
+    controllerGroup.setPosition(controllerPos);
+    // Calculate `mainRect` and set `clipPath`.
+    // mainRect should not be calculated by `this.group.getBoundingRect()`
+    // for sake of the overflow.
+    var mainRect = {
+      x: 0,
+      y: 0
+    };
+    // Consider content may be overflow (should be clipped).
+    mainRect[wh] = showController ? maxSize[wh] : contentRect[wh];
+    mainRect[hw] = Math.max(contentRect[hw], controllerRect[hw]);
+    // `containerRect[yx] + containerPos[1 - orientIdx]` is 0.
+    mainRect[yx] = Math.min(0, controllerRect[yx] + controllerPos[1 - orientIdx]);
+    containerGroup.__rectSize = maxSize[wh];
+    if (showController) {
+      var clipShape = {
+        x: 0,
+        y: 0
+      };
+      clipShape[wh] = Math.max(maxSize[wh] - controllerRect[wh] - pageButtonGap, 0);
+      clipShape[hw] = mainRect[hw];
+      containerGroup.setClipPath(new Rect["default"]({
+        shape: clipShape
+      }));
+      // Consider content may be larger than container, container rect
+      // can not be obtained from `containerGroup.getBoundingRect()`.
+      containerGroup.__rectSize = clipShape[wh];
+    } else {
+      // Do not remove or ignore controller. Keep them set as placeholders.
+      controllerGroup.eachChild(function (child) {
+        child.attr({
+          invisible: true,
+          silent: true
+        });
+      });
+    }
+    // Content translate animation.
+    var pageInfo = this._getPageInfo(legendModel);
+    pageInfo.pageIndex != null && basicTransition.updateProps(contentGroup, {
+      x: pageInfo.contentPosition[0],
+      y: pageInfo.contentPosition[1]
+    },
+    // When switch from "show controller" to "not show controller", view should be
+    // updated immediately without animation, otherwise causes weird effect.
+    showController ? legendModel : null);
+    this._updatePageInfoView(legendModel, pageInfo);
+    return mainRect;
+  };
+  ScrollableLegendView.prototype._pageGo = function (to, legendModel, api) {
+    var scrollDataIndex = this._getPageInfo(legendModel)[to];
+    scrollDataIndex != null && api.dispatchAction({
+      type: 'legendScroll',
+      scrollDataIndex: scrollDataIndex,
+      legendId: legendModel.id
+    });
+  };
+  ScrollableLegendView.prototype._updatePageInfoView = function (legendModel, pageInfo) {
+    var controllerGroup = this._controllerGroup;
+    util.each(['pagePrev', 'pageNext'], function (name) {
+      var key = name + 'DataIndex';
+      var canJump = pageInfo[key] != null;
+      var icon = controllerGroup.childOfName(name);
+      if (icon) {
+        icon.setStyle('fill', canJump ? legendModel.get('pageIconColor', true) : legendModel.get('pageIconInactiveColor', true));
+        icon.cursor = canJump ? 'pointer' : 'default';
+      }
+    });
+    var pageText = controllerGroup.childOfName('pageText');
+    var pageFormatter = legendModel.get('pageFormatter');
+    var pageIndex = pageInfo.pageIndex;
+    var current = pageIndex != null ? pageIndex + 1 : 0;
+    var total = pageInfo.pageCount;
+    pageText && pageFormatter && pageText.setStyle('text', util.isString(pageFormatter) ? pageFormatter.replace('{current}', current == null ? '' : current + '').replace('{total}', total == null ? '' : total + '') : pageFormatter({
+      current: current,
+      total: total
+    }));
+  };
+  /**
+   *  contentPosition: Array.<number>, null when data item not found.
+   *  pageIndex: number, null when data item not found.
+   *  pageCount: number, always be a number, can be 0.
+   *  pagePrevDataIndex: number, null when no previous page.
+   *  pageNextDataIndex: number, null when no next page.
+   * }
+   */
+  ScrollableLegendView.prototype._getPageInfo = function (legendModel) {
+    var scrollDataIndex = legendModel.get('scrollDataIndex', true);
+    var contentGroup = this.getContentGroup();
+    var containerRectSize = this._containerGroup.__rectSize;
+    var orientIdx = legendModel.getOrient().index;
+    var wh = WH[orientIdx];
+    var xy = XY[orientIdx];
+    var targetItemIndex = this._findTargetItemIndex(scrollDataIndex);
+    var children = contentGroup.children();
+    var targetItem = children[targetItemIndex];
+    var itemCount = children.length;
+    var pCount = !itemCount ? 0 : 1;
+    var result = {
+      contentPosition: [contentGroup.x, contentGroup.y],
+      pageCount: pCount,
+      pageIndex: pCount - 1,
+      pagePrevDataIndex: null,
+      pageNextDataIndex: null
+    };
+    if (!targetItem) {
+      return result;
+    }
+    var targetItemInfo = getItemInfo(targetItem);
+    result.contentPosition[orientIdx] = -targetItemInfo.s;
+    // Strategy:
+    // (1) Always align based on the left/top most item.
+    // (2) It is user-friendly that the last item shown in the
+    // current window is shown at the begining of next window.
+    // Otherwise if half of the last item is cut by the window,
+    // it will have no chance to display entirely.
+    // (3) Consider that item size probably be different, we
+    // have calculate pageIndex by size rather than item index,
+    // and we can not get page index directly by division.
+    // (4) The window is to narrow to contain more than
+    // one item, we should make sure that the page can be fliped.
+    for (var i = targetItemIndex + 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i <= itemCount; ++i) {
+      currItemInfo = getItemInfo(children[i]);
+      if (
+      // Half of the last item is out of the window.
+      !currItemInfo && winEndItemInfo.e > winStartItemInfo.s + containerRectSize
+      // If the current item does not intersect with the window, the new page
+      // can be started at the current item or the last item.
+      || currItemInfo && !intersect(currItemInfo, winStartItemInfo.s)) {
+        if (winEndItemInfo.i > winStartItemInfo.i) {
+          winStartItemInfo = winEndItemInfo;
+        } else {
+          // e.g., when page size is smaller than item size.
+          winStartItemInfo = currItemInfo;
+        }
+        if (winStartItemInfo) {
+          if (result.pageNextDataIndex == null) {
+            result.pageNextDataIndex = winStartItemInfo.i;
+          }
+          ++result.pageCount;
+        }
+      }
+      winEndItemInfo = currItemInfo;
+    }
+    for (var i = targetItemIndex - 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i >= -1; --i) {
+      currItemInfo = getItemInfo(children[i]);
+      if (
+      // If the the end item does not intersect with the window started
+      // from the current item, a page can be settled.
+      (!currItemInfo || !intersect(winEndItemInfo, currItemInfo.s)
+      // e.g., when page size is smaller than item size.
+      ) && winStartItemInfo.i < winEndItemInfo.i) {
+        winEndItemInfo = winStartItemInfo;
+        if (result.pagePrevDataIndex == null) {
+          result.pagePrevDataIndex = winStartItemInfo.i;
+        }
+        ++result.pageCount;
+        ++result.pageIndex;
+      }
+      winStartItemInfo = currItemInfo;
+    }
+    return result;
+    function getItemInfo(el) {
+      if (el) {
+        var itemRect = el.getBoundingRect();
+        var start = itemRect[xy] + el[xy];
+        return {
+          s: start,
+          e: start + itemRect[wh],
+          i: el.__legendDataIndex
+        };
+      }
+    }
+    function intersect(itemInfo, winStart) {
+      return itemInfo.e >= winStart && itemInfo.s <= winStart + containerRectSize;
+    }
+  };
+  ScrollableLegendView.prototype._findTargetItemIndex = function (targetDataIndex) {
+    if (!this._showController) {
+      return 0;
+    }
+    var index;
+    var contentGroup = this.getContentGroup();
+    var defaultIndex;
+    contentGroup.eachChild(function (child, idx) {
+      var legendDataIdx = child.__legendDataIndex;
+      // FIXME
+      // If the given targetDataIndex (from model) is illegal,
+      // we use defaultIndex. But the index on the legend model and
+      // action payload is still illegal. That case will not be
+      // changed until some scenario requires.
+      if (defaultIndex == null && legendDataIdx != null) {
+        defaultIndex = idx;
+      }
+      if (legendDataIdx === targetDataIndex) {
+        index = idx;
+      }
+    });
+    return index != null ? index : defaultIndex;
+  };
+  ScrollableLegendView.type = 'legend.scroll';
+  return ScrollableLegendView;
+}(LegendView["default"]);
+
+exports["default"] = ScrollableLegendView;

package/lib/node_modules/echarts/lib/component/legend/install.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var extension = require('../../extension.js');
+var installLegendPlain = require('./installLegendPlain.js');
+var installLegendScroll = require('./installLegendScroll.js');
+
+function install(registers) {
+  extension.use(installLegendPlain.install);
+  extension.use(installLegendScroll.install);
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/legend/installLegendPlain.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var LegendModel = require('./LegendModel.js');
+var LegendView = require('./LegendView.js');
+var legendFilter = require('./legendFilter.js');
+var legendAction = require('./legendAction.js');
+
+function install(registers) {
+  registers.registerComponentModel(LegendModel["default"]);
+  registers.registerComponentView(LegendView["default"]);
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.SERIES_FILTER, legendFilter["default"]);
+  registers.registerSubTypeDefaulter('legend', function () {
+    return 'plain';
+  });
+  legendAction.installLegendAction(registers);
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/legend/installLegendScroll.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var extension = require('../../extension.js');
+var installLegendPlain = require('./installLegendPlain.js');
+var ScrollableLegendModel = require('./ScrollableLegendModel.js');
+var ScrollableLegendView = require('./ScrollableLegendView.js');
+var scrollableLegendAction = require('./scrollableLegendAction.js');
+
+function install(registers) {
+  extension.use(installLegendPlain.install);
+  registers.registerComponentModel(ScrollableLegendModel["default"]);
+  registers.registerComponentView(ScrollableLegendView["default"]);
+  scrollableLegendAction["default"](registers);
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/legend/legendAction.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+
+function legendSelectActionHandler(methodName, payload, ecModel) {
+  var selectedMap = {};
+  var isToggleSelect = methodName === 'toggleSelected';
+  var isSelected;
+  // Update all legend components
+  ecModel.eachComponent('legend', function (legendModel) {
+    if (isToggleSelect && isSelected != null) {
+      // Force other legend has same selected status
+      // Or the first is toggled to true and other are toggled to false
+      // In the case one legend has some item unSelected in option. And if other legend
+      // doesn't has the item, they will assume it is selected.
+      legendModel[isSelected ? 'select' : 'unSelect'](payload.name);
+    } else if (methodName === 'allSelect' || methodName === 'inverseSelect') {
+      legendModel[methodName]();
+    } else {
+      legendModel[methodName](payload.name);
+      isSelected = legendModel.isSelected(payload.name);
+    }
+    var legendData = legendModel.getData();
+    util.each(legendData, function (model) {
+      var name = model.get('name');
+      // Wrap element
+      if (name === '\n' || name === '') {
+        return;
+      }
+      var isItemSelected = legendModel.isSelected(name);
+      if (selectedMap.hasOwnProperty(name)) {
+        // Unselected if any legend is unselected
+        selectedMap[name] = selectedMap[name] && isItemSelected;
+      } else {
+        selectedMap[name] = isItemSelected;
+      }
+    });
+  });
+  // Return the event explicitly
+  return methodName === 'allSelect' || methodName === 'inverseSelect' ? {
+    selected: selectedMap
+  } : {
+    name: payload.name,
+    selected: selectedMap
+  };
+}
+function installLegendAction(registers) {
+  /**
+   * @event legendToggleSelect
+   * @type {Object}
+   * @property {string} type 'legendToggleSelect'
+   * @property {string} [from]
+   * @property {string} name Series name or data item name
+   */
+  registers.registerAction('legendToggleSelect', 'legendselectchanged', util.curry(legendSelectActionHandler, 'toggleSelected'));
+  registers.registerAction('legendAllSelect', 'legendselectall', util.curry(legendSelectActionHandler, 'allSelect'));
+  registers.registerAction('legendInverseSelect', 'legendinverseselect', util.curry(legendSelectActionHandler, 'inverseSelect'));
+  /**
+   * @event legendSelect
+   * @type {Object}
+   * @property {string} type 'legendSelect'
+   * @property {string} name Series name or data item name
+   */
+  registers.registerAction('legendSelect', 'legendselected', util.curry(legendSelectActionHandler, 'select'));
+  /**
+   * @event legendUnSelect
+   * @type {Object}
+   * @property {string} type 'legendUnSelect'
+   * @property {string} name Series name or data item name
+   */
+  registers.registerAction('legendUnSelect', 'legendunselected', util.curry(legendSelectActionHandler, 'unSelect'));
+}
+
+exports.installLegendAction = installLegendAction;

package/lib/node_modules/echarts/lib/component/legend/legendFilter.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+function legendFilter(ecModel) {
+  var legendModels = ecModel.findComponents({
+    mainType: 'legend'
+  });
+  if (legendModels && legendModels.length) {
+    ecModel.filterSeries(function (series) {
+      // If in any legend component the status is not selected.
+      // Because in legend series is assumed selected when it is not in the legend data.
+      for (var i = 0; i < legendModels.length; i++) {
+        if (!legendModels[i].isSelected(series.name)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+}
+
+exports["default"] = legendFilter;

package/lib/node_modules/echarts/lib/component/legend/scrollableLegendAction.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+function installScrollableLegendAction(registers) {
+  /**
+   * @event legendScroll
+   * @type {Object}
+   * @property {string} type 'legendScroll'
+   * @property {string} scrollDataIndex
+   */
+  registers.registerAction('legendScroll', 'legendscroll', function (payload, ecModel) {
+    var scrollDataIndex = payload.scrollDataIndex;
+    scrollDataIndex != null && ecModel.eachComponent({
+      mainType: 'legend',
+      subType: 'scroll',
+      query: payload
+    }, function (legendModel) {
+      legendModel.setScrollDataIndex(scrollDataIndex);
+    });
+  });
+}
+
+exports["default"] = installScrollableLegendAction;

package/lib/node_modules/echarts/lib/component/marker/MarkAreaModel.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var MarkerModel = require('./MarkerModel.js');
+
+var MarkAreaModel = /** @class */function (_super) {
+  tslib.__extends(MarkAreaModel, _super);
+  function MarkAreaModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = MarkAreaModel.type;
+    return _this;
+  }
+  MarkAreaModel.prototype.createMarkerModelFromSeries = function (markerOpt, masterMarkerModel, ecModel) {
+    return new MarkAreaModel(markerOpt, masterMarkerModel, ecModel);
+  };
+  MarkAreaModel.type = 'markArea';
+  MarkAreaModel.defaultOption = {
+    // zlevel: 0,
+    // PENDING
+    z: 1,
+    tooltip: {
+      trigger: 'item'
+    },
+    // markArea should fixed on the coordinate system
+    animation: false,
+    label: {
+      show: true,
+      position: 'top'
+    },
+    itemStyle: {
+      // color and borderColor default to use color from series
+      // color: 'auto'
+      // borderColor: 'auto'
+      borderWidth: 0
+    },
+    emphasis: {
+      label: {
+        show: true,
+        position: 'top'
+      }
+    }
+  };
+  return MarkAreaModel;
+}(MarkerModel["default"]);
+
+exports["default"] = MarkAreaModel;