office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/animation/basicTransition.js

@@ -0,0 +1,214 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../zrender/lib/core/util.js');
+var model = require('../util/model.js');
+
+// Stored properties for further transition.
+var transitionStore = model.makeInner();
+/**
+ * Return null if animation is disabled.
+ */
+function getAnimationConfig(animationType, animatableModel, dataIndex,
+// Extra opts can override the option in animatable model.
+extraOpts,
+// TODO It's only for pictorial bar now.
+extraDelayParams) {
+  var animationPayload;
+  // Check if there is global animation configuration from dataZoom/resize can override the config in option.
+  // If animation is enabled. Will use this animation config in payload.
+  // If animation is disabled. Just ignore it.
+  if (animatableModel && animatableModel.ecModel) {
+    var updatePayload = animatableModel.ecModel.getUpdatePayload();
+    animationPayload = updatePayload && updatePayload.animation;
+  }
+  var animationEnabled = animatableModel && animatableModel.isAnimationEnabled();
+  var isUpdate = animationType === 'update';
+  if (animationEnabled) {
+    var duration = void 0;
+    var easing = void 0;
+    var delay = void 0;
+    if (extraOpts) {
+      duration = util.retrieve2(extraOpts.duration, 200);
+      easing = util.retrieve2(extraOpts.easing, 'cubicOut');
+      delay = 0;
+    } else {
+      duration = animatableModel.getShallow(isUpdate ? 'animationDurationUpdate' : 'animationDuration');
+      easing = animatableModel.getShallow(isUpdate ? 'animationEasingUpdate' : 'animationEasing');
+      delay = animatableModel.getShallow(isUpdate ? 'animationDelayUpdate' : 'animationDelay');
+    }
+    // animation from payload has highest priority.
+    if (animationPayload) {
+      animationPayload.duration != null && (duration = animationPayload.duration);
+      animationPayload.easing != null && (easing = animationPayload.easing);
+      animationPayload.delay != null && (delay = animationPayload.delay);
+    }
+    if (util.isFunction(delay)) {
+      delay = delay(dataIndex, extraDelayParams);
+    }
+    if (util.isFunction(duration)) {
+      duration = duration(dataIndex);
+    }
+    var config = {
+      duration: duration || 0,
+      delay: delay,
+      easing: easing
+    };
+    return config;
+  } else {
+    return null;
+  }
+}
+function animateOrSetProps(animationType, el, props, animatableModel, dataIndex, cb, during) {
+  var isFrom = false;
+  var removeOpt;
+  if (util.isFunction(dataIndex)) {
+    during = cb;
+    cb = dataIndex;
+    dataIndex = null;
+  } else if (util.isObject(dataIndex)) {
+    cb = dataIndex.cb;
+    during = dataIndex.during;
+    isFrom = dataIndex.isFrom;
+    removeOpt = dataIndex.removeOpt;
+    dataIndex = dataIndex.dataIndex;
+  }
+  var isRemove = animationType === 'leave';
+  if (!isRemove) {
+    // Must stop the remove animation.
+    el.stopAnimation('leave');
+  }
+  var animationConfig = getAnimationConfig(animationType, animatableModel, dataIndex, isRemove ? removeOpt || {} : null, animatableModel && animatableModel.getAnimationDelayParams ? animatableModel.getAnimationDelayParams(el, dataIndex) : null);
+  if (animationConfig && animationConfig.duration > 0) {
+    var duration = animationConfig.duration;
+    var animationDelay = animationConfig.delay;
+    var animationEasing = animationConfig.easing;
+    var animateConfig = {
+      duration: duration,
+      delay: animationDelay || 0,
+      easing: animationEasing,
+      done: cb,
+      force: !!cb || !!during,
+      // Set to final state in update/init animation.
+      // So the post processing based on the path shape can be done correctly.
+      setToFinal: !isRemove,
+      scope: animationType,
+      during: during
+    };
+    isFrom ? el.animateFrom(props, animateConfig) : el.animateTo(props, animateConfig);
+  } else {
+    el.stopAnimation();
+    // If `isFrom`, the props is the "from" props.
+    !isFrom && el.attr(props);
+    // Call during at least once.
+    during && during(1);
+    cb && cb();
+  }
+}
+/**
+ * Update graphic element properties with or without animation according to the
+ * configuration in series.
+ *
+ * Caution: this method will stop previous animation.
+ * So do not use this method to one element twice before
+ * animation starts, unless you know what you are doing.
+ * @example
+ *     graphic.updateProps(el, {
+ *         position: [100, 100]
+ *     }, seriesModel, dataIndex, function () { console.log('Animation done!'); });
+ *     // Or
+ *     graphic.updateProps(el, {
+ *         position: [100, 100]
+ *     }, seriesModel, function () { console.log('Animation done!'); });
+ */
+function updateProps(el, props,
+// TODO: TYPE AnimatableModel
+animatableModel, dataIndex, cb, during) {
+  animateOrSetProps('update', el, props, animatableModel, dataIndex, cb, during);
+}
+/**
+ * Init graphic element properties with or without animation according to the
+ * configuration in series.
+ *
+ * Caution: this method will stop previous animation.
+ * So do not use this method to one element twice before
+ * animation starts, unless you know what you are doing.
+ */
+function initProps(el, props, animatableModel, dataIndex, cb, during) {
+  animateOrSetProps('enter', el, props, animatableModel, dataIndex, cb, during);
+}
+/**
+ * If element is removed.
+ * It can determine if element is having remove animation.
+ */
+function isElementRemoved(el) {
+  if (!el.__zr) {
+    return true;
+  }
+  for (var i = 0; i < el.animators.length; i++) {
+    var animator = el.animators[i];
+    if (animator.scope === 'leave') {
+      return true;
+    }
+  }
+  return false;
+}
+/**
+ * Remove graphic element
+ */
+function removeElement(el, props, animatableModel, dataIndex, cb, during) {
+  // Don't do remove animation twice.
+  if (isElementRemoved(el)) {
+    return;
+  }
+  animateOrSetProps('leave', el, props, animatableModel, dataIndex, cb, during);
+}
+function fadeOutDisplayable(el, animatableModel, dataIndex, done) {
+  el.removeTextContent();
+  el.removeTextGuideLine();
+  removeElement(el, {
+    style: {
+      opacity: 0
+    }
+  }, animatableModel, dataIndex, done);
+}
+function removeElementWithFadeOut(el, animatableModel, dataIndex) {
+  function doRemove() {
+    el.parent && el.parent.remove(el);
+  }
+  // Hide label and labelLine first
+  // TODO Also use fade out animation?
+  if (!el.isGroup) {
+    fadeOutDisplayable(el, animatableModel, dataIndex, doRemove);
+  } else {
+    el.traverse(function (disp) {
+      if (!disp.isGroup) {
+        // Can invoke doRemove multiple times.
+        fadeOutDisplayable(disp, animatableModel, dataIndex, doRemove);
+      }
+    });
+  }
+}
+/**
+ * Save old style for style transition in universalTransition module.
+ * It's used when element will be reused in each render.
+ * For chart like map, heatmap, which will always create new element.
+ * We don't need to save this because universalTransition can get old style from the old element
+ */
+function saveOldStyle(el) {
+  transitionStore(el).oldStyle = el.style;
+}
+function getOldStyle(el) {
+  return transitionStore(el).oldStyle;
+}
+
+exports.getAnimationConfig = getAnimationConfig;
+exports.getOldStyle = getOldStyle;
+exports.initProps = initProps;
+exports.isElementRemoved = isElementRemoved;
+exports.removeElement = removeElement;
+exports.removeElementWithFadeOut = removeElementWithFadeOut;
+exports.saveOldStyle = saveOldStyle;
+exports.transitionStore = transitionStore;
+exports.updateProps = updateProps;

package/lib/node_modules/echarts/lib/animation/customGraphicKeyframeAnimation.js

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../zrender/lib/core/util.js');
+var customGraphicTransition = require('./customGraphicTransition.js');
+var basicTransition = require('./basicTransition.js');
+var log = require('../util/log.js');
+var model = require('../util/model.js');
+
+var getStateToRestore = model.makeInner();
+var KEYFRAME_EXCLUDE_KEYS = ['percent', 'easing', 'shape', 'style', 'extra'];
+/**
+ * Stop previous keyframe animation and restore the attributes.
+ * Avoid new keyframe animation starts with wrong internal state when the percent: 0 is not set.
+ */
+function stopPreviousKeyframeAnimationAndRestore(el) {
+  // Stop previous keyframe animation.
+  el.stopAnimation('keyframe');
+  // Restore
+  el.attr(getStateToRestore(el));
+}
+function applyKeyframeAnimation(el, animationOpts, animatableModel) {
+  if (!animatableModel.isAnimationEnabled() || !animationOpts) {
+    return;
+  }
+  if (util.isArray(animationOpts)) {
+    util.each(animationOpts, function (singleAnimationOpts) {
+      applyKeyframeAnimation(el, singleAnimationOpts, animatableModel);
+    });
+    return;
+  }
+  var keyframes = animationOpts.keyframes;
+  var duration = animationOpts.duration;
+  if (animatableModel && duration == null) {
+    // Default to use duration of config.
+    // NOTE: animation config from payload will be ignored because they are mainly for transitions.
+    var config = basicTransition.getAnimationConfig('enter', animatableModel, 0);
+    duration = config && config.duration;
+  }
+  if (!keyframes || !duration) {
+    return;
+  }
+  var stateToRestore = getStateToRestore(el);
+  util.each(customGraphicTransition.ELEMENT_ANIMATABLE_PROPS, function (targetPropName) {
+    if (targetPropName && !el[targetPropName]) {
+      return;
+    }
+    var animator;
+    var endFrameIsSet = false;
+    // Sort keyframes by percent.
+    keyframes.sort(function (a, b) {
+      return a.percent - b.percent;
+    });
+    util.each(keyframes, function (kf) {
+      // Stop current animation.
+      var animators = el.animators;
+      var kfValues = targetPropName ? kf[targetPropName] : kf;
+      if (process.env.NODE_ENV !== 'production') {
+        if (kf.percent >= 1) {
+          endFrameIsSet = true;
+        }
+      }
+      if (!kfValues) {
+        return;
+      }
+      var propKeys = util.keys(kfValues);
+      if (!targetPropName) {
+        // PENDING performance?
+        propKeys = util.filter(propKeys, function (key) {
+          return util.indexOf(KEYFRAME_EXCLUDE_KEYS, key) < 0;
+        });
+      }
+      if (!propKeys.length) {
+        return;
+      }
+      if (!animator) {
+        animator = el.animate(targetPropName, animationOpts.loop, true);
+        animator.scope = 'keyframe';
+      }
+      for (var i = 0; i < animators.length; i++) {
+        // Stop all other animation that is not keyframe.
+        if (animators[i] !== animator && animators[i].targetName === animator.targetName) {
+          animators[i].stopTracks(propKeys);
+        }
+      }
+      targetPropName && (stateToRestore[targetPropName] = stateToRestore[targetPropName] || {});
+      var savedTarget = targetPropName ? stateToRestore[targetPropName] : stateToRestore;
+      util.each(propKeys, function (key) {
+        // Save original value.
+        savedTarget[key] = ((targetPropName ? el[targetPropName] : el) || {})[key];
+      });
+      animator.whenWithKeys(duration * kf.percent, kfValues, propKeys, kf.easing);
+    });
+    if (!animator) {
+      return;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      if (!endFrameIsSet) {
+        log.warn('End frame with percent: 1 is missing in the keyframeAnimation.', true);
+      }
+    }
+    animator.delay(animationOpts.delay || 0).duration(duration).start(animationOpts.easing);
+  });
+}
+
+exports.applyKeyframeAnimation = applyKeyframeAnimation;
+exports.stopPreviousKeyframeAnimationAndRestore = stopPreviousKeyframeAnimationAndRestore;