office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/model/mixin/dataFormat.js

@@ -0,0 +1,165 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var dataProvider = require('../../data/helper/dataProvider.js');
+var format = require('../../util/format.js');
+var log = require('../../util/log.js');
+
+var DIMENSION_LABEL_REG = /\{@(.+?)\}/g;
+var DataFormatMixin = /** @class */function () {
+  function DataFormatMixin() {}
+  /**
+   * Get params for formatter
+   */
+  DataFormatMixin.prototype.getDataParams = function (dataIndex, dataType) {
+    var data = this.getData(dataType);
+    var rawValue = this.getRawValue(dataIndex, dataType);
+    var rawDataIndex = data.getRawIndex(dataIndex);
+    var name = data.getName(dataIndex);
+    var itemOpt = data.getRawDataItem(dataIndex);
+    var style = data.getItemVisual(dataIndex, 'style');
+    var color = style && style[data.getItemVisual(dataIndex, 'drawType') || 'fill'];
+    var borderColor = style && style.stroke;
+    var mainType = this.mainType;
+    var isSeries = mainType === 'series';
+    var userOutput = data.userOutput && data.userOutput.get();
+    return {
+      componentType: mainType,
+      componentSubType: this.subType,
+      componentIndex: this.componentIndex,
+      seriesType: isSeries ? this.subType : null,
+      seriesIndex: this.seriesIndex,
+      seriesId: isSeries ? this.id : null,
+      seriesName: isSeries ? this.name : null,
+      name: name,
+      dataIndex: rawDataIndex,
+      data: itemOpt,
+      dataType: dataType,
+      value: rawValue,
+      color: color,
+      borderColor: borderColor,
+      dimensionNames: userOutput ? userOutput.fullDimensions : null,
+      encode: userOutput ? userOutput.encode : null,
+      // Param name list for mapping `a`, `b`, `c`, `d`, `e`
+      $vars: ['seriesName', 'name', 'value']
+    };
+  };
+  /**
+   * Format label
+   * @param dataIndex
+   * @param status 'normal' by default
+   * @param dataType
+   * @param labelDimIndex Only used in some chart that
+   *        use formatter in different dimensions, like radar.
+   * @param formatter Formatter given outside.
+   * @return return null/undefined if no formatter
+   */
+  DataFormatMixin.prototype.getFormattedLabel = function (dataIndex, status, dataType, labelDimIndex, formatter, extendParams) {
+    status = status || 'normal';
+    var data = this.getData(dataType);
+    var params = this.getDataParams(dataIndex, dataType);
+    if (extendParams) {
+      params.value = extendParams.interpolatedValue;
+    }
+    if (labelDimIndex != null && util.isArray(params.value)) {
+      params.value = params.value[labelDimIndex];
+    }
+    if (!formatter) {
+      var itemModel = data.getItemModel(dataIndex);
+      // @ts-ignore
+      formatter = itemModel.get(status === 'normal' ? ['label', 'formatter'] : [status, 'label', 'formatter']);
+    }
+    if (util.isFunction(formatter)) {
+      params.status = status;
+      params.dimensionIndex = labelDimIndex;
+      return formatter(params);
+    } else if (util.isString(formatter)) {
+      var str = format.formatTpl(formatter, params);
+      // Support 'aaa{@[3]}bbb{@product}ccc'.
+      // Do not support '}' in dim name util have to.
+      return str.replace(DIMENSION_LABEL_REG, function (origin, dimStr) {
+        var len = dimStr.length;
+        var dimLoose = dimStr;
+        if (dimLoose.charAt(0) === '[' && dimLoose.charAt(len - 1) === ']') {
+          dimLoose = +dimLoose.slice(1, len - 1); // Also support: '[]' => 0
+          if (process.env.NODE_ENV !== 'production') {
+            if (isNaN(dimLoose)) {
+              log.error("Invalide label formatter: @" + dimStr + ", only support @[0], @[1], @[2], ...");
+            }
+          }
+        }
+        var val = dataProvider.retrieveRawValue(data, dataIndex, dimLoose);
+        if (extendParams && util.isArray(extendParams.interpolatedValue)) {
+          var dimIndex = data.getDimensionIndex(dimLoose);
+          if (dimIndex >= 0) {
+            val = extendParams.interpolatedValue[dimIndex];
+          }
+        }
+        return val != null ? val + '' : '';
+      });
+    }
+  };
+  /**
+   * Get raw value in option
+   */
+  DataFormatMixin.prototype.getRawValue = function (idx, dataType) {
+    return dataProvider.retrieveRawValue(this.getData(dataType), idx);
+  };
+  /**
+   * Should be implemented.
+   * @param {number} dataIndex
+   * @param {boolean} [multipleSeries=false]
+   * @param {string} [dataType]
+   */
+  DataFormatMixin.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+    // Empty function
+    return;
+  };
+  return DataFormatMixin;
+}();
+// PENDING: previously we accept this type when calling `formatTooltip`,
+// but guess little chance has been used outside. Do we need to backward
+// compat it?
+// type TooltipFormatResultLegacyObject = {
+//     // `html` means the markup language text, either in 'html' or 'richText'.
+//     // The name `html` is not appropriate because in 'richText' it is not a HTML
+//     // string. But still support it for backward compatibility.
+//     html: string;
+//     markers: Dictionary<ColorString>;
+// };
+/**
+ * For backward compat, normalize the return from `formatTooltip`.
+ */
+function normalizeTooltipFormatResult(result) {
+  var markupText;
+  // let markers: Dictionary<ColorString>;
+  var markupFragment;
+  if (util.isObject(result)) {
+    if (result.type) {
+      markupFragment = result;
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        console.warn('The return type of `formatTooltip` is not supported: ' + log.makePrintable(result));
+      }
+    }
+    // else {
+    //     markupText = (result as TooltipFormatResultLegacyObject).html;
+    //     markers = (result as TooltipFormatResultLegacyObject).markers;
+    //     if (markersExisting) {
+    //         markers = zrUtil.merge(markersExisting, markers);
+    //     }
+    // }
+  } else {
+    markupText = result;
+  }
+  return {
+    text: markupText,
+    // markers: markers || markersExisting,
+    frag: markupFragment
+  };
+}
+
+exports.DataFormatMixin = DataFormatMixin;
+exports.normalizeTooltipFormatResult = normalizeTooltipFormatResult;

package/lib/node_modules/echarts/lib/model/mixin/itemStyle.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var makeStyleMapper = require('./makeStyleMapper.js');
+
+var ITEM_STYLE_KEY_MAP = [['fill', 'color'], ['stroke', 'borderColor'], ['lineWidth', 'borderWidth'], ['opacity'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['shadowColor'], ['lineDash', 'borderType'], ['lineDashOffset', 'borderDashOffset'], ['lineCap', 'borderCap'], ['lineJoin', 'borderJoin'], ['miterLimit', 'borderMiterLimit']
+// Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+// So do not transfer decal directly.
+];
+
+var getItemStyle = makeStyleMapper["default"](ITEM_STYLE_KEY_MAP);
+var ItemStyleMixin = /** @class */function () {
+  function ItemStyleMixin() {}
+  ItemStyleMixin.prototype.getItemStyle = function (excludes, includes) {
+    return getItemStyle(this, excludes, includes);
+  };
+  return ItemStyleMixin;
+}();
+
+exports.ITEM_STYLE_KEY_MAP = ITEM_STYLE_KEY_MAP;
+exports.ItemStyleMixin = ItemStyleMixin;

package/lib/node_modules/echarts/lib/model/mixin/lineStyle.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var makeStyleMapper = require('./makeStyleMapper.js');
+
+var LINE_STYLE_KEY_MAP = [['lineWidth', 'width'], ['stroke', 'color'], ['opacity'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['shadowColor'], ['lineDash', 'type'], ['lineDashOffset', 'dashOffset'], ['lineCap', 'cap'], ['lineJoin', 'join'], ['miterLimit']
+// Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+// So do not transfer decal directly.
+];
+
+var getLineStyle = makeStyleMapper["default"](LINE_STYLE_KEY_MAP);
+var LineStyleMixin = /** @class */function () {
+  function LineStyleMixin() {}
+  LineStyleMixin.prototype.getLineStyle = function (excludes) {
+    return getLineStyle(this, excludes);
+  };
+  return LineStyleMixin;
+}();
+
+exports.LINE_STYLE_KEY_MAP = LINE_STYLE_KEY_MAP;
+exports.LineStyleMixin = LineStyleMixin;

package/lib/node_modules/echarts/lib/model/mixin/makeStyleMapper.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+
+function makeStyleMapper(properties, ignoreParent) {
+  // Normalize
+  for (var i = 0; i < properties.length; i++) {
+    if (!properties[i][1]) {
+      properties[i][1] = properties[i][0];
+    }
+  }
+  ignoreParent = ignoreParent || false;
+  return function (model, excludes, includes) {
+    var style = {};
+    for (var i = 0; i < properties.length; i++) {
+      var propName = properties[i][1];
+      if (excludes && util.indexOf(excludes, propName) >= 0 || includes && util.indexOf(includes, propName) < 0) {
+        continue;
+      }
+      var val = model.getShallow(propName, ignoreParent);
+      if (val != null) {
+        style[properties[i][0]] = val;
+      }
+    }
+    // TODO Text or image?
+    return style;
+  };
+}
+
+exports["default"] = makeStyleMapper;

package/lib/node_modules/echarts/lib/model/mixin/palette.js

@@ -0,0 +1,69 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var model = require('../../util/model.js');
+
+var innerColor = model.makeInner();
+var innerDecal = model.makeInner();
+var PaletteMixin = /** @class */function () {
+  function PaletteMixin() {}
+  PaletteMixin.prototype.getColorFromPalette = function (name, scope, requestNum) {
+    var defaultPalette = model.normalizeToArray(this.get('color', true));
+    var layeredPalette = this.get('colorLayer', true);
+    return getFromPalette(this, innerColor, defaultPalette, layeredPalette, name, scope, requestNum);
+  };
+  PaletteMixin.prototype.clearColorPalette = function () {
+    clearPalette(this, innerColor);
+  };
+  return PaletteMixin;
+}();
+function getDecalFromPalette(ecModel, name, scope, requestNum) {
+  var defaultDecals = model.normalizeToArray(ecModel.get(['aria', 'decal', 'decals']));
+  return getFromPalette(ecModel, innerDecal, defaultDecals, null, name, scope, requestNum);
+}
+function getNearestPalette(palettes, requestColorNum) {
+  var paletteNum = palettes.length;
+  // TODO palettes must be in order
+  for (var i = 0; i < paletteNum; i++) {
+    if (palettes[i].length > requestColorNum) {
+      return palettes[i];
+    }
+  }
+  return palettes[paletteNum - 1];
+}
+/**
+ * @param name MUST NOT be null/undefined. Otherwise call this function
+ *             twise with the same parameters will get different result.
+ * @param scope default this.
+ * @return Can be null/undefined
+ */
+function getFromPalette(that, inner, defaultPalette, layeredPalette, name, scope, requestNum) {
+  scope = scope || that;
+  var scopeFields = inner(scope);
+  var paletteIdx = scopeFields.paletteIdx || 0;
+  var paletteNameMap = scopeFields.paletteNameMap = scopeFields.paletteNameMap || {};
+  // Use `hasOwnProperty` to avoid conflict with Object.prototype.
+  if (paletteNameMap.hasOwnProperty(name)) {
+    return paletteNameMap[name];
+  }
+  var palette = requestNum == null || !layeredPalette ? defaultPalette : getNearestPalette(layeredPalette, requestNum);
+  // In case can't find in layered color palette.
+  palette = palette || defaultPalette;
+  if (!palette || !palette.length) {
+    return;
+  }
+  var pickedPaletteItem = palette[paletteIdx];
+  if (name) {
+    paletteNameMap[name] = pickedPaletteItem;
+  }
+  scopeFields.paletteIdx = (paletteIdx + 1) % palette.length;
+  return pickedPaletteItem;
+}
+function clearPalette(that, inner) {
+  inner(that).paletteIdx = 0;
+  inner(that).paletteNameMap = {};
+}
+
+exports.PaletteMixin = PaletteMixin;
+exports.getDecalFromPalette = getDecalFromPalette;

package/lib/node_modules/echarts/lib/model/mixin/textStyle.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var labelStyle = require('../../label/labelStyle.js');
+var Text = require('../../../../zrender/lib/graphic/Text.js');
+
+var PATH_COLOR = ['textStyle', 'color'];
+var textStyleParams = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'padding', 'lineHeight', 'rich', 'width', 'height', 'overflow'];
+// TODO Performance improvement?
+var tmpText = new Text["default"]();
+var TextStyleMixin = /** @class */function () {
+  function TextStyleMixin() {}
+  /**
+   * Get color property or get color from option.textStyle.color
+   */
+  // TODO Callback
+  TextStyleMixin.prototype.getTextColor = function (isEmphasis) {
+    var ecModel = this.ecModel;
+    return this.getShallow('color') || (!isEmphasis && ecModel ? ecModel.get(PATH_COLOR) : null);
+  };
+  /**
+   * Create font string from fontStyle, fontWeight, fontSize, fontFamily
+   * @return {string}
+   */
+  TextStyleMixin.prototype.getFont = function () {
+    return labelStyle.getFont({
+      fontStyle: this.getShallow('fontStyle'),
+      fontWeight: this.getShallow('fontWeight'),
+      fontSize: this.getShallow('fontSize'),
+      fontFamily: this.getShallow('fontFamily')
+    }, this.ecModel);
+  };
+  TextStyleMixin.prototype.getTextRect = function (text) {
+    var style = {
+      text: text,
+      verticalAlign: this.getShallow('verticalAlign') || this.getShallow('baseline')
+    };
+    for (var i = 0; i < textStyleParams.length; i++) {
+      style[textStyleParams[i]] = this.getShallow(textStyleParams[i]);
+    }
+    tmpText.useStyle(style);
+    tmpText.update();
+    return tmpText.getBoundingRect();
+  };
+  return TextStyleMixin;
+}();
+
+exports["default"] = TextStyleMixin;

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

@@ -0,0 +1,132 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../zrender/lib/core/util.js');
+var model = require('../util/model.js');
+
+/**
+ * @class
+ * For example:
+ * {
+ *     coordSysName: 'cartesian2d',
+ *     coordSysDims: ['x', 'y', ...],
+ *     axisMap: HashMap({
+ *         x: xAxisModel,
+ *         y: yAxisModel
+ *     }),
+ *     categoryAxisMap: HashMap({
+ *         x: xAxisModel,
+ *         y: undefined
+ *     }),
+ *     // The index of the first category axis in `coordSysDims`.
+ *     // `null/undefined` means no category axis exists.
+ *     firstCategoryDimIndex: 1,
+ *     // To replace user specified encode.
+ * }
+ */
+var CoordSysInfo = /** @class */function () {
+  function CoordSysInfo(coordSysName) {
+    this.coordSysDims = [];
+    this.axisMap = util.createHashMap();
+    this.categoryAxisMap = util.createHashMap();
+    this.coordSysName = coordSysName;
+  }
+  return CoordSysInfo;
+}();
+function getCoordSysInfoBySeries(seriesModel) {
+  var coordSysName = seriesModel.get('coordinateSystem');
+  var result = new CoordSysInfo(coordSysName);
+  var fetch = fetchers[coordSysName];
+  if (fetch) {
+    fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);
+    return result;
+  }
+}
+var fetchers = {
+  cartesian2d: function (seriesModel, result, axisMap, categoryAxisMap) {
+    var xAxisModel = seriesModel.getReferringComponents('xAxis', model.SINGLE_REFERRING).models[0];
+    var yAxisModel = seriesModel.getReferringComponents('yAxis', model.SINGLE_REFERRING).models[0];
+    if (process.env.NODE_ENV !== 'production') {
+      if (!xAxisModel) {
+        throw new Error('xAxis "' + util.retrieve(seriesModel.get('xAxisIndex'), seriesModel.get('xAxisId'), 0) + '" not found');
+      }
+      if (!yAxisModel) {
+        throw new Error('yAxis "' + util.retrieve(seriesModel.get('xAxisIndex'), seriesModel.get('yAxisId'), 0) + '" not found');
+      }
+    }
+    result.coordSysDims = ['x', 'y'];
+    axisMap.set('x', xAxisModel);
+    axisMap.set('y', yAxisModel);
+    if (isCategory(xAxisModel)) {
+      categoryAxisMap.set('x', xAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+    if (isCategory(yAxisModel)) {
+      categoryAxisMap.set('y', yAxisModel);
+      result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
+    }
+  },
+  singleAxis: function (seriesModel, result, axisMap, categoryAxisMap) {
+    var singleAxisModel = seriesModel.getReferringComponents('singleAxis', model.SINGLE_REFERRING).models[0];
+    if (process.env.NODE_ENV !== 'production') {
+      if (!singleAxisModel) {
+        throw new Error('singleAxis should be specified.');
+      }
+    }
+    result.coordSysDims = ['single'];
+    axisMap.set('single', singleAxisModel);
+    if (isCategory(singleAxisModel)) {
+      categoryAxisMap.set('single', singleAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+  },
+  polar: function (seriesModel, result, axisMap, categoryAxisMap) {
+    var polarModel = seriesModel.getReferringComponents('polar', model.SINGLE_REFERRING).models[0];
+    var radiusAxisModel = polarModel.findAxisModel('radiusAxis');
+    var angleAxisModel = polarModel.findAxisModel('angleAxis');
+    if (process.env.NODE_ENV !== 'production') {
+      if (!angleAxisModel) {
+        throw new Error('angleAxis option not found');
+      }
+      if (!radiusAxisModel) {
+        throw new Error('radiusAxis option not found');
+      }
+    }
+    result.coordSysDims = ['radius', 'angle'];
+    axisMap.set('radius', radiusAxisModel);
+    axisMap.set('angle', angleAxisModel);
+    if (isCategory(radiusAxisModel)) {
+      categoryAxisMap.set('radius', radiusAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+    if (isCategory(angleAxisModel)) {
+      categoryAxisMap.set('angle', angleAxisModel);
+      result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
+    }
+  },
+  geo: function (seriesModel, result, axisMap, categoryAxisMap) {
+    result.coordSysDims = ['lng', 'lat'];
+  },
+  parallel: function (seriesModel, result, axisMap, categoryAxisMap) {
+    var ecModel = seriesModel.ecModel;
+    var parallelModel = ecModel.getComponent('parallel', seriesModel.get('parallelIndex'));
+    var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice();
+    util.each(parallelModel.parallelAxisIndex, function (axisIndex, index) {
+      var axisModel = ecModel.getComponent('parallelAxis', axisIndex);
+      var axisDim = coordSysDims[index];
+      axisMap.set(axisDim, axisModel);
+      if (isCategory(axisModel)) {
+        categoryAxisMap.set(axisDim, axisModel);
+        if (result.firstCategoryDimIndex == null) {
+          result.firstCategoryDimIndex = index;
+        }
+      }
+    });
+  }
+};
+function isCategory(axisModel) {
+  return axisModel.get('type') === 'category';
+}
+
+exports.getCoordSysInfoBySeries = getCoordSysInfoBySeries;