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

package/android/src/main/java/com/swmansion/reanimated/nodes/Node.java

@@ -1,139 +0,0 @@
-package com.swmansion.reanimated.nodes;
-
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.UiThreadUtil;
-import com.swmansion.reanimated.NodesManager;
-import com.swmansion.reanimated.UpdateContext;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.Stack;
-import javax.annotation.Nullable;
-
-public abstract class Node {
-
-  public static final Double ZERO = Double.valueOf(0);
-  public static final Double ONE = Double.valueOf(1);
-
-  protected final int mNodeID;
-  protected final NodesManager mNodesManager;
-
-  protected final UpdateContext mUpdateContext;
-
-  private final Map<String, Long> mLastLoopID = new HashMap<>();
-  private final Map<String, Object> mMemoizedValue = new HashMap<>();
-  private @Nullable List<Node> mChildren; /* lazy-initialized when a child is added */
-
-  public Node(int nodeID, @Nullable ReadableMap config, NodesManager nodesManager) {
-    mLastLoopID.put("", -1L);
-    mNodeID = nodeID;
-    mNodesManager = nodesManager;
-    mUpdateContext = nodesManager.updateContext;
-  }
-
-  protected abstract @Nullable Object evaluate();
-
-  public final @Nullable Object value() {
-    if (!mLastLoopID.containsKey(mUpdateContext.callID)
-        || mLastLoopID.get(mUpdateContext.callID) < mUpdateContext.updateLoopID) {
-      mLastLoopID.put(mUpdateContext.callID, mUpdateContext.updateLoopID);
-      Object result = evaluate();
-      mMemoizedValue.put(mUpdateContext.callID, result);
-
-      return result;
-    }
-    return mMemoizedValue.get(mUpdateContext.callID);
-  }
-
-  /**
-   * This method will never return null. If value is null or of a different type we try to cast and
-   * return 0 if we fail to properly cast the value. This is to match iOS behavior where the node
-   * would not throw even if the value was not set.
-   */
-  public final Double doubleValue() {
-    Object value = value();
-    if (value == null) {
-      return ZERO;
-    } else if (value instanceof Double) {
-      return (Double) value;
-    } else if (value instanceof Number) {
-      return Double.valueOf(((Number) value).doubleValue());
-    } else if (value instanceof Boolean) {
-      return ((Boolean) value).booleanValue() ? ONE : ZERO;
-    }
-    throw new IllegalStateException("Value of node " + this + " cannot be cast to a number");
-  }
-
-  public void addChild(Node child) {
-    if (mChildren == null) {
-      mChildren = new ArrayList<>();
-    }
-    mChildren.add(child);
-    child.dangerouslyRescheduleEvaluate();
-  }
-
-  public void removeChild(Node child) {
-    if (mChildren != null) {
-      mChildren.remove(child);
-    }
-  }
-
-  protected void markUpdated() {
-    UiThreadUtil.assertOnUiThread();
-    mUpdateContext.updatedNodes.add(this);
-    mNodesManager.postRunUpdatesAfterAnimation();
-  }
-
-  public void onDrop() {
-    // noop
-  }
-
-  protected final void dangerouslyRescheduleEvaluate() {
-    mLastLoopID.put(mUpdateContext.callID, -1L);
-    markUpdated();
-  }
-
-  protected final void forceUpdateMemoizedValue(Object value) {
-    mMemoizedValue.put(mUpdateContext.callID, value);
-    markUpdated();
-  }
-
-  private static void findAndUpdateNodes(
-      Node node, Set<Node> visitedNodes, Stack<FinalNode> finalNodes) {
-    if (visitedNodes.contains(node)) {
-      return;
-    } else {
-      visitedNodes.add(node);
-    }
-
-    List<Node> children = node.mChildren;
-    if (children != null) {
-      for (Node child : children) {
-        findAndUpdateNodes(child, visitedNodes, finalNodes);
-      }
-    }
-    if (node instanceof FinalNode) {
-      finalNodes.push((FinalNode) node);
-    }
-  }
-
-  public static void runUpdates(UpdateContext updateContext) {
-    UiThreadUtil.assertOnUiThread();
-    ArrayList<Node> updatedNodes = updateContext.updatedNodes;
-    Set<Node> visitedNodes = new HashSet<>();
-    Stack<FinalNode> finalNodes = new Stack<>();
-    for (int i = 0; i < updatedNodes.size(); i++) {
-      findAndUpdateNodes(updatedNodes.get(i), visitedNodes, finalNodes);
-      if (i == updatedNodes.size() - 1) {
-        while (!finalNodes.isEmpty()) {
-          finalNodes.pop().update();
-        }
-      }
-    }
-    updatedNodes.clear();
-    updateContext.updateLoopID++;
-  }
-}

package/android/src/main/java/com/swmansion/reanimated/nodes/NoopNode.java

@@ -1,37 +0,0 @@
-package com.swmansion.reanimated.nodes;
-
-import com.swmansion.reanimated.NodesManager;
-
-/**
- * This node is used by {@link NodesManager} to return in place of a missing node that might have
- * been requested. This way we avoid a top of null-checks and we make nodes manager compatible with
- * the iOS code which does not crash for missing nodes. In most of the cases it is desirable to
- * handle missing nodes gracefully as it usually means the node hasn't been hooked under animated
- * view prop but is referenced in the graph (e.g. to support some edge case).
- */
-public class NoopNode extends ValueNode {
-
-  public NoopNode(NodesManager nodesManager) {
-    super(-2, null, nodesManager);
-  }
-
-  @Override
-  public void setValue(Object value) {
-    // no-op
-  }
-
-  @Override
-  public void addChild(Node child) {
-    // no-op
-  }
-
-  @Override
-  public void removeChild(Node child) {
-    // no-op
-  }
-
-  @Override
-  protected void markUpdated() {
-    // no-op
-  }
-}

package/android/src/main/java/com/swmansion/reanimated/nodes/OperatorNode.java

@@ -1,377 +0,0 @@
-package com.swmansion.reanimated.nodes;
-
-import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
-import com.facebook.react.bridge.ReadableMap;
-import com.swmansion.reanimated.NodesManager;
-import com.swmansion.reanimated.Utils;
-
-public class OperatorNode extends Node {
-
-  private static boolean truthy(Object value) {
-    return value != null && !value.equals(0.);
-  }
-
-  private interface Operator {
-    double evaluate(Node[] input);
-  }
-
-  private abstract static class ReduceOperator implements Operator {
-    @Override
-    public double evaluate(Node[] input) {
-      double acc = input[0].doubleValue();
-      for (int i = 1; i < input.length; i++) {
-        acc = reduce(acc, input[i].doubleValue());
-      }
-      return acc;
-    }
-
-    public abstract double reduce(Double x, Double y);
-  }
-
-  private abstract static class SingleOperator implements Operator {
-    @Override
-    public double evaluate(Node[] input) {
-      return eval((Double) input[0].value());
-    }
-
-    public abstract double eval(Double x);
-  }
-
-  private abstract static class CompOperator implements Operator {
-    @Override
-    public double evaluate(Node[] input) {
-      return eval((Double) input[0].value(), (Double) input[1].value()) ? 1. : 0.;
-    }
-
-    public abstract boolean eval(Double x, Double y);
-  }
-
-  // arithmetic
-  private static final Operator ADD =
-      new ReduceOperator() {
-        @Override
-        public double reduce(Double x, Double y) {
-          return x + y;
-        }
-      };
-  private static final Operator SUB =
-      new ReduceOperator() {
-        @Override
-        public double reduce(Double x, Double y) {
-          return x - y;
-        }
-      };
-  private static final Operator MULTIPLY =
-      new ReduceOperator() {
-        @Override
-        public double reduce(Double x, Double y) {
-          return x * y;
-        }
-      };
-  private static final Operator DIVIDE =
-      new ReduceOperator() {
-        @Override
-        public double reduce(Double x, Double y) {
-          return x / y;
-        }
-      };
-  private static final Operator POW =
-      new ReduceOperator() {
-        @Override
-        public double reduce(Double x, Double y) {
-          return Math.pow(x, y);
-        }
-      };
-  private static final Operator MODULO =
-      new ReduceOperator() {
-        @Override
-        public double reduce(Double x, Double y) {
-          return ((x % y) + y) % y;
-        }
-      };
-  private static final Operator SQRT =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.sqrt(x);
-        }
-      };
-  private static final Operator LOG =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.log(x);
-        }
-      };
-  private static final Operator SIN =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.sin(x);
-        }
-      };
-  private static final Operator COS =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.cos(x);
-        }
-      };
-  private static final Operator TAN =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.tan(x);
-        }
-      };
-  private static final Operator ACOS =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.acos(x);
-        }
-      };
-  private static final Operator ASIN =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.asin(x);
-        }
-      };
-  private static final Operator ATAN =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.atan(x);
-        }
-      };
-  private static final Operator EXP =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.exp(x);
-        }
-      };
-  private static final Operator ROUND =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.round(x);
-        }
-      };
-  private static final Operator ABS =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.abs(x);
-        }
-      };
-  private static final Operator FLOOR =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.floor(x);
-        }
-      };
-  private static final Operator CEIL =
-      new SingleOperator() {
-        @Override
-        public double eval(Double x) {
-          return Math.ceil(x);
-        }
-      };
-  private static final Operator MIN =
-      new ReduceOperator() {
-        @Override
-        public double reduce(Double x, Double y) {
-          return Math.min(x, y);
-        }
-      };
-  private static final Operator MAX =
-      new ReduceOperator() {
-        @Override
-        public double reduce(Double x, Double y) {
-          return Math.max(x, y);
-        }
-      };
-
-  // logical
-  private static final Operator AND =
-      new Operator() {
-        @Override
-        public double evaluate(Node[] input) {
-          boolean res = truthy(input[0].value());
-          for (int i = 1; i < input.length && res; i++) {
-            res = res && truthy(input[i].value());
-          }
-          return res ? 1. : 0.;
-        }
-      };
-  private static final Operator OR =
-      new Operator() {
-        @Override
-        public double evaluate(Node[] input) {
-          boolean res = truthy(input[0].value());
-          for (int i = 1; i < input.length && !res; i++) {
-            res = res || truthy(input[i].value());
-          }
-          return res ? 1. : 0.;
-        }
-      };
-  private static final Operator NOT =
-      new Operator() {
-        @Override
-        public double evaluate(Node[] input) {
-          return truthy(input[0].value()) ? 0. : 1.;
-        }
-      };
-  private static final Operator DEFINED =
-      new Operator() {
-        @Override
-        public double evaluate(Node[] input) {
-          Object res = input[0].value();
-          return (res != null && !(res instanceof Double && ((Double) res).isNaN())) ? 1. : 0.;
-        }
-      };
-
-  // comparison
-  private static final Operator LESS_THAN =
-      new CompOperator() {
-        @Override
-        public boolean eval(Double x, Double y) {
-          if (x == null || y == null) {
-            return false;
-          }
-          return x < y;
-        }
-      };
-  private static final Operator EQ =
-      new CompOperator() {
-        @Override
-        public boolean eval(Double x, Double y) {
-          if (x == null || y == null) {
-            return x == y;
-          }
-          return x.doubleValue() == y.doubleValue();
-        }
-      };
-  private static final Operator GREATER_THAN =
-      new CompOperator() {
-        @Override
-        public boolean eval(Double x, Double y) {
-          if (x == null || y == null) {
-            return false;
-          }
-          return x > y;
-        }
-      };
-  private static final Operator LESS_OR_EQ =
-      new CompOperator() {
-        @Override
-        public boolean eval(Double x, Double y) {
-          return x <= y;
-        }
-      };
-  private static final Operator GREATER_OR_EQ =
-      new CompOperator() {
-        @Override
-        public boolean eval(Double x, Double y) {
-          return x >= y;
-        }
-      };
-  private static final Operator NEQ =
-      new CompOperator() {
-        @Override
-        public boolean eval(Double x, Double y) {
-          if (x == null || y == null) {
-            return x == y;
-          }
-          return x.doubleValue() != y.doubleValue();
-        }
-      };
-
-  private final int[] mInputIDs;
-  private final Node[] mInputNodes;
-  private final Operator mOperator;
-
-  public OperatorNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
-    super(nodeID, config, nodesManager);
-    mInputIDs = Utils.processIntArray(config.getArray("input"));
-    mInputNodes = new Node[mInputIDs.length];
-
-    String op = config.getString("op");
-    if ("add".equals(op)) {
-      mOperator = ADD;
-    } else if ("sub".equals(op)) {
-      mOperator = SUB;
-    } else if ("multiply".equals(op)) {
-      mOperator = MULTIPLY;
-    } else if ("divide".equals(op)) {
-      mOperator = DIVIDE;
-    } else if ("pow".equals(op)) {
-      mOperator = POW;
-    } else if ("modulo".equals(op)) {
-      mOperator = MODULO;
-    } else if ("sqrt".equals(op)) {
-      mOperator = SQRT;
-    } else if ("log".equals(op)) {
-      mOperator = LOG;
-    } else if ("sin".equals(op)) {
-      mOperator = SIN;
-    } else if ("cos".equals(op)) {
-      mOperator = COS;
-    } else if ("tan".equals(op)) {
-      mOperator = TAN;
-    } else if ("acos".equals(op)) {
-      mOperator = ACOS;
-    } else if ("asin".equals(op)) {
-      mOperator = ASIN;
-    } else if ("atan".equals(op)) {
-      mOperator = ATAN;
-    } else if ("exp".equals(op)) {
-      mOperator = EXP;
-    } else if ("round".equals(op)) {
-      mOperator = ROUND;
-    } else if ("and".equals(op)) {
-      mOperator = AND;
-    } else if ("or".equals(op)) {
-      mOperator = OR;
-    } else if ("not".equals(op)) {
-      mOperator = NOT;
-    } else if ("defined".equals(op)) {
-      mOperator = DEFINED;
-    } else if ("lessThan".equals(op)) {
-      mOperator = LESS_THAN;
-    } else if ("eq".equals(op)) {
-      mOperator = EQ;
-    } else if ("greaterThan".equals(op)) {
-      mOperator = GREATER_THAN;
-    } else if ("lessOrEq".equals(op)) {
-      mOperator = LESS_OR_EQ;
-    } else if ("greaterOrEq".equals(op)) {
-      mOperator = GREATER_OR_EQ;
-    } else if ("neq".equals(op)) {
-      mOperator = NEQ;
-    } else if ("abs".equals(op)) {
-      mOperator = ABS;
-    } else if ("floor".equals(op)) {
-      mOperator = FLOOR;
-    } else if ("ceil".equals(op)) {
-      mOperator = CEIL;
-    } else if ("max".equals(op)) {
-      mOperator = MAX;
-    } else if ("min".equals(op)) {
-      mOperator = MIN;
-    } else {
-      throw new JSApplicationIllegalArgumentException("Unrecognized operator " + op);
-    }
-  }
-
-  @Override
-  protected Object evaluate() {
-    for (int i = 0; i < mInputIDs.length; i++) {
-      mInputNodes[i] = mNodesManager.findNodeById(mInputIDs[i], Node.class);
-    }
-    return mOperator.evaluate(mInputNodes);
-  }
-}

package/android/src/main/java/com/swmansion/reanimated/nodes/ParamNode.java

@@ -1,71 +0,0 @@
-package com.swmansion.reanimated.nodes;
-
-import com.facebook.react.bridge.ReadableMap;
-import com.swmansion.reanimated.NodesManager;
-import java.util.Stack;
-
-public class ParamNode extends ValueNode {
-
-  private final Stack<Integer> mArgsStack;
-  private String mPrevCallID;
-
-  public ParamNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
-    super(nodeID, config, nodesManager);
-    mArgsStack = new Stack<>();
-  }
-
-  @Override
-  public void setValue(Object value) {
-    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
-    String callID = mUpdateContext.callID;
-    mUpdateContext.callID = mPrevCallID;
-    ((ValueNode) node).setValue(value);
-    mUpdateContext.callID = callID;
-    forceUpdateMemoizedValue(value);
-  }
-
-  public void beginContext(Integer ref, String prevCallID) {
-    mPrevCallID = prevCallID;
-    mArgsStack.push(ref);
-  }
-
-  public void endContext() {
-    mArgsStack.pop();
-  }
-
-  @Override
-  protected Object evaluate() {
-    String callID = mUpdateContext.callID;
-    mUpdateContext.callID = mPrevCallID;
-    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
-    Object val = node.value();
-    mUpdateContext.callID = callID;
-    return val;
-  }
-
-  public void start() {
-    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
-    if (node instanceof ParamNode) {
-      ((ParamNode) node).start();
-    } else {
-      ((ClockNode) node).start();
-    }
-  }
-
-  public void stop() {
-    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
-    if (node instanceof ParamNode) {
-      ((ParamNode) node).stop();
-    } else {
-      ((ClockNode) node).stop();
-    }
-  }
-
-  public boolean isRunning() {
-    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
-    if (node instanceof ParamNode) {
-      return ((ParamNode) node).isRunning();
-    }
-    return ((ClockNode) node).isRunning;
-  }
-}