addimated/lib/exports.js

An always interruptable, declarative animation library for React

import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
import invariant from "invariant";
import React from "react";
import * as Animated from "./index";

function defaultAnimationFactory(animatedValue, toValue) {
  return Animated.timing(animatedValue, {
    toValue: toValue
  });
}

function useInitializedRef(initializer) {
  var initialValue = React.useMemo(initializer, []);
  return React.useRef(initialValue);
}

function useAnimatedValue(value) {
  var animationFactory = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultAnimationFactory;

  var _React$useState = React.useState(false),
      _React$useState2 = _slicedToArray(_React$useState, 2),
      isAnimating = _React$useState2[0],
      setIsAnimating = _React$useState2[1];

  var animatedValueRef = useInitializedRef(function () {
    return Animated.createAnimatedValue(value);
  });
  var animatedValue = animatedValueRef.current;
  !animatedValue ? process.env.NODE_ENV !== "production" ? invariant(false, "") : invariant(false) : void 0;
  var prevValueRef = React.useRef(null);
  React.useLayoutEffect(function () {
    if (prevValueRef.current != null && value !== prevValueRef.current) {
      setIsAnimating(true);
      animationFactory(animatedValue, value).start(function (result) {
        if (result.finished) {
          setIsAnimating(false);
        }
      });
    }

    prevValueRef.current = value;
  }, [value, animationFactory]);
  return [animatedValue, isAnimating];
}

export * from "./index";
export { useAnimatedValue };
//# sourceMappingURL=exports.js.map