addimated/lib-commonjs/index.js

An always interruptable, declarative animation library for React

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createAnimatedValue = createAnimatedValue;
exports.createAnimatedValueXY = createAnimatedValueXY;
exports.interpolate = interpolate;
exports.spring = spring;
exports.timing = timing;
exports.delay = delay;
exports.sequence = sequence;
exports.parallel = parallel;
exports.stagger = stagger;
Object.defineProperty(exports, "createAnimatedComponent", {
  enumerable: true,
  get: function get() {
    return _createAnimatedComponent.createAnimatedComponent;
  }
});
exports.Easing = exports.img = exports.span = exports.div = exports.button = exports.a = void 0;

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

var _AnimatedInterpolation = require("./AnimatedInterpolation");

var _AnimatedValue = require("./AnimatedValue");

var _AnimatedValueXY = require("./AnimatedValueXY");

var _createAnimatedComponent = require("./createAnimatedComponent");

var Easing = _interopRequireWildcard(require("./Easing"));

exports.Easing = Easing;

var _Interpolation = require("./Interpolation");

var _Manager = require("./Manager");

var _SpringAnimation = require("./SpringAnimation");

var _TimingAnimation = require("./TimingAnimation");

var globalManager;

function maybeVectorAnim(value, config, anim) {
  if (value instanceof _AnimatedValueXY.AnimatedValueXY) {
    var configX = (0, _objectSpread2.default)({}, config);
    var configY = (0, _objectSpread2.default)({}, config);

    for (var key in config) {
      var _config$key = config[key],
          x = _config$key.x,
          y = _config$key.y;

      if (x !== undefined && y !== undefined) {
        configX[key] = x;
        configY[key] = y;
      }
    }

    var aX = anim(value.x, configX);
    var aY = anim(value.y, configY);
    return parallel([aX, aY]);
  } else {
    return null;
  }
}

function spring(value, config) {
  var vectorAnim = maybeVectorAnim(value, config, spring);
  if (vectorAnim) return vectorAnim;
  var singleValue = value;
  var singleConfig = config;
  return {
    start: function start(callback) {
      singleValue.animate(new _SpringAnimation.SpringAnimation(singleConfig), callback);
    }
  };
}

function timing(value, config) {
  var vectorAnim = maybeVectorAnim(value, config, timing);
  if (vectorAnim) return vectorAnim;
  var singleValue = value;
  var singleConfig = config;
  return {
    start: function start(callback) {
      singleValue.animate(new _TimingAnimation.TimingAnimation(singleConfig), callback);
    }
  };
}

function sequence(animations) {
  var current = 0;
  return {
    start: function start(callback) {
      var onComplete = function onComplete(result) {
        if (!result.finished) {
          callback && callback(result);
          return;
        }

        current++;

        if (current === animations.length) {
          callback && callback(result);
          return;
        }

        animations[current].start(onComplete);
      };

      if (animations.length === 0) {
        callback && callback({
          finished: true
        });
      } else {
        animations[current].start(onComplete);
      }
    }
  };
}

function parallel(animations) {
  var doneCount = 0;
  var result = {
    start: function start(callback) {
      if (doneCount === animations.length) {
        callback && callback({
          finished: true
        });
        return;
      }

      animations.forEach(function (anim) {
        var cb = function cb(endResult) {
          doneCount++;

          if (doneCount === animations.length) {
            doneCount = 0;
            callback && callback(endResult);
            return;
          }
        };

        if (!anim) {
          cb({
            finished: true
          });
        } else {
          anim.start(cb);
        }
      });
    }
  };
  return result;
}

function delay(time) {
  return timing(createAnimatedValue(0), {
    toValue: 0,
    duration: time
  });
}

function stagger(time, animations) {
  return parallel(animations.map(function (animation, i) {
    return sequence([delay(time * i), animation]);
  }));
}

function createAnimatedValue(value) {
  globalManager = globalManager || new _Manager.Manager();
  return new _AnimatedValue.AnimatedValue(value, globalManager);
}

function createAnimatedValueXY(valueIn) {
  globalManager = globalManager || new _Manager.Manager();
  return new _AnimatedValueXY.AnimatedValueXY(valueIn, globalManager);
}

function interpolate(value, config) {
  return new _AnimatedInterpolation.AnimatedInterpolation(value, _Interpolation.Interpolation.create(config));
}

var a = (0, _createAnimatedComponent.createAnimatedComponent)("a");
exports.a = a;
var button = (0, _createAnimatedComponent.createAnimatedComponent)("button");
exports.button = button;
var div = (0, _createAnimatedComponent.createAnimatedComponent)("div");
exports.div = div;
var span = (0, _createAnimatedComponent.createAnimatedComponent)("span");
exports.span = span;
var img = (0, _createAnimatedComponent.createAnimatedComponent)("img"); // types

exports.img = img;
//# sourceMappingURL=index.js.map