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

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

package/lib/reanimated1/core/InternalAnimatedValue.js

@@ -1,87 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-import { val } from '../val';
-import ReanimatedModule from '../../ReanimatedModule';
-import invariant from 'invariant';
-
-function sanitizeValue(value) {
-  return value === null || value === undefined || typeof value === 'string'
-    ? value
-    : Number(value);
-}
-
-const CONSTANT_VALUES = new Map();
-
-function initializeConstantValues() {
-  if (CONSTANT_VALUES.size !== 0) {
-    return;
-  }
-  [0, -1, 1, -2, 2].forEach((v) =>
-    CONSTANT_VALUES.set(v, new InternalAnimatedValue(v, true))
-  );
-}
-
-/**
- * This class has been made internal in order to omit dependencies' cycles which
- * were caused by imperative setValue and interpolate – they are currently exposed with AnimatedValue.js
- */
-export default class InternalAnimatedValue extends AnimatedNode {
-  static valueForConstant(number) {
-    initializeConstantValues();
-    return (
-      CONSTANT_VALUES.get(number) || new InternalAnimatedValue(number, true)
-    );
-  }
-
-  constructor(value, constant = false) {
-    invariant(value !== null, 'Animated.Value cannot be set to the null');
-    super({ type: 'value', value: sanitizeValue(value) });
-    this._startingValue = this._value = value;
-    this._animation = null;
-    this._constant = constant;
-  }
-
-  __detach() {
-    if (!this._constant) {
-      if (ReanimatedModule.getValue) {
-        ReanimatedModule.getValue(
-          this.__nodeID,
-          (val) => (this.__nodeConfig.value = val)
-        );
-      } else {
-        this.__nodeConfig.value = this.__getValue();
-      }
-    }
-    this.__detachAnimation(this._animation);
-    super.__detach();
-  }
-
-  __detachAnimation(animation) {
-    animation && animation.__detach();
-    if (this._animation === animation) {
-      this._animation = null;
-    }
-  }
-
-  __attachAnimation(animation) {
-    this.__detachAnimation(this._animation);
-    this._animation = animation;
-  }
-
-  __onEvaluate() {
-    if (this.__inputNodes && this.__inputNodes.length) {
-      this.__inputNodes.forEach(val);
-    }
-    return this._value;
-  }
-
-  // AnimatedValue will override this method to modify the value of a native node.
-  setValue(value) {
-    this.__detachAnimation(this._animation);
-    this._updateValue(value);
-  }
-
-  _updateValue(value) {
-    this._value = value;
-    this.__forceUpdateCache(value);
-  }
-}

package/lib/reanimated1/core/__mocks__/AnimatedProps.js

@@ -1,86 +0,0 @@
-import AnimatedNode from '../AnimatedNode';
-import AnimatedEvent from '../AnimatedEvent';
-import AnimatedStyle, { createOrReuseStyleNode } from '../AnimatedStyle';
-
-import deepEqual from 'lodash.isequal';
-
-// This file has been mocked as react-native's `findNodeHandle` is returning undefined value;
-// and I became easier to mock whole this file instead of mocking RN
-
-function sanitizeProps(inputProps) {
-  const props = {};
-  for (const key in inputProps) {
-    const value = inputProps[key];
-    if (value instanceof AnimatedNode && !(value instanceof AnimatedEvent)) {
-      props[key] = value.__nodeID;
-    }
-  }
-  return props;
-}
-
-export function createOrReusePropsNode(props, callback, oldNode) {
-  if (props.style) {
-    props = {
-      ...props,
-      style: createOrReuseStyleNode(
-        props.style,
-        oldNode && oldNode._props.style
-      ),
-    };
-  }
-  const config = sanitizeProps(props);
-  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();
-  }
-
-  __getProps() {
-    const props = {};
-    for (const key in this._props) {
-      const value = this._props[key];
-      if (value instanceof AnimatedNode) {
-        if (value instanceof AnimatedStyle) {
-          props[key] = value.__getProps();
-        }
-      } else {
-        props[key] = value;
-      }
-    }
-    return props;
-  }
-
-  __onEvaluate() {
-    const props = {};
-    for (const key in this._props) {
-      const value = this._props[key];
-      if (value instanceof AnimatedNode) {
-        props[key] = value.__getValue();
-      }
-    }
-    return props;
-  }
-
-  update() {
-    this._callback();
-  }
-
-  setNativeView(animatedView) {
-    if (this._animatedView === animatedView) {
-      return;
-    }
-    this._animatedView = animatedView;
-  }
-}

package/lib/reanimated1/core/createEventObjectProxyPolyfill.js

@@ -1,44 +0,0 @@
-// JSC on Android and iOS 8 & 9 does not support proxies.
-// The below workaround provides a proxy-like functionality for event data by
-// creating an object which contains predefined fields for the most commonly
-// used event attributes. If your app uses even attribute which is not listed
-// here please submit a PR to add that and we will merge it right away
-export default function createEventObjectProxyPolyfill() {
-  const nodesMap = {
-    // Gesture handlers-related event
-    translationX: {},
-    translationY: {},
-    state: {},
-    oldState: {},
-    absoluteX: {},
-    absoluteY: {},
-    x: {},
-    y: {},
-    velocityX: {},
-    velocityY: {},
-    scale: {},
-    focalX: {},
-    focalY: {},
-    rotation: {},
-    anchorX: {},
-    anchorY: {},
-    velocity: {},
-    numberOfPointers: {},
-    // onLayour-related event
-    layout: { x: {}, y: {}, width: {}, height: {} },
-    // ScrollView event
-    contentOffset: { y: {}, x: {} },
-    layoutMeasurement: { width: {}, height: {} },
-    contentSize: { width: {}, height: {} },
-    zoomScale: {},
-    contentInset: { right: {}, top: {}, left: {}, bottom: {} },
-  };
-  const traverse = (obj) => {
-    for (const key in obj) {
-      traverse(obj[key]);
-      Object.assign(obj[key], { __isProxy: true });
-    }
-  };
-  traverse(nodesMap);
-  return nodesMap;
-}

package/lib/reanimated1/derived/__mocks__/evaluateOnce.js

@@ -1,14 +0,0 @@
-import { always } from '../../base';
-export function evaluateOnce(node, children = [], callback) {
-  if (!Array.isArray(children)) {
-    children = [children];
-  }
-  const alwaysNode = always(node);
-  for (let i = 0; i < children.length; i++) {
-    alwaysNode.__addChild(children[i]);
-  }
-  for (let i = 0; i < children.length; i++) {
-    alwaysNode.__removeChild(children[i]);
-  }
-  callback && callback();
-}

package/lib/reanimated1/derived/acc.js

@@ -1,11 +0,0 @@
-import { set, add, proc } from '../base';
-import AnimatedValue from '../core/InternalAnimatedValue';
-
-const procAcc = proc(function (v, acc) {
-  return set(acc, add(acc, v));
-});
-
-export default function acc(v) {
-  const acc = new AnimatedValue(0);
-  return procAcc(v, acc);
-}

package/lib/reanimated1/derived/color.js

@@ -1,47 +0,0 @@
-import { Platform } from 'react-native';
-
-import {
-  add,
-  cond,
-  concat,
-  lessThan,
-  multiply,
-  round,
-  sub,
-  proc,
-} from '../base';
-import AnimatedNode from '../core/AnimatedNode';
-
-const procColor = proc(function (r, g, b, a) {
-  const color = add(
-    multiply(a, 1 << 24),
-    multiply(round(r), 1 << 16),
-    multiply(round(g), 1 << 8),
-    round(b)
-  );
-
-  if (Platform.OS === 'android') {
-    // on Android color is represented as signed 32 bit int
-    return cond(
-      lessThan(color, (1 << 31) >>> 0),
-      color,
-      sub(color, Math.pow(2, 32))
-    );
-  }
-  return color;
-});
-
-export default function color(r, g, b, a = 1) {
-  if (Platform.OS === 'web') {
-    // doesn't support bit shifting
-    return concat('rgba(', r, ',', g, ',', b, ',', a, ')');
-  }
-
-  if (a instanceof AnimatedNode) {
-    a = round(multiply(a, 255));
-  } else {
-    a = Math.round(a * 255);
-  }
-
-  return procColor(r, g, b, a);
-}

package/lib/reanimated1/derived/diff.js

@@ -1,16 +0,0 @@
-import { cond, block, defined, sub, set, proc } from '../base';
-import AnimatedValue from '../core/InternalAnimatedValue';
-
-const procDiff = proc(function (v, stash, prev) {
-  return block([
-    set(stash, cond(defined(prev), sub(v, prev), 0)),
-    set(prev, v),
-    stash,
-  ]);
-});
-
-export default function diff(v) {
-  const stash = new AnimatedValue(0);
-  const prev = new AnimatedValue();
-  return procDiff(v, stash, prev);
-}

package/lib/reanimated1/derived/diffClamp.js

@@ -1,11 +0,0 @@
-import { cond, defined, set, add, min, max } from '../base';
-import AnimatedValue from '../core/InternalAnimatedValue';
-import diff from './diff';
-
-export default function diffClamp(a, minVal, maxVal) {
-  const value = new AnimatedValue();
-  return set(
-    value,
-    min(max(add(cond(defined(value), value, a), diff(a)), minVal), maxVal)
-  );
-}

package/lib/reanimated1/derived/evaluateOnce.js

@@ -1,35 +0,0 @@
-import AnimatedValue from '../core/InternalAnimatedValue';
-import { createAnimatedSet as set } from '../core/AnimatedSet';
-import { createAnimatedCall as call } from '../core/AnimatedCall';
-import { createAnimatedAlways as always } from '../core/AnimatedAlways';
-import { createAnimatedCond as cond } from '../core/AnimatedCond';
-
-/**
- * evaluate given node and notify children
- * @param node - node to be evaluated
- * @param input - nodes (or one node) representing values which states input for node.
- * @param callback - after callback
- */
-
-export function evaluateOnce(node, input = [], callback) {
-  if (!Array.isArray(input)) {
-    input = [input];
-  }
-  const done = new AnimatedValue(0);
-  const evalNode = cond(
-    done,
-    0,
-    call([node, set(done, 1)], () => {
-      callback && callback();
-      for (let i = 0; i < input.length; i++) {
-        input[i].__removeChild(alwaysNode);
-        alwaysNode.__detach();
-      }
-    })
-  );
-  const alwaysNode = always(evalNode);
-  for (let i = 0; i < input.length; i++) {
-    input[i].__addChild(alwaysNode);
-    alwaysNode.__attach();
-  }
-}