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

package/src/reanimated1/core/AnimatedOperator.js

@@ -1,103 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-import { val } from '../val';
-
-import invariant from 'invariant';
-import { adapt } from '../core/AnimatedBlock';
-
-function reduce(fn) {
-  return (input) => input.reduce((a, b) => fn(val(a), val(b)));
-}
-
-function reduceFrom(fn, initialValue) {
-  return (input) => input.reduce((a, b) => fn(val(a), val(b)), initialValue);
-}
-
-function infix(fn) {
-  return (input) => fn(val(input[0]), val(input[1]));
-}
-
-function single(fn) {
-  return (input) => fn(val(input[0]));
-}
-
-const OPERATIONS = {
-  // arithmetic
-  add: reduce((a, b) => a + b),
-  sub: reduce((a, b) => a - b),
-  multiply: reduce((a, b) => a * b),
-  divide: reduce((a, b) => a / b),
-  pow: reduce((a, b) => Math.pow(a, b)),
-  modulo: reduce((a, b) => ((a % b) + b) % b),
-  sqrt: single((a) => Math.sqrt(a)),
-  log: single((a) => Math.log(a)),
-  sin: single((a) => Math.sin(a)),
-  cos: single((a) => Math.cos(a)),
-  tan: single((a) => Math.tan(a)),
-  acos: single((a) => Math.acos(a)),
-  asin: single((a) => Math.asin(a)),
-  atan: single((a) => Math.atan(a)),
-  exp: single((a) => Math.exp(a)),
-  round: single((a) => Math.round(a)),
-  abs: single((a) => Math.abs(a)),
-  ceil: single((a) => Math.ceil(a)),
-  floor: single((a) => Math.floor(a)),
-  max: reduce((a, b) => Math.max(a, b)),
-  min: reduce((a, b) => Math.min(a, b)),
-
-  // logical
-  and: reduceFrom((a, b) => a && b, true),
-  or: reduceFrom((a, b) => a || b, false),
-  not: single((a) => !a),
-  defined: single((a) => a !== null && a !== undefined && !isNaN(a)),
-
-  // comparing
-  lessThan: infix((a, b) => a < b),
-  /* eslint-disable-next-line eqeqeq */
-  eq: infix((a, b) => a == b),
-  greaterThan: infix((a, b) => a > b),
-  lessOrEq: infix((a, b) => a <= b),
-  greaterOrEq: infix((a, b) => a >= b),
-  /* eslint-disable-next-line eqeqeq */
-  neq: infix((a, b) => a != b),
-};
-
-class AnimatedOperator extends AnimatedNode {
-  _input;
-  _op;
-  _operation;
-
-  constructor(operator, input) {
-    invariant(
-      typeof operator === 'string',
-      `Reanimated: Animated.operator node first argument should be of type String, but got: ${operator}`
-    );
-    invariant(
-      input.every(
-        (el) =>
-          el instanceof AnimatedNode ||
-          typeof el === 'string' ||
-          typeof el === 'number'
-      ),
-      `Reanimated: Animated.operator node second argument should be one or more of type AnimatedNode, String or Number but got ${input}`
-    );
-    super({ type: 'op', op: operator, input }, input);
-    this._op = operator;
-    this._input = input;
-  }
-
-  toString() {
-    return `AnimatedOperator, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    if (!this._operation) {
-      this._operation = OPERATIONS[this._op];
-      invariant(this._operation, `Illegal operator '%s'`, this._op);
-    }
-    return this._operation(this._input);
-  }
-}
-
-export function createAnimatedOperator(name) {
-  return (...args) => new AnimatedOperator(name, args.map(adapt));
-}

package/src/reanimated1/core/AnimatedParam.js

@@ -1,88 +0,0 @@
-import invariant from 'invariant';
-import AnimatedNode, { getCallID, setCallID } from './AnimatedNode';
-import AnimatedClock from './AnimatedClock';
-import { val } from '../val';
-
-export class AnimatedParam extends AnimatedNode {
-  argsStack = [];
-  _prevCallID;
-
-  constructor() {
-    super({ type: 'param' }, []);
-    this.__attach();
-  }
-
-  beginContext(ref, prevCallID) {
-    this._prevCallID = prevCallID;
-    this.argsStack.push(ref);
-  }
-
-  endContext() {
-    this.argsStack.pop();
-  }
-
-  _getTopNode() {
-    if (this.argsStack.length === 0)
-      throw new Error(`param: Invocation failed because argsStack is empty`);
-    const top = this.argsStack[this.argsStack.length - 1];
-    return top;
-  }
-
-  setValue(value) {
-    const top = this._getTopNode();
-    if (top.setValue) {
-      const callID = getCallID();
-      setCallID(this._prevCallID);
-      top.setValue(value);
-      setCallID(callID);
-    } else {
-      throw new Error(
-        `param: setValue(${value}) failed because the top element has no known method for updating it's current value.`
-      );
-    }
-  }
-
-  __onEvaluate() {
-    const callID = getCallID();
-    setCallID(this._prevCallID);
-    const top = this._getTopNode();
-    const value = val(top);
-    setCallID(callID);
-    return value;
-  }
-
-  start() {
-    const node = this._getTopNode();
-    invariant(
-      node instanceof AnimatedClock || node instanceof AnimatedParam,
-      `param: top node should be of type AnimatedClock but got ${node}`
-    );
-    node.start();
-  }
-
-  stop() {
-    const node = this._getTopNode();
-    invariant(
-      node instanceof AnimatedClock || node instanceof AnimatedParam,
-      `param: top node should be of type AnimatedClock but got ${node}`
-    );
-    node.stop();
-  }
-
-  isRunning() {
-    const node = this._getTopNode();
-
-    if (node instanceof AnimatedParam) {
-      return node.isRunning();
-    }
-    invariant(
-      node instanceof AnimatedClock,
-      `param: top node should be of type AnimatedClock but got ${node}`
-    );
-    return node.isStarted();
-  }
-}
-
-export function createAnimatedParam() {
-  return new AnimatedParam();
-}

package/src/reanimated1/core/AnimatedProps.js

@@ -1,108 +0,0 @@
-import { findNodeHandle } from 'react-native';
-
-import AnimatedNode from './AnimatedNode';
-import AnimatedEvent from './AnimatedEvent';
-import { createOrReuseStyleNode } from './AnimatedStyle';
-
-import invariant from 'invariant';
-import deepEqual from 'lodash.isequal';
-import { val } from '../val';
-
-function sanitizeProps(inputProps) {
-  let props;
-  for (const key in inputProps) {
-    const value = inputProps[key];
-    if (value instanceof AnimatedNode && !(value instanceof AnimatedEvent)) {
-      if (props === undefined) {
-        props = {};
-      }
-      props[key] = value.__nodeID;
-    }
-  }
-  return props;
-}
-
-export function createOrReusePropsNode(props, callback, oldNode) {
-  if (props.style) {
-    const style = createOrReuseStyleNode(
-      props.style,
-      oldNode && oldNode._props.style
-    );
-    if (style) {
-      props = {
-        ...props,
-        style,
-      };
-    }
-  }
-  const config = sanitizeProps(props);
-  if (config === undefined) {
-    return undefined;
-  }
-  if (oldNode && deepEqual(config, oldNode._config)) {
-    return oldNode;
-  }
-  return new AnimatedProps(props, config, callback);
-}
-
-class AnimatedProps extends AnimatedNode {
-  constructor(props, config, callback) {
-    super(
-      { type: 'props', props: config },
-      Object.values(props).filter((n) => !(n instanceof AnimatedEvent))
-    );
-    this._config = config;
-    this._props = props;
-    this._callback = callback;
-    this.__attach();
-  }
-
-  toString() {
-    return `AnimatedProps, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    const props = {};
-    for (const key in this._props) {
-      const value = this._props[key];
-      if (value instanceof AnimatedNode) {
-        props[key] = value.__getValue();
-      }
-    }
-    return props;
-  }
-
-  __detach() {
-    const nativeViewTag = findNodeHandle(this._animatedView);
-    invariant(
-      nativeViewTag != null,
-      'Unable to locate attached view in the native tree'
-    );
-    this._disconnectAnimatedView(nativeViewTag);
-    super.__detach();
-  }
-
-  update() {
-    this._callback();
-
-    if (!this._animatedView) {
-      return;
-    }
-
-    val(this);
-  }
-
-  setNativeView(animatedView) {
-    if (this._animatedView === animatedView) {
-      return;
-    }
-    this._animatedView = animatedView;
-
-    const nativeViewTag = findNodeHandle(this._animatedView);
-    invariant(
-      nativeViewTag != null,
-      'Unable to locate attached view in the native tree'
-    );
-    this._connectAnimatedView(nativeViewTag);
-  }
-}

package/src/reanimated1/core/AnimatedSet.js

@@ -1,38 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-import invariant from 'invariant';
-import { val } from '../val';
-import { adapt } from '../core/AnimatedBlock';
-
-class AnimatedSet extends AnimatedNode {
-  _what;
-  _value;
-
-  constructor(what, value) {
-    invariant(
-      what instanceof AnimatedNode,
-      `Reanimated: Animated.set first argument should be of type AnimatedNode but got ${what}`
-    );
-    invariant(
-      value instanceof AnimatedNode,
-      `Reanimated: Animated.set second argument should be of type AnimatedNode, String or Number but got ${value}`
-    );
-    super({ type: 'set', what, value }, [value]);
-    invariant(!what._constant, 'Value to be set cannot be constant');
-    this._what = what;
-    this._value = value;
-  }
-
-  toString() {
-    return `AnimatedSet, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    const newValue = val(this._value);
-    this._what.setValue(newValue);
-    return newValue;
-  }
-}
-
-export function createAnimatedSet(what, value) {
-  return new AnimatedSet(what, adapt(value));
-}

package/src/reanimated1/core/AnimatedStartClock.js

@@ -1,30 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-import AnimatedClock from './AnimatedClock';
-import { AnimatedParam } from './AnimatedParam';
-import invariant from 'invariant';
-
-class AnimatedStartClock extends AnimatedNode {
-  _clockNode;
-
-  constructor(clockNode) {
-    invariant(
-      clockNode instanceof AnimatedClock || clockNode instanceof AnimatedParam,
-      `Reanimated: Animated.startClock argument should be of type AnimatedClock but got ${clockNode}`
-    );
-    super({ type: 'clockStart', clock: clockNode });
-    this._clockNode = clockNode;
-  }
-
-  toString() {
-    return `AnimatedStartClock, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    this._clockNode.start();
-    return 0;
-  }
-}
-
-export function createAnimatedStartClock(clock) {
-  return new AnimatedStartClock(clock);
-}

package/src/reanimated1/core/AnimatedStopClock.js

@@ -1,30 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-import AnimatedClock from './AnimatedClock';
-import { AnimatedParam } from './AnimatedParam';
-import invariant from 'invariant';
-
-class AnimatedStopClock extends AnimatedNode {
-  _clockNode;
-
-  constructor(clockNode) {
-    invariant(
-      clockNode instanceof AnimatedClock || clockNode instanceof AnimatedParam,
-      `Reanimated: Animated.stopClock argument should be of type AnimatedClock but got ${clockNode}`
-    );
-    super({ type: 'clockStop', clock: clockNode });
-    this._clockNode = clockNode;
-  }
-
-  toString() {
-    return `AnimatedStopClock, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    this._clockNode.stop();
-    return 0;
-  }
-}
-
-export function createAnimatedStopClock(clock) {
-  return new AnimatedStopClock(clock);
-}

package/src/reanimated1/core/AnimatedStyle.js

@@ -1,78 +0,0 @@
-import { StyleSheet } from 'react-native';
-
-import AnimatedNode from './AnimatedNode';
-import { createOrReuseTransformNode } from './AnimatedTransform';
-
-import deepEqual from 'lodash.isequal';
-
-function sanitizeStyle(inputStyle) {
-  let style;
-  for (const key in inputStyle) {
-    const value = inputStyle[key];
-    if (value instanceof AnimatedNode) {
-      if (style === undefined) {
-        style = {};
-      }
-      style[key] = value.__nodeID;
-    }
-  }
-  return style;
-}
-
-export function createOrReuseStyleNode(style, oldNode) {
-  style = StyleSheet.flatten(style) || {};
-  if (style.transform) {
-    const transform = createOrReuseTransformNode(
-      style.transform,
-      oldNode && oldNode._style.transform
-    );
-    if (transform) {
-      style = {
-        ...style,
-        transform,
-      };
-    }
-  }
-  const config = sanitizeStyle(style);
-  if (config === undefined) {
-    return undefined;
-  }
-  if (oldNode && deepEqual(config, oldNode._config)) {
-    return oldNode;
-  }
-  return new AnimatedStyle(style, config);
-}
-
-/**
- * AnimatedStyle should never be directly instantiated, use createOrReuseStyleNode
- * in order to make a new instance of this node.
- */
-export default class AnimatedStyle extends AnimatedNode {
-  constructor(style, config) {
-    super({ type: 'style', style: config }, Object.values(style));
-    this._config = config;
-    this._style = style;
-  }
-
-  toString() {
-    return `AnimatedStyle, id: ${this.__nodeID}`;
-  }
-
-  _walkStyleAndGetAnimatedValues(style) {
-    const updatedStyle = {};
-    for (const key in style) {
-      const value = style[key];
-      if (value instanceof AnimatedNode) {
-        updatedStyle[key] = value.__getValue();
-      } else if (value && !Array.isArray(value) && typeof value === 'object') {
-        // Support animating nested values (for example: shadowOffset.height)
-        updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value);
-      }
-    }
-    return updatedStyle;
-  }
-
-  __onEvaluate() {
-    return this._walkStyleAndGetAnimatedValues(this._style);
-  }
-}

package/src/reanimated1/core/AnimatedTransform.js

@@ -1,78 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-
-import deepEqual from 'lodash.isequal';
-
-function sanitizeTransform(inputTransform) {
-  const outputTransform = [];
-  let hasAnimatedTransform = false;
-  inputTransform.forEach((transform) => {
-    for (const key in transform) {
-      const value = transform[key];
-      if (value instanceof AnimatedNode) {
-        hasAnimatedTransform = true;
-        outputTransform.push({
-          property: key,
-          nodeID: value.__nodeID,
-        });
-      } else {
-        outputTransform.push({
-          property: key,
-          value,
-        });
-      }
-    }
-  });
-  return hasAnimatedTransform ? outputTransform : undefined;
-}
-
-function extractAnimatedParentNodes(transform) {
-  const parents = [];
-  transform.forEach((transform) => {
-    for (const key in transform) {
-      const value = transform[key];
-      if (value instanceof AnimatedNode) {
-        parents.push(value);
-      }
-    }
-  });
-  return parents;
-}
-
-export function createOrReuseTransformNode(transform, oldNode) {
-  const config = sanitizeTransform(transform);
-  if (config === undefined) {
-    return undefined;
-  }
-  if (oldNode && deepEqual(config, oldNode._config)) {
-    return oldNode;
-  }
-  return new AnimatedTransform(transform, config);
-}
-
-class AnimatedTransform extends AnimatedNode {
-  constructor(transform, config) {
-    super(
-      { type: 'transform', transform: config },
-      extractAnimatedParentNodes(transform)
-    );
-    this._config = config;
-    this._transform = transform;
-  }
-
-  toString() {
-    return `AnimatedTransform, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    return this._transform.map((transform) => {
-      const result = {};
-      for (const key in transform) {
-        const value = transform[key];
-        if (value instanceof AnimatedNode) {
-          result[key] = value.__getValue();
-        }
-      }
-      return result;
-    });
-  }
-}

package/src/reanimated1/core/AnimatedValue.js

@@ -1,38 +0,0 @@
-import { createAnimatedSet as set } from '../core/AnimatedSet';
-import interpolate from '../derived/interpolate';
-import InternalAnimatedValue from './InternalAnimatedValue';
-import { Platform } from 'react-native';
-import { evaluateOnce } from '../derived/evaluateOnce';
-import ReanimatedModule from '../../ReanimatedModule';
-import { val } from '../val';
-
-// Animated value wrapped with extra methods for omit cycle of dependencies
-export default class AnimatedValue extends InternalAnimatedValue {
-  setValue(value) {
-    this.__detachAnimation(this._animation);
-    if (
-      Platform.OS === 'web' ||
-      Platform.OS === 'windows' ||
-      Platform.OS === 'macos'
-    ) {
-      this._updateValue(val(value));
-    } else {
-      if (ReanimatedModule.setValue && typeof value === 'number') {
-        // FIXME Remove it after some time
-        // For OTA-safety
-        // FIXME handle setting value with a node
-        ReanimatedModule.setValue(this.__nodeID, value);
-      } else {
-        evaluateOnce(set(this, value), this);
-      }
-    }
-  }
-
-  toString() {
-    return `AnimatedValue, id: ${this.__nodeID}`;
-  }
-
-  interpolate(config) {
-    return interpolate(this, config);
-  }
-}

package/src/reanimated1/core/Core.test.js

@@ -1,30 +0,0 @@
-import React from 'react';
-import Animated from '../../Animated';
-
-import renderer from 'react-test-renderer';
-
-jest.mock('../../ReanimatedEventEmitter');
-jest.mock('../../ReanimatedModule');
-jest.mock('../../reanimated2/NativeReanimated/NativeReanimated');
-
-describe('Core Animated components', () => {
-  xit('fails if something other then a node or function that returns a node is passed to Animated.Code exec prop', () => {
-    console.error = jest.fn();
-
-    expect(() =>
-      renderer.create(<Animated.Code exec="not a node" />)
-    ).toThrowError(
-      "<Animated.Code /> expects the 'exec' prop or children to be an animated node or a function returning an animated node."
-    );
-  });
-
-  xit('fails if something other then a node or function that returns a node is passed to Animated.Code children', () => {
-    console.error = jest.fn();
-
-    expect(() =>
-      renderer.create(<Animated.Code>not a node</Animated.Code>)
-    ).toThrowError(
-      "<Animated.Code /> expects the 'exec' prop or children to be an animated node or a function returning an animated node."
-    );
-  });
-});