office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/component/timeline/TimelineModel.js

@@ -0,0 +1,151 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Component = require('../../model/Component.js');
+var SeriesData = require('../../data/SeriesData.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var model = require('../../util/model.js');
+
+var TimelineModel = /** @class */function (_super) {
+  tslib.__extends(TimelineModel, _super);
+  function TimelineModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = TimelineModel.type;
+    _this.layoutMode = 'box';
+    return _this;
+  }
+  /**
+   * @override
+   */
+  TimelineModel.prototype.init = function (option, parentModel, ecModel) {
+    this.mergeDefaultAndTheme(option, ecModel);
+    this._initData();
+  };
+  /**
+   * @override
+   */
+  TimelineModel.prototype.mergeOption = function (option) {
+    _super.prototype.mergeOption.apply(this, arguments);
+    this._initData();
+  };
+  TimelineModel.prototype.setCurrentIndex = function (currentIndex) {
+    if (currentIndex == null) {
+      currentIndex = this.option.currentIndex;
+    }
+    var count = this._data.count();
+    if (this.option.loop) {
+      currentIndex = (currentIndex % count + count) % count;
+    } else {
+      currentIndex >= count && (currentIndex = count - 1);
+      currentIndex < 0 && (currentIndex = 0);
+    }
+    this.option.currentIndex = currentIndex;
+  };
+  /**
+   * @return {number} currentIndex
+   */
+  TimelineModel.prototype.getCurrentIndex = function () {
+    return this.option.currentIndex;
+  };
+  /**
+   * @return {boolean}
+   */
+  TimelineModel.prototype.isIndexMax = function () {
+    return this.getCurrentIndex() >= this._data.count() - 1;
+  };
+  /**
+   * @param {boolean} state true: play, false: stop
+   */
+  TimelineModel.prototype.setPlayState = function (state) {
+    this.option.autoPlay = !!state;
+  };
+  /**
+   * @return {boolean} true: play, false: stop
+   */
+  TimelineModel.prototype.getPlayState = function () {
+    return !!this.option.autoPlay;
+  };
+  /**
+   * @private
+   */
+  TimelineModel.prototype._initData = function () {
+    var thisOption = this.option;
+    var dataArr = thisOption.data || [];
+    var axisType = thisOption.axisType;
+    var names = this._names = [];
+    var processedDataArr;
+    if (axisType === 'category') {
+      processedDataArr = [];
+      util.each(dataArr, function (item, index) {
+        var value = model.convertOptionIdName(model.getDataItemValue(item), '');
+        var newItem;
+        if (util.isObject(item)) {
+          newItem = util.clone(item);
+          newItem.value = index;
+        } else {
+          newItem = index;
+        }
+        processedDataArr.push(newItem);
+        names.push(value);
+      });
+    } else {
+      processedDataArr = dataArr;
+    }
+    var dimType = {
+      category: 'ordinal',
+      time: 'time',
+      value: 'number'
+    }[axisType] || 'number';
+    var data = this._data = new SeriesData["default"]([{
+      name: 'value',
+      type: dimType
+    }], this);
+    data.initData(processedDataArr, names);
+  };
+  TimelineModel.prototype.getData = function () {
+    return this._data;
+  };
+  /**
+   * @public
+   * @return {Array.<string>} categoreis
+   */
+  TimelineModel.prototype.getCategories = function () {
+    if (this.get('axisType') === 'category') {
+      return this._names.slice();
+    }
+  };
+  TimelineModel.type = 'timeline';
+  /**
+   * @protected
+   */
+  TimelineModel.defaultOption = {
+    // zlevel: 0,                  // 一级层叠
+    z: 4,
+    show: true,
+    axisType: 'time',
+    realtime: true,
+    left: '20%',
+    top: null,
+    right: '20%',
+    bottom: 0,
+    width: null,
+    height: 40,
+    padding: 5,
+    controlPosition: 'left',
+    autoPlay: false,
+    rewind: false,
+    loop: true,
+    playInterval: 2000,
+    currentIndex: 0,
+    itemStyle: {},
+    label: {
+      color: '#000'
+    },
+    data: []
+  };
+  return TimelineModel;
+}(Component["default"]);
+
+exports["default"] = TimelineModel;

package/lib/node_modules/echarts/lib/component/timeline/TimelineView.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Component = require('../../view/Component.js');
+
+var TimelineView = /** @class */function (_super) {
+  tslib.__extends(TimelineView, _super);
+  function TimelineView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = TimelineView.type;
+    return _this;
+  }
+  TimelineView.type = 'timeline';
+  return TimelineView;
+}(Component["default"]);
+
+exports["default"] = TimelineView;

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

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SliderTimelineModel = require('./SliderTimelineModel.js');
+var SliderTimelineView = require('./SliderTimelineView.js');
+var timelineAction = require('./timelineAction.js');
+var preprocessor = require('./preprocessor.js');
+
+function install(registers) {
+  registers.registerComponentModel(SliderTimelineModel["default"]);
+  registers.registerComponentView(SliderTimelineView["default"]);
+  registers.registerSubTypeDefaulter('timeline', function () {
+    // Only slider now.
+    return 'slider';
+  });
+  timelineAction.installTimelineAction(registers);
+  registers.registerPreprocessor(preprocessor["default"]);
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/timeline/preprocessor.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+
+function timelinePreprocessor(option) {
+  var timelineOpt = option && option.timeline;
+  if (!util.isArray(timelineOpt)) {
+    timelineOpt = timelineOpt ? [timelineOpt] : [];
+  }
+  util.each(timelineOpt, function (opt) {
+    if (!opt) {
+      return;
+    }
+    compatibleEC2(opt);
+  });
+}
+function compatibleEC2(opt) {
+  var type = opt.type;
+  var ec2Types = {
+    'number': 'value',
+    'time': 'time'
+  };
+  // Compatible with ec2
+  if (ec2Types[type]) {
+    opt.axisType = ec2Types[type];
+    delete opt.type;
+  }
+  transferItem(opt);
+  if (has(opt, 'controlPosition')) {
+    var controlStyle = opt.controlStyle || (opt.controlStyle = {});
+    if (!has(controlStyle, 'position')) {
+      controlStyle.position = opt.controlPosition;
+    }
+    if (controlStyle.position === 'none' && !has(controlStyle, 'show')) {
+      controlStyle.show = false;
+      delete controlStyle.position;
+    }
+    delete opt.controlPosition;
+  }
+  util.each(opt.data || [], function (dataItem) {
+    if (util.isObject(dataItem) && !util.isArray(dataItem)) {
+      if (!has(dataItem, 'value') && has(dataItem, 'name')) {
+        // In ec2, using name as value.
+        dataItem.value = dataItem.name;
+      }
+      transferItem(dataItem);
+    }
+  });
+}
+function transferItem(opt) {
+  var itemStyle = opt.itemStyle || (opt.itemStyle = {});
+  var itemStyleEmphasis = itemStyle.emphasis || (itemStyle.emphasis = {});
+  // Transfer label out
+  var label = opt.label || opt.label || {};
+  var labelNormal = label.normal || (label.normal = {});
+  var excludeLabelAttr = {
+    normal: 1,
+    emphasis: 1
+  };
+  util.each(label, function (value, name) {
+    if (!excludeLabelAttr[name] && !has(labelNormal, name)) {
+      labelNormal[name] = value;
+    }
+  });
+  if (itemStyleEmphasis.label && !has(label, 'emphasis')) {
+    label.emphasis = itemStyleEmphasis.label;
+    delete itemStyleEmphasis.label;
+  }
+}
+function has(obj, attr) {
+  return obj.hasOwnProperty(attr);
+}
+
+exports["default"] = timelinePreprocessor;

package/lib/node_modules/echarts/lib/component/timeline/timelineAction.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+
+function installTimelineAction(registers) {
+  registers.registerAction({
+    type: 'timelineChange',
+    event: 'timelineChanged',
+    update: 'prepareAndUpdate'
+  }, function (payload, ecModel, api) {
+    var timelineModel = ecModel.getComponent('timeline');
+    if (timelineModel && payload.currentIndex != null) {
+      timelineModel.setCurrentIndex(payload.currentIndex);
+      if (!timelineModel.get('loop', true) && timelineModel.isIndexMax() && timelineModel.getPlayState()) {
+        timelineModel.setPlayState(false);
+        // The timeline has played to the end, trigger event
+        api.dispatchAction({
+          type: 'timelinePlayChange',
+          playState: false,
+          from: payload.from
+        });
+      }
+    }
+    // Set normalized currentIndex to payload.
+    ecModel.resetOption('timeline', {
+      replaceMerge: timelineModel.get('replaceMerge', true)
+    });
+    return util.defaults({
+      currentIndex: timelineModel.option.currentIndex
+    }, payload);
+  });
+  registers.registerAction({
+    type: 'timelinePlayChange',
+    event: 'timelinePlayChanged',
+    update: 'update'
+  }, function (payload, ecModel) {
+    var timelineModel = ecModel.getComponent('timeline');
+    if (timelineModel && payload.playState != null) {
+      timelineModel.setPlayState(payload.playState);
+    }
+  });
+}
+
+exports.installTimelineAction = installTimelineAction;

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

@@ -0,0 +1,191 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+require('../../util/graphic.js');
+var innerStore = require('../../util/innerStore.js');
+var labelStyle = require('../../label/labelStyle.js');
+var layout = require('../../util/layout.js');
+var Component = require('../../model/Component.js');
+var Component$1 = require('../../view/Component.js');
+var format = require('../../util/format.js');
+var Text = require('../../../../zrender/lib/graphic/Text.js');
+var Rect = require('../../../../zrender/lib/graphic/shape/Rect.js');
+
+var TitleModel = /** @class */function (_super) {
+  tslib.__extends(TitleModel, _super);
+  function TitleModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = TitleModel.type;
+    _this.layoutMode = {
+      type: 'box',
+      ignoreSize: true
+    };
+    return _this;
+  }
+  TitleModel.type = 'title';
+  TitleModel.defaultOption = {
+    // zlevel: 0,
+    z: 6,
+    show: true,
+    text: '',
+    target: 'blank',
+    subtext: '',
+    subtarget: 'blank',
+    left: 0,
+    top: 0,
+    backgroundColor: 'rgba(0,0,0,0)',
+    borderColor: '#ccc',
+    borderWidth: 0,
+    padding: 5,
+    itemGap: 10,
+    textStyle: {
+      fontSize: 18,
+      fontWeight: 'bold',
+      color: '#464646'
+    },
+    subtextStyle: {
+      fontSize: 12,
+      color: '#6E7079'
+    }
+  };
+  return TitleModel;
+}(Component["default"]);
+// View
+var TitleView = /** @class */function (_super) {
+  tslib.__extends(TitleView, _super);
+  function TitleView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = TitleView.type;
+    return _this;
+  }
+  TitleView.prototype.render = function (titleModel, ecModel, api) {
+    this.group.removeAll();
+    if (!titleModel.get('show')) {
+      return;
+    }
+    var group = this.group;
+    var textStyleModel = titleModel.getModel('textStyle');
+    var subtextStyleModel = titleModel.getModel('subtextStyle');
+    var textAlign = titleModel.get('textAlign');
+    var textVerticalAlign = util.retrieve2(titleModel.get('textBaseline'), titleModel.get('textVerticalAlign'));
+    var textEl = new Text["default"]({
+      style: labelStyle.createTextStyle(textStyleModel, {
+        text: titleModel.get('text'),
+        fill: textStyleModel.getTextColor()
+      }, {
+        disableBox: true
+      }),
+      z2: 10
+    });
+    var textRect = textEl.getBoundingRect();
+    var subText = titleModel.get('subtext');
+    var subTextEl = new Text["default"]({
+      style: labelStyle.createTextStyle(subtextStyleModel, {
+        text: subText,
+        fill: subtextStyleModel.getTextColor(),
+        y: textRect.height + titleModel.get('itemGap'),
+        verticalAlign: 'top'
+      }, {
+        disableBox: true
+      }),
+      z2: 10
+    });
+    var link = titleModel.get('link');
+    var sublink = titleModel.get('sublink');
+    var triggerEvent = titleModel.get('triggerEvent', true);
+    textEl.silent = !link && !triggerEvent;
+    subTextEl.silent = !sublink && !triggerEvent;
+    if (link) {
+      textEl.on('click', function () {
+        format.windowOpen(link, '_' + titleModel.get('target'));
+      });
+    }
+    if (sublink) {
+      subTextEl.on('click', function () {
+        format.windowOpen(sublink, '_' + titleModel.get('subtarget'));
+      });
+    }
+    innerStore.getECData(textEl).eventData = innerStore.getECData(subTextEl).eventData = triggerEvent ? {
+      componentType: 'title',
+      componentIndex: titleModel.componentIndex
+    } : null;
+    group.add(textEl);
+    subText && group.add(subTextEl);
+    // If no subText, but add subTextEl, there will be an empty line.
+    var groupRect = group.getBoundingRect();
+    var layoutOption = titleModel.getBoxLayoutParams();
+    layoutOption.width = groupRect.width;
+    layoutOption.height = groupRect.height;
+    var layoutRect = layout.getLayoutRect(layoutOption, {
+      width: api.getWidth(),
+      height: api.getHeight()
+    }, titleModel.get('padding'));
+    // Adjust text align based on position
+    if (!textAlign) {
+      // Align left if title is on the left. center and right is same
+      textAlign = titleModel.get('left') || titleModel.get('right');
+      // @ts-ignore
+      if (textAlign === 'middle') {
+        textAlign = 'center';
+      }
+      // Adjust layout by text align
+      if (textAlign === 'right') {
+        layoutRect.x += layoutRect.width;
+      } else if (textAlign === 'center') {
+        layoutRect.x += layoutRect.width / 2;
+      }
+    }
+    if (!textVerticalAlign) {
+      textVerticalAlign = titleModel.get('top') || titleModel.get('bottom');
+      // @ts-ignore
+      if (textVerticalAlign === 'center') {
+        textVerticalAlign = 'middle';
+      }
+      if (textVerticalAlign === 'bottom') {
+        layoutRect.y += layoutRect.height;
+      } else if (textVerticalAlign === 'middle') {
+        layoutRect.y += layoutRect.height / 2;
+      }
+      textVerticalAlign = textVerticalAlign || 'top';
+    }
+    group.x = layoutRect.x;
+    group.y = layoutRect.y;
+    group.markRedraw();
+    var alignStyle = {
+      align: textAlign,
+      verticalAlign: textVerticalAlign
+    };
+    textEl.setStyle(alignStyle);
+    subTextEl.setStyle(alignStyle);
+    // Render background
+    // Get groupRect again because textAlign has been changed
+    groupRect = group.getBoundingRect();
+    var padding = layoutRect.margin;
+    var style = titleModel.getItemStyle(['color', 'opacity']);
+    style.fill = titleModel.get('backgroundColor');
+    var rect = new Rect["default"]({
+      shape: {
+        x: groupRect.x - padding[3],
+        y: groupRect.y - padding[0],
+        width: groupRect.width + padding[1] + padding[3],
+        height: groupRect.height + padding[0] + padding[2],
+        r: titleModel.get('borderRadius')
+      },
+      style: style,
+      subPixelOptimize: true,
+      silent: true
+    });
+    group.add(rect);
+  };
+  TitleView.type = 'title';
+  return TitleView;
+}(Component$1["default"]);
+function install(registers) {
+  registers.registerComponentModel(TitleModel);
+  registers.registerComponentView(TitleView);
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/toolbox/ToolboxModel.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+var featureManager = require('./featureManager.js');
+var Component = require('../../model/Component.js');
+
+var ToolboxModel = /** @class */function (_super) {
+  tslib.__extends(ToolboxModel, _super);
+  function ToolboxModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ToolboxModel.type;
+    return _this;
+  }
+  ToolboxModel.prototype.optionUpdated = function () {
+    _super.prototype.optionUpdated.apply(this, arguments);
+    var ecModel = this.ecModel;
+    util.each(this.option.feature, function (featureOpt, featureName) {
+      var Feature = featureManager.getFeature(featureName);
+      if (Feature) {
+        if (Feature.getDefaultOption) {
+          Feature.defaultOption = Feature.getDefaultOption(ecModel);
+        }
+        util.merge(featureOpt, Feature.defaultOption);
+      }
+    });
+  };
+  ToolboxModel.type = 'toolbox';
+  ToolboxModel.layoutMode = {
+    type: 'box',
+    ignoreSize: true
+  };
+  ToolboxModel.defaultOption = {
+    show: true,
+    z: 6,
+    // zlevel: 0,
+    orient: 'horizontal',
+    left: 'right',
+    top: 'top',
+    // right
+    // bottom
+    backgroundColor: 'transparent',
+    borderColor: '#ccc',
+    borderRadius: 0,
+    borderWidth: 0,
+    padding: 5,
+    itemSize: 15,
+    itemGap: 8,
+    showTitle: true,
+    iconStyle: {
+      borderColor: '#666',
+      color: 'none'
+    },
+    emphasis: {
+      iconStyle: {
+        borderColor: '#3E98C5'
+      }
+    },
+    // textStyle: {},
+    // feature
+    tooltip: {
+      show: false,
+      position: 'bottom'
+    }
+  };
+  return ToolboxModel;
+}(Component["default"]);
+
+exports["default"] = ToolboxModel;