react-native-reanimated 2.8.0 → 3.0.0-rc.0

package/src/reanimated1/Transitioning.js

@@ -1,158 +0,0 @@
-import React from 'react';
-import { View, findNodeHandle } from 'react-native';
-import ReanimatedModule from '../ReanimatedModule';
-
-const TransitioningContext = React.createContext();
-
-function configFromProps(type, props) {
-  const config = { type };
-  if ('durationMs' in props) {
-    config.durationMs = props.durationMs;
-  }
-  if ('interpolation' in props) {
-    config.interpolation = props.interpolation;
-  }
-  if ('type' in props) {
-    config.animation = props.type;
-  }
-  if ('delayMs' in props) {
-    config.delayMs = props.delayMs;
-  }
-  if ('propagation' in props) {
-    config.propagation = props.propagation;
-  }
-  return config;
-}
-
-/**
- * The below wrapper is used to support legacy context API with Context.Consumer
- * render prop. We need it as we want to access `context` from within
- * `componentDidMount` callback. If we decided to drop support for older
- * react native we could rewrite it using hooks or `static contextType` API.
- */
-function wrapTransitioningContext(Comp) {
-  return (props) => {
-    return (
-      <TransitioningContext.Consumer>
-        {(context) => <Comp context={context} {...props} />}
-      </TransitioningContext.Consumer>
-    );
-  };
-}
-
-class In extends React.Component {
-  componentDidMount() {
-    this.props.context.push(configFromProps('in', this.props));
-  }
-
-  render() {
-    return this.props.children || null;
-  }
-}
-
-class Change extends React.Component {
-  componentDidMount() {
-    this.props.context.push(configFromProps('change', this.props));
-  }
-
-  render() {
-    return this.props.children || null;
-  }
-}
-
-class Out extends React.Component {
-  componentDidMount() {
-    this.props.context.push(configFromProps('out', this.props));
-  }
-
-  render() {
-    return this.props.children || null;
-  }
-}
-
-class Together extends React.Component {
-  transitions = [];
-  componentDidMount() {
-    const config = configFromProps('group', this.props);
-    config.transitions = this.transitions;
-    this.props.context.push(config);
-  }
-
-  render() {
-    return (
-      <TransitioningContext.Provider value={this.transitions}>
-        {this.props.children}
-      </TransitioningContext.Provider>
-    );
-  }
-}
-
-class Sequence extends React.Component {
-  transitions = [];
-  componentDidMount() {
-    const config = configFromProps('group', this.props);
-    config.sequence = true;
-    config.transitions = this.transitions;
-    this.props.context.push(config);
-  }
-
-  render() {
-    return (
-      <TransitioningContext.Provider value={this.transitions}>
-        {this.props.children}
-      </TransitioningContext.Provider>
-    );
-  }
-}
-
-function createTransitioningComponent(Component) {
-  class Wrapped extends React.Component {
-    propTypes = Component.propTypes;
-    transitions = [];
-    viewRef = React.createRef();
-
-    componentDidMount() {
-      if (this.props.animateMount) {
-        this.animateNextTransition();
-      }
-    }
-
-    setNativeProps(props) {
-      this.viewRef.current.setNativeProps(props);
-    }
-
-    animateNextTransition() {
-      const viewTag = findNodeHandle(this.viewRef.current);
-      ReanimatedModule.animateNextTransition(viewTag, {
-        transitions: this.transitions,
-      });
-    }
-
-    render() {
-      const { transition, ...rest } = this.props;
-      return (
-        <React.Fragment>
-          <TransitioningContext.Provider value={this.transitions}>
-            {transition}
-          </TransitioningContext.Provider>
-          <Component {...rest} ref={this.viewRef} collapsable={false} />
-        </React.Fragment>
-      );
-    }
-  }
-  return Wrapped;
-}
-
-const Transitioning = {
-  View: createTransitioningComponent(View),
-};
-
-const Transition = {
-  Sequence: wrapTransitioningContext(Sequence),
-  Together: wrapTransitioningContext(Together),
-  In: wrapTransitioningContext(In),
-  Out: wrapTransitioningContext(Out),
-  Change: wrapTransitioningContext(Change),
-};
-
-export { Transitioning, Transition, createTransitioningComponent };

package/src/reanimated1/animations/Animation.js

@@ -1,32 +0,0 @@
-import AnimatedValue from '../core/InternalAnimatedValue';
-
-class Animation {
-  static springDefaultState() {
-    return {
-      position: new AnimatedValue(0),
-      finished: new AnimatedValue(0),
-      velocity: new AnimatedValue(0),
-      time: new AnimatedValue(0),
-    };
-  }
-
-  static decayDefaultState() {
-    return {
-      position: new AnimatedValue(0),
-      finished: new AnimatedValue(0),
-      velocity: new AnimatedValue(0),
-      time: new AnimatedValue(0),
-    };
-  }
-
-  static timingDefaultState() {
-    return {
-      position: new AnimatedValue(0),
-      finished: new AnimatedValue(0),
-      time: new AnimatedValue(0),
-      frameTime: new AnimatedValue(0),
-    };
-  }
-}
-
-export default Animation;

package/src/reanimated1/animations/SpringUtils.js

@@ -1,199 +0,0 @@
-import {
-  cond,
-  sub,
-  divide,
-  multiply,
-  add,
-  pow,
-  lessOrEq,
-  and,
-  greaterThan,
-} from './../base';
-import AnimatedValue from './../core/InternalAnimatedValue';
-
-function stiffnessFromOrigamiValue(oValue) {
-  return (oValue - 30) * 3.62 + 194;
-}
-
-function dampingFromOrigamiValue(oValue) {
-  return (oValue - 8) * 3 + 25;
-}
-
-function stiffnessFromOrigamiNode(oValue) {
-  return add(multiply(sub(oValue, 30), 3.62), 194);
-}
-
-function dampingFromOrigamiNode(oValue) {
-  return add(multiply(sub(oValue, 8), 3), 25);
-}
-
-function makeConfigFromOrigamiTensionAndFriction(prevConfig) {
-  const { tension, friction, ...rest } = prevConfig;
-  return {
-    ...rest,
-    stiffness:
-      typeof tension === 'number'
-        ? stiffnessFromOrigamiValue(tension)
-        : stiffnessFromOrigamiNode(tension),
-    damping:
-      typeof friction === 'number'
-        ? dampingFromOrigamiValue(friction)
-        : dampingFromOrigamiNode(friction),
-  };
-}
-
-function makeConfigFromBouncinessAndSpeed(prevConfig) {
-  const { bounciness, speed, ...rest } = prevConfig;
-  if (typeof bounciness === 'number' && typeof speed === 'number') {
-    return fromBouncinessAndSpeedNumbers(bounciness, speed, rest);
-  }
-  return fromBouncinessAndSpeedNodes(bounciness, speed, rest);
-}
-
-function fromBouncinessAndSpeedNodes(bounciness, speed, rest) {
-  function normalize(value, startValue, endValue) {
-    return divide(sub(value, startValue), sub(endValue, startValue));
-  }
-
-  function projectNormal(n, start, end) {
-    return add(start, multiply(n, sub(end, start)));
-  }
-
-  function linearInterpolation(t, start, end) {
-    return add(multiply(t, end), multiply(sub(1, t), start));
-  }
-
-  function quadraticOutInterpolation(t, start, end) {
-    return linearInterpolation(sub(multiply(2, t), multiply(t, t)), start, end);
-  }
-
-  function b3Friction1(x) {
-    return add(
-      sub(multiply(0.0007, pow(x, 3)), multiply(0.031, pow(x, 2))),
-      multiply(0.64, x),
-      1.28
-    );
-  }
-
-  function b3Friction2(x) {
-    return add(
-      sub(multiply(0.000044, pow(x, 3)), multiply(0.006, pow(x, 2))),
-      multiply(0.36, x),
-      2
-    );
-  }
-
-  function b3Friction3(x) {
-    return add(
-      sub(multiply(0.00000045, pow(x, 3)), multiply(0.000332, pow(x, 2))),
-      multiply(0.1078, x),
-      5.84
-    );
-  }
-
-  function b3Nobounce(tension) {
-    return cond(
-      lessOrEq(tension, 18),
-      b3Friction1(tension),
-      cond(
-        and(greaterThan(tension, 18), lessOrEq(tension, 44)),
-        b3Friction2(tension),
-        b3Friction3(tension)
-      )
-    );
-  }
-
-  let b = normalize(divide(bounciness, 1.7), 0, 20);
-  b = projectNormal(b, 0, 0.8);
-  const s = normalize(divide(speed, 1.7), 0, 20);
-  const bouncyTension = projectNormal(s, 0.5, 200);
-  const bouncyFriction = quadraticOutInterpolation(
-    b,
-    b3Nobounce(bouncyTension),
-    0.01
-  );
-  return {
-    ...rest,
-    stiffness: stiffnessFromOrigamiNode(bouncyTension),
-    damping: dampingFromOrigamiNode(bouncyFriction),
-  };
-}
-
-function fromBouncinessAndSpeedNumbers(bounciness, speed, rest) {
-  function normalize(value, startValue, endValue) {
-    return (value - startValue) / (endValue - startValue);
-  }
-
-  function projectNormal(n, start, end) {
-    return start + n * (end - start);
-  }
-
-  function linearInterpolation(t, start, end) {
-    return t * end + (1 - t) * start;
-  }
-
-  function quadraticOutInterpolation(t, start, end) {
-    return linearInterpolation(2 * t - t * t, start, end);
-  }
-
-  function b3Friction1(x) {
-    return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
-  }
-
-  function b3Friction2(x) {
-    return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
-  }
-
-  function b3Friction3(x) {
-    return (
-      0.00000045 * Math.pow(x, 3) -
-      0.000332 * Math.pow(x, 2) +
-      0.1078 * x +
-      5.84
-    );
-  }
-
-  function b3Nobounce(tension) {
-    if (tension <= 18) {
-      return b3Friction1(tension);
-    } else if (tension > 18 && tension <= 44) {
-      return b3Friction2(tension);
-    } else {
-      return b3Friction3(tension);
-    }
-  }
-
-  let b = normalize(bounciness / 1.7, 0, 20);
-  b = projectNormal(b, 0, 0.8);
-  const s = normalize(speed / 1.7, 0, 20);
-  const bouncyTension = projectNormal(s, 0.5, 200);
-  const bouncyFriction = quadraticOutInterpolation(
-    b,
-    b3Nobounce(bouncyTension),
-    0.01
-  );
-
-  return {
-    ...rest,
-    stiffness: stiffnessFromOrigamiValue(bouncyTension),
-    damping: dampingFromOrigamiValue(bouncyFriction),
-  };
-}
-
-function makeDefaultConfig() {
-  return {
-    stiffness: new AnimatedValue(100),
-    mass: new AnimatedValue(1),
-    damping: new AnimatedValue(10),
-    overshootClamping: false,
-    restSpeedThreshold: 0.001,
-    restDisplacementThreshold: 0.001,
-    toValue: new AnimatedValue(0),
-  };
-}
-
-export default {
-  makeDefaultConfig,
-  makeConfigFromBouncinessAndSpeed,
-  makeConfigFromOrigamiTensionAndFriction,
-};

package/src/reanimated1/animations/backwardCompatibleAnimWrapper.js

@@ -1,117 +0,0 @@
-import {
-  always,
-  block,
-  call,
-  clockRunning,
-  cond,
-  set,
-  startClock,
-  stopClock,
-} from '../base';
-import Clock from '../core/AnimatedClock';
-import { evaluateOnce } from '../derived/evaluateOnce';
-
-function createOldAnimationObject(node, animationStateDefaults, value, config) {
-  const newClock = new Clock();
-  const currentState = animationStateDefaults();
-  let alwaysNode;
-  let isStarted = false;
-  let isDone = false;
-  let wasStopped = false;
-  let animationCallback;
-  const animation = {
-    start: (currentAnimationCallback) => {
-      animationCallback = currentAnimationCallback;
-      if (isStarted) {
-        animationCallback && animationCallback({ finished: false });
-        return;
-      }
-      if (isDone) {
-        console.warn('Animation has been finished before');
-        // inconsistent with React Native
-        return;
-      }
-
-      if (!value.isNativelyInitialized()) {
-        return;
-      }
-
-      isStarted = true;
-      evaluateOnce(
-        set(currentState.position, value),
-        currentState.position,
-        () => {
-          alwaysNode = always(
-            set(
-              value,
-              block([
-                cond(clockRunning(newClock), 0, startClock(newClock)),
-                node(newClock, currentState, config),
-                cond(currentState.finished, [
-                  call([], () => {
-                    isStarted = false;
-                    if (!wasStopped) {
-                      isDone = true;
-                    }
-                    value.__detachAnimation(animation);
-                    isDone = true;
-                    if (!wasStopped) {
-                      wasStopped = false;
-                    }
-                  }),
-                  stopClock(newClock),
-                ]),
-                currentState.position,
-              ])
-            )
-          );
-          value.__attachAnimation(animation);
-          alwaysNode.__addChild(value);
-        }
-      );
-    },
-    __detach: () => {
-      animationCallback && animationCallback({ finished: isDone });
-      animationCallback = null;
-      value.__initialized && alwaysNode.__removeChild(value);
-    },
-    stop: () => {
-      if (isDone) {
-        console.warn(
-          'Calling stop has no effect as the animation has already completed'
-        );
-        return;
-      }
-      if (!isStarted) {
-        console.warn(
-          "Calling stop has no effect as the animation hasn't been started"
-        );
-        return;
-      }
-      wasStopped = true;
-      evaluateOnce(set(currentState.finished, 1), currentState.finished);
-    },
-    __stopImmediately_testOnly: (result) => {
-      animation.stop();
-      isDone = result;
-      value.__detachAnimation(animation);
-    },
-  };
-  return animation;
-}
-
-/**
- * Depending on the arguments list we either return animation node or return an
- * animation object that is compatible with the original Animated API
- */
-export default function backwardsCompatibleAnimWrapper(
-  node,
-  animationStateDefaults
-) {
-  return (clock, state, config) => {
-    if (config !== undefined) {
-      return node(clock, state, config);
-    }
-    return createOldAnimationObject(node, animationStateDefaults, clock, state);
-  };
-}

package/src/reanimated1/animations/decay.js

@@ -1,54 +0,0 @@
-import {
-  cond,
-  sub,
-  pow,
-  divide,
-  multiply,
-  add,
-  block,
-  set,
-  lessThan,
-  proc,
-  abs,
-} from '../base';
-
-const VELOCITY_EPS = 5;
-
-function decay(clock, state, config) {
-  const lastTime = cond(state.time, state.time, clock);
-  const deltaTime = sub(clock, lastTime);
-
-  // v0 = v / 1000
-  // v = v0 * powf(deceleration, dt);
-  // v = v * 1000;
-
-  // x0 = x;
-  // x = x0 + v0 * deceleration * (1 - powf(deceleration, dt)) / (1 - deceleration)
-  const kv = pow(config.deceleration, deltaTime);
-  const kx = divide(
-    multiply(config.deceleration, sub(1, kv)),
-    sub(1, config.deceleration)
-  );
-  const v0 = divide(state.velocity, 1000);
-  const v = multiply(v0, kv, 1000);
-  const x = add(state.position, multiply(v0, kx));
-  return block([
-    set(state.position, x),
-    set(state.velocity, v),
-    set(state.time, clock),
-    cond(lessThan(abs(v), VELOCITY_EPS), set(state.finished, 1)),
-  ]);
-}
-
-const procDecay = proc(
-  (clock, time, velocity, position, finished, deceleration) =>
-    decay(clock, { time, velocity, position, finished }, { deceleration })
-);
-
-export default function decayAnimation(
-  clock,
-  { time, velocity, position, finished },
-  { deceleration }
-) {
-  return procDecay(clock, time, velocity, position, finished, deceleration);
-}