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

package/lib/reanimated1/core/AnimatedEvent.js

@@ -1,126 +0,0 @@
-import { Platform, findNodeHandle } from 'react-native';
-import ReanimatedModule from '../../ReanimatedModule';
-
-import AnimatedNode from './AnimatedNode';
-import InternalAnimatedValue from './AnimatedValue';
-import { createAnimatedAlways } from './AnimatedAlways';
-
-import invariant from 'invariant';
-import createEventObjectProxyPolyfill from './createEventObjectProxyPolyfill';
-
-function sanitizeArgMapping(argMapping) {
-  // Find animated values in `argMapping` and create an array representing their
-  // key path inside the `nativeEvent` object. Ex.: ['contentOffset', 'x'].
-  const eventMappings = [];
-  const alwaysNodes = [];
-
-  const getNode = (node) => {
-    if (
-      Platform.OS === 'web' ||
-      Platform.OS === 'windows' ||
-      Platform.OS === 'macos'
-    ) {
-      return node;
-    }
-    return node.__nodeID;
-  };
-
-  const traverse = (value, path) => {
-    if (value instanceof InternalAnimatedValue) {
-      eventMappings.push(path.concat(getNode(value)));
-    } else if (typeof value === 'object' && value.__val) {
-      eventMappings.push(path.concat(getNode(value.__val)));
-    } else if (typeof value === 'function') {
-      const node = new InternalAnimatedValue(0);
-      alwaysNodes.push(createAnimatedAlways(value(node)));
-      eventMappings.push(path.concat(getNode(node)));
-    } else if (typeof value === 'object') {
-      for (const key in value) {
-        traverse(value[key], path.concat(key));
-      }
-    }
-  };
-
-  invariant(
-    argMapping[0] && argMapping[0].nativeEvent,
-    'Native driven events only support animated values contained inside `nativeEvent`.'
-  );
-
-  // Assume that the event containing `nativeEvent` is always the first argument.
-  const ev = argMapping[0].nativeEvent;
-  if (typeof ev === 'object') {
-    traverse(ev, []);
-  } else if (typeof ev === 'function') {
-    const proxyHandler = {
-      get: function (target, name) {
-        if (name === '__isProxy') {
-          return true;
-        }
-        if (!target[name] && name !== '__val') {
-          target[name] = new Proxy({}, proxyHandler);
-        }
-        return target[name];
-      },
-      set: function (target, prop, value) {
-        if (prop === '__val') {
-          target[prop] = value;
-          return true;
-        }
-        return false;
-      },
-    };
-
-    const proxy =
-      typeof Proxy === 'function'
-        ? new Proxy({}, proxyHandler)
-        : createEventObjectProxyPolyfill();
-    alwaysNodes.push(createAnimatedAlways(ev(proxy)));
-    traverse(proxy, []);
-  }
-
-  return { eventMappings, alwaysNodes };
-}
-
-export default class AnimatedEvent extends AnimatedNode {
-  constructor(argMapping, _config = {}) {
-    const { eventMappings, alwaysNodes } = sanitizeArgMapping(argMapping);
-    super({ type: 'event', argMapping: eventMappings });
-    this._alwaysNodes = alwaysNodes;
-  }
-
-  toString() {
-    return `AnimatedEvent, id: ${this.__nodeID}`;
-  }
-
-  // The below field is a temporary workaround to make AnimatedEvent object be recognized
-  // as Animated.event event callback and therefore filtered out from being send over the
-  // bridge which was causing the object to be frozen in JS.
-  __isNative = true;
-
-  attachEvent(viewRef, eventName) {
-    for (let i = 0; i < this._alwaysNodes.length; i++) {
-      this._alwaysNodes[i].__attach();
-    }
-    this.__attach();
-    const viewTag = findNodeHandle(viewRef);
-    ReanimatedModule.attachEvent(viewTag, eventName, this.__nodeID);
-  }
-
-  __onEvaluate() {
-    return 0;
-  }
-
-  detachEvent(viewRef, eventName) {
-    for (let i = 0; i < this._alwaysNodes.length; i++) {
-      this._alwaysNodes[i].isNativelyInitialized() &&
-        this._alwaysNodes[i].__detach();
-    }
-    const viewTag = findNodeHandle(viewRef);
-    ReanimatedModule.detachEvent(viewTag, eventName, this.__nodeID);
-    this.__detach();
-  }
-}
-
-export function createAnimatedEvent(argMapping, config) {
-  return new AnimatedEvent(argMapping, config);
-}

package/lib/reanimated1/core/AnimatedFunction.js

@@ -1,55 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-import { createAnimatedCallFunc } from './AnimatedCallFunc';
-import { createAnimatedParam } from './AnimatedParam';
-import { val } from '../val';
-import invariant from 'invariant';
-
-class AnimatedFunction extends AnimatedNode {
-  _what;
-
-  constructor(what, ...params) {
-    invariant(
-      what instanceof AnimatedNode,
-      `Reanimated: AnimatedCallFunc 'what' argument should be of type AnimatedNode but got ${what}`
-    );
-    super(
-      {
-        type: 'func',
-        what,
-      },
-      [what, ...params]
-    );
-    this._what = what;
-    this.__attach();
-  }
-
-  __onEvaluate() {
-    return val(this._what);
-  }
-
-  toString() {
-    return `AnimatedFunction, id: ${this.__nodeID}`;
-  }
-}
-
-export function createAnimatedFunction(cb) {
-  const params = new Array(cb.length);
-  for (let i = 0; i < params.length; i++) {
-    params[i] = createAnimatedParam();
-  }
-  // eslint-disable-next-line node/no-callback-literal
-  const what = cb(...params);
-  const func = new AnimatedFunction(what, ...params);
-  return (...args) => {
-    if (args.length !== params.length) {
-      throw new Error(
-        'Parameter mismatch when calling reanimated function. Expected ' +
-          params.length +
-          ' parameters, got ' +
-          args.length +
-          '.'
-      );
-    }
-    return createAnimatedCallFunc(func, args, params);
-  };
-}

package/lib/reanimated1/core/AnimatedNode.js

@@ -1,223 +0,0 @@
-import ReanimatedModule from '../../ReanimatedModule';
-import { Platform } from 'react-native';
-
-const UPDATED_NODES = [];
-
-let loopID = 1;
-let propUpdatesEnqueued = null;
-let nodeCount = 0;
-let callID = '';
-
-export function getCallID() {
-  return callID;
-}
-
-export function setCallID(nextCallID) {
-  callID = nextCallID;
-}
-
-function sanitizeConfig(config) {
-  if (
-    Platform.OS === 'web' ||
-    Platform.OS === 'windows' ||
-    Platform.OS === 'macos' ||
-    ['undefined', 'string', 'function', 'boolean', 'number'].includes(
-      typeof config
-    )
-  ) {
-    return config;
-  } else if (Array.isArray(config)) {
-    return config.map(sanitizeConfig);
-  } else if (config instanceof AnimatedNode) {
-    return config.__nodeID;
-  } else if (typeof config === 'object') {
-    const output = {};
-    for (const property in config) {
-      if (property in config) {
-        output[property] = sanitizeConfig(config[property]);
-      }
-    }
-    return output;
-  }
-  // unhandled
-  return config;
-}
-
-function runPropUpdates() {
-  const visitedNodes = new Set();
-  const findAndUpdateNodes = (node) => {
-    if (!node) {
-      console.warn('findAndUpdateNodes was passed a nullish node');
-      return;
-    }
-
-    if (visitedNodes.has(node)) {
-      return;
-    } else {
-      visitedNodes.add(node);
-    }
-    if (typeof node.update === 'function') {
-      node.update();
-    } else {
-      const nodes = node.__getChildren();
-      if (nodes) {
-        for (let i = 0, l = nodes.length; i < l; i++) {
-          findAndUpdateNodes(nodes[i]);
-        }
-      }
-    }
-  };
-  for (let i = 0; i < UPDATED_NODES.length; i++) {
-    const node = UPDATED_NODES[i];
-    findAndUpdateNodes(node);
-  }
-  UPDATED_NODES.length = 0; // clear array
-  propUpdatesEnqueued = null;
-  loopID += 1;
-}
-
-const scheduleUpdates =
-  Platform.OS === 'web' ? requestAnimationFrame : setImmediate;
-
-export default class AnimatedNode {
-  __nodeID;
-  __lastLoopID = { '': -1 };
-  __memoizedValue = { '': null };
-  __children = [];
-
-  constructor(nodeConfig, inputNodes) {
-    this.__nodeID = ++nodeCount;
-    this.__nodeConfig = sanitizeConfig(nodeConfig);
-    this.__initialized = false;
-    this.__inputNodes =
-      inputNodes && inputNodes.filter((node) => node instanceof AnimatedNode);
-  }
-
-  toString() {
-    return `AnimatedNode, id: ${this.__nodeID}`;
-  }
-
-  __attach() {
-    this.__nativeInitialize();
-
-    const nodes = this.__inputNodes;
-
-    if (nodes) {
-      for (let i = 0, l = nodes.length; i < l; i++) {
-        nodes[i].__addChild(this);
-      }
-    }
-  }
-
-  __detach() {
-    const nodes = this.__inputNodes;
-
-    if (nodes) {
-      for (let i = 0, l = nodes.length; i < l; i++) {
-        nodes[i].__removeChild(this);
-      }
-    }
-
-    this.__nativeTearDown();
-  }
-
-  __getValue() {
-    if (!(callID in this.__lastLoopID) || this.__lastLoopID[callID] < loopID) {
-      this.__lastLoopID[callID] = loopID;
-      const result = this.__onEvaluate();
-      this.__memoizedValue[callID] = result;
-      return result;
-    }
-    return this.__memoizedValue[callID];
-  }
-
-  __forceUpdateCache(newValue) {
-    this.__memoizedValue[callID] = newValue;
-    this.__markUpdated();
-  }
-
-  __dangerouslyRescheduleEvaluate() {
-    this.__lastLoopID[callID] = -1;
-    this.__markUpdated();
-  }
-
-  __markUpdated() {
-    UPDATED_NODES.push(this);
-    if (!propUpdatesEnqueued) {
-      propUpdatesEnqueued = scheduleUpdates(runPropUpdates);
-    }
-  }
-
-  __nativeInitialize() {
-    if (!this.__initialized) {
-      ReanimatedModule.createNode(this.__nodeID, { ...this.__nodeConfig });
-      this.__initialized = true;
-    }
-  }
-
-  __nativeTearDown() {
-    if (this.__initialized) {
-      ReanimatedModule.dropNode(this.__nodeID);
-      this.__initialized = false;
-    }
-  }
-
-  isNativelyInitialized() {
-    return this.__initialized;
-  }
-
-  __onEvaluate() {
-    throw new Error('Missing implementation of onEvaluate');
-  }
-
-  __getProps() {
-    return this.__getValue();
-  }
-
-  __getChildren() {
-    return this.__children;
-  }
-
-  __addChild(child) {
-    if (this.__children.length === 0) {
-      this.__attach();
-    }
-    this.__children.push(child);
-    child.__nativeInitialize();
-
-    if (ReanimatedModule.connectNodes) {
-      ReanimatedModule.connectNodes(this.__nodeID, child.__nodeID);
-    } else {
-      child.__dangerouslyRescheduleEvaluate();
-    }
-  }
-
-  __removeChild(child) {
-    const index = this.__children.indexOf(child);
-    if (index === -1) {
-      console.warn("Trying to remove a child that doesn't exist");
-      return;
-    }
-
-    if (ReanimatedModule.disconnectNodes) {
-      ReanimatedModule.disconnectNodes(this.__nodeID, child.__nodeID);
-    }
-
-    this.__children.splice(index, 1);
-    if (this.__children.length === 0) {
-      this.__detach();
-    }
-  }
-
-  _connectAnimatedView(nativeViewTag) {
-    if (ReanimatedModule.connectNodeToView) {
-      ReanimatedModule.connectNodeToView(this.__nodeID, nativeViewTag);
-    } else {
-      this.__dangerouslyRescheduleEvaluate();
-    }
-  }
-
-  _disconnectAnimatedView(nativeViewTag) {
-    ReanimatedModule.disconnectNodeFromView(this.__nodeID, nativeViewTag);
-  }
-}

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