@shopify/react-native-skia 0.1.155 → 0.1.157

package/cpp/jsi/JsiSimpleValueWrapper.h

@@ -1,108 +1,99 @@
-
 #pragma once
 
+#include <memory>
+
 #include <jsi/jsi.h>
 
-namespace RNJsi
-{
-using namespace facebook;
+namespace RNJsi {
+namespace jsi = facebook::jsi;
 
 /**
- Implements a simple wrapper class for JSI primitives like numbers and boolean values. Objects,
- strings and arrays are stored as values inside a property holder. The class also provides a method
- for comparing values that will compare numbers, booleans and strings.
+ Implements a simple wrapper class for JSI primitives like numbers and boolean
+ values. Objects, strings and arrays are stored as values inside a property
+ holder. The class also provides a method for comparing values that will compare
+ numbers, booleans and strings.
  */
-class JsiSimpleValueWrapper
-{
+class JsiSimpleValueWrapper {
 private:
-  enum ValueType {
-    NonInitialized,
-    Undefined,
-    Null,
-    Bool,
-    Number,
-    JsiValue
-  };
+  enum ValueType { NonInitialized, Undefined, Null, Bool, Number, JsiValue };
 
 public:
-    JsiSimpleValueWrapper(jsi::Runtime& runtime) :
-      _type(ValueType::NonInitialized),
-      _propNameId(jsi::PropNameID::forUtf8(runtime, "value"))
-    {}
+  explicit JsiSimpleValueWrapper(jsi::Runtime &runtime)
+      : _type(ValueType::NonInitialized),
+        _propNameId(jsi::PropNameID::forUtf8(runtime, "value")) {}
 
-    jsi::Value getCurrent(jsi::Runtime &runtime)
-    {
-      switch (_type)
-      {
-          case ValueType::NonInitialized:
-              return nullptr;
-          case ValueType::Undefined:
-            return jsi::Value::undefined();
-          case ValueType::Null:
-            return jsi::Value::null();
-          case ValueType::Bool:
-            return _boolValue;
-          case ValueType::Number:
-            return _numberValue;
-          case ValueType::JsiValue:
-            if (_valueHolder == nullptr) {
-                return jsi::Value::undefined();
-            }
-            return _valueHolder->getProperty(runtime, _propNameId);
+  jsi::Value getCurrent(jsi::Runtime &runtime) {
+    switch (_type) {
+    case ValueType::NonInitialized:
+      return nullptr;
+    case ValueType::Undefined:
+      return jsi::Value::undefined();
+    case ValueType::Null:
+      return jsi::Value::null();
+    case ValueType::Bool:
+      return _boolValue;
+    case ValueType::Number:
+      return _numberValue;
+    case ValueType::JsiValue:
+      if (_valueHolder == nullptr) {
+        return jsi::Value::undefined();
       }
+      return _valueHolder->getProperty(runtime, _propNameId);
     }
+  }
 
-    void setCurrent(jsi::Runtime &runtime, const jsi::Value &value)
-    {
-      if(value.isNumber()) {
-        _type = ValueType::Number;
-        _numberValue = value.asNumber();
-      } else if(value.isBool()) {
-        _type = ValueType::Bool;
-        _boolValue = value.getBool();
-      } else if(value.isUndefined()) {
-        _type = ValueType::Undefined;
-      } else if(value.isNull()) {
-        _type = ValueType::Null;
-      } else {
-        _type = ValueType::JsiValue;
-        // Save as javascript object - we don't want to have to copy strings, objects and values
-        if(_valueHolder == nullptr) {
-            _valueHolder = std::make_shared<jsi::Object>(runtime);
-        }
-        _valueHolder->setProperty(runtime, _propNameId, value);
+  void setCurrent(jsi::Runtime &runtime, const jsi::Value &value) {
+    if (value.isNumber()) {
+      _type = ValueType::Number;
+      _numberValue = value.asNumber();
+    } else if (value.isBool()) {
+      _type = ValueType::Bool;
+      _boolValue = value.getBool();
+    } else if (value.isUndefined()) {
+      _type = ValueType::Undefined;
+    } else if (value.isNull()) {
+      _type = ValueType::Null;
+    } else {
+      _type = ValueType::JsiValue;
+      // Save as javascript object - we don't want to have to copy strings,
+      // objects and values
+      if (_valueHolder == nullptr) {
+        _valueHolder = std::make_shared<jsi::Object>(runtime);
       }
+      _valueHolder->setProperty(runtime, _propNameId, value);
     }
+  }
 
-    bool equals(jsi::Runtime& runtime, const jsi::Value &value) {
-      if (_type == ValueType::NonInitialized) {
-          return false;
-      }
-      if(value.isNumber() && _type == ValueType::Number) {
-        return _numberValue == value.asNumber();
-      } else if(value.isBool() && _type == ValueType::Bool) {
-        return _boolValue == value.getBool();
-      } else if(value.isUndefined()) {
-        return _type == ValueType::Undefined;
-      } else if(value.isNull()) {
-        return _type == ValueType::Null;
-      } else if(value.isString()) {
-          auto current = getCurrent(runtime);
-          if (current.isString()) {
-              return jsi::String::strictEquals(runtime, value.asString(runtime), current.asString(runtime));
-          }
-          return false;
+  bool equals(jsi::Runtime &runtime, const jsi::Value &value) {
+    if (_type == ValueType::NonInitialized) {
+      return false;
+    }
+    if (value.isNumber() && _type == ValueType::Number) {
+      return _numberValue == value.asNumber();
+    } else if (value.isBool() && _type == ValueType::Bool) {
+      return _boolValue == value.getBool();
+    } else if (value.isUndefined()) {
+      return _type == ValueType::Undefined;
+    } else if (value.isNull()) {
+      return _type == ValueType::Null;
+    } else if (value.isString()) {
+      auto current = getCurrent(runtime);
+      if (current.isString()) {
+        return jsi::String::strictEquals(runtime, value.asString(runtime),
+                                         current.asString(runtime));
       }
       return false;
     }
+    return false;
+  }
 
 private:
-    jsi::PropNameID _propNameId;
-    std::shared_ptr<jsi::Object> _valueHolder;
+  jsi::PropNameID _propNameId;
+  std::shared_ptr<jsi::Object> _valueHolder;
 
-    bool _boolValue;
-    double _numberValue;
+  bool _boolValue;
+  double _numberValue;
 
-    ValueType _type;
+  ValueType _type;
 };
-}
+} // namespace RNJsi

package/cpp/jsi/JsiValueWrapper.h

@@ -1,46 +1,42 @@
-
 #pragma once
 
 #include <jsi/jsi.h>
+#include <memory>
+#include <string>
+
+namespace RNJsi {
+namespace jsi = facebook::jsi;
 
-namespace RNJsi
-{
-using namespace facebook;
-
-enum JsiWrapperValueType
-{
-    NonInitialized,
-    Undefined,
-    Null,
-    Bool,
-    Number,
-    String,
-    Object,
-    Function,
-    Array,
-    HostObject,
-    Unknown
+enum JsiWrapperValueType {
+  NonInitialized,
+  Undefined,
+  Null,
+  Bool,
+  Number,
+  String,
+  Object,
+  Function,
+  Array,
+  HostObject,
+  Unknown
 };
 
 /**
- Implements a simple wrapper class for JSI values where the value can be read without asking the runtime for any assistance
- Meaning that we can access members without being on the JS thread.
+ Implements a simple wrapper class for JSI values where the value can be read
+ without asking the runtime for any assistance Meaning that we can access
+ members without being on the JS thread.
  */
-class JsiValueWrapper
-{
+class JsiValueWrapper {
 public:
-  JsiValueWrapper(jsi::Runtime& runtime) :
-    _type(JsiWrapperValueType::NonInitialized)
-  {}
-  
-  JsiValueWrapper(jsi::Runtime& runtime, const jsi::Value &value) :
-    _type(JsiWrapperValueType::NonInitialized)
-  {
+  explicit JsiValueWrapper(jsi::Runtime &runtime)
+      : _type(JsiWrapperValueType::NonInitialized) {}
+
+  JsiValueWrapper(jsi::Runtime &runtime, const jsi::Value &value)
+      : _type(JsiWrapperValueType::NonInitialized) {
     setCurrent(runtime, value);
   }
 
-  void setCurrent(jsi::Runtime &runtime, const jsi::Value &value)
-  {
+  void setCurrent(jsi::Runtime &runtime, const jsi::Value &value) {
     if (value.isNumber()) {
       _type = JsiWrapperValueType::Number;
       _numberValue = value.asNumber();
@@ -59,11 +55,13 @@ public:
       _objectValue = std::make_shared<jsi::Object>(value.asObject(runtime));
       if (_objectValue->isFunction(runtime)) {
         _type = JsiWrapperValueType::Function;
-        _functionValue = std::make_shared<jsi::Function>(_objectValue->asFunction(runtime));
+        _functionValue =
+            std::make_shared<jsi::Function>(_objectValue->asFunction(runtime));
         _objectValue = nullptr;
       } else if (_objectValue->isArray(runtime)) {
         _type = JsiWrapperValueType::Array;
-        _arrayValue = std::make_shared<jsi::Array>(_objectValue->asArray(runtime));
+        _arrayValue =
+            std::make_shared<jsi::Array>(_objectValue->asArray(runtime));
         _objectValue = nullptr;
       } else if (_objectValue->isHostObject(runtime)) {
         _type = JsiWrapperValueType::HostObject;
@@ -74,7 +72,7 @@ public:
       throw std::runtime_error("Could not store jsi::Value of provided type");
     }
     // Save in value holder as well so that we can return current
-    if(_valueHolder == nullptr) {
+    if (_valueHolder == nullptr) {
       _valueHolder = std::make_shared<jsi::Object>(runtime);
     }
     _valueHolder->setProperty(runtime, "current", value);
@@ -82,57 +80,57 @@ public:
 
   bool isUndefinedOrNull() {
     return _type == JsiWrapperValueType::Undefined ||
-      _type == JsiWrapperValueType::Null;
+           _type == JsiWrapperValueType::Null;
   }
-  
+
   bool getAsBool() {
     assert(_type == JsiWrapperValueType::Bool);
     return _boolValue;
   }
-  
+
   double getAsNumber() {
     assert(_type == JsiWrapperValueType::Number);
     return _numberValue;
   }
-  
-  const std::string& getAsString() {
+
+  const std::string &getAsString() {
     assert(_type == JsiWrapperValueType::String);
     return _stringValue;
   }
-  
+
   std::shared_ptr<jsi::Function> getAsFunction() {
     assert(_type == JsiWrapperValueType::Function);
     return _functionValue;
   }
-  
+
   std::shared_ptr<jsi::Array> getAsArray() {
     assert(_type == JsiWrapperValueType::Array);
     return _arrayValue;
   }
-  
+
   std::shared_ptr<jsi::Object> getAsObject() {
     assert(_type == JsiWrapperValueType::Object);
     return _objectValue;
   }
-  
+
   std::shared_ptr<jsi::HostObject> getAsHostObject() {
     assert(_type == JsiWrapperValueType::HostObject);
     return _hostObjectValue;
   }
-  
+
   JsiWrapperValueType getType() { return _type; }
 
 private:
-    std::shared_ptr<jsi::Object> _valueHolder;
+  std::shared_ptr<jsi::Object> _valueHolder;
 
-    bool _boolValue;
-    double _numberValue;
-    std::string _stringValue;
-    std::shared_ptr<jsi::Object> _objectValue;
-    std::shared_ptr<jsi::Function> _functionValue;
-    std::shared_ptr<jsi::Array> _arrayValue;
-    std::shared_ptr<jsi::HostObject> _hostObjectValue;
+  bool _boolValue;
+  double _numberValue;
+  std::string _stringValue;
+  std::shared_ptr<jsi::Object> _objectValue;
+  std::shared_ptr<jsi::Function> _functionValue;
+  std::shared_ptr<jsi::Array> _arrayValue;
+  std::shared_ptr<jsi::HostObject> _hostObjectValue;
 
-    JsiWrapperValueType _type;
+  JsiWrapperValueType _type;
 };
-}
+} // namespace RNJsi

package/cpp/rnskia/RNSkAnimation.h

@@ -1,68 +1,65 @@
-
 #pragma once
 
 #include <array>
+#include <memory>
 
 #include <JsiHostObject.h>
-#include <RNSkPlatformContext.h>
 #include <RNSkClockValue.h>
+#include <RNSkPlatformContext.h>
 #include <jsi/jsi.h>
 
-namespace RNSkia
-{
-using namespace facebook;
+namespace RNSkia {
+namespace jsi = facebook::jsi;
 
 /**
  Implements an animation that can be used to drive other values
  */
-class RNSkAnimation : public RNSkClockValue
-{
-  
+class RNSkAnimation : public RNSkClockValue {
+
 public:
   RNSkAnimation(std::shared_ptr<RNSkPlatformContext> platformContext,
-                     size_t identifier,
-                     jsi::Runtime& runtime,
-                     const jsi::Value *arguments,
-                     size_t count) :
-    RNSkClockValue(platformContext, identifier, runtime, arguments, count) {
+                size_t identifier, jsi::Runtime &runtime,
+                const jsi::Value *arguments, size_t count)
+      : RNSkClockValue(platformContext, identifier, runtime, arguments, count) {
     // Save the update function
-    _updateFunction = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
-        
+    _updateFunction = std::make_shared<jsi::Function>(
+        arguments[0].asObject(runtime).asFunction(runtime));
+
     // Set state to undefined initially.
     _args[1] = jsi::Value::undefined();
   }
-  
+
   JSI_HOST_FUNCTION(cancel) {
     stopClock();
     return jsi::Value::undefined();
   }
-  
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkAnimation, cancel))
 
-    
 protected:
-   
   void tick(jsi::Runtime &runtime, const jsi::Value &value) override {
     // Set up arguments and call the update function
     _args[0] = value.asNumber();
-    _args[1] = _updateFunction->call(runtime, static_cast<const jsi::Value*>(_args.data()), _args.size());
-    
+    _args[1] = _updateFunction->call(
+        runtime, static_cast<const jsi::Value *>(_args.data()), _args.size());
+
     // Get finished
-    auto finished = _args[1].asObject(runtime).getProperty(runtime, "finished").getBool();
-    if(finished) {
+    auto finished =
+        _args[1].asObject(runtime).getProperty(runtime, "finished").getBool();
+    if (finished) {
       stopClock();
     }
-    
+
     // Get the next value
-    auto nextValue = _args[1].asObject(runtime).getProperty(runtime, "current").asNumber();
-    
+    auto nextValue =
+        _args[1].asObject(runtime).getProperty(runtime, "current").asNumber();
+
     // Update self
     update(runtime, nextValue);
   }
-  
+
 private:
-  
   std::shared_ptr<jsi::Function> _updateFunction;
   std::array<jsi::Value, 2> _args;
 };
-}
+} // namespace RNSkia

package/cpp/rnskia/RNSkDispatchQueue.cpp

@@ -4,81 +4,70 @@
 #include <mutex>
 #include <utility>
 
-namespace RNSkia
-{
+namespace RNSkia {
 
-  RNSkDispatchQueue::~RNSkDispatchQueue()
-  {
-    // Signal to dispatch threads that it's time to wrap up
-    std::unique_lock<std::mutex> lock(lock_);
-    quit_ = true;
-    lock.unlock();
-    cv_.notify_all();
+RNSkDispatchQueue::~RNSkDispatchQueue() {
+  // Signal to dispatch threads that it's time to wrap up
+  std::unique_lock<std::mutex> lock(lock_);
+  quit_ = true;
+  lock.unlock();
+  cv_.notify_all();
 
-    // Wait for threads to finish before we exit
-    for (size_t i = 0; i < threads_.size(); i++)
-    {
-      if (threads_[i].joinable())
-      {
-        threads_[i].join();
-      }
+  // Wait for threads to finish before we exit
+  for (size_t i = 0; i < threads_.size(); i++) {
+    if (threads_[i].joinable()) {
+      threads_[i].join();
     }
   }
+}
 
-  RNSkDispatchQueue::RNSkDispatchQueue(std::string name, size_t thread_cnt)
-      : name_{std::move(name)}, threads_(thread_cnt)
-  {
-    for (size_t i = 0; i < threads_.size(); i++)
-    {
-      threads_[i] = std::thread(&RNSkDispatchQueue::dispatch_thread_handler, this);
-    }
+RNSkDispatchQueue::RNSkDispatchQueue(std::string name, size_t thread_cnt)
+    : name_{std::move(name)}, threads_(thread_cnt) {
+  for (size_t i = 0; i < threads_.size(); i++) {
+    threads_[i] =
+        std::thread(&RNSkDispatchQueue::dispatch_thread_handler, this);
   }
+}
 
-  void RNSkDispatchQueue::dispatch(const fp_t &op)
-  {
-    std::unique_lock<std::mutex> lock(lock_);
-    q_.push(op);
+void RNSkDispatchQueue::dispatch(const fp_t &op) {
+  std::unique_lock<std::mutex> lock(lock_);
+  q_.push(op);
 
-    // Manual unlocking is done before notifying, to avoid waking up
-    // the waiting thread only to block again (see notify_one for details)
-    lock.unlock();
-    cv_.notify_one();
-  }
+  // Manual unlocking is done before notifying, to avoid waking up
+  // the waiting thread only to block again (see notify_one for details)
+  lock.unlock();
+  cv_.notify_one();
+}
 
-  void RNSkDispatchQueue::dispatch(fp_t &&op)
-  {
-    std::unique_lock<std::mutex> lock(lock_);
-    q_.push(std::move(op));
+void RNSkDispatchQueue::dispatch(fp_t &&op) {
+  std::unique_lock<std::mutex> lock(lock_);
+  q_.push(std::move(op));
 
-    // Manual unlocking is done before notifying, to avoid waking up
-    // the waiting thread only to block again (see notify_one for details)
-    lock.unlock();
-    cv_.notify_one();
-  }
+  // Manual unlocking is done before notifying, to avoid waking up
+  // the waiting thread only to block again (see notify_one for details)
+  lock.unlock();
+  cv_.notify_one();
+}
 
-  void RNSkDispatchQueue::dispatch_thread_handler(void)
-  {
-    std::unique_lock<std::mutex> lock(lock_);
+void RNSkDispatchQueue::dispatch_thread_handler(void) {
+  std::unique_lock<std::mutex> lock(lock_);
 
-    do
-    {
-      // Wait until we have data or a quit signal
-      cv_.wait(lock, [this]
-               { return (q_.size() || quit_); });
+  do {
+    // Wait until we have data or a quit signal
+    cv_.wait(lock, [this] { return (q_.size() || quit_); });
 
-      // after wait, we own the lock
-      if (!quit_ && q_.size())
-      {
-        auto op = std::move(q_.front());
-        q_.pop();
+    // after wait, we own the lock
+    if (!quit_ && q_.size()) {
+      auto op = std::move(q_.front());
+      q_.pop();
 
-        // unlock now that we're done messing with the queue
-        lock.unlock();
+      // unlock now that we're done messing with the queue
+      lock.unlock();
 
-        op();
+      op();
 
-        lock.lock();
-      }
-    } while (!quit_);
-  }
+      lock.lock();
+    }
+  } while (!quit_);
+}
 } // namespace RNSkia

package/cpp/rnskia/RNSkDispatchQueue.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <condition_variable>
 #include <cstdint>
 #include <cstdio>
@@ -15,7 +17,7 @@ class RNSkDispatchQueue {
   typedef std::function<void(void)> fp_t;
 
 public:
-  RNSkDispatchQueue(std::string name, size_t thread_cnt = 1);
+  explicit RNSkDispatchQueue(std::string name, size_t thread_cnt = 1);
 
   ~RNSkDispatchQueue();
 

package/cpp/rnskia/RNSkInfoParameter.h

@@ -13,11 +13,9 @@
 
 namespace RNSkia {
 
-using namespace facebook;
-using namespace RNJsi;
-using namespace std::chrono;
+namespace jsi = facebook::jsi;
 
-class RNSkInfoObject : public JsiHostObject {
+class RNSkInfoObject : public RNJsi::JsiHostObject {
 public:
   JSI_PROPERTY_GET(width) { return _width; }
   JSI_PROPERTY_GET(height) { return _height; }
@@ -34,9 +32,10 @@ public:
         touchObj.setProperty(runtime, "x", t.x);
         touchObj.setProperty(runtime, "y", t.y);
         touchObj.setProperty(runtime, "force", t.force);
-        touchObj.setProperty(runtime, "type", (double)t.type);
-        touchObj.setProperty(runtime, "timestamp", (double)t.timestamp / 1000.0);
-        touchObj.setProperty(runtime, "id", (double)t.id);
+        touchObj.setProperty(runtime, "type", static_cast<double>(t.type));
+        touchObj.setProperty(runtime, "timestamp",
+                             static_cast<double>(t.timestamp / 1000.0));
+        touchObj.setProperty(runtime, "id", static_cast<double>(t.id));
         touches.setValueAtIndex(runtime, n, touchObj);
       }
       ops.setValueAtIndex(runtime, i, touches);
@@ -67,13 +66,14 @@ public:
 
   void endDrawOperation() { _touchesCache.clear(); }
 
-  void updateTouches(std::vector<RNSkTouchInfo>& touches) {
+  void updateTouches(std::vector<RNSkTouchInfo> &touches) {
     std::lock_guard<std::mutex> lock(_mutex);
     // Add timestamp
-    auto ms = std::chrono::duration_cast<milliseconds>(
-        system_clock::now().time_since_epoch()).count();
-    
-    for(size_t i=0; i<touches.size(); i++) {
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                  std::chrono::system_clock::now().time_since_epoch())
+                  .count();
+
+    for (size_t i = 0; i < touches.size(); i++) {
       touches.at(i).timestamp = ms;
     }
     _currentTouches.push_back(std::move(touches));