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

package/src/reanimated1/derived/index.js

@@ -1,8 +0,0 @@
-export { default as acc } from './acc';
-export { default as color } from './color';
-export { default as diff } from './diff';
-export { default as diffClamp } from './diffClamp';
-export { default as interpolateNode, Extrapolate } from './interpolate';
-export { default as interpolateColors } from './interpolateColors';
-export { default as onChange } from './onChange';
-export { default as useCode } from './useCode';

package/src/reanimated1/derived/interpolate.js

@@ -1,152 +0,0 @@
-import {
-  lessThan,
-  multiply,
-  sub,
-  add,
-  divide,
-  greaterThan,
-  lessOrEq,
-  eq,
-} from '../operators';
-import invariant from 'invariant';
-
-import AnimatedNode from '../core/AnimatedNode';
-import { createAnimatedCond as cond } from '../core/AnimatedCond';
-import { createAnimatedFunction as proc } from '../core/AnimatedFunction';
-
-const interpolateInternalSingleProc = proc(function (
-  value,
-  inS,
-  inE,
-  outS,
-  outE
-) {
-  const progress = divide(sub(value, inS), sub(inE, inS));
-  // logic below was made in order to provide a compatibility witn an Animated API
-  const resultForNonZeroRange = add(outS, multiply(progress, sub(outE, outS)));
-  const result = cond(
-    eq(inS, inE),
-    cond(lessOrEq(value, inS), outS, outE),
-    resultForNonZeroRange
-  );
-  return result;
-});
-
-function interpolateInternalSingle(value, inputRange, outputRange, offset) {
-  const inS = inputRange[offset];
-  const inE = inputRange[offset + 1];
-  const outS = outputRange[offset];
-  const outE = outputRange[offset + 1];
-  return interpolateInternalSingleProc(value, inS, inE, outS, outE);
-}
-
-function interpolateInternal(value, inputRange, outputRange, offset = 0) {
-  if (inputRange.length - offset === 2) {
-    return interpolateInternalSingle(value, inputRange, outputRange, offset);
-  }
-  return cond(
-    lessThan(value, inputRange[offset + 1]),
-    interpolateInternalSingle(value, inputRange, outputRange, offset),
-    interpolateInternal(value, inputRange, outputRange, offset + 1)
-  );
-}
-
-export const Extrapolate = {
-  EXTEND: 'extend',
-  CLAMP: 'clamp',
-  IDENTITY: 'identity',
-};
-
-function checkNonDecreasing(name, arr) {
-  for (let i = 1; i < arr.length; ++i) {
-    // We can't validate animated nodes in JS.
-    if (arr[i] instanceof AnimatedNode || arr[i - 1] instanceof AnimatedNode)
-      continue;
-    invariant(
-      arr[i] >= arr[i - 1],
-      '%s must be monotonically non-decreasing. (%s)',
-      name,
-      arr
-    );
-  }
-}
-
-function checkMinElements(name, arr) {
-  invariant(
-    arr.length >= 2,
-    '%s must have at least 2 elements. (%s)',
-    name,
-    arr
-  );
-}
-
-function checkValidNumbers(name, arr) {
-  for (let i = 0; i < arr.length; i++) {
-    // We can't validate animated nodes in JS.
-    if (arr[i] instanceof AnimatedNode || typeof arr[i] !== 'number') continue;
-    invariant(
-      Number.isFinite(arr[i]),
-      '%s cannot include %s. (%s)',
-      name,
-      arr[i],
-      arr
-    );
-  }
-}
-
-function convertToRadians(outputRange) {
-  for (const [i, value] of outputRange.entries()) {
-    if (typeof value === 'string' && value.endsWith('deg')) {
-      outputRange[i] = parseFloat(value) * (Math.PI / 180);
-    } else if (typeof value === 'string' && value.endsWith('rad')) {
-      outputRange[i] = parseFloat(value);
-    }
-  }
-}
-
-export default function interpolate(value, config) {
-  const {
-    inputRange,
-    outputRange,
-    extrapolate = Extrapolate.EXTEND,
-    extrapolateLeft,
-    extrapolateRight,
-  } = config;
-
-  checkMinElements('inputRange', inputRange);
-  checkValidNumbers('inputRange', inputRange);
-  checkMinElements('outputRange', outputRange);
-  checkValidNumbers('outputRange', outputRange);
-  checkNonDecreasing('inputRange', inputRange);
-  invariant(
-    inputRange.length === outputRange.length,
-    'inputRange and outputRange must be the same length.'
-  );
-
-  convertToRadians(outputRange);
-  const left = extrapolateLeft || extrapolate;
-  const right = extrapolateRight || extrapolate;
-  let output = interpolateInternal(value, inputRange, outputRange);
-
-  if (left === Extrapolate.CLAMP) {
-    output = cond(lessThan(value, inputRange[0]), outputRange[0], output);
-  } else if (left === Extrapolate.IDENTITY) {
-    output = cond(lessThan(value, inputRange[0]), value, output);
-  }
-
-  if (right === Extrapolate.CLAMP) {
-    output = cond(
-      greaterThan(value, inputRange[inputRange.length - 1]),
-      outputRange[outputRange.length - 1],
-      output
-    );
-  } else if (right === Extrapolate.IDENTITY) {
-    output = cond(
-      greaterThan(value, inputRange[inputRange.length - 1]),
-      value,
-      output
-    );
-  }
-
-  return output;
-}

package/src/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/src/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/src/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/src/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/src/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/src/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/src/reanimated1/val.js

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