@shopify/react-native-skia 0.1.155 → 0.1.156

package/cpp/rnskia/values/RNSkClockValue.h

@@ -6,126 +6,125 @@
 #include <jsi/jsi.h>
 
 #include <algorithm>
-#include <functional>
 #include <chrono>
+#include <functional>
+#include <memory>
 
-namespace RNSkia
-{
-using namespace facebook;
+namespace RNSkia {
+namespace jsi = facebook::jsi;
 /**
- Implements a readonly Value that is updated every time the screen is redrawn. Its value will be the
- number of milliseconds since the animation value was started.
+ Implements a readonly Value that is updated every time the screen is redrawn.
+ Its value will be the number of milliseconds since the animation value was
+ started.
  */
-class RNSkClockValue : public RNSkReadonlyValue
-{
-enum RNSkClockState {
-    NotStarted = 0,
-    Running = 1,
-    Stopped = 2
-};
-  
+class RNSkClockValue : public RNSkReadonlyValue {
+  enum RNSkClockState { NotStarted = 0, Running = 1, Stopped = 2 };
+
 public:
   RNSkClockValue(std::shared_ptr<RNSkPlatformContext> platformContext,
-                 size_t identifier,
-                 jsi::Runtime& runtime,
-                 const jsi::Value *arguments,
-                 size_t count) : RNSkReadonlyValue(platformContext),
-        _runtime(runtime),
+                 size_t identifier, jsi::Runtime &runtime,
+                 const jsi::Value *arguments, size_t count)
+      : RNSkReadonlyValue(platformContext), _runtime(runtime),
         _identifier(identifier) {
     // Start by updating to zero (start value)
     update(_runtime, static_cast<double>(0));
   }
-  
-  virtual ~RNSkClockValue() {
-    stopClock();
-  }
-  
+
+  virtual ~RNSkClockValue() { stopClock(); }
+
   JSI_HOST_FUNCTION(start) {
     startClock();
     return jsi::Value::undefined();
   }
-  
+
   JSI_HOST_FUNCTION(stop) {
     stopClock();
     return jsi::Value::undefined();
   }
-  
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkReadonlyValue, addListener),
                        JSI_EXPORT_FUNC(RNSkClockValue, start),
                        JSI_EXPORT_FUNC(RNSkClockValue, stop))
-  
-  
+
   virtual void startClock() {
-    if(_state == RNSkClockState::Running) {
+    if (_state == RNSkClockState::Running) {
       return;
     }
-    
+
     auto now = std::chrono::high_resolution_clock::now();
-    if(_state == RNSkClockState::NotStarted) {
+    if (_state == RNSkClockState::NotStarted) {
       _start = now;
       _stop = now;
     }
-    
+
     // Subtract pause time from start
     auto timeSinceStop = now - _stop;
     _start += timeSinceStop;
-    
+
     _state = RNSkClockState::Running;
-    
-    getContext()->beginDrawLoop(_identifier, [weakSelf = weak_from_this()](bool invalidated){
-      auto self = weakSelf.lock();
-      if(self) {
-        std::dynamic_pointer_cast<RNSkClockValue>(self)->notifyUpdate(invalidated);
-      }
-    });
+
+    getContext()->beginDrawLoop(
+        _identifier, [weakSelf = weak_from_this()](bool invalidated) {
+          auto self = weakSelf.lock();
+          if (self) {
+            std::dynamic_pointer_cast<RNSkClockValue>(self)->notifyUpdate(
+                invalidated);
+          }
+        });
   }
-  
+
   virtual void stopClock() {
-    if(_state == RNSkClockState::Running) {
+    if (_state == RNSkClockState::Running) {
       _state = RNSkClockState::Stopped;
       _stop = std::chrono::high_resolution_clock::now();
       getContext()->endDrawLoop(_identifier);
     }
   }
-  
+
 protected:
   virtual void tick(jsi::Runtime &runtime, const jsi::Value &value) {
     RNSkClockValue::update(runtime, value);
   }
-  
+
   void notifyUpdate(bool invalidated) {
-    if(invalidated) {
+    if (invalidated) {
       stopClock();
       return;
     }
-    
-    if(_state != RNSkClockState::Running) {
+
+    if (_state != RNSkClockState::Running) {
       return;
     }
-    
+
     // Ensure we call any updates from the draw loop on the javascript thread
     getContext()->runOnJavascriptThread(
-      // To ensure that this shared_ptr instance is not deallocated before we are done
-      // running the update lambda we pass a shared from this to the lambda scope.
-      [weakSelf = weak_from_this()]() {
-        auto self = weakSelf.lock();
-        if(self) {
-          auto selfClockValue = std::dynamic_pointer_cast<RNSkClockValue>(self);
-          if(selfClockValue->getState() == RNSkClockState::Running) {
-            auto now = std::chrono::high_resolution_clock::now();
-            auto deltaFromStart = std::chrono::duration_cast<std::chrono::milliseconds>(now - selfClockValue->_start).count();
-            selfClockValue->tick(selfClockValue->_runtime, static_cast<double>(deltaFromStart));
+        // To ensure that this shared_ptr instance is not deallocated before we
+        // are done running the update lambda we pass a shared from this to the
+        // lambda scope.
+        [weakSelf = weak_from_this()]() {
+          auto self = weakSelf.lock();
+          if (self) {
+            auto selfClockValue =
+                std::dynamic_pointer_cast<RNSkClockValue>(self);
+            if (selfClockValue->getState() == RNSkClockState::Running) {
+              auto now = std::chrono::high_resolution_clock::now();
+              auto deltaFromStart =
+                  std::chrono::duration_cast<std::chrono::milliseconds>(
+                      now - selfClockValue->_start)
+                      .count();
+              selfClockValue->tick(selfClockValue->_runtime,
+                                   static_cast<double>(deltaFromStart));
+            }
           }
-        }
-    });
+        });
   }
-  
+
   /**
    Returns the draw identifier for the clock. This identifier is used
    for the draw loop.
    */
   size_t getIdentifier() { return _identifier; }
-  
+
   /**
    Returns the state of the clock
    */
@@ -135,7 +134,7 @@ protected:
   size_t _identifier;
   std::chrono::time_point<std::chrono::steady_clock> _start;
   std::chrono::time_point<std::chrono::steady_clock> _stop;
-  std::atomic<RNSkClockState> _state = { RNSkClockState::NotStarted };
+  std::atomic<RNSkClockState> _state = {RNSkClockState::NotStarted};
 };
 
-}
+} // namespace RNSkia

package/cpp/rnskia/values/RNSkComputedValue.h

@@ -6,54 +6,55 @@
 #include <jsi/jsi.h>
 
 #include <algorithm>
-#include <functional>
 #include <chrono>
+#include <functional>
 #include <memory>
 #include <vector>
 
-namespace RNSkia
-{
-using namespace facebook;
+namespace RNSkia {
+namespace jsi = facebook::jsi;
 
 /**
-  Creates a readonly value that depends on one or more other values. The derived value has a callback
-  function that is used to calculate the new value when any of the dependencies change.
+  Creates a readonly value that depends on one or more other values. The derived
+  value has a callback function that is used to calculate the new value when any
+  of the dependencies change.
  */
-class RNSkComputedValue : public RNSkReadonlyValue
-{
+class RNSkComputedValue : public RNSkReadonlyValue {
 public:
   RNSkComputedValue(std::shared_ptr<RNSkPlatformContext> platformContext,
-                    jsi::Runtime &runtime,
-                    const jsi::Value *arguments,
-                    size_t count
-                   )
+                    jsi::Runtime &runtime, const jsi::Value *arguments,
+                    size_t count)
       : RNSkReadonlyValue(platformContext) {
     // Verify input
-    if(!arguments[0].isObject() ||
-       !arguments[0].asObject(runtime).isFunction(runtime)) {
-      throw jsi::JSError(runtime, "Expected callback function as first parameter");
+    if (!arguments[0].isObject() ||
+        !arguments[0].asObject(runtime).isFunction(runtime)) {
+      throw jsi::JSError(runtime,
+                         "Expected callback function as first parameter");
     }
 
-    if(!arguments[1].isObject() ||
-       !arguments[1].asObject(runtime).isArray(runtime)) {
-      throw jsi::JSError(runtime, "Expected array of dependencies as second parameter");
+    if (!arguments[1].isObject() ||
+        !arguments[1].asObject(runtime).isArray(runtime)) {
+      throw jsi::JSError(runtime,
+                         "Expected array of dependencies as second parameter");
     }
 
     // Get callback for calculating result
-    _callback = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
+    _callback = std::make_shared<jsi::Function>(
+        arguments[0].asObject(runtime).asFunction(runtime));
   }
 
   void invalidate() override {
     RNSkReadonlyValue::invalidate();
 
     // Unregister listeners
-    for(const auto &unsubscribe: _unsubscribers) {
+    for (const auto &unsubscribe : _unsubscribers) {
       unsubscribe();
     }
     _unsubscribers.clear();
   }
 
-  void initializeDependencies(jsi::Runtime &runtime, const jsi::Value *arguments, size_t count) {
+  void initializeDependencies(jsi::Runtime &runtime,
+                              const jsi::Value *arguments, size_t count) {
     // Save dependencies
     std::vector<std::shared_ptr<RNSkReadonlyValue>> dependencies;
 
@@ -61,14 +62,14 @@ public:
     auto deps = arguments[1].asObject(runtime).asArray(runtime);
     const std::size_t size = deps.size(runtime);
     dependencies.reserve(size);
-    for(size_t i=0; i<size; ++i) {
+    for (size_t i = 0; i < size; ++i) {
       auto dep = deps.getValueAtIndex(runtime, i);
-      if(!dep.isObject() ||
-         !dep.asObject(runtime).isHostObject(runtime)) {
+      if (!dep.isObject() || !dep.asObject(runtime).isHostObject(runtime)) {
         continue;
       }
-      auto value = dep.asObject(runtime).asHostObject<RNSkReadonlyValue>(runtime);
-      if(value == nullptr) {
+      auto value =
+          dep.asObject(runtime).asHostObject<RNSkReadonlyValue>(runtime);
+      if (value == nullptr) {
         continue;
       }
       dependencies.push_back(value);
@@ -76,10 +77,11 @@ public:
 
     // register change handler on dependencies
     _unsubscribers.reserve(_unsubscribers.size() + size);
-    for(const auto &dep: dependencies) {
-      _unsubscribers.push_back(dep->addListener([weakSelf = weak_from_this()](jsi::Runtime& runtime) {
+    for (const auto &dep : dependencies) {
+      _unsubscribers.push_back(dep->addListener([weakSelf = weak_from_this()](
+                                                    jsi::Runtime &runtime) {
         auto self = weakSelf.lock();
-        if(self) {
+        if (self) {
           auto selfAsThis = std::dynamic_pointer_cast<RNSkComputedValue>(self);
           selfAsThis->dependencyUpdated(runtime);
         }
@@ -99,4 +101,4 @@ private:
   std::shared_ptr<jsi::Function> _callback;
   std::vector<std::function<void()>> _unsubscribers;
 };
-}
+} // namespace RNSkia

package/cpp/rnskia/values/RNSkReadonlyValue.h

@@ -2,76 +2,76 @@
 #pragma once
 
 #include <algorithm>
-#include <functional>
 #include <chrono>
-#include <unordered_map>
+#include <functional>
 #include <memory>
+#include <unordered_map>
+#include <utility>
 
 #include <jsi/jsi.h>
 
+#include <JsiSimpleValueWrapper.h>
 #include <JsiSkHostObjects.h>
 #include <RNSkPlatformContext.h>
-#include <JsiSimpleValueWrapper.h>
 
-namespace RNSkia
-{
-using namespace facebook;
+namespace RNSkia {
+namespace jsi = facebook::jsi;
 
 /**
- Implements a readonly Value that is updated every time the screen is redrawn. Its value will be the
- number of milliseconds since the animation value was started.
+ Implements a readonly Value that is updated every time the screen is redrawn.
+ Its value will be the number of milliseconds since the animation value was
+ started.
  */
-class RNSkReadonlyValue : public JsiSkHostObject,
-                          public std::enable_shared_from_this<RNSkReadonlyValue>
-{
+class RNSkReadonlyValue
+    : public JsiSkHostObject,
+      public std::enable_shared_from_this<RNSkReadonlyValue> {
 public:
-  RNSkReadonlyValue(std::shared_ptr<RNSkPlatformContext> platformContext)
+  explicit RNSkReadonlyValue(
+      std::shared_ptr<RNSkPlatformContext> platformContext)
       : JsiSkHostObject(platformContext),
-      _valueHolder(std::make_unique<JsiSimpleValueWrapper>(*platformContext->getJsRuntime()))
-      { }
+        _valueHolder(std::make_unique<RNJsi::JsiSimpleValueWrapper>(
+            *platformContext->getJsRuntime())) {}
 
-  virtual ~RNSkReadonlyValue() {
-    invalidate();
-  }
+  virtual ~RNSkReadonlyValue() { invalidate(); }
 
   JSI_PROPERTY_GET(__typename__) {
     return jsi::String::createFromUtf8(runtime, "RNSkValue");
   }
 
-  JSI_PROPERTY_GET(current) {
-    return getCurrent(runtime);
-  }
+  JSI_PROPERTY_GET(current) { return getCurrent(runtime); }
 
-  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(RNSkReadonlyValue, __typename__),
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(RNSkReadonlyValue,
+                                                  __typename__),
                               JSI_EXPORT_PROP_GET(RNSkReadonlyValue, current))
 
   JSI_HOST_FUNCTION(addListener) {
-    if(!arguments[0].isObject() || !arguments[0].asObject(runtime).isFunction(runtime)) {
+    if (!arguments[0].isObject() ||
+        !arguments[0].asObject(runtime).isFunction(runtime)) {
       throw jsi::JSError(runtime, "Expected function as first parameter.");
       return jsi::Value::undefined();
     }
-    auto callback = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
-
-    auto unsubscribe = addListener([weakSelf = weak_from_this(),
-                                    callback = std::move(callback)](jsi::Runtime& runtime){
-      auto self = weakSelf.lock();
-      if(self) {
-        auto selfReadonlyValue = std::dynamic_pointer_cast<RNSkReadonlyValue>(self);
-        callback->call(runtime, selfReadonlyValue->get_current(runtime));
-      }
-    });
-
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forUtf8(runtime, "unsubscribe"),
-                                                 0,
-                                                 JSI_HOST_FUNCTION_LAMBDA {
-      unsubscribe();
-      return jsi::Value::undefined();
-    });
+    auto callback = std::make_shared<jsi::Function>(
+        arguments[0].asObject(runtime).asFunction(runtime));
+
+    auto unsubscribe =
+        addListener([weakSelf = weak_from_this(),
+                     callback = std::move(callback)](jsi::Runtime &runtime) {
+          auto self = weakSelf.lock();
+          if (self) {
+            auto selfReadonlyValue =
+                std::dynamic_pointer_cast<RNSkReadonlyValue>(self);
+            callback->call(runtime, selfReadonlyValue->get_current(runtime));
+          }
+        });
+
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "unsubscribe"), 0,
+        JSI_HOST_FUNCTION_LAMBDA {
+          unsubscribe();
+          return jsi::Value::undefined();
+        });
   }
 
-
-
   JSI_HOST_FUNCTION(__invalidate) {
     invalidate();
     return jsi::Value::undefined();
@@ -81,17 +81,18 @@ public:
                        JSI_EXPORT_FUNC(RNSkReadonlyValue, __invalidate))
 
   /**
-  * Adds a callback that will be called whenever the value changes
-  * @param cb Callback
-  * @return unsubscribe function
-  */
-  const std::function<void()> addListener(const std::function<void(jsi::Runtime&)> cb) {
+   * Adds a callback that will be called whenever the value changes
+   * @param cb Callback
+   * @return unsubscribe function
+   */
+  const std::function<void()>
+  addListener(const std::function<void(jsi::Runtime &)> cb) {
     std::lock_guard<std::mutex> lock(_mutex);
     auto listenerId = _listenerId++;
     _listeners.emplace(listenerId, cb);
     return [weakSelf = weak_from_this(), listenerId]() {
       auto self = weakSelf.lock();
-      if(self) {
+      if (self) {
         self->removeListener(listenerId);
       }
     };
@@ -99,22 +100,23 @@ public:
 
   /**
     Updates the underlying value and notifies all listeners about the change.
-    Listeners are only notified if the value was actually changed for numeric, boolean and string
-    values. For all other values listeners are notified without comparison.
+    Listeners are only notified if the value was actually changed for numeric,
+   boolean and string values. For all other values listeners are notified
+   without comparison.
    @param runtime Current JS Runtime
    @param value Next value
    */
   virtual void update(jsi::Runtime &runtime, const jsi::Value &value) {
     auto equal = _valueHolder->equals(runtime, value);
     _valueHolder->setCurrent(runtime, value);
-    if(!equal) {
+    if (!equal) {
       notifyListeners(runtime);
     }
   }
 
   /**
-   Override to implement invalidation logic for the value. In the base class this function
-   clears all subscribers.
+   Override to implement invalidation logic for the value. In the base class
+   this function clears all subscribers.
    */
   virtual void invalidate() {
     std::lock_guard<std::mutex> lock(_mutex);
@@ -126,18 +128,17 @@ public:
   }
 
 protected:
-
   /**
     Notifies listeners about changes
    @param runtime Current JS Runtime
    */
   void notifyListeners(jsi::Runtime &runtime) {
-    std::unordered_map<long, std::function<void(jsi::Runtime&)>> tmp;
+    std::unordered_map<long, std::function<void(jsi::Runtime &)>> tmp;
     {
       std::lock_guard<std::mutex> lock(_mutex);
       tmp.insert(_listeners.cbegin(), _listeners.cend());
     }
-    for(const auto &listener: tmp) {
+    for (const auto &listener : tmp) {
       listener.second(runtime);
     }
   }
@@ -152,10 +153,10 @@ protected:
   }
 
 private:
-  std::unique_ptr<JsiSimpleValueWrapper> _valueHolder;
+  std::unique_ptr<RNJsi::JsiSimpleValueWrapper> _valueHolder;
 
   long _listenerId = 0;
-  std::unordered_map<long, std::function<void(jsi::Runtime&)>> _listeners;
+  std::unordered_map<long, std::function<void(jsi::Runtime &)>> _listeners;
   std::mutex _mutex;
 };
-}
+} // namespace RNSkia

package/cpp/rnskia/values/RNSkValue.h

@@ -4,33 +4,29 @@
 #include <memory>
 
 #include <JsiHostObject.h>
+#include <RNSkAnimation.h>
 #include <RNSkPlatformContext.h>
 #include <RNSkReadonlyValue.h>
-#include <RNSkAnimation.h>
 #include <jsi/jsi.h>
 
-namespace RNSkia
-{
-using namespace facebook;
+namespace RNSkia {
+namespace jsi = facebook::jsi;
 /**
- Implements a Value that can be both read and written to. It inherits from the ReadonlyValue with
- functionailty for subscribing to changes.
+ Implements a Value that can be both read and written to. It inherits from the
+ ReadonlyValue with functionailty for subscribing to changes.
  */
-class RNSkValue : public RNSkReadonlyValue
-{
+class RNSkValue : public RNSkReadonlyValue {
 public:
   RNSkValue(std::shared_ptr<RNSkPlatformContext> platformContext,
-            jsi::Runtime& runtime, const jsi::Value *arguments, size_t count)
+            jsi::Runtime &runtime, const jsi::Value *arguments, size_t count)
       : RNSkReadonlyValue(platformContext) {
-        if(count == 1) {
-          update(runtime, arguments[0]);
-        }
-      }
-
-  ~RNSkValue() {
-    unsubscribe();
+    if (count == 1) {
+      update(runtime, arguments[0]);
+    }
   }
 
+  ~RNSkValue() { unsubscribe(); }
+
   JSI_PROPERTY_SET(current) {
     // When someone else is setting the value we need to stop any ongoing
     // animations
@@ -43,13 +39,15 @@ public:
     unsubscribe();
 
     // Verify input
-    if(value.isObject() && value.asObject(runtime).isHostObject<RNSkAnimation>(runtime)) {
-      auto animation = value.asObject(runtime).getHostObject<RNSkAnimation>(runtime);
-      if(animation != nullptr) {
+    if (value.isObject() &&
+        value.asObject(runtime).isHostObject<RNSkAnimation>(runtime)) {
+      auto animation =
+          value.asObject(runtime).getHostObject<RNSkAnimation>(runtime);
+      if (animation != nullptr) {
         // Now we have a value animation - let us connect and start
         subscribe(animation);
       }
-    } else if(value.isUndefined() || value.isNull()) {
+    } else if (value.isUndefined() || value.isNull()) {
       // Do nothing - we've already unsubscribed
     } else {
       throw jsi::JSError(runtime, "Animation expected.");
@@ -57,7 +55,7 @@ public:
   }
 
   JSI_PROPERTY_GET(animation) {
-    if(_animation != nullptr) {
+    if (_animation != nullptr) {
       return jsi::Object::createFromHostObject(runtime, _animation);
     }
     return jsi::Value::undefined();
@@ -66,46 +64,46 @@ public:
   JSI_EXPORT_PROPERTY_SETTERS(JSI_EXPORT_PROP_SET(RNSkValue, current),
                               JSI_EXPORT_PROP_SET(RNSkValue, animation))
 
-  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(RNSkReadonlyValue, __typename__),
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(RNSkReadonlyValue,
+                                                  __typename__),
                               JSI_EXPORT_PROP_GET(RNSkValue, current),
                               JSI_EXPORT_PROP_GET(RNSkValue, animation))
 
-  JSI_EXPORT_FUNCTIONS(
-    JSI_EXPORT_FUNC(RNSkValue, addListener),
-    JSI_EXPORT_FUNC(RNSkReadonlyValue, __invalidate)
-  )
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkValue, addListener),
+                       JSI_EXPORT_FUNC(RNSkReadonlyValue, __invalidate))
 
 private:
   void subscribe(std::shared_ptr<RNSkAnimation> animation) {
-    if(animation != nullptr) {
+    if (animation != nullptr) {
       _animation = animation;
-      _unsubscribe = std::make_shared<std::function<void()>>(
-        _animation->addListener([weakSelf = weak_from_this()](jsi::Runtime &runtime) {
-        auto self = weakSelf.lock();
-        if(self) {
-          auto selfAsThis = std::dynamic_pointer_cast<RNSkValue>(self);
-          selfAsThis->animationDidUpdate(runtime);
-        }
-      }));
+      _unsubscribe =
+          std::make_shared<std::function<void()>>(_animation->addListener(
+              [weakSelf = weak_from_this()](jsi::Runtime &runtime) {
+                auto self = weakSelf.lock();
+                if (self) {
+                  auto selfAsThis = std::dynamic_pointer_cast<RNSkValue>(self);
+                  selfAsThis->animationDidUpdate(runtime);
+                }
+              }));
       // Start the animation
       _animation->startClock();
     }
   }
 
-  void animationDidUpdate(jsi::Runtime& runtime) {
-    if(_animation != nullptr) {
+  void animationDidUpdate(jsi::Runtime &runtime) {
+    if (_animation != nullptr) {
       // Update ourselves from the current animation value
       update(runtime, _animation->get_current(runtime));
     }
   }
 
   void unsubscribe() {
-    if(_unsubscribe != nullptr) {
+    if (_unsubscribe != nullptr) {
       (*_unsubscribe)();
       _unsubscribe = nullptr;
     }
 
-    if(_animation != nullptr) {
+    if (_animation != nullptr) {
       _animation->stopClock();
       _animation = nullptr;
     }
@@ -115,4 +113,4 @@ private:
   std::shared_ptr<std::function<void()>> _unsubscribe;
 };
 
-}
+} // namespace RNSkia