react-native-reanimated 2.9.0 → 3.0.0-rc.1

package/lib/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/lib/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);
-}

package/lib/reanimated1/animations/spring.js

@@ -1,198 +0,0 @@
-import {
-  cond,
-  sub,
-  divide,
-  multiply,
-  sqrt,
-  add,
-  block,
-  set,
-  exp,
-  sin,
-  cos,
-  eq,
-  or,
-  neq,
-  and,
-  lessThan,
-  greaterThan,
-  proc,
-  min,
-  abs,
-} from '../base';
-import AnimatedValue from '../core/InternalAnimatedValue';
-
-const MAX_STEPS_MS = 64;
-
-function spring(clock, state, config) {
-  const lastTime = cond(state.time, state.time, clock);
-
-  const deltaTime = min(sub(clock, lastTime), MAX_STEPS_MS);
-
-  const c = config.damping;
-  const m = config.mass;
-  const k = config.stiffness;
-
-  const v0 = multiply(-1, state.velocity);
-  const x0 = sub(config.toValue, state.position);
-
-  const zeta = divide(c, multiply(2, sqrt(multiply(k, m)))); // damping ratio
-  const omega0 = sqrt(divide(k, m)); // undamped angular frequency of the oscillator (rad/ms)
-  const omega1 = multiply(omega0, sqrt(sub(1, multiply(zeta, zeta)))); // exponential decay
-
-  const t = divide(deltaTime, 1000); // in seconds
-
-  const sin1 = sin(multiply(omega1, t));
-  const cos1 = cos(multiply(omega1, t));
-
-  // under damped
-  const underDampedEnvelope = exp(multiply(-1, zeta, omega0, t));
-  const underDampedFrag1 = multiply(
-    underDampedEnvelope,
-    add(
-      multiply(sin1, divide(add(v0, multiply(zeta, omega0, x0)), omega1)),
-      multiply(x0, cos1)
-    )
-  );
-  const underDampedPosition = sub(config.toValue, underDampedFrag1);
-  // This looks crazy -- it's actually just the derivative of the oscillation function
-  const underDampedVelocity = sub(
-    multiply(zeta, omega0, underDampedFrag1),
-    multiply(
-      underDampedEnvelope,
-      sub(
-        multiply(cos1, add(v0, multiply(zeta, omega0, x0))),
-        multiply(omega1, x0, sin1)
-      )
-    )
-  );
-
-  // critically damped
-  const criticallyDampedEnvelope = exp(multiply(-1, omega0, t));
-  const criticallyDampedPosition = sub(
-    config.toValue,
-    multiply(
-      criticallyDampedEnvelope,
-      add(x0, multiply(add(v0, multiply(omega0, x0)), t))
-    )
-  );
-  const criticallyDampedVelocity = multiply(
-    criticallyDampedEnvelope,
-    add(
-      multiply(v0, sub(multiply(t, omega0), 1)),
-      multiply(t, x0, omega0, omega0)
-    )
-  );
-
-  // conditions for stopping the spring animations
-  const prevPosition = state.prevPosition
-    ? state.prevPosition
-    : new AnimatedValue(0);
-
-  const isOvershooting = cond(
-    and(config.overshootClamping, neq(config.stiffness, 0)),
-    cond(
-      lessThan(prevPosition, config.toValue),
-      greaterThan(state.position, config.toValue),
-      lessThan(state.position, config.toValue)
-    )
-  );
-  const isVelocity = lessThan(abs(state.velocity), config.restSpeedThreshold);
-  const isDisplacement = or(
-    eq(config.stiffness, 0),
-    lessThan(
-      abs(sub(config.toValue, state.position)),
-      config.restDisplacementThreshold
-    )
-  );
-
-  return block([
-    set(prevPosition, state.position),
-    cond(
-      lessThan(zeta, 1),
-      [
-        set(state.position, underDampedPosition),
-        set(state.velocity, underDampedVelocity),
-      ],
-      [
-        set(state.position, criticallyDampedPosition),
-        set(state.velocity, criticallyDampedVelocity),
-      ]
-    ),
-    set(state.time, clock),
-    cond(or(isOvershooting, and(isVelocity, isDisplacement)), [
-      cond(neq(config.stiffness, 0), [
-        set(state.velocity, 0),
-        set(state.position, config.toValue),
-      ]),
-      set(state.finished, 1),
-    ]),
-  ]);
-}
-
-const procSpring = proc(
-  (
-    finished,
-    velocity,
-    position,
-    time,
-    prevPosition,
-    toValue,
-    damping,
-    mass,
-    stiffness,
-    overshootClamping,
-    restSpeedThreshold,
-    restDisplacementThreshold,
-    clock
-  ) =>
-    spring(
-      clock,
-      {
-        finished,
-        velocity,
-        position,
-        time,
-        prevPosition,
-      },
-      {
-        toValue,
-        damping,
-        mass,
-        stiffness,
-        overshootClamping,
-        restDisplacementThreshold,
-        restSpeedThreshold,
-      }
-    )
-);
-
-export default function springAnimation(
-  clock,
-  { finished, velocity, position, time, prevPosition },
-  {
-    toValue,
-    damping,
-    mass,
-    stiffness,
-    overshootClamping,
-    restDisplacementThreshold,
-    restSpeedThreshold,
-  }
-) {
-  return procSpring(
-    finished,
-    velocity,
-    position,
-    time,
-    prevPosition,
-    toValue,
-    damping,
-    mass,
-    stiffness,
-    overshootClamping,
-    restSpeedThreshold,
-    restDisplacementThreshold,
-    clock
-  );
-}

package/lib/reanimated1/animations/timing.js

@@ -1,74 +0,0 @@
-import {
-  cond,
-  sub,
-  divide,
-  multiply,
-  add,
-  block,
-  set,
-  greaterOrEq,
-  proc,
-} from '../base';
-
-const internalTiming = proc(function (
-  clock,
-  time,
-  frameTime,
-  position,
-  finished,
-  toValue,
-  duration,
-  nextProgress,
-  progress,
-  newFrameTime
-) {
-  const state = {
-    time,
-    finished,
-    frameTime,
-    position,
-  };
-
-  const config = {
-    duration,
-    toValue,
-  };
-
-  const distanceLeft = sub(config.toValue, state.position);
-  const fullDistance = divide(distanceLeft, sub(1, progress));
-  const startPosition = sub(config.toValue, fullDistance);
-  const nextPosition = add(startPosition, multiply(fullDistance, nextProgress));
-
-  return block([
-    cond(
-      greaterOrEq(newFrameTime, config.duration),
-      [set(state.position, config.toValue), set(state.finished, 1)],
-      set(state.position, nextPosition)
-    ),
-    set(state.frameTime, newFrameTime),
-    set(state.time, clock),
-  ]);
-});
-
-export default function timing(clock, state, config) {
-  if (config.duration === 0) {
-    // when duration is zero we end the timing immediately
-    return block([set(state.position, config.toValue), set(state.finished, 1)]);
-  }
-  const lastTime = cond(state.time, state.time, clock);
-  const newFrameTime = add(state.frameTime, sub(clock, lastTime));
-  const nextProgress = config.easing(divide(newFrameTime, config.duration));
-  const progress = config.easing(divide(state.frameTime, config.duration));
-  return internalTiming(
-    clock,
-    state.time,
-    state.frameTime,
-    state.position,
-    state.finished,
-    config.toValue,
-    config.duration,
-    nextProgress,
-    progress,
-    newFrameTime
-  );
-}

package/lib/reanimated1/base.js

@@ -1,13 +0,0 @@
-export { createAnimatedCond as cond } from './core/AnimatedCond';
-export { createAnimatedSet as set } from './core/AnimatedSet';
-export { createAnimatedStartClock as startClock } from './core/AnimatedStartClock';
-export { createAnimatedStopClock as stopClock } from './core/AnimatedStopClock';
-export { createAnimatedClockTest as clockRunning } from './core/AnimatedClockTest';
-export { createAnimatedDebug as debug } from './core/AnimatedDebug';
-export { createAnimatedCall as call } from './core/AnimatedCall';
-export { createAnimatedEvent as event } from './core/AnimatedEvent';
-export { createAnimatedAlways as always } from './core/AnimatedAlways';
-export { createAnimatedConcat as concat } from './core/AnimatedConcat';
-export { createAnimatedBlock as block, adapt } from './core/AnimatedBlock';
-export { createAnimatedFunction as proc } from './core/AnimatedFunction';
-export * from './operators';

package/lib/reanimated1/core/AnimatedAlways.js

@@ -1,33 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-import invariant from 'invariant';
-import { val } from '../val';
-
-class AnimatedAlways extends AnimatedNode {
-  _what;
-
-  constructor(what) {
-    invariant(
-      what instanceof AnimatedNode,
-      `Reanimated: Animated.always node argument should be of type AnimatedNode but got ${what}`
-    );
-    super({ type: 'always', what }, [what]);
-    this._what = what;
-  }
-
-  toString() {
-    return `AnimatedAlways, id: ${this.__nodeID}`;
-  }
-
-  update() {
-    this.__getValue();
-  }
-
-  __onEvaluate() {
-    val(this._what);
-    return 0;
-  }
-}
-
-export function createAnimatedAlways(item) {
-  return new AnimatedAlways(item);
-}

package/lib/reanimated1/core/AnimatedBezier.js

@@ -1,150 +0,0 @@
-import { val } from '../val';
-import AnimatedNode from './AnimatedNode';
-import invariant from 'invariant';
-
-// These values are established by empiricism with tests (tradeoff: performance VS precision)
-var NEWTON_ITERATIONS = 4;
-var NEWTON_MIN_SLOPE = 0.001;
-var SUBDIVISION_PRECISION = 0.0000001;
-var SUBDIVISION_MAX_ITERATIONS = 10;
-
-var kSplineTableSize = 11;
-var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
-
-var float32ArraySupported = typeof Float32Array === 'function';
-
-function A(aA1, aA2) {
-  return 1.0 - 3.0 * aA2 + 3.0 * aA1;
-}
-function B(aA1, aA2) {
-  return 3.0 * aA2 - 6.0 * aA1;
-}
-function C(aA1) {
-  return 3.0 * aA1;
-}
-
-// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
-function calcBezier(aT, aA1, aA2) {
-  return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
-}
-
-// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
-function getSlope(aT, aA1, aA2) {
-  return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
-}
-
-function binarySubdivide(aX, aA, aB, mX1, mX2) {
-  var currentX = 0;
-  var currentT = 0;
-  var i = 0;
-  do {
-    currentT = aA + (aB - aA) / 2.0;
-    currentX = calcBezier(currentT, mX1, mX2) - aX;
-    if (currentX > 0.0) {
-      aB = currentT;
-    } else {
-      aA = currentT;
-    }
-  } while (
-    Math.abs(currentX) > SUBDIVISION_PRECISION &&
-    ++i < SUBDIVISION_MAX_ITERATIONS
-  );
-  return currentT;
-}
-
-function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
-  for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
-    var currentSlope = getSlope(aGuessT, mX1, mX2);
-    if (currentSlope === 0.0) {
-      return aGuessT;
-    }
-    var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
-    aGuessT -= currentX / currentSlope;
-  }
-  return aGuessT;
-}
-
-function bezier(mX1, mY1, mX2, mY2) {
-  // Precompute samples table
-  var sampleValues = float32ArraySupported
-    ? new Float32Array(kSplineTableSize)
-    : new Array(kSplineTableSize);
-  if (mX1 !== mY1 || mX2 !== mY2) {
-    for (var i = 0; i < kSplineTableSize; ++i) {
-      sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
-    }
-  }
-
-  function getTForX(aX) {
-    var intervalStart = 0.0;
-    var currentSample = 1;
-    var lastSample = kSplineTableSize - 1;
-
-    for (
-      ;
-      currentSample !== lastSample && sampleValues[currentSample] <= aX;
-      ++currentSample
-    ) {
-      intervalStart += kSampleStepSize;
-    }
-    --currentSample;
-
-    // Interpolate to provide an initial guess for t
-    var dist =
-      (aX - sampleValues[currentSample]) /
-      (sampleValues[currentSample + 1] - sampleValues[currentSample]);
-    var guessForT = intervalStart + dist * kSampleStepSize;
-
-    var initialSlope = getSlope(guessForT, mX1, mX2);
-    if (initialSlope >= NEWTON_MIN_SLOPE) {
-      return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
-    } else if (initialSlope === 0.0) {
-      return guessForT;
-    } else {
-      return binarySubdivide(
-        aX,
-        intervalStart,
-        intervalStart + kSampleStepSize,
-        mX1,
-        mX2
-      );
-    }
-  }
-
-  return function BezierEasing(x) {
-    if (mX1 === mY1 && mX2 === mY2) {
-      return x; // linear
-    }
-    // Because JavaScript number are imprecise, we should guarantee the extremes are right.
-    if (x === 0) {
-      return 0;
-    }
-    if (x === 1) {
-      return 1;
-    }
-    return calcBezier(getTForX(x), mY1, mY2);
-  };
-}
-
-export default class AnimatedBezier extends AnimatedNode {
-  _value;
-  _bezier;
-
-  constructor(value, mX1, mY1, mX2, mY2) {
-    invariant(
-      value instanceof AnimatedNode,
-      `Reanimated: Bezier node argument should be of type AnimatedNode but got ${value}`
-    );
-    super({ type: 'bezier', mX1, mY1, mX2, mY2, input: value }, [value]);
-    this._value = value;
-    this._bezier = bezier(mX1, mY1, mX2, mY2);
-  }
-
-  toString() {
-    return `AnimatedBezier, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    return this._bezier(val(this._value));
-  }
-}

package/lib/reanimated1/core/AnimatedBlock.js

@@ -1,52 +0,0 @@
-import invariant from 'invariant';
-import { val } from '../val';
-import AnimatedNode from './AnimatedNode';
-import InternalAnimatedValue from './InternalAnimatedValue';
-
-class AnimatedBlock extends AnimatedNode {
-  _array;
-
-  constructor(array) {
-    invariant(
-      array.every((el) => el instanceof AnimatedNode),
-      `Reanimated: Animated.block node argument should be an array with elements of type AnimatedNode. One or more of them are not AnimatedNodes`
-    );
-    super({ type: 'block', block: array }, array);
-    this._array = array;
-  }
-
-  toString() {
-    return `AnimatedBlock, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    let result;
-    this._array.forEach((node) => {
-      result = val(node);
-    });
-    return result;
-  }
-}
-
-export function createAnimatedBlock(items) {
-  return adapt(items);
-}
-
-function nodify(v) {
-  if (typeof v === 'object' && v?.__isProxy) {
-    if (!v.__val) {
-      v.__val = new InternalAnimatedValue(0);
-    }
-    return v.__val;
-  }
-  // TODO: cache some typical static values (e.g. 0, 1, -1)
-  return v instanceof AnimatedNode
-    ? v
-    : InternalAnimatedValue.valueForConstant(v);
-}
-
-export function adapt(v) {
-  return Array.isArray(v)
-    ? new AnimatedBlock(v.map((node) => adapt(node)))
-    : nodify(v);
-}