office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/label/labelLayoutHelper.js

@@ -0,0 +1,261 @@
+import '../util/graphic.js';
+import OrientedBoundingRect from '../../../zrender/lib/core/OrientedBoundingRect.js';
+import BoundingRect from '../../../zrender/lib/core/BoundingRect.js';
+
+function prepareLayoutList(input) {
+  var list = [];
+  for (var i = 0; i < input.length; i++) {
+    var rawItem = input[i];
+    if (rawItem.defaultAttr.ignore) {
+      continue;
+    }
+    var label = rawItem.label;
+    var transform = label.getComputedTransform();
+    // NOTE: Get bounding rect after getComputedTransform, or label may not been updated by the host el.
+    var localRect = label.getBoundingRect();
+    var isAxisAligned = !transform || transform[1] < 1e-5 && transform[2] < 1e-5;
+    var minMargin = label.style.margin || 0;
+    var globalRect = localRect.clone();
+    globalRect.applyTransform(transform);
+    globalRect.x -= minMargin / 2;
+    globalRect.y -= minMargin / 2;
+    globalRect.width += minMargin;
+    globalRect.height += minMargin;
+    var obb = isAxisAligned ? new OrientedBoundingRect(localRect, transform) : null;
+    list.push({
+      label: label,
+      labelLine: rawItem.labelLine,
+      rect: globalRect,
+      localRect: localRect,
+      obb: obb,
+      priority: rawItem.priority,
+      defaultAttr: rawItem.defaultAttr,
+      layoutOption: rawItem.computedLayoutOption,
+      axisAligned: isAxisAligned,
+      transform: transform
+    });
+  }
+  return list;
+}
+function shiftLayout(list, xyDim, sizeDim, minBound, maxBound, balanceShift) {
+  var len = list.length;
+  if (len < 2) {
+    return;
+  }
+  list.sort(function (a, b) {
+    return a.rect[xyDim] - b.rect[xyDim];
+  });
+  var lastPos = 0;
+  var delta;
+  var adjusted = false;
+  var totalShifts = 0;
+  for (var i = 0; i < len; i++) {
+    var item = list[i];
+    var rect = item.rect;
+    delta = rect[xyDim] - lastPos;
+    if (delta < 0) {
+      // shiftForward(i, len, -delta);
+      rect[xyDim] -= delta;
+      item.label[xyDim] -= delta;
+      adjusted = true;
+    }
+    var shift = Math.max(-delta, 0);
+    totalShifts += shift;
+    lastPos = rect[xyDim] + rect[sizeDim];
+  }
+  if (totalShifts > 0 && balanceShift) {
+    // Shift back to make the distribution more equally.
+    shiftList(-totalShifts / len, 0, len);
+  }
+  // TODO bleedMargin?
+  var first = list[0];
+  var last = list[len - 1];
+  var minGap;
+  var maxGap;
+  updateMinMaxGap();
+  // If ends exceed two bounds, squeeze at most 80%, then take the gap of two bounds.
+  minGap < 0 && squeezeGaps(-minGap, 0.8);
+  maxGap < 0 && squeezeGaps(maxGap, 0.8);
+  updateMinMaxGap();
+  takeBoundsGap(minGap, maxGap, 1);
+  takeBoundsGap(maxGap, minGap, -1);
+  // Handle bailout when there is not enough space.
+  updateMinMaxGap();
+  if (minGap < 0) {
+    squeezeWhenBailout(-minGap);
+  }
+  if (maxGap < 0) {
+    squeezeWhenBailout(maxGap);
+  }
+  function updateMinMaxGap() {
+    minGap = first.rect[xyDim] - minBound;
+    maxGap = maxBound - last.rect[xyDim] - last.rect[sizeDim];
+  }
+  function takeBoundsGap(gapThisBound, gapOtherBound, moveDir) {
+    if (gapThisBound < 0) {
+      // Move from other gap if can.
+      var moveFromMaxGap = Math.min(gapOtherBound, -gapThisBound);
+      if (moveFromMaxGap > 0) {
+        shiftList(moveFromMaxGap * moveDir, 0, len);
+        var remained = moveFromMaxGap + gapThisBound;
+        if (remained < 0) {
+          squeezeGaps(-remained * moveDir, 1);
+        }
+      } else {
+        squeezeGaps(-gapThisBound * moveDir, 1);
+      }
+    }
+  }
+  function shiftList(delta, start, end) {
+    if (delta !== 0) {
+      adjusted = true;
+    }
+    for (var i = start; i < end; i++) {
+      var item = list[i];
+      var rect = item.rect;
+      rect[xyDim] += delta;
+      item.label[xyDim] += delta;
+    }
+  }
+  // Squeeze gaps if the labels exceed margin.
+  function squeezeGaps(delta, maxSqeezePercent) {
+    var gaps = [];
+    var totalGaps = 0;
+    for (var i = 1; i < len; i++) {
+      var prevItemRect = list[i - 1].rect;
+      var gap = Math.max(list[i].rect[xyDim] - prevItemRect[xyDim] - prevItemRect[sizeDim], 0);
+      gaps.push(gap);
+      totalGaps += gap;
+    }
+    if (!totalGaps) {
+      return;
+    }
+    var squeezePercent = Math.min(Math.abs(delta) / totalGaps, maxSqeezePercent);
+    if (delta > 0) {
+      for (var i = 0; i < len - 1; i++) {
+        // Distribute the shift delta to all gaps.
+        var movement = gaps[i] * squeezePercent;
+        // Forward
+        shiftList(movement, 0, i + 1);
+      }
+    } else {
+      // Backward
+      for (var i = len - 1; i > 0; i--) {
+        // Distribute the shift delta to all gaps.
+        var movement = gaps[i - 1] * squeezePercent;
+        shiftList(-movement, i, len);
+      }
+    }
+  }
+  /**
+   * Squeeze to allow overlap if there is no more space available.
+   * Let other overlapping strategy like hideOverlap do the job instead of keep exceeding the bounds.
+   */
+  function squeezeWhenBailout(delta) {
+    var dir = delta < 0 ? -1 : 1;
+    delta = Math.abs(delta);
+    var moveForEachLabel = Math.ceil(delta / (len - 1));
+    for (var i = 0; i < len - 1; i++) {
+      if (dir > 0) {
+        // Forward
+        shiftList(moveForEachLabel, 0, i + 1);
+      } else {
+        // Backward
+        shiftList(-moveForEachLabel, len - i - 1, len);
+      }
+      delta -= moveForEachLabel;
+      if (delta <= 0) {
+        return;
+      }
+    }
+  }
+  return adjusted;
+}
+/**
+ * Adjust labels on x direction to avoid overlap.
+ */
+function shiftLayoutOnX(list, leftBound, rightBound,
+// If average the shifts on all labels and add them to 0
+// TODO: Not sure if should enable it.
+// Pros: The angle of lines will distribute more equally
+// Cons: In some layout. It may not what user wanted. like in pie. the label of last sector is usually changed unexpectedly.
+balanceShift) {
+  return shiftLayout(list, 'x', 'width', leftBound, rightBound, balanceShift);
+}
+/**
+ * Adjust labels on y direction to avoid overlap.
+ */
+function shiftLayoutOnY(list, topBound, bottomBound,
+// If average the shifts on all labels and add them to 0
+balanceShift) {
+  return shiftLayout(list, 'y', 'height', topBound, bottomBound, balanceShift);
+}
+function hideOverlap(labelList) {
+  var displayedLabels = [];
+  // TODO, render overflow visible first, put in the displayedLabels.
+  labelList.sort(function (a, b) {
+    return b.priority - a.priority;
+  });
+  var globalRect = new BoundingRect(0, 0, 0, 0);
+  function hideEl(el) {
+    if (!el.ignore) {
+      // Show on emphasis.
+      var emphasisState = el.ensureState('emphasis');
+      if (emphasisState.ignore == null) {
+        emphasisState.ignore = false;
+      }
+    }
+    el.ignore = true;
+  }
+  for (var i = 0; i < labelList.length; i++) {
+    var labelItem = labelList[i];
+    var isAxisAligned = labelItem.axisAligned;
+    var localRect = labelItem.localRect;
+    var transform = labelItem.transform;
+    var label = labelItem.label;
+    var labelLine = labelItem.labelLine;
+    globalRect.copy(labelItem.rect);
+    // Add a threshold because layout may be aligned precisely.
+    globalRect.width -= 0.1;
+    globalRect.height -= 0.1;
+    globalRect.x += 0.05;
+    globalRect.y += 0.05;
+    var obb = labelItem.obb;
+    var overlapped = false;
+    for (var j = 0; j < displayedLabels.length; j++) {
+      var existsTextCfg = displayedLabels[j];
+      // Fast rejection.
+      if (!globalRect.intersect(existsTextCfg.rect)) {
+        continue;
+      }
+      if (isAxisAligned && existsTextCfg.axisAligned) {
+        // Is overlapped
+        overlapped = true;
+        break;
+      }
+      if (!existsTextCfg.obb) {
+        // If self is not axis aligned. But other is.
+        existsTextCfg.obb = new OrientedBoundingRect(existsTextCfg.localRect, existsTextCfg.transform);
+      }
+      if (!obb) {
+        // If self is axis aligned. But other is not.
+        obb = new OrientedBoundingRect(localRect, transform);
+      }
+      if (obb.intersect(existsTextCfg.obb)) {
+        overlapped = true;
+        break;
+      }
+    }
+    // TODO Callback to determine if this overlap should be handled?
+    if (overlapped) {
+      hideEl(label);
+      labelLine && hideEl(labelLine);
+    } else {
+      label.attr('ignore', labelItem.defaultAttr.ignore);
+      labelLine && labelLine.attr('ignore', labelItem.defaultAttr.labelGuideIgnore);
+      displayedLabels.push(labelItem);
+    }
+  }
+}
+
+export { hideOverlap, prepareLayoutList, shiftLayoutOnX, shiftLayoutOnY };

package/esm/node_modules/echarts/lib/label/labelStyle.js

@@ -0,0 +1,444 @@
+import ZRText from '../../../zrender/lib/graphic/Text.js';
+import { retrieve2, extend, keys, trim, isFunction } from '../../../zrender/lib/core/util.js';
+import { DISPLAY_STATES, SPECIAL_STATES } from '../util/states.js';
+import { deprecateReplaceLog } from '../util/log.js';
+import { makeInner, interpolateRawValues } from '../util/model.js';
+import '../util/graphic.js';
+import { initProps, updateProps } from '../animation/basicTransition.js';
+
+var EMPTY_OBJ = {};
+function setLabelText(label, labelTexts) {
+  for (var i = 0; i < SPECIAL_STATES.length; i++) {
+    var stateName = SPECIAL_STATES[i];
+    var text = labelTexts[stateName];
+    var state = label.ensureState(stateName);
+    state.style = state.style || {};
+    state.style.text = text;
+  }
+  var oldStates = label.currentStates.slice();
+  label.clearStates(true);
+  label.setStyle({
+    text: labelTexts.normal
+  });
+  label.useStates(oldStates, true);
+}
+function getLabelText(opt, stateModels, interpolatedValue) {
+  var labelFetcher = opt.labelFetcher;
+  var labelDataIndex = opt.labelDataIndex;
+  var labelDimIndex = opt.labelDimIndex;
+  var normalModel = stateModels.normal;
+  var baseText;
+  if (labelFetcher) {
+    baseText = labelFetcher.getFormattedLabel(labelDataIndex, 'normal', null, labelDimIndex, normalModel && normalModel.get('formatter'), interpolatedValue != null ? {
+      interpolatedValue: interpolatedValue
+    } : null);
+  }
+  if (baseText == null) {
+    baseText = isFunction(opt.defaultText) ? opt.defaultText(labelDataIndex, opt, interpolatedValue) : opt.defaultText;
+  }
+  var statesText = {
+    normal: baseText
+  };
+  for (var i = 0; i < SPECIAL_STATES.length; i++) {
+    var stateName = SPECIAL_STATES[i];
+    var stateModel = stateModels[stateName];
+    statesText[stateName] = retrieve2(labelFetcher ? labelFetcher.getFormattedLabel(labelDataIndex, stateName, null, labelDimIndex, stateModel && stateModel.get('formatter')) : null, baseText);
+  }
+  return statesText;
+}
+function setLabelStyle(targetEl, labelStatesModels, opt, stateSpecified
+// TODO specified position?
+) {
+  opt = opt || EMPTY_OBJ;
+  var isSetOnText = targetEl instanceof ZRText;
+  var needsCreateText = false;
+  for (var i = 0; i < DISPLAY_STATES.length; i++) {
+    var stateModel = labelStatesModels[DISPLAY_STATES[i]];
+    if (stateModel && stateModel.getShallow('show')) {
+      needsCreateText = true;
+      break;
+    }
+  }
+  var textContent = isSetOnText ? targetEl : targetEl.getTextContent();
+  if (needsCreateText) {
+    if (!isSetOnText) {
+      // Reuse the previous
+      if (!textContent) {
+        textContent = new ZRText();
+        targetEl.setTextContent(textContent);
+      }
+      // Use same state proxy
+      if (targetEl.stateProxy) {
+        textContent.stateProxy = targetEl.stateProxy;
+      }
+    }
+    var labelStatesTexts = getLabelText(opt, labelStatesModels);
+    var normalModel = labelStatesModels.normal;
+    var showNormal = !!normalModel.getShallow('show');
+    var normalStyle = createTextStyle(normalModel, stateSpecified && stateSpecified.normal, opt, false, !isSetOnText);
+    normalStyle.text = labelStatesTexts.normal;
+    if (!isSetOnText) {
+      // Always create new
+      targetEl.setTextConfig(createTextConfig(normalModel, opt, false));
+    }
+    for (var i = 0; i < SPECIAL_STATES.length; i++) {
+      var stateName = SPECIAL_STATES[i];
+      var stateModel = labelStatesModels[stateName];
+      if (stateModel) {
+        var stateObj = textContent.ensureState(stateName);
+        var stateShow = !!retrieve2(stateModel.getShallow('show'), showNormal);
+        if (stateShow !== showNormal) {
+          stateObj.ignore = !stateShow;
+        }
+        stateObj.style = createTextStyle(stateModel, stateSpecified && stateSpecified[stateName], opt, true, !isSetOnText);
+        stateObj.style.text = labelStatesTexts[stateName];
+        if (!isSetOnText) {
+          var targetElEmphasisState = targetEl.ensureState(stateName);
+          targetElEmphasisState.textConfig = createTextConfig(stateModel, opt, true);
+        }
+      }
+    }
+    // PENDING: if there is many requirements that emphasis position
+    // need to be different from normal position, we might consider
+    // auto silent is those cases.
+    textContent.silent = !!normalModel.getShallow('silent');
+    // Keep x and y
+    if (textContent.style.x != null) {
+      normalStyle.x = textContent.style.x;
+    }
+    if (textContent.style.y != null) {
+      normalStyle.y = textContent.style.y;
+    }
+    textContent.ignore = !showNormal;
+    // Always create new style.
+    textContent.useStyle(normalStyle);
+    textContent.dirty();
+    if (opt.enableTextSetter) {
+      labelInner(textContent).setLabelText = function (interpolatedValue) {
+        var labelStatesTexts = getLabelText(opt, labelStatesModels, interpolatedValue);
+        setLabelText(textContent, labelStatesTexts);
+      };
+    }
+  } else if (textContent) {
+    // Not display rich text.
+    textContent.ignore = true;
+  }
+  targetEl.dirty();
+}
+function getLabelStatesModels(itemModel, labelName) {
+  labelName = labelName || 'label';
+  var statesModels = {
+    normal: itemModel.getModel(labelName)
+  };
+  for (var i = 0; i < SPECIAL_STATES.length; i++) {
+    var stateName = SPECIAL_STATES[i];
+    statesModels[stateName] = itemModel.getModel([stateName, labelName]);
+  }
+  return statesModels;
+}
+/**
+ * Set basic textStyle properties.
+ */
+function createTextStyle(textStyleModel, specifiedTextStyle,
+// Fixed style in the code. Can't be set by model.
+opt, isNotNormal, isAttached // If text is attached on an element. If so, auto color will handling in zrender.
+) {
+  var textStyle = {};
+  setTextStyleCommon(textStyle, textStyleModel, opt, isNotNormal, isAttached);
+  specifiedTextStyle && extend(textStyle, specifiedTextStyle);
+  // textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);
+  return textStyle;
+}
+function createTextConfig(textStyleModel, opt, isNotNormal) {
+  opt = opt || {};
+  var textConfig = {};
+  var labelPosition;
+  var labelRotate = textStyleModel.getShallow('rotate');
+  var labelDistance = retrieve2(textStyleModel.getShallow('distance'), isNotNormal ? null : 5);
+  var labelOffset = textStyleModel.getShallow('offset');
+  labelPosition = textStyleModel.getShallow('position') || (isNotNormal ? null : 'inside');
+  // 'outside' is not a valid zr textPostion value, but used
+  // in bar series, and magric type should be considered.
+  labelPosition === 'outside' && (labelPosition = opt.defaultOutsidePosition || 'top');
+  if (labelPosition != null) {
+    textConfig.position = labelPosition;
+  }
+  if (labelOffset != null) {
+    textConfig.offset = labelOffset;
+  }
+  if (labelRotate != null) {
+    labelRotate *= Math.PI / 180;
+    textConfig.rotation = labelRotate;
+  }
+  if (labelDistance != null) {
+    textConfig.distance = labelDistance;
+  }
+  // fill and auto is determined by the color of path fill if it's not specified by developers.
+  textConfig.outsideFill = textStyleModel.get('color') === 'inherit' ? opt.inheritColor || null : 'auto';
+  return textConfig;
+}
+/**
+ * The uniform entry of set text style, that is, retrieve style definitions
+ * from `model` and set to `textStyle` object.
+ *
+ * Never in merge mode, but in overwrite mode, that is, all of the text style
+ * properties will be set. (Consider the states of normal and emphasis and
+ * default value can be adopted, merge would make the logic too complicated
+ * to manage.)
+ */
+function setTextStyleCommon(textStyle, textStyleModel, opt, isNotNormal, isAttached) {
+  // Consider there will be abnormal when merge hover style to normal style if given default value.
+  opt = opt || EMPTY_OBJ;
+  var ecModel = textStyleModel.ecModel;
+  var globalTextStyle = ecModel && ecModel.option.textStyle;
+  // Consider case:
+  // {
+  //     data: [{
+  //         value: 12,
+  //         label: {
+  //             rich: {
+  //                 // no 'a' here but using parent 'a'.
+  //             }
+  //         }
+  //     }],
+  //     rich: {
+  //         a: { ... }
+  //     }
+  // }
+  var richItemNames = getRichItemNames(textStyleModel);
+  var richResult;
+  if (richItemNames) {
+    richResult = {};
+    for (var name_1 in richItemNames) {
+      if (richItemNames.hasOwnProperty(name_1)) {
+        // Cascade is supported in rich.
+        var richTextStyle = textStyleModel.getModel(['rich', name_1]);
+        // In rich, never `disableBox`.
+        // FIXME: consider `label: {formatter: '{a|xx}', color: 'blue', rich: {a: {}}}`,
+        // the default color `'blue'` will not be adopted if no color declared in `rich`.
+        // That might confuses users. So probably we should put `textStyleModel` as the
+        // root ancestor of the `richTextStyle`. But that would be a break change.
+        setTokenTextStyle(richResult[name_1] = {}, richTextStyle, globalTextStyle, opt, isNotNormal, isAttached, false, true);
+      }
+    }
+  }
+  if (richResult) {
+    textStyle.rich = richResult;
+  }
+  var overflow = textStyleModel.get('overflow');
+  if (overflow) {
+    textStyle.overflow = overflow;
+  }
+  var margin = textStyleModel.get('minMargin');
+  if (margin != null) {
+    textStyle.margin = margin;
+  }
+  setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isNotNormal, isAttached, true, false);
+}
+// Consider case:
+// {
+//     data: [{
+//         value: 12,
+//         label: {
+//             rich: {
+//                 // no 'a' here but using parent 'a'.
+//             }
+//         }
+//     }],
+//     rich: {
+//         a: { ... }
+//     }
+// }
+// TODO TextStyleModel
+function getRichItemNames(textStyleModel) {
+  // Use object to remove duplicated names.
+  var richItemNameMap;
+  while (textStyleModel && textStyleModel !== textStyleModel.ecModel) {
+    var rich = (textStyleModel.option || EMPTY_OBJ).rich;
+    if (rich) {
+      richItemNameMap = richItemNameMap || {};
+      var richKeys = keys(rich);
+      for (var i = 0; i < richKeys.length; i++) {
+        var richKey = richKeys[i];
+        richItemNameMap[richKey] = 1;
+      }
+    }
+    textStyleModel = textStyleModel.parentModel;
+  }
+  return richItemNameMap;
+}
+var TEXT_PROPS_WITH_GLOBAL = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'textShadowColor', 'textShadowBlur', 'textShadowOffsetX', 'textShadowOffsetY'];
+var TEXT_PROPS_SELF = ['align', 'lineHeight', 'width', 'height', 'tag', 'verticalAlign', 'ellipsis'];
+var TEXT_PROPS_BOX = ['padding', 'borderWidth', 'borderRadius', 'borderDashOffset', 'backgroundColor', 'borderColor', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY'];
+function setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isNotNormal, isAttached, isBlock, inRich) {
+  // In merge mode, default value should not be given.
+  globalTextStyle = !isNotNormal && globalTextStyle || EMPTY_OBJ;
+  var inheritColor = opt && opt.inheritColor;
+  var fillColor = textStyleModel.getShallow('color');
+  var strokeColor = textStyleModel.getShallow('textBorderColor');
+  var opacity = retrieve2(textStyleModel.getShallow('opacity'), globalTextStyle.opacity);
+  if (fillColor === 'inherit' || fillColor === 'auto') {
+    if (process.env.NODE_ENV !== 'production') {
+      if (fillColor === 'auto') {
+        deprecateReplaceLog('color: \'auto\'', 'color: \'inherit\'');
+      }
+    }
+    if (inheritColor) {
+      fillColor = inheritColor;
+    } else {
+      fillColor = null;
+    }
+  }
+  if (strokeColor === 'inherit' || strokeColor === 'auto') {
+    if (process.env.NODE_ENV !== 'production') {
+      if (strokeColor === 'auto') {
+        deprecateReplaceLog('color: \'auto\'', 'color: \'inherit\'');
+      }
+    }
+    if (inheritColor) {
+      strokeColor = inheritColor;
+    } else {
+      strokeColor = null;
+    }
+  }
+  if (!isAttached) {
+    // Only use default global textStyle.color if text is individual.
+    // Otherwise it will use the strategy of attached text color because text may be on a path.
+    fillColor = fillColor || globalTextStyle.color;
+    strokeColor = strokeColor || globalTextStyle.textBorderColor;
+  }
+  if (fillColor != null) {
+    textStyle.fill = fillColor;
+  }
+  if (strokeColor != null) {
+    textStyle.stroke = strokeColor;
+  }
+  var textBorderWidth = retrieve2(textStyleModel.getShallow('textBorderWidth'), globalTextStyle.textBorderWidth);
+  if (textBorderWidth != null) {
+    textStyle.lineWidth = textBorderWidth;
+  }
+  var textBorderType = retrieve2(textStyleModel.getShallow('textBorderType'), globalTextStyle.textBorderType);
+  if (textBorderType != null) {
+    textStyle.lineDash = textBorderType;
+  }
+  var textBorderDashOffset = retrieve2(textStyleModel.getShallow('textBorderDashOffset'), globalTextStyle.textBorderDashOffset);
+  if (textBorderDashOffset != null) {
+    textStyle.lineDashOffset = textBorderDashOffset;
+  }
+  if (!isNotNormal && opacity == null && !inRich) {
+    opacity = opt && opt.defaultOpacity;
+  }
+  if (opacity != null) {
+    textStyle.opacity = opacity;
+  }
+  // TODO
+  if (!isNotNormal && !isAttached) {
+    // Set default finally.
+    if (textStyle.fill == null && opt.inheritColor) {
+      textStyle.fill = opt.inheritColor;
+    }
+  }
+  // Do not use `getFont` here, because merge should be supported, where
+  // part of these properties may be changed in emphasis style, and the
+  // others should remain their original value got from normal style.
+  for (var i = 0; i < TEXT_PROPS_WITH_GLOBAL.length; i++) {
+    var key = TEXT_PROPS_WITH_GLOBAL[i];
+    var val = retrieve2(textStyleModel.getShallow(key), globalTextStyle[key]);
+    if (val != null) {
+      textStyle[key] = val;
+    }
+  }
+  for (var i = 0; i < TEXT_PROPS_SELF.length; i++) {
+    var key = TEXT_PROPS_SELF[i];
+    var val = textStyleModel.getShallow(key);
+    if (val != null) {
+      textStyle[key] = val;
+    }
+  }
+  if (textStyle.verticalAlign == null) {
+    var baseline = textStyleModel.getShallow('baseline');
+    if (baseline != null) {
+      textStyle.verticalAlign = baseline;
+    }
+  }
+  if (!isBlock || !opt.disableBox) {
+    for (var i = 0; i < TEXT_PROPS_BOX.length; i++) {
+      var key = TEXT_PROPS_BOX[i];
+      var val = textStyleModel.getShallow(key);
+      if (val != null) {
+        textStyle[key] = val;
+      }
+    }
+    var borderType = textStyleModel.getShallow('borderType');
+    if (borderType != null) {
+      textStyle.borderDash = borderType;
+    }
+    if ((textStyle.backgroundColor === 'auto' || textStyle.backgroundColor === 'inherit') && inheritColor) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (textStyle.backgroundColor === 'auto') {
+          deprecateReplaceLog('backgroundColor: \'auto\'', 'backgroundColor: \'inherit\'');
+        }
+      }
+      textStyle.backgroundColor = inheritColor;
+    }
+    if ((textStyle.borderColor === 'auto' || textStyle.borderColor === 'inherit') && inheritColor) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (textStyle.borderColor === 'auto') {
+          deprecateReplaceLog('borderColor: \'auto\'', 'borderColor: \'inherit\'');
+        }
+      }
+      textStyle.borderColor = inheritColor;
+    }
+  }
+}
+function getFont(opt, ecModel) {
+  var gTextStyleModel = ecModel && ecModel.getModel('textStyle');
+  return trim([
+  // FIXME in node-canvas fontWeight is before fontStyle
+  opt.fontStyle || gTextStyleModel && gTextStyleModel.getShallow('fontStyle') || '', opt.fontWeight || gTextStyleModel && gTextStyleModel.getShallow('fontWeight') || '', (opt.fontSize || gTextStyleModel && gTextStyleModel.getShallow('fontSize') || 12) + 'px', opt.fontFamily || gTextStyleModel && gTextStyleModel.getShallow('fontFamily') || 'sans-serif'].join(' '));
+}
+var labelInner = makeInner();
+function setLabelValueAnimation(label, labelStatesModels, value, getDefaultText) {
+  if (!label) {
+    return;
+  }
+  var obj = labelInner(label);
+  obj.prevValue = obj.value;
+  obj.value = value;
+  var normalLabelModel = labelStatesModels.normal;
+  obj.valueAnimation = normalLabelModel.get('valueAnimation');
+  if (obj.valueAnimation) {
+    obj.precision = normalLabelModel.get('precision');
+    obj.defaultInterpolatedText = getDefaultText;
+    obj.statesModels = labelStatesModels;
+  }
+}
+function animateLabelValue(textEl, dataIndex, data, animatableModel, labelFetcher) {
+  var labelInnerStore = labelInner(textEl);
+  if (!labelInnerStore.valueAnimation || labelInnerStore.prevValue === labelInnerStore.value) {
+    // Value not changed, no new label animation
+    return;
+  }
+  var defaultInterpolatedText = labelInnerStore.defaultInterpolatedText;
+  // Consider the case that being animating, do not use the `obj.value`,
+  // Otherwise it will jump to the `obj.value` when this new animation started.
+  var currValue = retrieve2(labelInnerStore.interpolatedValue, labelInnerStore.prevValue);
+  var targetValue = labelInnerStore.value;
+  function during(percent) {
+    var interpolated = interpolateRawValues(data, labelInnerStore.precision, currValue, targetValue, percent);
+    labelInnerStore.interpolatedValue = percent === 1 ? null : interpolated;
+    var labelText = getLabelText({
+      labelDataIndex: dataIndex,
+      labelFetcher: labelFetcher,
+      defaultText: defaultInterpolatedText ? defaultInterpolatedText(interpolated) : interpolated + ''
+    }, labelInnerStore.statesModels, interpolated);
+    setLabelText(textEl, labelText);
+  }
+  textEl.percent = 0;
+  (labelInnerStore.prevValue == null ? initProps : updateProps)(textEl, {
+    // percent is used to prevent animation from being aborted #15916
+    percent: 1
+  }, animatableModel, dataIndex, null, during);
+}
+
+export { animateLabelValue, createTextConfig, createTextStyle, getFont, getLabelStatesModels, labelInner, setLabelStyle, setLabelText, setLabelValueAnimation };