react-native-reanimated 2.13.0 → 2.14.0

package/android/src/main/cpp/NativeProxy.cpp

@@ -12,7 +12,11 @@
 #elif JS_RUNTIME_V8
 #include <v8runtime/V8RuntimeFactory.h>
 #else
+#if REACT_NATIVE_MINOR_VERSION >= 71
+#include <jsc/JSCRuntime.h>
+#else
 #include <jsi/JSCRuntime.h>
+#endif // REACT_NATIVE_MINOR_VERSION
 #endif
 
 #include <android/log.h>
@@ -21,6 +25,7 @@
 #include "LayoutAnimationsProxy.h"
 #include "NativeProxy.h"
 #include "PlatformDepMethodsHolder.h"
+#include "ReanimatedVersion.h"
 
 namespace reanimated {
 
@@ -174,6 +179,9 @@ void NativeProxy::installJSIBindings() {
   runtime_->global().setProperty(
       *runtime_, "_WORKLET_RUNTIME", workletRuntimeValue);
 
+  auto version = getReanimatedVersionString(*runtime_);
+  runtime_->global().setProperty(*runtime_, "_REANIMATED_VERSION_CPP", version);
+
   std::shared_ptr<ErrorHandler> errorHandler =
       std::make_shared<AndroidErrorHandler>(scheduler_);
 

package/android/src/main/java/com/swmansion/reanimated/ReanimatedPackage.java

@@ -16,8 +16,10 @@ import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
 import com.facebook.react.uimanager.ReanimatedUIManager;
 import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
 import com.facebook.systrace.Systrace;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public class ReanimatedPackage extends TurboReactPackage implements ReactPackage {
@@ -68,12 +70,11 @@ public class ReanimatedPackage extends TurboReactPackage implements ReactPackage
     ReactMarker.logMarker(CREATE_UI_MANAGER_MODULE_START);
     Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "createUIManagerModule");
     final ReactInstanceManager reactInstanceManager = getReactInstanceManager(reactContext);
+    List<ViewManager> viewManagers = reactInstanceManager.getOrCreateViewManagers(reactContext);
     int minTimeLeftInFrameForNonBatchedOperationMs = -1;
     try {
-      return new ReanimatedUIManager(
-          reactContext,
-          reactInstanceManager.getOrCreateViewManagers(reactContext),
-          minTimeLeftInFrameForNonBatchedOperationMs);
+      return ReanimatedUIManagerFactory.create(
+          reactContext, viewManagers, minTimeLeftInFrameForNonBatchedOperationMs);
     } finally {
       Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
       ReactMarker.logMarker(CREATE_UI_MANAGER_MODULE_END);

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

@@ -23,7 +23,7 @@ public class ReanimatedSensorContainer {
     if (sensor.initialize()) {
       sensorId = nextSensorId;
       nextSensorId++;
-      sensors.put(sensorId, new ReanimatedSensor(reactContext, sensorType, interval, setter));
+      sensors.put(sensorId, sensor);
     }
     return sensorId;
   }

package/android/src/reactNativeVersionPatch/ReanimatedUIManager/70/com/swmansion/reanimated/ReanimatedUIManagerFactory.java

@@ -0,0 +1,16 @@
+package com.swmansion.reanimated;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ReanimatedUIManager;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.List;
+
+public class ReanimatedUIManagerFactory {
+
+  static UIManagerModule create(ReactApplicationContext reactContext, List<ViewManager> viewManagers, int minTimeLeftInFrameForNonBatchedOperationMs) {
+    return new ReanimatedUIManager(reactContext, viewManagers, minTimeLeftInFrameForNonBatchedOperationMs);
+  }
+
+}

package/android/src/reactNativeVersionPatch/ReanimatedUIManager/latest/com/swmansion/reanimated/ReanimatedUIManagerFactory.java

@@ -0,0 +1,63 @@
+package com.swmansion.reanimated;
+
+import android.os.Build;
+import android.util.Log;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ReanimatedUIImplementation;
+import com.facebook.react.uimanager.ReanimatedUIManager;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.uimanager.ViewManagerRegistry;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.List;
+
+public class ReanimatedUIManagerFactory {
+
+  static UIManagerModule create(ReactApplicationContext reactContext, List<ViewManager> viewManagers, int minTimeLeftInFrameForNonBatchedOperationMs) {
+    ViewManagerRegistry viewManagerRegistry = new ViewManagerRegistry(viewManagers);
+
+    UIManagerModule uiManagerModule =
+        new ReanimatedUIManager(
+            reactContext, viewManagers, minTimeLeftInFrameForNonBatchedOperationMs);
+
+    UIImplementation uiImplementation =
+        new ReanimatedUIImplementation(
+            reactContext,
+            viewManagerRegistry,
+            uiManagerModule.getEventDispatcher(),
+            minTimeLeftInFrameForNonBatchedOperationMs);
+
+    Class clazz = uiManagerModule.getClass().getSuperclass();
+    if (clazz == null) {
+      Log.e("reanimated", "unable to resolve super class of ReanimatedUIManager");
+      return uiManagerModule;
+    }
+
+    try {
+      Field uiImplementationField = clazz.getDeclaredField("mUIImplementation");
+      uiImplementationField.setAccessible(true);
+
+      if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        try {
+          // accessFlags is supported only by API >=23
+          Field modifiersField = Field.class.getDeclaredField("accessFlags");
+          modifiersField.setAccessible(true);
+          modifiersField.setInt(
+              uiImplementationField, uiImplementationField.getModifiers() & ~Modifier.FINAL);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+          e.printStackTrace();
+        }
+      }
+      uiImplementationField.set(uiManagerModule, uiImplementation);
+    } catch (NoSuchFieldException | IllegalAccessException e) {
+      e.printStackTrace();
+    }
+
+    return uiManagerModule;
+  }
+
+}

package/android/src/reactNativeVersionPatch/ReanimatedUIManager/latest/com/swmansion/reanimated/layoutReanimation/ReanimatedUIManager.java

@@ -0,0 +1,271 @@
+package com.facebook.react.uimanager;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import java.util.List;
+
+@ReactModule(name = UIManagerModule.NAME)
+public class ReanimatedUIManager extends UIManagerModule {
+
+  public ReanimatedUIManager(
+      ReactApplicationContext reactContext,
+      List<ViewManager> viewManagersList,
+      int minTimeLeftInFrameForNonBatchedOperationMs) {
+    super(reactContext, viewManagersList, minTimeLeftInFrameForNonBatchedOperationMs);
+  }
+
+  public void onBatchComplete() {
+    super.onBatchComplete();
+  }
+
+  @Override
+  public boolean canOverrideExistingModule() {
+    return true;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public @Nullable WritableMap getConstantsForViewManager(@Nullable String viewManagerName) {
+    return super.getConstantsForViewManager(viewManagerName);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap getDefaultEventTypes() {
+    return super.getDefaultEventTypes();
+  }
+
+  /** Unregisters a new root view. */
+  @ReactMethod
+  public void removeRootView(int rootViewTag) {
+    super.removeRootView(rootViewTag);
+  }
+
+  @ReactMethod
+  public void createView(int tag, String className, int rootViewTag, ReadableMap props) {
+    super.createView(tag, className, rootViewTag, props);
+  }
+
+  @ReactMethod
+  public void updateView(final int tag, final String className, final ReadableMap props) {
+    super.updateView(tag, className, props);
+  }
+
+  /**
+   * Interface for adding/removing/moving views within a parent view from JS.
+   *
+   * @param viewTag the view tag of the parent view
+   * @param moveFrom a list of indices in the parent view to move views from
+   * @param moveTo parallel to moveFrom, a list of indices in the parent view to move views to
+   * @param addChildTags a list of tags of views to add to the parent
+   * @param addAtIndices parallel to addChildTags, a list of indices to insert those children at
+   * @param removeFrom a list of indices of views to permanently remove. The memory for the
+   *     corresponding views and data structures should be reclaimed.
+   */
+  @ReactMethod
+  public void manageChildren(
+      int viewTag,
+      @Nullable ReadableArray moveFrom,
+      @Nullable ReadableArray moveTo,
+      @Nullable ReadableArray addChildTags,
+      @Nullable ReadableArray addAtIndices,
+      @Nullable ReadableArray removeFrom) {
+    super.manageChildren(viewTag, moveFrom, moveTo, addChildTags, addAtIndices, removeFrom);
+  }
+
+  /**
+   * Interface for fast tracking the initial adding of views. Children view tags are assumed to be
+   * in order
+   *
+   * @param viewTag the view tag of the parent view
+   * @param childrenTags An array of tags to add to the parent in order
+   */
+  @ReactMethod
+  public void setChildren(int viewTag, ReadableArray childrenTags) {
+    super.setChildren(viewTag, childrenTags);
+  }
+
+  /**
+   * Replaces the View specified by oldTag with the View specified by newTag within oldTag's parent.
+   * This resolves to a simple {@link #manageChildren} call, but React doesn't have enough info in
+   * JS to formulate it itself.
+   *
+   * @deprecated This method will not be available in Fabric UIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void replaceExistingNonRootView(int oldTag, int newTag) {
+    super.replaceExistingNonRootView(oldTag, newTag);
+  }
+
+  /**
+   * Method which takes a container tag and then releases all subviews for that container upon
+   * receipt.
+   *
+   * @param containerTag the tag of the container for which the subviews must be removed
+   * @deprecated This method will not be available in Fabric UIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void removeSubviewsFromContainerWithID(int containerTag) {
+    super.removeSubviewsFromContainerWithID(containerTag);
+  }
+
+  /**
+   * Determines the location on screen, width, and height of the given view and returns the values
+   * via an async callback.
+   */
+  @ReactMethod
+  public void measure(int reactTag, Callback callback) {
+    super.measure(reactTag, callback);
+  }
+
+  /**
+   * Determines the location on screen, width, and height of the given view relative to the device
+   * screen and returns the values via an async callback. This is the absolute position including
+   * things like the status bar
+   */
+  @ReactMethod
+  public void measureInWindow(int reactTag, Callback callback) {
+    super.measureInWindow(reactTag, callback);
+  }
+
+  /**
+   * Measures the view specified by tag relative to the given ancestorTag. This means that the
+   * returned x, y are relative to the origin x, y of the ancestor view. Results are stored in the
+   * given outputBuffer. We allow ancestor view and measured view to be the same, in which case the
+   * position always will be (0, 0) and method will only measure the view dimensions.
+   *
+   * <p>NB: Unlike {@link #measure}, this will measure relative to the view layout, not the visible
+   * window which can cause unexpected results when measuring relative to things like ScrollViews
+   * that can have offset content on the screen.
+   */
+  @ReactMethod
+  public void measureLayout(
+      int tag, int ancestorTag, Callback errorCallback, Callback successCallback) {
+    super.measureLayout(tag, ancestorTag, errorCallback, successCallback);
+  }
+
+  /**
+   * Like {@link #measure} and {@link #measureLayout} but measures relative to the immediate parent.
+   *
+   * <p>NB: Unlike {@link #measure}, this will measure relative to the view layout, not the visible
+   * window which can cause unexpected results when measuring relative to things like ScrollViews
+   * that can have offset content on the screen.
+   *
+   * @deprecated this method will not be available in FabricUIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void measureLayoutRelativeToParent(
+      int tag, Callback errorCallback, Callback successCallback) {
+    super.measureLayoutRelativeToParent(tag, errorCallback, successCallback);
+  }
+
+  /**
+   * Find the touch target child native view in the supplied root view hierarchy, given a react
+   * target location.
+   *
+   * <p>This method is currently used only by Element Inspector DevTool.
+   *
+   * @param reactTag the tag of the root view to traverse
+   * @param point an array containing both X and Y target location
+   * @param callback will be called if with the identified child view react ID, and measurement
+   *     info. If no view was found, callback will be invoked with no data.
+   */
+  @ReactMethod
+  public void findSubviewIn(
+      final int reactTag, final ReadableArray point, final Callback callback) {
+    super.findSubviewIn(reactTag, point, callback);
+  }
+
+  /**
+   * Check if the first shadow node is the descendant of the second shadow node
+   *
+   * @deprecated this method will not be available in FabricUIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void viewIsDescendantOf(
+      final int reactTag, final int ancestorReactTag, final Callback callback) {
+    super.viewIsDescendantOf(reactTag, ancestorReactTag, callback);
+  }
+
+  @ReactMethod
+  public void setJSResponder(int reactTag, boolean blockNativeResponder) {
+    super.setJSResponder(reactTag, blockNativeResponder);
+  }
+
+  @ReactMethod
+  public void clearJSResponder() {
+    super.clearJSResponder();
+  }
+
+  @ReactMethod
+  public void dispatchViewManagerCommand(
+      int reactTag, Dynamic commandId, @Nullable ReadableArray commandArgs) {
+    super.dispatchViewManagerCommand(reactTag, commandId, commandArgs);
+  }
+
+  /**
+   * Show a PopupMenu.
+   *
+   * @param reactTag the tag of the anchor view (the PopupMenu is displayed next to this view); this
+   *     needs to be the tag of a native view (shadow views can not be anchors)
+   * @param items the menu items as an array of strings
+   * @param error will be called if there is an error displaying the menu
+   * @param success will be called with the position of the selected item as the first argument, or
+   *     no arguments if the menu is dismissed
+   */
+  @ReactMethod
+  public void showPopupMenu(int reactTag, ReadableArray items, Callback error, Callback success) {
+    super.showPopupMenu(reactTag, items, error, success);
+  }
+
+  @ReactMethod
+  public void dismissPopupMenu() {
+    super.dismissPopupMenu();
+  }
+
+  /**
+   * LayoutAnimation API on Android is currently experimental. Therefore, it needs to be enabled
+   * explicitly in order to avoid regression in existing application written for iOS using this API.
+   *
+   * <p>Warning : This method will be removed in future version of React Native, and layout
+   * animation will be enabled by default, so always check for its existence before invoking it.
+   *
+   * <p>TODO(9139831) : remove this method once layout animation is fully stable.
+   *
+   * @param enabled whether layout animation is enabled or not
+   */
+  @ReactMethod
+  public void setLayoutAnimationEnabledExperimental(boolean enabled) {
+    super.setLayoutAnimationEnabledExperimental(enabled);
+  }
+
+  /**
+   * Configure an animation to be used for the native layout changes, and native views creation. The
+   * animation will only apply during the current batch operations.
+   *
+   * <p>TODO(7728153) : animating view deletion is currently not supported.
+   *
+   * @param config the configuration of the animation for view addition/removal/update.
+   * @param success will be called when the animation completes, or when the animation get
+   *     interrupted. In this case, callback parameter will be false.
+   * @param error will be called if there was an error processing the animation
+   */
+  @ReactMethod
+  public void configureNextLayoutAnimation(ReadableMap config, Callback success, Callback error) {
+    super.configureNextLayoutAnimation(config, success, error);
+  }
+
+  @ReactMethod
+  public void sendAccessibilityEvent(int tag, int eventType) {
+    super.sendAccessibilityEvent(tag, eventType);
+  }
+}

package/android/src/reactNativeVersionPatch/nativeHierarchyManager/latest/com/swmansion/reanimated/layoutReanimation/ReanimatedNativeHierarchyManager.java

@@ -87,9 +87,9 @@ class ReaLayoutAnimator extends LayoutAnimationController {
       view.layout(x, y, x + width, y + height);
       if (view.getId() != -1) {
         mAnimationsManager.onViewCreate(
-            view,
-            (ViewGroup) view.getParent(),
-            new Snapshot(view, mWeakNativeViewHierarchyManage.get()));
+                view,
+                (ViewGroup) view.getParent(),
+                new Snapshot(view, mWeakNativeViewHierarchyManage.get()));
       }
     } else {
       Snapshot before = new Snapshot(view, mWeakNativeViewHierarchyManage.get());
@@ -269,33 +269,6 @@ public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager
     return !initOk || !((ReaLayoutAnimator) mReaLayoutAnimator).isLayoutAnimationEnabled();
   }
 
-  public synchronized void updateLayout(
-      int parentTag, int tag, int x, int y, int width, int height) {
-    super.updateLayout(parentTag, tag, x, y, width, height);
-    if (isLayoutAnimationDisabled()) {
-      return;
-    }
-    try {
-      View viewToUpdate = this.resolveView(tag);
-      ViewManager viewManager = this.resolveViewManager(tag);
-      String viewManagerName = viewManager.getName();
-      View container = resolveView(parentTag);
-      if (container != null
-          && viewManagerName.equals("RNSScreen")
-          && this.mReaLayoutAnimator != null) {
-        this.mReaLayoutAnimator.applyLayoutUpdate(
-            viewToUpdate,
-            (int) container.getX(),
-            (int) container.getY(),
-            container.getWidth(),
-            container.getHeight());
-      }
-    } catch (IllegalViewOperationException e) {
-      // (IllegalViewOperationException) == (vm == null)
-      e.printStackTrace();
-    }
-  }
-
   @Override
   public synchronized void manageChildren(
       int tag,

package/ios/REAModule.mm

@@ -2,8 +2,10 @@
 #import <RNReanimated/REAModule.h>
 #import <RNReanimated/REANodesManager.h>
 #import <RNReanimated/REATransitionManager.h>
+#import <RNReanimated/ReanimatedVersion.h>
 #import <RNReanimated/SingleInstanceChecker.h>
 
+using namespace facebook::react;
 using namespace reanimated;
 
 typedef void (^AnimatedOperation)(REANodesManager *nodesManager);

package/ios/native/REAInitializer.mm

@@ -1,5 +1,6 @@
 #import <RNReanimated/REAInitializer.h>
 #import <RNReanimated/REAUIManager.h>
+#import <RNReanimated/ReanimatedVersion.h>
 
 @interface RCTEventDispatcher (Reanimated)
 
@@ -56,6 +57,9 @@ JSIExecutor::RuntimeInstaller REAJSIExecutorRuntimeInstaller(
 
     runtime.global().setProperty(runtime, "_WORKLET_RUNTIME", workletRuntimeValue);
 
+    auto version = getReanimatedVersionString(runtime);
+    runtime.global().setProperty(runtime, "_REANIMATED_VERSION_CPP", version);
+
     runtime.global().setProperty(
         runtime,
         jsi::PropNameID::forAscii(runtime, "__reanimatedModuleProxy"),

package/lib/createAnimatedComponent.js

@@ -190,6 +190,11 @@ export default function createAnimatedComponent(Component, options) {
         _attachNativeEvents() {
             const node = this._getEventViewRef();
             const viewTag = findNodeHandle((options === null || options === void 0 ? void 0 : options.setNativeProps) ? this : node);
+            const componentName = Component.displayName || Component.name;
+            if ((componentName === null || componentName === void 0 ? void 0 : componentName.endsWith('FlashList')) && this._component) {
+                // @ts-ignore it's FlashList specific: https://github.com/Shopify/flash-list/blob/218f314e63806b4fe926741ef73f8b9cd6ebc7eb/src/FlashList.tsx#L824
+                viewTag = findNodeHandle(this._component.recyclerlistview_unsafe);
+            }
             for (const key in this.props) {
                 const prop = this.props[key];
                 if (prop instanceof AnimatedEvent) {

package/lib/reanimated2/Colors.js

@@ -460,10 +460,10 @@ function HSVtoRGB(h, s, v) {
     };
     /* eslint-enable */
 }
-export const hsvToColor = (h, s, v) => {
+export const hsvToColor = (h, s, v, a) => {
     'worklet';
     const { r, g, b } = HSVtoRGB(h, s, v);
-    return rgbaColor(r, g, b);
+    return rgbaColor(r, g, b, a);
 };
 export function processColorInitially(color) {
     'worklet';
@@ -505,18 +505,34 @@ export function processColor(color) {
     }
     return normalizedColor;
 }
-export function convertToHSVA(color) {
+export function convertToRGBA(color) {
     'worklet';
     const processedColor = processColorInitially(color); // argb;
     const a = (processedColor >>> 24) / 255;
-    const r = (processedColor << 8) >>> 24;
-    const g = (processedColor << 16) >>> 24;
-    const b = (processedColor << 24) >>> 24;
-    const { h, s, v } = RGBtoHSV(r, g, b);
-    return [h, s, v, a];
+    const r = ((processedColor << 8) >>> 24) / 255;
+    const g = ((processedColor << 16) >>> 24) / 255;
+    const b = ((processedColor << 24) >>> 24) / 255;
+    return [r, g, b, a];
 }
-export function toRGBA(HSVA) {
+export function rgbaArrayToRGBAColor(RGBA) {
     'worklet';
-    const { r, g, b } = HSVtoRGB(HSVA[0], HSVA[1], HSVA[2]);
-    return `rgba(${r}, ${g}, ${b}, ${HSVA[3]})`;
+    return `rgba(${Math.round(RGBA[0] * 255)}, ${Math.round(RGBA[1] * 255)}, ${Math.round(RGBA[2] * 255)}, ${RGBA[3]})`;
+}
+export function toLinearSpace(RGBA, gamma = 2.2) {
+    'worklet';
+    const res = [];
+    for (let i = 0; i < 3; ++i) {
+        res.push(Math.pow(RGBA[i], gamma));
+    }
+    res.push(RGBA[3]);
+    return res;
+}
+export function toGammaSpace(RGBA, gamma = 2.2) {
+    'worklet';
+    const res = [];
+    for (let i = 0; i < 3; ++i) {
+        res.push(Math.pow(RGBA[i], 1 / gamma));
+    }
+    res.push(RGBA[3]);
+    return res;
 }

package/lib/reanimated2/NativeReanimated/NativeReanimated.js

@@ -1,4 +1,5 @@
 import { NativeModules } from 'react-native';
+import { checkVersion } from '../platform-specific/checkVersion';
 export class NativeReanimated {
     constructor(native = true) {
         if (global.__reanimatedModuleProxy === undefined && native) {
@@ -7,6 +8,9 @@ export class NativeReanimated {
         }
         this.InnerNativeModule = global.__reanimatedModuleProxy;
         this.native = native;
+        if (native) {
+            checkVersion();
+        }
     }
     installCoreFunctions(valueSetter) {
         return this.InnerNativeModule.installCoreFunctions(valueSetter);

package/lib/reanimated2/animation/util.js

@@ -1,5 +1,5 @@
 /* global _WORKLET */
-import { convertToHSVA, isColor, toRGBA } from '../Colors';
+import { isColor, convertToRGBA, rgbaArrayToRGBAColor, toGammaSpace, toLinearSpace, } from '../Colors';
 import NativeReanimatedModule from '../NativeReanimated';
 let IN_STYLE_UPDATER = false;
 export function initialUpdaterRun(updater) {
@@ -75,39 +75,39 @@ function decorateAnimation(animation) {
                 ((_b = animation.__suffix) !== null && _b !== void 0 ? _b : '');
         return res;
     };
-    const tab = ['H', 'S', 'V', 'A'];
+    const tab = ['R', 'G', 'B', 'A'];
     const colorOnStart = (animation, value, timestamp, previousAnimation) => {
-        let HSVAValue;
-        let HSVACurrent;
-        let HSVAToValue;
+        let RGBAValue;
+        let RGBACurrent;
+        let RGBAToValue;
         const res = [];
         if (isColor(value)) {
-            HSVACurrent = convertToHSVA(animation.current);
-            HSVAValue = convertToHSVA(value);
+            RGBACurrent = toLinearSpace(convertToRGBA(animation.current));
+            RGBAValue = toLinearSpace(convertToRGBA(value));
             if (animation.toValue) {
-                HSVAToValue = convertToHSVA(animation.toValue);
+                RGBAToValue = toLinearSpace(convertToRGBA(animation.toValue));
             }
         }
         tab.forEach((i, index) => {
             animation[i] = Object.assign({}, animationCopy);
-            animation[i].current = HSVACurrent[index];
-            animation[i].toValue = HSVAToValue ? HSVAToValue[index] : undefined;
-            animation[i].onStart(animation[i], HSVAValue[index], timestamp, previousAnimation ? previousAnimation[i] : undefined);
+            animation[i].current = RGBACurrent[index];
+            animation[i].toValue = RGBAToValue ? RGBAToValue[index] : undefined;
+            animation[i].onStart(animation[i], RGBAValue[index], timestamp, previousAnimation ? previousAnimation[i] : undefined);
             res.push(animation[i].current);
         });
-        animation.current = toRGBA(res);
+        animation.current = rgbaArrayToRGBAColor(toGammaSpace(res));
     };
     const colorOnFrame = (animation, timestamp) => {
-        const HSVACurrent = convertToHSVA(animation.current);
+        const RGBACurrent = toLinearSpace(convertToRGBA(animation.current));
         const res = [];
         let finished = true;
         tab.forEach((i, index) => {
-            animation[i].current = HSVACurrent[index];
+            animation[i].current = RGBACurrent[index];
             // @ts-ignore: disable-next-line
             finished &= animation[i].onFrame(animation[i], timestamp);
             res.push(animation[i].current);
         });
-        animation.current = toRGBA(res);
+        animation.current = rgbaArrayToRGBAColor(toGammaSpace(res));
         return finished;
     };
     const arrayOnStart = (animation, value, timestamp, previousAnimation) => {