office-viewer 0.3.11 → 0.3.13

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

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../zrender/lib/core/util.js');
+var createRenderPlanner = require('../chart/helper/createRenderPlanner.js');
+var dataStackHelper = require('../data/helper/dataStackHelper.js');
+var vendor = require('../util/vendor.js');
+
+function pointsLayout(seriesType, forceStoreInTypedArray) {
+  return {
+    seriesType: seriesType,
+    plan: createRenderPlanner["default"](),
+    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 = util.map(coordSys.dimensions, function (dim) {
+        return data.mapDimension(dim);
+      }).slice(0, 2);
+      var dimLen = dims.length;
+      var stackResultDim = data.getCalculationInfo('stackResultDimension');
+      if (dataStackHelper.isDimensionStacked(data, dims[0])) {
+        dims[0] = stackResultDim;
+      }
+      if (dataStackHelper.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 && vendor.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);
+        }
+      };
+    }
+  };
+}
+
+exports["default"] = pointsLayout;

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

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../zrender/lib/core/util.js');
+var log = require('../util/log.js');
+var model = require('../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;
+  }
+  util.each([[seriesType + 'ToggleSelect', 'toggleSelect'], [seriesType + 'Select', 'select'], [seriesType + 'UnSelect', 'unselect']], function (eventsMap) {
+    ecRegisterAction(eventsMap[0], function (payload, ecModel, api) {
+      payload = util.extend({}, payload);
+      if (process.env.NODE_ENV !== 'production') {
+        log.deprecateReplaceLog(payload.type, eventsMap[1]);
+      }
+      api.dispatchAction(util.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') {
+      log.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 = model.queryDataIndex(data, payload.fromActionPayload);
+          ecIns.trigger(legacyEventName, {
+            type: legacyEventName,
+            seriesId: seriesModel.id,
+            name: util.isArray(dataIndex) ? data.getName(dataIndex[0]) : data.getName(dataIndex),
+            selected: util.isString(selectedMap) ? selectedMap : util.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);
+    }
+  });
+}
+
+exports.createLegacyDataSelectAction = createLegacyDataSelectAction;
+exports.handleLegacySelectEvents = handleLegacySelectEvents;

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

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../util/graphic.js');
+var Text = require('../../../zrender/lib/graphic/Text.js');
+
+function getTextRect(text, font, align, verticalAlign, padding, rich, truncate, lineHeight) {
+  var textEl = new Text["default"]({
+    style: {
+      text: text,
+      font: font,
+      align: align,
+      verticalAlign: verticalAlign,
+      padding: padding,
+      rich: rich,
+      overflow: truncate ? 'truncate' : null,
+      lineHeight: lineHeight
+    }
+  });
+  return textEl.getBoundingRect();
+}
+
+exports.getTextRect = getTextRect;

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

@@ -0,0 +1,128 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../zrender/lib/core/util.js');
+require('../util/graphic.js');
+var Group = require('../../../zrender/lib/graphic/Group.js');
+var Rect = require('../../../zrender/lib/graphic/shape/Rect.js');
+var Text = require('../../../zrender/lib/graphic/Text.js');
+var Arc = require('../../../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 || {};
+  util.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["default"]();
+  var mask = new Rect["default"]({
+    style: {
+      fill: opts.maskColor
+    },
+    zlevel: opts.zlevel,
+    z: 10000
+  });
+  group.add(mask);
+  var textContent = new Text["default"]({
+    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["default"]({
+    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["default"]({
+      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;
+}
+
+exports["default"] = defaultLoading;

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

@@ -0,0 +1,197 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../zrender/lib/core/util.js');
+var Model = require('./Model.js');
+var component = require('../util/component.js');
+var clazz = require('../util/clazz.js');
+var model = require('../util/model.js');
+var layout = require('../util/layout.js');
+
+var inner = model.makeInner();
+var ComponentModel = /** @class */function (_super) {
+  tslib.__extends(ComponentModel, _super);
+  function ComponentModel(option, parentModel, ecModel) {
+    var _this = _super.call(this, option, parentModel, ecModel) || this;
+    _this.uid = component.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 = layout.fetchLayoutMode(this);
+    var inputPositionParams = layoutMode ? layout.getLayoutParams(option) : {};
+    var themeModel = ecModel.getTheme();
+    util.merge(option, themeModel.get(this.mainType));
+    util.merge(option, this.getDefaultOption());
+    if (layoutMode) {
+      layout.mergeLayoutParam(option, inputPositionParams, layoutMode);
+    }
+  };
+  ComponentModel.prototype.mergeOption = function (option, ecModel) {
+    util.merge(this.option, option, true);
+    var layoutMode = layout.fetchLayoutMode(this);
+    if (layoutMode) {
+      layout.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 (!clazz.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 = util.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 model.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["default"]);
+clazz.mountExtend(ComponentModel, Model["default"]);
+clazz.enableClassManagement(ComponentModel);
+component.enableSubTypeDefaulter(ComponentModel);
+component.enableTopologicalTravel(ComponentModel, getDependencies);
+function getDependencies(componentType) {
+  var deps = [];
+  util.each(ComponentModel.getClassesByMainType(componentType), function (clz) {
+    deps = deps.concat(clz.dependencies || clz.prototype.dependencies || []);
+  });
+  // Ensure main type.
+  deps = util.map(deps, function (type) {
+    return clazz.parseClassType(type).main;
+  });
+  // Hack dataset for convenience.
+  if (componentType !== 'dataset' && util.indexOf(deps, 'dataset') <= 0) {
+    deps.unshift('dataset');
+  }
+  return deps;
+}
+var ComponentModel$1 = ComponentModel;
+
+exports["default"] = ComponentModel$1;