react-native-reanimated 2.3.0-alpha.3 → 2.3.0-beta.4

package/Common/cpp/Registries/EventHandlerRegistry.cpp

@@ -3,7 +3,8 @@
 
 namespace reanimated {
 
-void EventHandlerRegistry::registerEventHandler(std::shared_ptr<WorkletEventHandler> eventHandler) {
+void EventHandlerRegistry::registerEventHandler(
+    std::shared_ptr<WorkletEventHandler> eventHandler) {
   const std::lock_guard<std::mutex> lock(instanceMutex);
   eventMappings[eventHandler->eventName][eventHandler->id] = eventHandler;
   eventHandlers[eventHandler->id] = eventHandler;
@@ -21,7 +22,10 @@ void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
   }
 }
 
-void EventHandlerRegistry::processEvent(jsi::Runtime &rt, std::string eventName, std::string eventPayload) {
+void EventHandlerRegistry::processEvent(
+    jsi::Runtime &rt,
+    std::string eventName,
+    std::string eventPayload) {
   std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
   {
     const std::lock_guard<std::mutex> lock(instanceMutex);
@@ -38,15 +42,18 @@ void EventHandlerRegistry::processEvent(jsi::Runtime &rt, std::string eventName,
   std::string delimimter = "NativeMap:";
   auto positionToSplit = eventPayload.find(delimimter) + delimimter.size();
   auto lastBracketCharactedPosition = eventPayload.size() - positionToSplit - 1;
-  auto eventJSON = eventPayload.substr(positionToSplit,  lastBracketCharactedPosition);
+  auto eventJSON =
+      eventPayload.substr(positionToSplit, lastBracketCharactedPosition);
 
   if (eventJSON.compare(std::string("null")) == 0) {
     return;
   }
 
-  auto eventObject = jsi::Value::createFromJsonUtf8(rt, (uint8_t*)(&eventJSON[0]), eventJSON.size());
+  auto eventObject = jsi::Value::createFromJsonUtf8(
+      rt, reinterpret_cast<uint8_t *>(&eventJSON[0]), eventJSON.size());
 
-  eventObject.asObject(rt).setProperty(rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
+  eventObject.asObject(rt).setProperty(
+      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
   for (auto handler : handlersForEvent) {
     handler->process(rt, eventObject);
   }
@@ -55,7 +62,7 @@ void EventHandlerRegistry::processEvent(jsi::Runtime &rt, std::string eventName,
 bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(std::string eventName) {
   const std::lock_guard<std::mutex> lock(instanceMutex);
   auto it = eventMappings.find(eventName);
-  return (it != eventMappings.end()) and (!(it->second).empty());
+  return (it != eventMappings.end()) && (!(it->second).empty());
 }
 
-}
+} // namespace reanimated

package/Common/cpp/Registries/MapperRegistry.cpp

@@ -1,8 +1,8 @@
 #include "MapperRegistry.h"
-#include "Mapper.h"
-#include <map>
 #include <array>
+#include <map>
 #include <set>
+#include "Mapper.h"
 
 namespace reanimated {
 
@@ -21,7 +21,7 @@ void MapperRegistry::execute(jsi::Runtime &rt) {
     updateOrder();
     updatedSinceLastExecute = false;
   }
-  for (auto & mapper : sortedMappers) {
+  for (auto &mapper : sortedMappers) {
     if (mapper->dirty) {
       mapper->execute(rt);
     }
@@ -39,16 +39,18 @@ void MapperRegistry::updateOrder() { // Topological sorting
     std::shared_ptr<Mapper> mapper;
     std::shared_ptr<MutableValue> mutableValue;
 
-    NodeID(std::shared_ptr<Mapper> mapper) {
+    explicit NodeID(std::shared_ptr<Mapper> mapper) {
       if (mapper == nullptr) {
-        throw std::runtime_error("Graph couldn't be sorted (Mapper cannot be nullptr)");
+        throw std::runtime_error(
+            "Graph couldn't be sorted (Mapper cannot be nullptr)");
       }
       this->mapper = mapper;
     }
 
-    NodeID(std::shared_ptr<MutableValue> mutableValue) {
+    explicit NodeID(std::shared_ptr<MutableValue> mutableValue) {
       if (mutableValue == nullptr) {
-        throw std::runtime_error("Graph couldn't be sorted (Mutable cannot be nullptr)");
+        throw std::runtime_error(
+            "Graph couldn't be sorted (Mutable cannot be nullptr)");
       }
       this->mutableValue = mutableValue;
     }
@@ -57,8 +59,7 @@ void MapperRegistry::updateOrder() { // Topological sorting
       return mutableValue != nullptr;
     }
 
-    bool operator<(const NodeID& other) const
-    {
+    bool operator<(const NodeID &other) const {
       if (isMutable() != other.isMutable())
         return isMutable() < other.isMutable();
 
@@ -72,29 +73,31 @@ void MapperRegistry::updateOrder() { // Topological sorting
 
   std::map<NodeID, int> deg;
 
-  std::map<std::shared_ptr<MutableValue>, std::vector<std::shared_ptr<Mapper>>> mappersThatUseSharedValue;
+  std::map<std::shared_ptr<MutableValue>, std::vector<std::shared_ptr<Mapper>>>
+      mappersThatUseSharedValue;
 
   std::set<std::pair<int, NodeID>> nodes;
 
-  std::function<void(NodeID)> update = [&] (NodeID id) {
+  std::function<void(NodeID)> update = [&](NodeID id) {
     auto entry = std::make_pair(deg[id], id);
-    if (nodes.find(entry) == nodes.end()) return;
+    if (nodes.find(entry) == nodes.end())
+      return;
     nodes.erase(entry);
     entry.first--;
     deg[id]--;
     nodes.insert(entry);
   };
 
-  for (auto & entry : mappers) {
+  for (auto &entry : mappers) {
     auto id = NodeID(entry.second);
-    auto & mapper = entry.second;
+    auto &mapper = entry.second;
     deg[id] = mapper->inputs.size();
     nodes.insert(std::make_pair(deg[id], id));
 
     for (auto sharedValue : mapper->inputs) {
       auto sharedValueID = NodeID(sharedValue);
       mappersThatUseSharedValue[sharedValue].push_back(mapper);
-      if (deg.count(sharedValue) == 0) {
+      if (deg.count(sharedValueID) == 0) {
         deg[sharedValueID] = 0;
       }
     }
@@ -104,14 +107,14 @@ void MapperRegistry::updateOrder() { // Topological sorting
     }
   }
 
-  for (auto & entry : deg) {
+  for (auto &entry : deg) {
     auto id = entry.first;
     if (id.isMutable()) {
       nodes.insert(std::make_pair(entry.second, id));
     }
   }
 
-  while (nodes.size() > 0 and nodes.begin()->first == 0) {
+  while (nodes.size() > 0 && nodes.begin()->first == 0) {
     auto entry = *nodes.begin();
     nodes.erase(entry);
 
@@ -120,7 +123,7 @@ void MapperRegistry::updateOrder() { // Topological sorting
 
     if (id.isMutable()) {
       for (auto id : mappersThatUseSharedValue[id.mutableValue]) {
-        toUpdate.push_back(id);
+        toUpdate.push_back(NodeID(id));
       }
     } else {
       for (auto sharedValue : id.mapper->outputs) {
@@ -130,7 +133,8 @@ void MapperRegistry::updateOrder() { // Topological sorting
       sortedMappers.push_back(id.mapper);
     }
 
-    for (auto & id : toUpdate) update(id);
+    for (auto &id : toUpdate)
+      update(id);
   }
 
   if (nodes.size() > 0) {
@@ -138,4 +142,4 @@ void MapperRegistry::updateOrder() { // Topological sorting
   }
 }
 
-}
+} // namespace reanimated

package/Common/cpp/Registries/WorkletsCache.cpp

@@ -1,28 +1,38 @@
 #include "WorkletsCache.h"
-#include "ShareableValue.h"
 #include "FrozenObject.h"
+#include "ShareableValue.h"
 
 using namespace facebook;
 
-namespace reanimated
-{
+namespace reanimated {
 
 jsi::Value eval(jsi::Runtime &rt, const char *code) {
   return rt.global().getPropertyAsFunction(rt, "eval").call(rt, code);
 }
 
-jsi::Function function(jsi::Runtime &rt, const std::string& code) {
+jsi::Function function(jsi::Runtime &rt, const std::string &code) {
   return eval(rt, ("(" + code + ")").c_str()).getObject(rt).getFunction(rt);
 }
 
-std::shared_ptr<jsi::Function> WorkletsCache::getFunction(jsi::Runtime &rt, std::shared_ptr<FrozenObject> frozenObj) {
-  long long workletHash = ValueWrapper::asNumber(frozenObj->map["__workletHash"]->valueContainer);
+std::shared_ptr<jsi::Function> WorkletsCache::getFunction(
+    jsi::Runtime &rt,
+    std::shared_ptr<FrozenObject> frozenObj) {
+  long long workletHash =
+      ValueWrapper::asNumber(frozenObj->map["__workletHash"]->valueContainer);
   if (worklets.count(workletHash) == 0) {
-    auto codeBuffer = std::make_shared<const jsi::StringBuffer>("(" + ValueWrapper::asString(frozenObj->map["asString"]->valueContainer) + ")");
-    auto func = rt.evaluateJavaScript(codeBuffer, ValueWrapper::asString(frozenObj->map["__location"]->valueContainer)).asObject(rt).asFunction(rt);
+    auto codeBuffer = std::make_shared<const jsi::StringBuffer>(
+        "(" +
+        ValueWrapper::asString(frozenObj->map["asString"]->valueContainer) +
+        ")");
+    auto func = rt.evaluateJavaScript(
+                      codeBuffer,
+                      ValueWrapper::asString(
+                          frozenObj->map["__location"]->valueContainer))
+                    .asObject(rt)
+                    .asFunction(rt);
     worklets[workletHash] = std::make_shared<jsi::Function>(std::move(func));
   }
   return worklets[workletHash];
 }
 
-}
+} // namespace reanimated

package/Common/cpp/SharedItems/FrozenObject.cpp

@@ -1,26 +1,35 @@
 #include "FrozenObject.h"
-#include "SharedParent.h"
-#include "ShareableValue.h"
 #include "RuntimeManager.h"
+#include "ShareableValue.h"
+#include "SharedParent.h"
 
 namespace reanimated {
 
-FrozenObject::FrozenObject(jsi::Runtime &rt, const jsi::Object &object, RuntimeManager *runtimeManager) {
+FrozenObject::FrozenObject(
+    jsi::Runtime &rt,
+    const jsi::Object &object,
+    RuntimeManager *runtimeManager) {
   auto propertyNames = object.getPropertyNames(rt);
-  for (size_t i = 0, count = propertyNames.size(rt); i < count; i++) {
+  const size_t count = propertyNames.size(rt);
+  namesOrder.reserve(count);
+  for (size_t i = 0; i < count; i++) {
     auto propertyName = propertyNames.getValueAtIndex(rt, i).asString(rt);
+    namesOrder.push_back(propertyName.utf8(rt));
     std::string nameStr = propertyName.utf8(rt);
-    map[nameStr] = ShareableValue::adapt(rt, object.getProperty(rt, propertyName), runtimeManager);
+    map[nameStr] = ShareableValue::adapt(
+        rt, object.getProperty(rt, propertyName), runtimeManager);
     this->containsHostFunction |= map[nameStr]->containsHostFunction;
   }
 }
 
 jsi::Object FrozenObject::shallowClone(jsi::Runtime &rt) {
   jsi::Object object(rt);
-  for (auto prop : map) {
-    object.setProperty(rt, jsi::String::createFromUtf8(rt, prop.first), prop.second->getValue(rt));
+  for (auto propName : namesOrder) {
+    auto value = map[propName];
+    object.setProperty(
+        rt, jsi::String::createFromUtf8(rt, propName), value->getValue(rt));
   }
   return object;
 }
 
-}
+} // namespace reanimated

package/Common/cpp/SharedItems/MutableValue.cpp

@@ -1,8 +1,8 @@
 #include "MutableValue.h"
-#include "SharedParent.h"
-#include "ShareableValue.h"
-#include "RuntimeManager.h"
 #include "RuntimeDecorator.h"
+#include "RuntimeManager.h"
+#include "ShareableValue.h"
+#include "SharedParent.h"
 
 namespace reanimated {
 
@@ -11,7 +11,7 @@ void MutableValue::setValue(jsi::Runtime &rt, const jsi::Value &newValue) {
   value = ShareableValue::adapt(rt, newValue, runtimeManager);
 
   std::shared_ptr<MutableValue> thiz = shared_from_this();
-  auto notifyListeners = [thiz] () {
+  auto notifyListeners = [thiz]() {
     for (auto listener : thiz->listeners) {
       listener.second();
     }
@@ -19,9 +19,8 @@ void MutableValue::setValue(jsi::Runtime &rt, const jsi::Value &newValue) {
   if (RuntimeDecorator::isUIRuntime(rt)) {
     notifyListeners();
   } else {
-    runtimeManager->scheduler->scheduleOnUI([notifyListeners] {
-      notifyListeners();
-    });
+    runtimeManager->scheduler->scheduleOnUI(
+        [notifyListeners] { notifyListeners(); });
   }
 }
 
@@ -30,20 +29,26 @@ jsi::Value MutableValue::getValue(jsi::Runtime &rt) {
   return value->getValue(rt);
 }
 
-void MutableValue::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &newValue) {
+void MutableValue::set(
+    jsi::Runtime &rt,
+    const jsi::PropNameID &name,
+    const jsi::Value &newValue) {
   auto propName = name.utf8(rt);
   if (!runtimeManager->valueSetter) {
-    throw jsi::JSError(rt, "Value-Setter is not yet configured! Make sure the core-functions are installed.");
+    throw jsi::JSError(
+        rt,
+        "Value-Setter is not yet configured! Make sure the core-functions are installed.");
   }
 
   if (RuntimeDecorator::isUIRuntime(rt)) {
     // UI thread
     if (propName == "value") {
-      auto setterProxy = jsi::Object::createFromHostObject(rt, std::make_shared<MutableValueSetterProxy>(shared_from_this()));
+      auto setterProxy = jsi::Object::createFromHostObject(
+          rt, std::make_shared<MutableValueSetterProxy>(shared_from_this()));
       runtimeManager->valueSetter->getValue(rt)
-      .asObject(rt)
-      .asFunction(rt)
-      .callWithThis(rt, setterProxy, newValue);
+          .asObject(rt)
+          .asFunction(rt)
+          .callWithThis(rt, setterProxy, newValue);
     } else if (propName == "_animation") {
       // TODO: assert to allow animation to be set from UI only
       if (animation.expired()) {
@@ -51,7 +56,8 @@ void MutableValue::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi:
       }
       *animation.lock() = jsi::Value(rt, newValue);
     } else if (propName == "_value") {
-      auto setter = std::make_shared<MutableValueSetterProxy>(shared_from_this());
+      auto setter =
+          std::make_shared<MutableValueSetterProxy>(shared_from_this());
       setter->set(rt, jsi::PropNameID::forAscii(rt, "_value"), newValue);
     }
   } else {
@@ -60,12 +66,13 @@ void MutableValue::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi:
       auto shareable = ShareableValue::adapt(rt, newValue, runtimeManager);
       runtimeManager->scheduler->scheduleOnUI([this, shareable] {
         jsi::Runtime &rt = *this->runtimeManager->runtime.get();
-        auto setterProxy = jsi::Object::createFromHostObject(rt, std::make_shared<MutableValueSetterProxy>(shared_from_this()));
+        auto setterProxy = jsi::Object::createFromHostObject(
+            rt, std::make_shared<MutableValueSetterProxy>(shared_from_this()));
         jsi::Value newValue = shareable->getValue(rt);
         runtimeManager->valueSetter->getValue(rt)
-          .asObject(rt)
-          .asFunction(rt)
-          .callWithThis(rt, setterProxy, newValue);
+            .asObject(rt)
+            .asFunction(rt)
+            .callWithThis(rt, setterProxy, newValue);
       });
     }
   }
@@ -100,11 +107,18 @@ std::vector<jsi::PropNameID> MutableValue::getPropertyNames(jsi::Runtime &rt) {
   return result;
 }
 
-MutableValue::MutableValue(jsi::Runtime &rt, const jsi::Value &initial, RuntimeManager *runtimeManager, std::shared_ptr<Scheduler> s):
-StoreUser(s, *runtimeManager), runtimeManager(runtimeManager), value(ShareableValue::adapt(rt, initial, runtimeManager)) {
-}
-
-unsigned long int MutableValue::addListener(unsigned long id, std::function<void ()> listener) {
+MutableValue::MutableValue(
+    jsi::Runtime &rt,
+    const jsi::Value &initial,
+    RuntimeManager *runtimeManager,
+    std::shared_ptr<Scheduler> s)
+    : StoreUser(s, *runtimeManager),
+      runtimeManager(runtimeManager),
+      value(ShareableValue::adapt(rt, initial, runtimeManager)) {}
+
+unsigned long int MutableValue::addListener(
+    unsigned long id,
+    std::function<void()> listener) {
   listeners[id] = listener;
   return id;
 }
@@ -115,5 +129,4 @@ void MutableValue::removeListener(unsigned long listenerId) {
   }
 }
 
-
-}
+} // namespace reanimated

package/Common/cpp/SharedItems/MutableValueSetterProxy.cpp

@@ -1,13 +1,16 @@
 #include "MutableValueSetterProxy.h"
-#include "SharedParent.h"
-#include "MutableValue.h"
 #include <jsi/jsi.h>
+#include "MutableValue.h"
+#include "SharedParent.h"
 
 using namespace facebook;
 
 namespace reanimated {
 
-void MutableValueSetterProxy::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &newValue) {
+void MutableValueSetterProxy::set(
+    jsi::Runtime &rt,
+    const jsi::PropNameID &name,
+    const jsi::Value &newValue) {
   auto propName = name.utf8(rt);
   if (propName == "_value") {
     mutableValue->setValue(rt, newValue);
@@ -18,11 +21,13 @@ void MutableValueSetterProxy::set(jsi::Runtime &rt, const jsi::PropNameID &name,
     }
     *mutableValue->animation.lock() = jsi::Value(rt, newValue);
   } else if (propName == "value") {
-      // you call `this.value` inside of value setter, we should throw
+    // you call `this.value` inside of value setter, we should throw
   }
 }
 
-jsi::Value MutableValueSetterProxy::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
+jsi::Value MutableValueSetterProxy::get(
+    jsi::Runtime &rt,
+    const jsi::PropNameID &name) {
   auto propName = name.utf8(rt);
 
   if (propName == "value") {
@@ -39,5 +44,4 @@ jsi::Value MutableValueSetterProxy::get(jsi::Runtime &rt, const jsi::PropNameID
   return jsi::Value::undefined();
 }
 
-}
-
+} // namespace reanimated

package/Common/cpp/SharedItems/RemoteObject.cpp

@@ -1,7 +1,7 @@
 #include "RemoteObject.h"
-#include "SharedParent.h"
-#include "RuntimeDecorator.h"
 #include <jsi/jsi.h>
+#include "RuntimeDecorator.h"
+#include "SharedParent.h"
 
 using namespace facebook;
 
@@ -22,7 +22,10 @@ jsi::Value RemoteObject::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
   return jsi::Value::undefined();
 }
 
-void RemoteObject::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value) {
+void RemoteObject::set(
+    jsi::Runtime &rt,
+    const jsi::PropNameID &name,
+    const jsi::Value &value) {
   if (RuntimeDecorator::isWorkletRuntime(rt)) {
     backing.lock()->getObject(rt).setProperty(rt, name, value);
   }
@@ -33,9 +36,10 @@ std::vector<jsi::PropNameID> RemoteObject::getPropertyNames(jsi::Runtime &rt) {
   std::vector<jsi::PropNameID> res;
   auto propertyNames = backing.lock()->getObject(rt).getPropertyNames(rt);
   for (size_t i = 0, size = propertyNames.size(rt); i < size; i++) {
-    res.push_back(jsi::PropNameID::forString(rt, propertyNames.getValueAtIndex(rt, i).asString(rt)));
+    res.push_back(jsi::PropNameID::forString(
+        rt, propertyNames.getValueAtIndex(rt, i).asString(rt)));
   }
   return res;
 }
 
-}
+} // namespace reanimated