react-native-reanimated 2.14.4 → 2.16.0

package/lib/reanimated1/derived/interpolateColors.js

@@ -1,62 +0,0 @@
-import { processColor } from 'react-native';
-import { round } from '../base';
-import color from './color';
-import interpolate, { Extrapolate } from './interpolate';
-
-function red(c) {
-  return (c >> 16) & 255;
-}
-function green(c) {
-  return (c >> 8) & 255;
-}
-function blue(c) {
-  return c & 255;
-}
-function opacity(c) {
-  return ((c >> 24) & 255) / 255;
-}
-
-/**
- * Use this if you want to interpolate an `Animated.Value` into color values.
- *
- * #### Why is this needed?
- *
- * Unfortunately, if you'll pass color values directly into the `outputRange` option
- * of `interpolate()` function, that won't really work (at least at the moment).
- * See https://github.com/software-mansion/react-native-reanimated/issues/181 .
- *
- * So, for now you can just use this helper instead.
- */
-export default function interpolateColors(animationValue, options) {
-  const { inputRange, outputColorRange } = options;
-  const colors = outputColorRange.map(processColor);
-
-  const r = round(
-    interpolate(animationValue, {
-      inputRange,
-      outputRange: colors.map(red),
-      extrapolate: Extrapolate.CLAMP,
-    })
-  );
-  const g = round(
-    interpolate(animationValue, {
-      inputRange,
-      outputRange: colors.map(green),
-      extrapolate: Extrapolate.CLAMP,
-    })
-  );
-  const b = round(
-    interpolate(animationValue, {
-      inputRange,
-      outputRange: colors.map(blue),
-      extrapolate: Extrapolate.CLAMP,
-    })
-  );
-  const a = interpolate(animationValue, {
-    inputRange,
-    outputRange: colors.map(opacity),
-    extrapolate: Extrapolate.CLAMP,
-  });
-
-  return color(r, g, b, a);
-}

package/lib/reanimated1/derived/onChange.js

@@ -1,14 +0,0 @@
-import { block, cond, defined, neq, not, set, proc } from '../base';
-import AnimatedValue from '../core/InternalAnimatedValue';
-
-const procOnChange = proc(function (value, action, prevValue) {
-  return block([
-    cond(not(defined(prevValue)), set(prevValue, value)),
-    cond(neq(value, prevValue), [set(prevValue, value), action]),
-  ]);
-});
-
-export default function onChange(value, action) {
-  const prevValue = new AnimatedValue();
-  return procOnChange(value, action, prevValue);
-}

package/lib/reanimated1/derived/useCode.js

@@ -1,41 +0,0 @@
-import React from 'react';
-import { always, block } from '../base';
-
-/**
- * @callback NodeFactory
- * Function to create a node or an array of nodes.
- * @returns {(Node[] | Node | null | undefined | Boolean)}
- */
-
-/**
- * React hook to run a node.
- * @param {NodeFactory} nodeFactory Function to build the node to run.
- * @param dependencies Array of dependencies. Refresh the node on changes.
- */
-export default function useCode(nodeFactory, dependencies) {
-  if (!(React.useEffect instanceof Function)) return;
-
-  React.useEffect(() => {
-    // check and correct 1st parameter
-    if (!(nodeFactory instanceof Function)) {
-      console.warn(
-        'useCode() first argument should be a function that returns an animation node.'
-      );
-
-      const node = nodeFactory;
-      nodeFactory = () => node;
-    }
-
-    let node = nodeFactory();
-    if (node) {
-      // allow factory to return array
-      if (node instanceof Array) node = block(node);
-
-      const animatedAlways = always(node);
-      animatedAlways.__attach();
-
-      // return undo function
-      return () => animatedAlways.__detach();
-    }
-  }, dependencies);
-}

package/lib/reanimated1/index.js

@@ -1,53 +0,0 @@
-import EasingNode from './Easing';
-import AnimatedClock from './core/AnimatedClock';
-import AnimatedValue from './core/AnimatedValue';
-import AnimatedNode from './core/AnimatedNode';
-import AnimatedCode from './core/AnimatedCode';
-import decay from './animations/decay';
-import timing from './animations/timing';
-import spring from './animations/spring';
-import Animation from './animations/Animation';
-import {
-  Transition,
-  Transitioning,
-  createTransitioningComponent,
-} from './Transitioning';
-import SpringUtils from './animations/SpringUtils';
-import useValue from './useValue';
-import backwardCompatibleAnimWrapper from './animations/backwardCompatibleAnimWrapper';
-
-const decayWrapper = backwardCompatibleAnimWrapper(
-  decay,
-  Animation.decayDefaultState
-);
-const timingWrapper = backwardCompatibleAnimWrapper(
-  timing,
-  Animation.timingDefaultState
-);
-const springWrapper = backwardCompatibleAnimWrapper(
-  spring,
-  Animation.springDefaultState
-);
-
-// operations
-export * from './base';
-export * from './derived';
-export {
-  AnimatedCode as Code,
-  // transitions
-  EasingNode,
-  Transitioning,
-  Transition,
-  createTransitioningComponent,
-  // nodes
-  AnimatedClock as Clock,
-  AnimatedValue as Value,
-  AnimatedNode as Node,
-  // animations
-  decayWrapper as decay,
-  timingWrapper as timing,
-  springWrapper as spring,
-  SpringUtils,
-  // hooks
-  useValue,
-};

package/lib/reanimated1/operators.js

@@ -1,35 +0,0 @@
-import { createAnimatedOperator } from './core/AnimatedOperator';
-
-const operator = createAnimatedOperator;
-
-export const add = operator('add');
-export const sub = operator('sub');
-export const multiply = operator('multiply');
-export const divide = operator('divide');
-export const pow = operator('pow');
-export const modulo = operator('modulo');
-export const sqrt = operator('sqrt');
-export const log = operator('log');
-export const sin = operator('sin');
-export const cos = operator('cos');
-export const exp = operator('exp');
-export const round = operator('round');
-export const lessThan = operator('lessThan');
-export const eq = operator('eq');
-export const greaterThan = operator('greaterThan');
-export const lessOrEq = operator('lessOrEq');
-export const greaterOrEq = operator('greaterOrEq');
-export const neq = operator('neq');
-export const and = operator('and');
-export const or = operator('or');
-export const defined = operator('defined');
-export const not = operator('not');
-export const tan = operator('tan');
-export const acos = operator('acos');
-export const asin = operator('asin');
-export const atan = operator('atan');
-export const abs = operator('abs');
-export const ceil = operator('ceil');
-export const floor = operator('floor');
-export const max = operator('max');
-export const min = operator('min');

package/lib/reanimated1/useValue.js

@@ -1,10 +0,0 @@
-import React from 'react';
-import AnimatedValue from './core/AnimatedValue';
-
-export default function useValue(initialValue) {
-  const ref = React.useRef(null);
-  if (ref.current === null) {
-    ref.current = new AnimatedValue(initialValue);
-  }
-  return ref.current;
-}

package/lib/reanimated1/val.js

@@ -1,3 +0,0 @@
-export function val(v) {
-  return v && v.__getValue ? v.__getValue() : v || 0;
-}

package/lib/reanimated2/Bezier.js

@@ -1,126 +0,0 @@
-/**
- * https://github.com/gre/bezier-easing
- * BezierEasing - use bezier curve for transition easing function
- * by Gaëtan Renaudeau 2014 - 2015 – MIT License
- */
-// These values are established by empiricism with tests (tradeoff: performance VS precision)
-export function Bezier(mX1, mY1, mX2, mY2) {
-    'worklet';
-    const NEWTON_ITERATIONS = 4;
-    const NEWTON_MIN_SLOPE = 0.001;
-    const SUBDIVISION_PRECISION = 0.0000001;
-    const SUBDIVISION_MAX_ITERATIONS = 10;
-    const kSplineTableSize = 11;
-    const kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
-    function A(aA1, aA2) {
-        'worklet';
-        return 1.0 - 3.0 * aA2 + 3.0 * aA1;
-    }
-    function B(aA1, aA2) {
-        'worklet';
-        return 3.0 * aA2 - 6.0 * aA1;
-    }
-    function C(aA1) {
-        'worklet';
-        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) {
-        'worklet';
-        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) {
-        'worklet';
-        return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
-    }
-    function binarySubdivide(aX, aA, aB, mX1, mX2) {
-        'worklet';
-        let currentX;
-        let currentT;
-        let 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) {
-        'worklet';
-        for (let i = 0; i < NEWTON_ITERATIONS; ++i) {
-            const currentSlope = getSlope(aGuessT, mX1, mX2);
-            if (currentSlope === 0.0) {
-                return aGuessT;
-            }
-            const currentX = calcBezier(aGuessT, mX1, mX2) - aX;
-            aGuessT -= currentX / currentSlope;
-        }
-        return aGuessT;
-    }
-    function LinearEasing(x) {
-        'worklet';
-        return x;
-    }
-    if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
-        throw new Error('bezier x values must be in [0, 1] range');
-    }
-    if (mX1 === mY1 && mX2 === mY2) {
-        return LinearEasing;
-    }
-    // FIXME: Float32Array is not available in Hermes right now
-    //
-    // var float32ArraySupported = typeof Float32Array === 'function';
-    // const sampleValues = float32ArraySupported
-    // ? new Float32Array(kSplineTableSize)
-    // : new Array(kSplineTableSize);
-    // Precompute samples table
-    const sampleValues = new Array(kSplineTableSize);
-    for (let i = 0; i < kSplineTableSize; ++i) {
-        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
-    }
-    function getTForX(aX) {
-        'worklet';
-        let intervalStart = 0.0;
-        let currentSample = 1;
-        const lastSample = kSplineTableSize - 1;
-        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
-            intervalStart += kSampleStepSize;
-        }
-        --currentSample;
-        // Interpolate to provide an initial guess for t
-        const dist = (aX - sampleValues[currentSample]) /
-            (sampleValues[currentSample + 1] - sampleValues[currentSample]);
-        const guessForT = intervalStart + dist * kSampleStepSize;
-        const 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) {
-        'worklet';
-        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);
-    };
-}