office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/util/states.js

@@ -0,0 +1,697 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../zrender/lib/core/util.js');
+var innerStore = require('./innerStore.js');
+var color = require('../../../zrender/lib/tool/color.js');
+var model = require('./model.js');
+var Path = require('../../../zrender/lib/graphic/Path.js');
+var log = require('./log.js');
+
+// Reserve 0 as default.
+var _highlightNextDigit = 1;
+var _highlightKeyMap = {};
+var getSavedStates = model.makeInner();
+var getComponentStates = model.makeInner();
+var HOVER_STATE_NORMAL = 0;
+var HOVER_STATE_BLUR = 1;
+var HOVER_STATE_EMPHASIS = 2;
+var SPECIAL_STATES = ['emphasis', 'blur', 'select'];
+var DISPLAY_STATES = ['normal', 'emphasis', 'blur', 'select'];
+var Z2_EMPHASIS_LIFT = 10;
+var Z2_SELECT_LIFT = 9;
+var HIGHLIGHT_ACTION_TYPE = 'highlight';
+var DOWNPLAY_ACTION_TYPE = 'downplay';
+var SELECT_ACTION_TYPE = 'select';
+var UNSELECT_ACTION_TYPE = 'unselect';
+var TOGGLE_SELECT_ACTION_TYPE = 'toggleSelect';
+function hasFillOrStroke(fillOrStroke) {
+  return fillOrStroke != null && fillOrStroke !== 'none';
+}
+function doChangeHoverState(el, stateName, hoverStateEnum) {
+  if (el.onHoverStateChange && (el.hoverState || 0) !== hoverStateEnum) {
+    el.onHoverStateChange(stateName);
+  }
+  el.hoverState = hoverStateEnum;
+}
+function singleEnterEmphasis(el) {
+  // Only mark the flag.
+  // States will be applied in the echarts.ts in next frame.
+  doChangeHoverState(el, 'emphasis', HOVER_STATE_EMPHASIS);
+}
+function singleLeaveEmphasis(el) {
+  // Only mark the flag.
+  // States will be applied in the echarts.ts in next frame.
+  if (el.hoverState === HOVER_STATE_EMPHASIS) {
+    doChangeHoverState(el, 'normal', HOVER_STATE_NORMAL);
+  }
+}
+function singleEnterBlur(el) {
+  doChangeHoverState(el, 'blur', HOVER_STATE_BLUR);
+}
+function singleLeaveBlur(el) {
+  if (el.hoverState === HOVER_STATE_BLUR) {
+    doChangeHoverState(el, 'normal', HOVER_STATE_NORMAL);
+  }
+}
+function singleEnterSelect(el) {
+  el.selected = true;
+}
+function singleLeaveSelect(el) {
+  el.selected = false;
+}
+function updateElementState(el, updater, commonParam) {
+  updater(el, commonParam);
+}
+function traverseUpdateState(el, updater, commonParam) {
+  updateElementState(el, updater, commonParam);
+  el.isGroup && el.traverse(function (child) {
+    updateElementState(child, updater, commonParam);
+  });
+}
+function setStatesFlag(el, stateName) {
+  switch (stateName) {
+    case 'emphasis':
+      el.hoverState = HOVER_STATE_EMPHASIS;
+      break;
+    case 'normal':
+      el.hoverState = HOVER_STATE_NORMAL;
+      break;
+    case 'blur':
+      el.hoverState = HOVER_STATE_BLUR;
+      break;
+    case 'select':
+      el.selected = true;
+  }
+}
+function getFromStateStyle(el, props, toStateName, defaultValue) {
+  var style = el.style;
+  var fromState = {};
+  for (var i = 0; i < props.length; i++) {
+    var propName = props[i];
+    var val = style[propName];
+    fromState[propName] = val == null ? defaultValue && defaultValue[propName] : val;
+  }
+  for (var i = 0; i < el.animators.length; i++) {
+    var animator = el.animators[i];
+    if (animator.__fromStateTransition
+    // Don't consider the animation to emphasis state.
+    && animator.__fromStateTransition.indexOf(toStateName) < 0 && animator.targetName === 'style') {
+      animator.saveTo(fromState, props);
+    }
+  }
+  return fromState;
+}
+function createEmphasisDefaultState(el, stateName, targetStates, state) {
+  var hasSelect = targetStates && util.indexOf(targetStates, 'select') >= 0;
+  var cloned = false;
+  if (el instanceof Path["default"]) {
+    var store = getSavedStates(el);
+    var fromFill = hasSelect ? store.selectFill || store.normalFill : store.normalFill;
+    var fromStroke = hasSelect ? store.selectStroke || store.normalStroke : store.normalStroke;
+    if (hasFillOrStroke(fromFill) || hasFillOrStroke(fromStroke)) {
+      state = state || {};
+      var emphasisStyle = state.style || {};
+      // inherit case
+      if (emphasisStyle.fill === 'inherit') {
+        cloned = true;
+        state = util.extend({}, state);
+        emphasisStyle = util.extend({}, emphasisStyle);
+        emphasisStyle.fill = fromFill;
+      }
+      // Apply default color lift
+      else if (!hasFillOrStroke(emphasisStyle.fill) && hasFillOrStroke(fromFill)) {
+        cloned = true;
+        // Not modify the original value.
+        state = util.extend({}, state);
+        emphasisStyle = util.extend({}, emphasisStyle);
+        // Already being applied 'emphasis'. DON'T lift color multiple times.
+        emphasisStyle.fill = color.liftColor(fromFill);
+      }
+      // Not highlight stroke if fill has been highlighted.
+      else if (!hasFillOrStroke(emphasisStyle.stroke) && hasFillOrStroke(fromStroke)) {
+        if (!cloned) {
+          state = util.extend({}, state);
+          emphasisStyle = util.extend({}, emphasisStyle);
+        }
+        emphasisStyle.stroke = color.liftColor(fromStroke);
+      }
+      state.style = emphasisStyle;
+    }
+  }
+  if (state) {
+    // TODO Share with textContent?
+    if (state.z2 == null) {
+      if (!cloned) {
+        state = util.extend({}, state);
+      }
+      var z2EmphasisLift = el.z2EmphasisLift;
+      state.z2 = el.z2 + (z2EmphasisLift != null ? z2EmphasisLift : Z2_EMPHASIS_LIFT);
+    }
+  }
+  return state;
+}
+function createSelectDefaultState(el, stateName, state) {
+  // const hasSelect = indexOf(el.currentStates, stateName) >= 0;
+  if (state) {
+    // TODO Share with textContent?
+    if (state.z2 == null) {
+      state = util.extend({}, state);
+      var z2SelectLift = el.z2SelectLift;
+      state.z2 = el.z2 + (z2SelectLift != null ? z2SelectLift : Z2_SELECT_LIFT);
+    }
+  }
+  return state;
+}
+function createBlurDefaultState(el, stateName, state) {
+  var hasBlur = util.indexOf(el.currentStates, stateName) >= 0;
+  var currentOpacity = el.style.opacity;
+  var fromState = !hasBlur ? getFromStateStyle(el, ['opacity'], stateName, {
+    opacity: 1
+  }) : null;
+  state = state || {};
+  var blurStyle = state.style || {};
+  if (blurStyle.opacity == null) {
+    // clone state
+    state = util.extend({}, state);
+    blurStyle = util.extend({
+      // Already being applied 'emphasis'. DON'T mul opacity multiple times.
+      opacity: hasBlur ? currentOpacity : fromState.opacity * 0.1
+    }, blurStyle);
+    state.style = blurStyle;
+  }
+  return state;
+}
+function elementStateProxy(stateName, targetStates) {
+  var state = this.states[stateName];
+  if (this.style) {
+    if (stateName === 'emphasis') {
+      return createEmphasisDefaultState(this, stateName, targetStates, state);
+    } else if (stateName === 'blur') {
+      return createBlurDefaultState(this, stateName, state);
+    } else if (stateName === 'select') {
+      return createSelectDefaultState(this, stateName, state);
+    }
+  }
+  return state;
+}
+/**
+ * Set hover style (namely "emphasis style") of element.
+ * @param el Should not be `zrender/graphic/Group`.
+ * @param focus 'self' | 'selfInSeries' | 'series'
+ */
+function setDefaultStateProxy(el) {
+  el.stateProxy = elementStateProxy;
+  var textContent = el.getTextContent();
+  var textGuide = el.getTextGuideLine();
+  if (textContent) {
+    textContent.stateProxy = elementStateProxy;
+  }
+  if (textGuide) {
+    textGuide.stateProxy = elementStateProxy;
+  }
+}
+function enterEmphasisWhenMouseOver(el, e) {
+  !shouldSilent(el, e)
+  // "emphasis" event highlight has higher priority than mouse highlight.
+  && !el.__highByOuter && traverseUpdateState(el, singleEnterEmphasis);
+}
+function leaveEmphasisWhenMouseOut(el, e) {
+  !shouldSilent(el, e)
+  // "emphasis" event highlight has higher priority than mouse highlight.
+  && !el.__highByOuter && traverseUpdateState(el, singleLeaveEmphasis);
+}
+function enterEmphasis(el, highlightDigit) {
+  el.__highByOuter |= 1 << (highlightDigit || 0);
+  traverseUpdateState(el, singleEnterEmphasis);
+}
+function leaveEmphasis(el, highlightDigit) {
+  !(el.__highByOuter &= ~(1 << (highlightDigit || 0))) && traverseUpdateState(el, singleLeaveEmphasis);
+}
+function enterBlur(el) {
+  traverseUpdateState(el, singleEnterBlur);
+}
+function leaveBlur(el) {
+  traverseUpdateState(el, singleLeaveBlur);
+}
+function enterSelect(el) {
+  traverseUpdateState(el, singleEnterSelect);
+}
+function leaveSelect(el) {
+  traverseUpdateState(el, singleLeaveSelect);
+}
+function shouldSilent(el, e) {
+  return el.__highDownSilentOnTouch && e.zrByTouch;
+}
+function allLeaveBlur(api) {
+  var model = api.getModel();
+  var leaveBlurredSeries = [];
+  var allComponentViews = [];
+  model.eachComponent(function (componentType, componentModel) {
+    var componentStates = getComponentStates(componentModel);
+    var isSeries = componentType === 'series';
+    var view = isSeries ? api.getViewOfSeriesModel(componentModel) : api.getViewOfComponentModel(componentModel);
+    !isSeries && allComponentViews.push(view);
+    if (componentStates.isBlured) {
+      // Leave blur anyway
+      view.group.traverse(function (child) {
+        singleLeaveBlur(child);
+      });
+      isSeries && leaveBlurredSeries.push(componentModel);
+    }
+    componentStates.isBlured = false;
+  });
+  util.each(allComponentViews, function (view) {
+    if (view && view.toggleBlurSeries) {
+      view.toggleBlurSeries(leaveBlurredSeries, false, model);
+    }
+  });
+}
+function blurSeries(targetSeriesIndex, focus, blurScope, api) {
+  var ecModel = api.getModel();
+  blurScope = blurScope || 'coordinateSystem';
+  function leaveBlurOfIndices(data, dataIndices) {
+    for (var i = 0; i < dataIndices.length; i++) {
+      var itemEl = data.getItemGraphicEl(dataIndices[i]);
+      itemEl && leaveBlur(itemEl);
+    }
+  }
+  if (targetSeriesIndex == null) {
+    return;
+  }
+  if (!focus || focus === 'none') {
+    return;
+  }
+  var targetSeriesModel = ecModel.getSeriesByIndex(targetSeriesIndex);
+  var targetCoordSys = targetSeriesModel.coordinateSystem;
+  if (targetCoordSys && targetCoordSys.master) {
+    targetCoordSys = targetCoordSys.master;
+  }
+  var blurredSeries = [];
+  ecModel.eachSeries(function (seriesModel) {
+    var sameSeries = targetSeriesModel === seriesModel;
+    var coordSys = seriesModel.coordinateSystem;
+    if (coordSys && coordSys.master) {
+      coordSys = coordSys.master;
+    }
+    var sameCoordSys = coordSys && targetCoordSys ? coordSys === targetCoordSys : sameSeries; // If there is no coordinate system. use sameSeries instead.
+    if (!(
+    // Not blur other series if blurScope series
+    blurScope === 'series' && !sameSeries
+    // Not blur other coordinate system if blurScope is coordinateSystem
+    || blurScope === 'coordinateSystem' && !sameCoordSys
+    // Not blur self series if focus is series.
+    || focus === 'series' && sameSeries
+    // TODO blurScope: coordinate system
+    )) {
+      var view = api.getViewOfSeriesModel(seriesModel);
+      view.group.traverse(function (child) {
+        // For the elements that have been triggered by other components,
+        // and are still required to be highlighted,
+        // because the current is directly forced to blur the element,
+        // it will cause the focus self to be unable to highlight, so skip the blur of this element.
+        if (child.__highByOuter && sameSeries && focus === 'self') {
+          return;
+        }
+        singleEnterBlur(child);
+      });
+      if (util.isArrayLike(focus)) {
+        leaveBlurOfIndices(seriesModel.getData(), focus);
+      } else if (util.isObject(focus)) {
+        var dataTypes = util.keys(focus);
+        for (var d = 0; d < dataTypes.length; d++) {
+          leaveBlurOfIndices(seriesModel.getData(dataTypes[d]), focus[dataTypes[d]]);
+        }
+      }
+      blurredSeries.push(seriesModel);
+      getComponentStates(seriesModel).isBlured = true;
+    }
+  });
+  ecModel.eachComponent(function (componentType, componentModel) {
+    if (componentType === 'series') {
+      return;
+    }
+    var view = api.getViewOfComponentModel(componentModel);
+    if (view && view.toggleBlurSeries) {
+      view.toggleBlurSeries(blurredSeries, true, ecModel);
+    }
+  });
+}
+function blurComponent(componentMainType, componentIndex, api) {
+  if (componentMainType == null || componentIndex == null) {
+    return;
+  }
+  var componentModel = api.getModel().getComponent(componentMainType, componentIndex);
+  if (!componentModel) {
+    return;
+  }
+  getComponentStates(componentModel).isBlured = true;
+  var view = api.getViewOfComponentModel(componentModel);
+  if (!view || !view.focusBlurEnabled) {
+    return;
+  }
+  view.group.traverse(function (child) {
+    singleEnterBlur(child);
+  });
+}
+function blurSeriesFromHighlightPayload(seriesModel, payload, api) {
+  var seriesIndex = seriesModel.seriesIndex;
+  var data = seriesModel.getData(payload.dataType);
+  if (!data) {
+    if (process.env.NODE_ENV !== 'production') {
+      log.error("Unknown dataType " + payload.dataType);
+    }
+    return;
+  }
+  var dataIndex = model.queryDataIndex(data, payload);
+  // Pick the first one if there is multiple/none exists.
+  dataIndex = (util.isArray(dataIndex) ? dataIndex[0] : dataIndex) || 0;
+  var el = data.getItemGraphicEl(dataIndex);
+  if (!el) {
+    var count = data.count();
+    var current = 0;
+    // If data on dataIndex is NaN.
+    while (!el && current < count) {
+      el = data.getItemGraphicEl(current++);
+    }
+  }
+  if (el) {
+    var ecData = innerStore.getECData(el);
+    blurSeries(seriesIndex, ecData.focus, ecData.blurScope, api);
+  } else {
+    // If there is no element put on the data. Try getting it from raw option
+    // TODO Should put it on seriesModel?
+    var focus_1 = seriesModel.get(['emphasis', 'focus']);
+    var blurScope = seriesModel.get(['emphasis', 'blurScope']);
+    if (focus_1 != null) {
+      blurSeries(seriesIndex, focus_1, blurScope, api);
+    }
+  }
+}
+function findComponentHighDownDispatchers(componentMainType, componentIndex, name, api) {
+  var ret = {
+    focusSelf: false,
+    dispatchers: null
+  };
+  if (componentMainType == null || componentMainType === 'series' || componentIndex == null || name == null) {
+    return ret;
+  }
+  var componentModel = api.getModel().getComponent(componentMainType, componentIndex);
+  if (!componentModel) {
+    return ret;
+  }
+  var view = api.getViewOfComponentModel(componentModel);
+  if (!view || !view.findHighDownDispatchers) {
+    return ret;
+  }
+  var dispatchers = view.findHighDownDispatchers(name);
+  // At presnet, the component (like Geo) only blur inside itself.
+  // So we do not use `blurScope` in component.
+  var focusSelf;
+  for (var i = 0; i < dispatchers.length; i++) {
+    if (process.env.NODE_ENV !== 'production' && !isHighDownDispatcher(dispatchers[i])) {
+      log.error('param should be highDownDispatcher');
+    }
+    if (innerStore.getECData(dispatchers[i]).focus === 'self') {
+      focusSelf = true;
+      break;
+    }
+  }
+  return {
+    focusSelf: focusSelf,
+    dispatchers: dispatchers
+  };
+}
+function handleGlobalMouseOverForHighDown(dispatcher, e, api) {
+  if (process.env.NODE_ENV !== 'production' && !isHighDownDispatcher(dispatcher)) {
+    log.error('param should be highDownDispatcher');
+  }
+  var ecData = innerStore.getECData(dispatcher);
+  var _a = findComponentHighDownDispatchers(ecData.componentMainType, ecData.componentIndex, ecData.componentHighDownName, api),
+    dispatchers = _a.dispatchers,
+    focusSelf = _a.focusSelf;
+  // If `findHighDownDispatchers` is supported on the component,
+  // highlight/downplay elements with the same name.
+  if (dispatchers) {
+    if (focusSelf) {
+      blurComponent(ecData.componentMainType, ecData.componentIndex, api);
+    }
+    util.each(dispatchers, function (dispatcher) {
+      return enterEmphasisWhenMouseOver(dispatcher, e);
+    });
+  } else {
+    // Try blur all in the related series. Then emphasis the hoverred.
+    // TODO. progressive mode.
+    blurSeries(ecData.seriesIndex, ecData.focus, ecData.blurScope, api);
+    if (ecData.focus === 'self') {
+      blurComponent(ecData.componentMainType, ecData.componentIndex, api);
+    }
+    // Other than series, component that not support `findHighDownDispatcher` will
+    // also use it. But in this case, highlight/downplay are only supported in
+    // mouse hover but not in dispatchAction.
+    enterEmphasisWhenMouseOver(dispatcher, e);
+  }
+}
+function handleGlobalMouseOutForHighDown(dispatcher, e, api) {
+  if (process.env.NODE_ENV !== 'production' && !isHighDownDispatcher(dispatcher)) {
+    log.error('param should be highDownDispatcher');
+  }
+  allLeaveBlur(api);
+  var ecData = innerStore.getECData(dispatcher);
+  var dispatchers = findComponentHighDownDispatchers(ecData.componentMainType, ecData.componentIndex, ecData.componentHighDownName, api).dispatchers;
+  if (dispatchers) {
+    util.each(dispatchers, function (dispatcher) {
+      return leaveEmphasisWhenMouseOut(dispatcher, e);
+    });
+  } else {
+    leaveEmphasisWhenMouseOut(dispatcher, e);
+  }
+}
+function toggleSelectionFromPayload(seriesModel, payload, api) {
+  if (!isSelectChangePayload(payload)) {
+    return;
+  }
+  var dataType = payload.dataType;
+  var data = seriesModel.getData(dataType);
+  var dataIndex = model.queryDataIndex(data, payload);
+  if (!util.isArray(dataIndex)) {
+    dataIndex = [dataIndex];
+  }
+  seriesModel[payload.type === TOGGLE_SELECT_ACTION_TYPE ? 'toggleSelect' : payload.type === SELECT_ACTION_TYPE ? 'select' : 'unselect'](dataIndex, dataType);
+}
+function updateSeriesElementSelection(seriesModel) {
+  var allData = seriesModel.getAllData();
+  util.each(allData, function (_a) {
+    var data = _a.data,
+      type = _a.type;
+    data.eachItemGraphicEl(function (el, idx) {
+      seriesModel.isSelected(idx, type) ? enterSelect(el) : leaveSelect(el);
+    });
+  });
+}
+function getAllSelectedIndices(ecModel) {
+  var ret = [];
+  ecModel.eachSeries(function (seriesModel) {
+    var allData = seriesModel.getAllData();
+    util.each(allData, function (_a) {
+      _a.data;
+        var type = _a.type;
+      var dataIndices = seriesModel.getSelectedDataIndices();
+      if (dataIndices.length > 0) {
+        var item = {
+          dataIndex: dataIndices,
+          seriesIndex: seriesModel.seriesIndex
+        };
+        if (type != null) {
+          item.dataType = type;
+        }
+        ret.push(item);
+      }
+    });
+  });
+  return ret;
+}
+/**
+ * Enable the function that mouseover will trigger the emphasis state.
+ *
+ * NOTE:
+ * This function should be used on the element with dataIndex, seriesIndex.
+ *
+ */
+function enableHoverEmphasis(el, focus, blurScope) {
+  setAsHighDownDispatcher(el, true);
+  traverseUpdateState(el, setDefaultStateProxy);
+  enableHoverFocus(el, focus, blurScope);
+}
+function disableHoverEmphasis(el) {
+  setAsHighDownDispatcher(el, false);
+}
+function toggleHoverEmphasis(el, focus, blurScope, isDisabled) {
+  isDisabled ? disableHoverEmphasis(el) : enableHoverEmphasis(el, focus, blurScope);
+}
+function enableHoverFocus(el, focus, blurScope) {
+  var ecData = innerStore.getECData(el);
+  if (focus != null) {
+    // TODO dataIndex may be set after this function. This check is not useful.
+    // if (ecData.dataIndex == null) {
+    //     if (__DEV__) {
+    //         console.warn('focus can only been set on element with dataIndex');
+    //     }
+    // }
+    // else {
+    ecData.focus = focus;
+    ecData.blurScope = blurScope;
+    // }
+  } else if (ecData.focus) {
+    ecData.focus = null;
+  }
+}
+var OTHER_STATES = ['emphasis', 'blur', 'select'];
+var defaultStyleGetterMap = {
+  itemStyle: 'getItemStyle',
+  lineStyle: 'getLineStyle',
+  areaStyle: 'getAreaStyle'
+};
+/**
+ * Set emphasis/blur/selected states of element.
+ */
+function setStatesStylesFromModel(el, itemModel, styleType,
+// default itemStyle
+getter) {
+  styleType = styleType || 'itemStyle';
+  for (var i = 0; i < OTHER_STATES.length; i++) {
+    var stateName = OTHER_STATES[i];
+    var model = itemModel.getModel([stateName, styleType]);
+    var state = el.ensureState(stateName);
+    // Let it throw error if getterType is not found.
+    state.style = getter ? getter(model) : model[defaultStyleGetterMap[styleType]]();
+  }
+}
+/**
+ *
+ * Set element as highlight / downplay dispatcher.
+ * It will be checked when element received mouseover event or from highlight action.
+ * It's in change of all highlight/downplay behavior of it's children.
+ *
+ * @param el
+ * @param el.highDownSilentOnTouch
+ *        In touch device, mouseover event will be trigger on touchstart event
+ *        (see module:zrender/dom/HandlerProxy). By this mechanism, we can
+ *        conveniently use hoverStyle when tap on touch screen without additional
+ *        code for compatibility.
+ *        But if the chart/component has select feature, which usually also use
+ *        hoverStyle, there might be conflict between 'select-highlight' and
+ *        'hover-highlight' especially when roam is enabled (see geo for example).
+ *        In this case, `highDownSilentOnTouch` should be used to disable
+ *        hover-highlight on touch device.
+ * @param asDispatcher If `false`, do not set as "highDownDispatcher".
+ */
+function setAsHighDownDispatcher(el, asDispatcher) {
+  var disable = asDispatcher === false;
+  var extendedEl = el;
+  // Make `highDownSilentOnTouch` and `onStateChange` only work after
+  // `setAsHighDownDispatcher` called. Avoid it is modified by user unexpectedly.
+  if (el.highDownSilentOnTouch) {
+    extendedEl.__highDownSilentOnTouch = el.highDownSilentOnTouch;
+  }
+  // Simple optimize, since this method might be
+  // called for each elements of a group in some cases.
+  if (!disable || extendedEl.__highDownDispatcher) {
+    // Emphasis, normal can be triggered manually by API or other components like hover link.
+    // el[method]('emphasis', onElementEmphasisEvent)[method]('normal', onElementNormalEvent);
+    // Also keep previous record.
+    extendedEl.__highByOuter = extendedEl.__highByOuter || 0;
+    extendedEl.__highDownDispatcher = !disable;
+  }
+}
+function isHighDownDispatcher(el) {
+  return !!(el && el.__highDownDispatcher);
+}
+/**
+ * Enable component highlight/downplay features:
+ * + hover link (within the same name)
+ * + focus blur in component
+ */
+function enableComponentHighDownFeatures(el, componentModel, componentHighDownName) {
+  var ecData = innerStore.getECData(el);
+  ecData.componentMainType = componentModel.mainType;
+  ecData.componentIndex = componentModel.componentIndex;
+  ecData.componentHighDownName = componentHighDownName;
+}
+/**
+ * Support highlight/downplay record on each elements.
+ * For the case: hover highlight/downplay (legend, visualMap, ...) and
+ * user triggered highlight/downplay should not conflict.
+ * Only all of the highlightDigit cleared, return to normal.
+ * @param {string} highlightKey
+ * @return {number} highlightDigit
+ */
+function getHighlightDigit(highlightKey) {
+  var highlightDigit = _highlightKeyMap[highlightKey];
+  if (highlightDigit == null && _highlightNextDigit <= 32) {
+    highlightDigit = _highlightKeyMap[highlightKey] = _highlightNextDigit++;
+  }
+  return highlightDigit;
+}
+function isSelectChangePayload(payload) {
+  var payloadType = payload.type;
+  return payloadType === SELECT_ACTION_TYPE || payloadType === UNSELECT_ACTION_TYPE || payloadType === TOGGLE_SELECT_ACTION_TYPE;
+}
+function isHighDownPayload(payload) {
+  var payloadType = payload.type;
+  return payloadType === HIGHLIGHT_ACTION_TYPE || payloadType === DOWNPLAY_ACTION_TYPE;
+}
+function savePathStates(el) {
+  var store = getSavedStates(el);
+  store.normalFill = el.style.fill;
+  store.normalStroke = el.style.stroke;
+  var selectState = el.states.select || {};
+  store.selectFill = selectState.style && selectState.style.fill || null;
+  store.selectStroke = selectState.style && selectState.style.stroke || null;
+}
+
+exports.DISPLAY_STATES = DISPLAY_STATES;
+exports.DOWNPLAY_ACTION_TYPE = DOWNPLAY_ACTION_TYPE;
+exports.HIGHLIGHT_ACTION_TYPE = HIGHLIGHT_ACTION_TYPE;
+exports.HOVER_STATE_BLUR = HOVER_STATE_BLUR;
+exports.HOVER_STATE_EMPHASIS = HOVER_STATE_EMPHASIS;
+exports.HOVER_STATE_NORMAL = HOVER_STATE_NORMAL;
+exports.SELECT_ACTION_TYPE = SELECT_ACTION_TYPE;
+exports.SPECIAL_STATES = SPECIAL_STATES;
+exports.TOGGLE_SELECT_ACTION_TYPE = TOGGLE_SELECT_ACTION_TYPE;
+exports.UNSELECT_ACTION_TYPE = UNSELECT_ACTION_TYPE;
+exports.Z2_EMPHASIS_LIFT = Z2_EMPHASIS_LIFT;
+exports.Z2_SELECT_LIFT = Z2_SELECT_LIFT;
+exports.allLeaveBlur = allLeaveBlur;
+exports.blurComponent = blurComponent;
+exports.blurSeries = blurSeries;
+exports.blurSeriesFromHighlightPayload = blurSeriesFromHighlightPayload;
+exports.disableHoverEmphasis = disableHoverEmphasis;
+exports.enableComponentHighDownFeatures = enableComponentHighDownFeatures;
+exports.enableHoverEmphasis = enableHoverEmphasis;
+exports.enableHoverFocus = enableHoverFocus;
+exports.enterBlur = enterBlur;
+exports.enterEmphasis = enterEmphasis;
+exports.enterEmphasisWhenMouseOver = enterEmphasisWhenMouseOver;
+exports.enterSelect = enterSelect;
+exports.findComponentHighDownDispatchers = findComponentHighDownDispatchers;
+exports.getAllSelectedIndices = getAllSelectedIndices;
+exports.getHighlightDigit = getHighlightDigit;
+exports.handleGlobalMouseOutForHighDown = handleGlobalMouseOutForHighDown;
+exports.handleGlobalMouseOverForHighDown = handleGlobalMouseOverForHighDown;
+exports.isHighDownDispatcher = isHighDownDispatcher;
+exports.isHighDownPayload = isHighDownPayload;
+exports.isSelectChangePayload = isSelectChangePayload;
+exports.leaveBlur = leaveBlur;
+exports.leaveEmphasis = leaveEmphasis;
+exports.leaveEmphasisWhenMouseOut = leaveEmphasisWhenMouseOut;
+exports.leaveSelect = leaveSelect;
+exports.savePathStates = savePathStates;
+exports.setAsHighDownDispatcher = setAsHighDownDispatcher;
+exports.setDefaultStateProxy = setDefaultStateProxy;
+exports.setStatesFlag = setStatesFlag;
+exports.setStatesStylesFromModel = setStatesStylesFromModel;
+exports.toggleHoverEmphasis = toggleHoverEmphasis;
+exports.toggleSelectionFromPayload = toggleSelectionFromPayload;
+exports.updateSeriesElementSelection = updateSeriesElementSelection;