react-native-reanimated 2.3.3 → 2.5.0

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

@@ -0,0 +1,84 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.JavaOnlyArray;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+import com.swmansion.reanimated.NodesManager;
+import java.util.ArrayList;
+import java.util.List;
+
+public class TransformNode extends Node {
+
+  private abstract static class TransformConfig {
+    public String propertyName;
+
+    public abstract Object getValue(NodesManager nodesManager);
+  }
+
+  private static class AnimatedTransformConfig extends TransformConfig {
+    public int nodeID;
+
+    @Override
+    public Object getValue(NodesManager nodesManager) {
+      return nodesManager.getNodeValue(nodeID);
+    }
+  }
+
+  private static class StaticTransformConfig extends TransformConfig {
+    public Object value;
+
+    @Override
+    public Object getValue(NodesManager nodesManager) {
+      return value;
+    }
+  }
+
+  private static List<TransformConfig> processTransforms(ReadableArray transforms) {
+    List<TransformConfig> configs = new ArrayList<>(transforms.size());
+    for (int i = 0; i < transforms.size(); i++) {
+      ReadableMap transformConfigMap = transforms.getMap(i);
+      String property = transformConfigMap.getString("property");
+      if (transformConfigMap.hasKey("nodeID")) {
+        AnimatedTransformConfig transformConfig = new AnimatedTransformConfig();
+        transformConfig.propertyName = property;
+        transformConfig.nodeID = transformConfigMap.getInt("nodeID");
+        configs.add(transformConfig);
+      } else {
+        StaticTransformConfig transformConfig = new StaticTransformConfig();
+        transformConfig.propertyName = property;
+        ReadableType type = transformConfigMap.getType("value");
+        if (type == ReadableType.String) {
+          transformConfig.value = transformConfigMap.getString("value");
+        } else if (type == ReadableType.Array) {
+          transformConfig.value = transformConfigMap.getArray("value");
+        } else {
+          transformConfig.value = transformConfigMap.getDouble("value");
+        }
+        configs.add(transformConfig);
+      }
+    }
+    return configs;
+  }
+
+  private List<TransformConfig> mTransforms;
+
+  public TransformNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mTransforms = processTransforms(config.getArray("transform"));
+  }
+
+  @Override
+  protected WritableArray evaluate() {
+    List<JavaOnlyMap> transforms = new ArrayList<>(mTransforms.size());
+
+    for (TransformConfig transformConfig : mTransforms) {
+      transforms.add(
+          JavaOnlyMap.of(transformConfig.propertyName, transformConfig.getValue(mNodesManager)));
+    }
+
+    return JavaOnlyArray.from(transforms);
+  }
+}

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

@@ -0,0 +1,40 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.swmansion.reanimated.NodesManager;
+import javax.annotation.Nullable;
+
+public class ValueNode extends Node {
+
+  private Object mValue;
+
+  public ValueNode(int nodeID, @Nullable ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    if (config == null || !config.hasKey("value")) {
+      mValue = null;
+      return;
+    }
+    ReadableType type = config.getType("value");
+    if (type == ReadableType.String) {
+      mValue = config.getString("value");
+    } else if (type == ReadableType.Number) {
+      mValue = config.getDouble("value");
+    } else if (type == ReadableType.Null) {
+      mValue = null;
+    } else {
+      throw new IllegalStateException(
+          "Not supported value type. Must be boolean, number or string");
+    }
+  }
+
+  public void setValue(Object value) {
+    mValue = value;
+    forceUpdateMemoizedValue(mValue);
+  }
+
+  @Override
+  protected Object evaluate() {
+    return mValue;
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensor.java

@@ -0,0 +1,41 @@
+package com.swmansion.reanimated.sensor;
+
+import android.hardware.Sensor;
+import android.hardware.SensorManager;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.swmansion.reanimated.NativeProxy;
+import java.lang.ref.WeakReference;
+
+public class ReanimatedSensor {
+
+  ReanimatedSensorListener listener;
+  SensorManager sensorManager;
+  Sensor sensor;
+  ReanimatedSensorType sensorType;
+  int interval;
+
+  ReanimatedSensor(
+      WeakReference<ReactApplicationContext> reactContext,
+      ReanimatedSensorType sensorType,
+      int interval,
+      NativeProxy.SensorSetter setter) {
+    listener = new ReanimatedSensorListener(setter, interval);
+    sensorManager =
+        (SensorManager) reactContext.get().getSystemService(reactContext.get().SENSOR_SERVICE);
+    this.sensorType = sensorType;
+    this.interval = interval;
+  }
+
+  boolean initialize() {
+    sensor = sensorManager.getDefaultSensor(sensorType.getType());
+    if (sensor != null) {
+      sensorManager.registerListener(listener, sensor, interval * 1000);
+      return true;
+    }
+    return false;
+  }
+
+  void cancel() {
+    sensorManager.unregisterListener(listener, sensor);
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorContainer.java

@@ -0,0 +1,40 @@
+package com.swmansion.reanimated.sensor;
+
+import android.util.Log;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.swmansion.reanimated.NativeProxy;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+
+public class ReanimatedSensorContainer {
+
+  private int nextSensorId = 0;
+  private final WeakReference<ReactApplicationContext> reactContext;
+  private final HashMap<Integer, ReanimatedSensor> sensors = new HashMap<>();
+
+  public ReanimatedSensorContainer(WeakReference<ReactApplicationContext> reactContext) {
+    this.reactContext = reactContext;
+  }
+
+  public int registerSensor(
+      ReanimatedSensorType sensorType, int interval, NativeProxy.SensorSetter setter) {
+    ReanimatedSensor sensor = new ReanimatedSensor(reactContext, sensorType, interval, setter);
+    int sensorId = -1;
+    if (sensor.initialize()) {
+      sensorId = nextSensorId;
+      nextSensorId++;
+      sensors.put(sensorId, new ReanimatedSensor(reactContext, sensorType, interval, setter));
+    }
+    return sensorId;
+  }
+
+  public void unregisterSensor(int sensorId) {
+    ReanimatedSensor sensor = sensors.get(sensorId);
+    if (sensor != null) {
+      sensor.cancel();
+      sensors.remove(sensorId);
+    } else {
+      Log.e("Reanimated", "Tried to unregister nonexistent sensor");
+    }
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorListener.java

@@ -0,0 +1,31 @@
+package com.swmansion.reanimated.sensor;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import com.swmansion.reanimated.NativeProxy;
+
+public class ReanimatedSensorListener implements SensorEventListener {
+
+  private NativeProxy.SensorSetter setter;
+  private double lastRead = (double) System.currentTimeMillis();
+  private final double interval;
+
+  ReanimatedSensorListener(NativeProxy.SensorSetter setter, double interval) {
+    this.setter = setter;
+    this.interval = interval;
+  }
+
+  @Override
+  public void onSensorChanged(SensorEvent event) {
+    double current = (double) System.currentTimeMillis();
+    if (current - lastRead < interval) {
+      return;
+    }
+    lastRead = current;
+    setter.sensorSetter(event.values);
+  }
+
+  @Override
+  public void onAccuracyChanged(Sensor sensor, int accuracy) {}
+}

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorType.java

@@ -0,0 +1,35 @@
+package com.swmansion.reanimated.sensor;
+
+public enum ReanimatedSensorType {
+  ACCELEROMETER(1),
+  GYROSCOPE(2),
+  GRAVITY(3),
+  MAGNETIC_FIELD(4),
+  ROTATION_VECTOR(5);
+
+  private final int type;
+
+  ReanimatedSensorType(int type) {
+    this.type = type;
+  }
+
+  public int getType() {
+    return type;
+  }
+
+  public static ReanimatedSensorType getInstanceById(int typeId) {
+    switch (typeId) {
+      case 1:
+        return ReanimatedSensorType.ACCELEROMETER;
+      case 2:
+        return ReanimatedSensorType.GYROSCOPE;
+      case 3:
+        return ReanimatedSensorType.GRAVITY;
+      case 4:
+        return ReanimatedSensorType.MAGNETIC_FIELD;
+      case 5:
+        return ReanimatedSensorType.ROTATION_VECTOR;
+    }
+    throw new IllegalArgumentException("[Reanimated] Unknown sensor type");
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/transitions/ChangeTransition.java

@@ -0,0 +1,84 @@
+package com.swmansion.reanimated.transitions;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.TimeInterpolator;
+import android.view.ViewGroup;
+import androidx.annotation.Nullable;
+import androidx.transition.ChangeBounds;
+import androidx.transition.ChangeTransform;
+import androidx.transition.Transition;
+import androidx.transition.TransitionPropagation;
+import androidx.transition.TransitionValues;
+
+final class ChangeTransition extends Transition {
+
+  private final ChangeTransform mChangeTransform;
+  private final ChangeBounds mChangeBounds;
+
+  public ChangeTransition() {
+    mChangeTransform = new ChangeTransform();
+    mChangeBounds = new ChangeBounds();
+  }
+
+  @Override
+  public void captureStartValues(TransitionValues transitionValues) {
+    mChangeTransform.captureStartValues(transitionValues);
+    mChangeBounds.captureStartValues(transitionValues);
+  }
+
+  @Override
+  public void captureEndValues(TransitionValues transitionValues) {
+    mChangeTransform.captureEndValues(transitionValues);
+    mChangeBounds.captureEndValues(transitionValues);
+  }
+
+  @Override
+  public Transition setDuration(long duration) {
+    mChangeTransform.setDuration(duration);
+    mChangeBounds.setDuration(duration);
+    return super.setDuration(duration);
+  }
+
+  @Override
+  public Transition setStartDelay(long startDelay) {
+    mChangeTransform.setStartDelay(startDelay);
+    mChangeBounds.setStartDelay(startDelay);
+    return super.setStartDelay(startDelay);
+  }
+
+  @Override
+  public Transition setInterpolator(@Nullable TimeInterpolator interpolator) {
+    mChangeTransform.setInterpolator(interpolator);
+    mChangeBounds.setInterpolator(interpolator);
+    return super.setInterpolator(interpolator);
+  }
+
+  @Override
+  public void setPropagation(@Nullable TransitionPropagation transitionPropagation) {
+    mChangeTransform.setPropagation(transitionPropagation);
+    mChangeBounds.setPropagation(transitionPropagation);
+    super.setPropagation(transitionPropagation);
+  }
+
+  @Override
+  public Animator createAnimator(
+      ViewGroup sceneRoot, TransitionValues startValues, TransitionValues endValues) {
+    mChangeTransform.setReparent(false);
+    Animator changeTransformAnimator =
+        mChangeTransform.createAnimator(sceneRoot, startValues, endValues);
+    Animator changeBoundsAnimator = mChangeBounds.createAnimator(sceneRoot, startValues, endValues);
+
+    if (changeTransformAnimator == null) {
+      return changeBoundsAnimator;
+    }
+
+    if (changeBoundsAnimator == null) {
+      return changeTransformAnimator;
+    }
+
+    AnimatorSet animatorSet = new AnimatorSet();
+    animatorSet.playTogether(changeTransformAnimator, changeBoundsAnimator);
+    return animatorSet;
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/transitions/SaneSidePropagation.java

@@ -0,0 +1,25 @@
+package com.swmansion.reanimated.transitions;
+
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.transition.SidePropagation;
+import androidx.transition.Transition;
+import androidx.transition.TransitionValues;
+
+public class SaneSidePropagation extends SidePropagation {
+
+  @Override
+  public long getStartDelay(
+      ViewGroup sceneRoot,
+      Transition transition,
+      TransitionValues startValues,
+      TransitionValues endValues) {
+    long delay = super.getStartDelay(sceneRoot, transition, startValues, endValues);
+    if (delay != 0) {
+      if (endValues == null || getViewVisibility(startValues) == View.VISIBLE) {
+        return -delay;
+      }
+    }
+    return delay;
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/transitions/Scale.java

@@ -0,0 +1,86 @@
+package com.swmansion.reanimated.transitions;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.transition.Transition;
+import androidx.transition.TransitionListenerAdapter;
+import androidx.transition.TransitionValues;
+import androidx.transition.Visibility;
+
+public class Scale extends Visibility {
+
+  static final String PROPNAME_SCALE_X = "scale:scaleX";
+  static final String PROPNAME_SCALE_Y = "scale:scaleY";
+
+  @Override
+  public void captureStartValues(TransitionValues transitionValues) {
+    super.captureStartValues(transitionValues);
+    transitionValues.values.put(PROPNAME_SCALE_X, transitionValues.view.getScaleX());
+    transitionValues.values.put(PROPNAME_SCALE_Y, transitionValues.view.getScaleY());
+  }
+
+  public Scale setDisappearedScale(float disappearedScale) {
+    if (disappearedScale < 0f) {
+      throw new IllegalArgumentException("disappearedScale cannot be negative!");
+    }
+    return this;
+  }
+
+  private Animator createAnimation(
+      final View view, float startScale, float endScale, TransitionValues values) {
+    final float initialScaleX = view.getScaleX();
+    final float initialScaleY = view.getScaleY();
+    float startScaleX = initialScaleX * startScale;
+    float endScaleX = initialScaleX * endScale;
+    float startScaleY = initialScaleY * startScale;
+    float endScaleY = initialScaleY * endScale;
+
+    if (values != null) {
+      Float savedScaleX = (Float) values.values.get(PROPNAME_SCALE_X);
+      Float savedScaleY = (Float) values.values.get(PROPNAME_SCALE_Y);
+      // if saved value is not equal initial value it means that previous
+      // transition was interrupted and in the onTransitionEnd
+      // we've applied endScale. we should apply proper value to
+      // continue animation from the interrupted state
+      if (savedScaleX != null && savedScaleX != initialScaleX) {
+        startScaleX = savedScaleX;
+      }
+      if (savedScaleY != null && savedScaleY != initialScaleY) {
+        startScaleY = savedScaleY;
+      }
+    }
+
+    view.setScaleX(startScaleX);
+    view.setScaleY(startScaleY);
+
+    AnimatorSet animator = new AnimatorSet();
+    animator.playTogether(
+        ObjectAnimator.ofFloat(view, View.SCALE_X, startScaleX, endScaleX),
+        ObjectAnimator.ofFloat(view, View.SCALE_Y, startScaleY, endScaleY));
+    addListener(
+        new TransitionListenerAdapter() {
+          @Override
+          public void onTransitionEnd(Transition transition) {
+            view.setScaleX(initialScaleX);
+            view.setScaleY(initialScaleY);
+            transition.removeListener(this);
+          }
+        });
+    return animator;
+  }
+
+  @Override
+  public Animator onAppear(
+      ViewGroup sceneRoot, View view, TransitionValues startValues, TransitionValues endValues) {
+    return createAnimation(view, 0f, 1f, startValues);
+  }
+
+  @Override
+  public Animator onDisappear(
+      ViewGroup sceneRoot, View view, TransitionValues startValues, TransitionValues endValues) {
+    return createAnimation(view, 1f, 0f, startValues);
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/transitions/TransitionModule.java

@@ -0,0 +1,41 @@
+package com.swmansion.reanimated.transitions;
+
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.transition.TransitionManager;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.IllegalViewOperationException;
+import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import com.facebook.react.uimanager.UIBlock;
+import com.facebook.react.uimanager.UIManagerModule;
+
+public class TransitionModule {
+
+  private final UIManagerModule mUIManager;
+
+  public TransitionModule(UIManagerModule uiManager) {
+    mUIManager = uiManager;
+  }
+
+  public void animateNextTransition(final int rootTag, final ReadableMap config) {
+    mUIManager.prependUIBlock(
+        new UIBlock() {
+          @Override
+          public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+            try {
+              View rootView = nativeViewHierarchyManager.resolveView(rootTag);
+              if (rootView instanceof ViewGroup) {
+                ReadableArray transitions = config.getArray("transitions");
+                for (int i = 0, size = transitions.size(); i < size; i++) {
+                  TransitionManager.beginDelayedTransition(
+                      (ViewGroup) rootView, TransitionUtils.inflate(transitions.getMap(i)));
+                }
+              }
+            } catch (IllegalViewOperationException ex) {
+              // ignore, view might have not been registered yet
+            }
+          }
+        });
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/transitions/TransitionUtils.java

@@ -0,0 +1,161 @@
+package com.swmansion.reanimated.transitions;
+
+import android.view.Gravity;
+import android.view.animation.AccelerateDecelerateInterpolator;
+import android.view.animation.AccelerateInterpolator;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.LinearInterpolator;
+import androidx.transition.ChangeBounds;
+import androidx.transition.ChangeTransform;
+import androidx.transition.Fade;
+import androidx.transition.SidePropagation;
+import androidx.transition.Slide;
+import androidx.transition.Transition;
+import androidx.transition.TransitionSet;
+import androidx.transition.Visibility;
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import javax.annotation.Nullable;
+
+class TransitionUtils {
+
+  static @Nullable Transition inflate(ReadableMap config) {
+    String type = config.getString("type");
+    if ("group".equals(type)) {
+      return inflateGroup(config);
+    } else if ("in".equals(type)) {
+      return inflateIn(config);
+    } else if ("out".equals(type)) {
+      return inflateOut(config);
+    } else if ("change".equals(type)) {
+      return inflateChange(config);
+    }
+    throw new JSApplicationIllegalArgumentException("Unrecognized transition type " + type);
+  }
+
+  private static @Nullable Transition inflateGroup(ReadableMap config) {
+    TransitionSet set = new TransitionSet();
+    if (config.hasKey("sequence") && config.getBoolean("sequence")) {
+      set.setOrdering(TransitionSet.ORDERING_SEQUENTIAL);
+    } else {
+      set.setOrdering(TransitionSet.ORDERING_TOGETHER);
+    }
+    ReadableArray transitions = config.getArray("transitions");
+    for (int i = 0, size = transitions.size(); i < size; i++) {
+      Transition next = inflate(transitions.getMap(i));
+      if (next != null) {
+        set.addTransition(next);
+      }
+    }
+    return set;
+  }
+
+  static Visibility createVisibilityTransition(String type) {
+    if (type == null || "none".equals(type)) {
+      return null;
+    } else if ("fade".equals(type)) {
+      return new Fade(Fade.IN | Fade.OUT);
+    } else if ("scale".equals(type)) {
+      return new Scale();
+    } else if ("slide-top".equals(type)) {
+      return new Slide(Gravity.TOP);
+    } else if ("slide-bottom".equals(type)) {
+      return new Slide(Gravity.BOTTOM);
+    } else if ("slide-right".equals(type)) {
+      return new Slide(Gravity.RIGHT);
+    } else if ("slide-left".equals(type)) {
+      return new Slide(Gravity.LEFT);
+    }
+    throw new JSApplicationIllegalArgumentException("Invalid transition type " + type);
+  }
+
+  private static Transition inflateIn(ReadableMap config) {
+    Visibility transition = createTransition(config.getString("animation"));
+    if (transition == null) {
+      return null;
+    }
+    transition.setMode(Visibility.MODE_IN);
+    configureTransition(transition, config);
+    return transition;
+  }
+
+  private static Transition inflateOut(ReadableMap config) {
+    Visibility transition = createTransition(config.getString("animation"));
+    if (transition == null) {
+      return null;
+    }
+    transition.setMode(Visibility.MODE_OUT);
+    configureTransition(transition, config);
+    return transition;
+  }
+
+  private static Transition inflateChange(ReadableMap config) {
+    ChangeBounds changeBounds = new ChangeBounds();
+    ChangeTransform changeTransform = new ChangeTransform();
+    configureTransition(changeBounds, config);
+    configureTransition(changeTransform, config);
+    return new TransitionSet().addTransition(changeBounds).addTransition(changeTransform);
+  }
+
+  private static Visibility createTransition(String type) {
+    if (type == null || "none".equals(type)) {
+      return null;
+    } else if ("fade".equals(type)) {
+      return new Fade(Fade.IN | Fade.OUT);
+    } else if ("scale".equals(type)) {
+      return new Scale();
+    } else if ("slide-top".equals(type)) {
+      return new Slide(Gravity.TOP);
+    } else if ("slide-bottom".equals(type)) {
+      return new Slide(Gravity.BOTTOM);
+    } else if ("slide-right".equals(type)) {
+      return new Slide(Gravity.RIGHT);
+    } else if ("slide-left".equals(type)) {
+      return new Slide(Gravity.LEFT);
+    }
+    throw new JSApplicationIllegalArgumentException("Invalid transition type " + type);
+  }
+
+  private static void configureTransition(Transition transition, ReadableMap params) {
+    if (params.hasKey("durationMs")) {
+      int durationMs = params.getInt("durationMs");
+      transition.setDuration(durationMs);
+    }
+    if (params.hasKey("interpolation")) {
+      String interpolation = params.getString("interpolation");
+      if (interpolation.equals("easeIn")) {
+        transition.setInterpolator(new AccelerateInterpolator());
+      } else if (interpolation.equals("easeOut")) {
+        transition.setInterpolator(new DecelerateInterpolator());
+      } else if (interpolation.equals("easeInOut")) {
+        transition.setInterpolator(new AccelerateDecelerateInterpolator());
+      } else if (interpolation.equals("linear")) {
+        transition.setInterpolator(new LinearInterpolator());
+      } else {
+        throw new JSApplicationIllegalArgumentException(
+            "Invalid interpolation type " + interpolation);
+      }
+    }
+    if (params.hasKey("propagation")) {
+      String propagation = params.getString("propagation");
+      SidePropagation sidePropagation = new SaneSidePropagation();
+      if ("top".equals(propagation)) {
+        sidePropagation.setSide(Gravity.BOTTOM);
+      } else if ("bottom".equals(propagation)) {
+        sidePropagation.setSide(Gravity.TOP);
+      } else if ("left".equals(propagation)) {
+        sidePropagation.setSide(Gravity.RIGHT);
+      } else if ("right".equals(propagation)) {
+        sidePropagation.setSide(Gravity.LEFT);
+      }
+      transition.setPropagation(sidePropagation);
+    } else {
+      transition.setPropagation(null);
+    }
+    if (params.hasKey("delayMs")) {
+      int delayMs = params.getInt("delayMs");
+      transition.setStartDelay(delayMs);
+    }
+  }
+}

package/ios/LayoutReanimation/REAAnimationsManager.h

@@ -5,10 +5,10 @@
 NS_ASSUME_NONNULL_BEGIN
 
 typedef NS_ENUM(NSInteger, ViewState) {
+  Inactive,
   Appearing,
   Disappearing,
   Layout,
-  Inactive,
   ToRemove,
 };