@shopify/react-native-skia 2.10.0 → 2.10.2

package/cpp/api/JsiSkImageInfo.h

@@ -60,14 +60,12 @@ public:
                                       std::move(context), imageInfo));
   }
 
-  JSI_PROPERTY_GET(width) { return static_cast<double>(getObject()->width()); }
-  JSI_PROPERTY_GET(height) {
-    return static_cast<double>(getObject()->height());
-  }
-  JSI_PROPERTY_GET(colorType) {
+  double getWidth() { return static_cast<double>(getObject()->width()); }
+  double getHeight() { return static_cast<double>(getObject()->height()); }
+  double getColorType() {
     return static_cast<double>(getObject()->colorType());
   }
-  JSI_PROPERTY_GET(alphaType) {
+  double getAlphaType() {
     return static_cast<double>(getObject()->alphaType());
   }
 
@@ -77,13 +75,12 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostGetter(runtime, prototype, "width", &JsiSkImageInfo::get_width);
-    installHostGetter(runtime, prototype, "height",
-                      &JsiSkImageInfo::get_height);
-    installHostGetter(runtime, prototype, "colorType",
-                      &JsiSkImageInfo::get_colorType);
-    installHostGetter(runtime, prototype, "alphaType",
-                      &JsiSkImageInfo::get_alphaType);
+    installGetter(runtime, prototype, "width", &JsiSkImageInfo::getWidth);
+    installGetter(runtime, prototype, "height", &JsiSkImageInfo::getHeight);
+    installGetter(runtime, prototype, "colorType",
+                  &JsiSkImageInfo::getColorType);
+    installGetter(runtime, prototype, "alphaType",
+                  &JsiSkImageInfo::getAlphaType);
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkMaskFilterFactory.h

@@ -6,6 +6,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkColorFilter.h"
+#include "JsiSkConverters.h"
 #include "JsiSkMaskFilter.h"
 #include "JsiSkNativeObjects.h"
 
@@ -25,22 +26,18 @@ class JsiSkMaskFilterFactory
 public:
   static constexpr const char *CLASS_NAME = "MaskFilterFactory";
 
-  JSI_HOST_FUNCTION(MakeBlur) {
-    int blurStyle = arguments[0].asNumber();
-    float sigma = arguments[1].asNumber();
-    bool respectCTM = arguments[2].getBool();
-    return makeJsiObject(
-        runtime,
-        std::make_shared<JsiSkMaskFilter>(
-            getContext(),
-            SkMaskFilter::MakeBlur((SkBlurStyle)blurStyle, sigma, respectCTM)));
+  std::shared_ptr<JsiSkMaskFilter> MakeBlur(int blurStyle, float sigma,
+                                            bool respectCTM) {
+    return std::make_shared<JsiSkMaskFilter>(
+        getContext(), SkMaskFilter::MakeBlur(static_cast<SkBlurStyle>(blurStyle),
+                                             sigma, respectCTM));
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "MakeBlur",
-                      &JsiSkMaskFilterFactory::MakeBlur);
+    installMethod(runtime, prototype, "MakeBlur",
+                  &JsiSkMaskFilterFactory::MakeBlur);
   }
 
   explicit JsiSkMaskFilterFactory(std::shared_ptr<RNSkPlatformContext> context)

package/cpp/api/JsiSkMatrix.h

@@ -2,9 +2,11 @@
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
@@ -59,82 +61,39 @@ public:
                            std::to_string(array.size(runtime)));
   }
 
-  JSI_HOST_FUNCTION(concat) {
-    auto matrix = tryGetJsiObject<JsiSkMatrix>(runtime, arguments[0]);
-    if (matrix) {
-      getObject()->preConcat(*matrix->getObject());
-    } else {
-      auto m3 = JsiSkMatrix::getMatrix(runtime, arguments[0]);
-      getObject()->preConcat(m3);
-    }
-    return thisValue.asObject(runtime);
+  void concat(std::shared_ptr<SkMatrix> matrix) {
+    getObject()->preConcat(*matrix);
   }
 
-  JSI_HOST_FUNCTION(translate) {
-    auto x = arguments[0].asNumber();
-    auto y = arguments[1].asNumber();
-    getObject()->preTranslate(x, y);
-    return thisValue.asObject(runtime);
-  }
+  void translate(double x, double y) { getObject()->preTranslate(x, y); }
 
-  JSI_HOST_FUNCTION(postTranslate) {
-    auto x = arguments[0].asNumber();
-    auto y = arguments[1].asNumber();
-    getObject()->postTranslate(x, y);
-    return thisValue.asObject(runtime);
-  }
+  void postTranslate(double x, double y) { getObject()->postTranslate(x, y); }
 
-  JSI_HOST_FUNCTION(scale) {
-    auto x = arguments[0].asNumber();
-    auto y = count > 1 ? arguments[1].asNumber() : 1;
-    getObject()->preScale(x, y);
-    return thisValue.asObject(runtime);
+  void scale(double x, JsiOptional<double> y) {
+    getObject()->preScale(x, y.has_value() ? *y : 1);
   }
 
-  JSI_HOST_FUNCTION(postScale) {
-    auto x = arguments[0].asNumber();
-    auto y = count > 1 ? arguments[1].asNumber() : 1;
-    getObject()->postScale(x, y);
-    return thisValue.asObject(runtime);
+  void postScale(double x, JsiOptional<double> y) {
+    getObject()->postScale(x, y.has_value() ? *y : 1);
   }
 
-  JSI_HOST_FUNCTION(skew) {
-    auto x = arguments[0].asNumber();
-    auto y = arguments[1].asNumber();
-    getObject()->preSkew(x, y);
-    return thisValue.asObject(runtime);
-  }
+  void skew(double x, double y) { getObject()->preSkew(x, y); }
 
-  JSI_HOST_FUNCTION(postSkew) {
-    auto x = arguments[0].asNumber();
-    auto y = arguments[1].asNumber();
-    getObject()->postSkew(x, y);
-    return thisValue.asObject(runtime);
-  }
+  void postSkew(double x, double y) { getObject()->postSkew(x, y); }
 
-  JSI_HOST_FUNCTION(rotate) {
-    auto a = arguments[0].asNumber();
-    getObject()->preRotate(SkRadiansToDegrees(a));
-    return thisValue.asObject(runtime);
-  }
+  void rotate(double a) { getObject()->preRotate(SkRadiansToDegrees(a)); }
 
-  JSI_HOST_FUNCTION(postRotate) {
-    auto a = arguments[0].asNumber();
-    getObject()->postRotate(SkRadiansToDegrees(a));
-    return thisValue.asObject(runtime);
-  }
+  void postRotate(double a) { getObject()->postRotate(SkRadiansToDegrees(a)); }
 
-  JSI_HOST_FUNCTION(identity) {
-    getObject()->setIdentity();
-    return thisValue.asObject(runtime);
-  }
+  void identity() { getObject()->setIdentity(); }
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Woverloaded-virtual"
-  JSI_HOST_FUNCTION(get) {
-    auto values = jsi::Array(runtime, 9);
+  std::vector<float> get() {
+    std::vector<float> values;
+    values.reserve(9);
     for (auto i = 0; i < 9; i++) {
-      values.setValueAtIndex(runtime, i, getObject()->get(i));
+      values.push_back(getObject()->get(i));
     }
     return values;
   }
@@ -142,19 +101,23 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "concat", &JsiSkMatrix::concat);
-    installHostMethod(runtime, prototype, "translate", &JsiSkMatrix::translate);
-    installHostMethod(runtime, prototype, "postTranslate",
-                      &JsiSkMatrix::postTranslate);
-    installHostMethod(runtime, prototype, "scale", &JsiSkMatrix::scale);
-    installHostMethod(runtime, prototype, "postScale", &JsiSkMatrix::postScale);
-    installHostMethod(runtime, prototype, "skew", &JsiSkMatrix::skew);
-    installHostMethod(runtime, prototype, "postSkew", &JsiSkMatrix::postSkew);
-    installHostMethod(runtime, prototype, "rotate", &JsiSkMatrix::rotate);
-    installHostMethod(runtime, prototype, "postRotate",
-                      &JsiSkMatrix::postRotate);
-    installHostMethod(runtime, prototype, "identity", &JsiSkMatrix::identity);
-    installHostMethod(runtime, prototype, "get", &JsiSkMatrix::get);
+    installChainableMethod(runtime, prototype, "concat", &JsiSkMatrix::concat);
+    installChainableMethod(runtime, prototype, "translate",
+                           &JsiSkMatrix::translate);
+    installChainableMethod(runtime, prototype, "postTranslate",
+                           &JsiSkMatrix::postTranslate);
+    installChainableMethod(runtime, prototype, "scale", &JsiSkMatrix::scale);
+    installChainableMethod(runtime, prototype, "postScale",
+                           &JsiSkMatrix::postScale);
+    installChainableMethod(runtime, prototype, "skew", &JsiSkMatrix::skew);
+    installChainableMethod(runtime, prototype, "postSkew",
+                           &JsiSkMatrix::postSkew);
+    installChainableMethod(runtime, prototype, "rotate", &JsiSkMatrix::rotate);
+    installChainableMethod(runtime, prototype, "postRotate",
+                           &JsiSkMatrix::postRotate);
+    installChainableMethod(runtime, prototype, "identity",
+                           &JsiSkMatrix::identity);
+    installMethod(runtime, prototype, "get", &JsiSkMatrix::get);
   }
 
   /**

package/cpp/api/JsiSkNativeObjects.h

@@ -11,11 +11,6 @@
 #include "rnskia/RNSkPlatformContext.h"
 #include "utils/RNSkLog.h"
 
-#define STR_CAT_NX(A, B) A##B
-#define STR_CAT(A, B) STR_CAT_NX(A, B)
-#define STR_GET get_
-#define STR_SET set_
-
 /**
  * Creates a new Host function declaration as a lambda with all deps passed
  * with implicit lambda capture clause
@@ -25,31 +20,23 @@
       const jsi::Value *arguments, size_t count) -> jsi::Value
 
 /**
- * Creates a new Host function declaration
+ * Creates a new Host function declaration. Only used for methods that cannot
+ * be expressed as typed signatures (heterogeneous argument dispatch, typed
+ * array construction, lenient options objects, promises) — everything else
+ * uses installMethod/installGetter/installChainableMethod with typed C++
+ * signatures converted through RNJsi::JSIConverter.
  */
 #define JSI_HOST_FUNCTION(NAME)                                                \
   jsi::Value NAME(jsi::Runtime &runtime, const jsi::Value &thisValue,          \
                   const jsi::Value *arguments, size_t count)
 
-/**
- * Creates a new property setter function declaration
- */
-#define JSI_PROPERTY_SET(NAME)                                                 \
-  void STR_CAT(STR_SET, NAME)(jsi::Runtime & runtime, const jsi::Value &value)
-
-/**
- * Creates a new property getter function declaration
- */
-#define JSI_PROPERTY_GET(NAME)                                                 \
-  jsi::Value STR_CAT(STR_GET, NAME)(jsi::Runtime & runtime)
-
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
 // Minimum memory pressure reported for any native object — aliased from the
 // NativeObject infrastructure so dispose() and create() agree on the floor.
-static constexpr size_t kMinMemoryPressure = rnwgpu::kMinMemoryPressure;
+static constexpr size_t kMinMemoryPressure = RNJsi::kMinMemoryPressure;
 
 /**
  * Creates the JS object for a wrapper instance (a class based on the
@@ -113,16 +100,18 @@ std::shared_ptr<T> getJsiObject(jsi::Runtime &runtime,
  *   NativeObject::installPrototype; wrapping classes additionally call
  *   `installCommon(runtime, proto)` to install dispose().
  *
- * The existing JSI_HOST_FUNCTION / JSI_PROPERTY_GET / JSI_PROPERTY_SET method
- * bodies keep working unchanged; they are installed on the prototype with the
- * installHostMethod / installHostGetter / installHostSetter helpers below,
- * which resolve the C++ instance from `this` via native state.
+ * Most methods use typed C++ signatures installed with installMethod /
+ * installGetter / installChainableMethod (arguments and results converted
+ * through RNJsi::JSIConverter, see JsiSkConverters.h). Methods that cannot
+ * be typed keep the classic JSI_HOST_FUNCTION signature and are installed
+ * with installHostMethod, which resolves the C++ instance from `this` via
+ * native state.
  */
 template <typename Derived>
-class JsiSkNativeObject : public rnwgpu::NativeObject<Derived> {
+class JsiSkNativeObject : public RNJsi::NativeObject<Derived> {
 public:
   explicit JsiSkNativeObject(std::shared_ptr<RNSkPlatformContext> context)
-      : rnwgpu::NativeObject<Derived>(Derived::CLASS_NAME),
+      : RNJsi::NativeObject<Derived>(Derived::CLASS_NAME),
         _context(std::move(context)) {}
 
   /**
@@ -131,7 +120,7 @@ public:
    */
   static std::shared_ptr<Derived> fromThis(jsi::Runtime &runtime,
                                            const jsi::Value &thisValue) {
-    return rnwgpu::NativeObject<Derived>::fromValue(runtime, thisValue);
+    return RNJsi::NativeObject<Derived>::fromValue(runtime, thisValue);
   }
 
 protected:
@@ -213,8 +202,6 @@ protected:
 
   using HostMethod = jsi::Value (Derived::*)(jsi::Runtime &, const jsi::Value &,
                                              const jsi::Value *, size_t);
-  using HostGetter = jsi::Value (Derived::*)(jsi::Runtime &);
-  using HostSetter = void (Derived::*)(jsi::Runtime &, const jsi::Value &);
 
   /**
    * Installs a method with the classic host-function signature
@@ -233,87 +220,68 @@ protected:
   }
 
   /**
-   * Installs a property getter with the classic JSI_PROPERTY_GET signature on
-   * the prototype.
+   * Installs a typed mutating method that returns `this` for chaining
+   * (e.g. path.moveTo(...).lineTo(...)). Arguments are converted through
+   * RNJsi::JSIConverter like installMethod; the member function's return
+   * value (if any) is ignored and the JS function returns thisValue.
    */
-  static void installHostGetter(jsi::Runtime &runtime, jsi::Object &prototype,
-                                const char *name, HostGetter getter) {
-    auto getterFunc = jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, std::string("get_") + name),
-        0,
-        [getter](jsi::Runtime &rt, const jsi::Value &thisValue,
-                 const jsi::Value *, size_t) -> jsi::Value {
+  template <typename ReturnType, typename... Args>
+  static void installChainableMethod(jsi::Runtime &runtime,
+                                     jsi::Object &prototype, const char *name,
+                                     ReturnType (Derived::*method)(Args...)) {
+    auto func = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, name), sizeof...(Args),
+        [method](jsi::Runtime &rt, const jsi::Value &thisValue,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
           auto native = fromThis(rt, thisValue);
-          return ((*native).*getter)(rt);
+          invokeChainable(native.get(), method, rt, args,
+                          std::index_sequence_for<Args...>{}, count);
+          return jsi::Value(rt, thisValue);
         });
-    defineProperty(runtime, prototype, name, &getterFunc, nullptr);
+    prototype.setProperty(runtime, name, func);
   }
 
   /**
-   * Installs a property setter with the classic JSI_PROPERTY_SET signature on
-   * the prototype, preserving a previously installed getter.
+   * Chainable variant for methods that need the calling jsi::Runtime as
+   * their first parameter (e.g. the deprecated SkPath mutators, which log a
+   * warning to the JS console).
    */
-  static void installHostSetter(jsi::Runtime &runtime, jsi::Object &prototype,
-                                const char *name, HostSetter setter) {
-    auto setterFunc = jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, std::string("set_") + name),
-        1,
-        [setter](jsi::Runtime &rt, const jsi::Value &thisValue,
-                 const jsi::Value *arguments, size_t count) -> jsi::Value {
-          if (count < 1) {
-            throw jsi::JSError(rt, "Setter requires a value argument");
-          }
+  template <typename ReturnType, typename... Args>
+  static void installChainableMethodWithRuntime(
+      jsi::Runtime &runtime, jsi::Object &prototype, const char *name,
+      ReturnType (Derived::*method)(jsi::Runtime &, Args...)) {
+    auto func = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, name), sizeof...(Args),
+        [method](jsi::Runtime &rt, const jsi::Value &thisValue,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
           auto native = fromThis(rt, thisValue);
-          ((*native).*setter)(rt, arguments[0]);
-          return jsi::Value::undefined();
+          invokeChainableWithRuntime(native.get(), method, rt, args,
+                                     std::index_sequence_for<Args...>{}, count);
+          return jsi::Value(rt, thisValue);
         });
-    defineProperty(runtime, prototype, name, nullptr, &setterFunc);
+    prototype.setProperty(runtime, name, func);
   }
 
-  /**
-   * Installs both getter and setter for a property on the prototype.
-   */
-  static void installHostProperty(jsi::Runtime &runtime, jsi::Object &prototype,
-                                  const char *name, HostGetter getter,
-                                  HostSetter setter) {
-    installHostGetter(runtime, prototype, name, getter);
-    installHostSetter(runtime, prototype, name, setter);
+private:
+  // Invokes a typed member function with JSI argument conversion, discarding
+  // the result. Used by installChainableMethod, which returns thisValue.
+  template <typename ReturnType, typename... Args, size_t... Is>
+  static void invokeChainable(Derived *obj,
+                              ReturnType (Derived::*method)(Args...),
+                              jsi::Runtime &runtime, const jsi::Value *args,
+                              std::index_sequence<Is...>, size_t count) {
+    (obj->*method)(RNJsi::JSIConverter<std::decay_t<Args>>::fromJSI(
+        runtime, args[Is], Is >= count)...);
   }
 
-private:
-  static void defineProperty(jsi::Runtime &runtime, jsi::Object &prototype,
-                             const char *name, jsi::Function *getter,
-                             jsi::Function *setter) {
-    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
-    auto defineProp =
-        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
-    auto getOwnPropertyDescriptor =
-        objectCtor.getPropertyAsFunction(runtime, "getOwnPropertyDescriptor");
-    auto existing = getOwnPropertyDescriptor.call(
-        runtime, prototype, jsi::String::createFromUtf8(runtime, name));
-
-    jsi::Object descriptor(runtime);
-    if (existing.isObject()) {
-      auto existingObj = existing.getObject(runtime);
-      if (existingObj.hasProperty(runtime, "get")) {
-        descriptor.setProperty(runtime, "get",
-                               existingObj.getProperty(runtime, "get"));
-      }
-      if (existingObj.hasProperty(runtime, "set")) {
-        descriptor.setProperty(runtime, "set",
-                               existingObj.getProperty(runtime, "set"));
-      }
-    }
-    if (getter != nullptr) {
-      descriptor.setProperty(runtime, "get", *getter);
-    }
-    if (setter != nullptr) {
-      descriptor.setProperty(runtime, "set", *setter);
-    }
-    descriptor.setProperty(runtime, "enumerable", true);
-    descriptor.setProperty(runtime, "configurable", true);
-    defineProp.call(runtime, prototype,
-                    jsi::String::createFromUtf8(runtime, name), descriptor);
+  template <typename ReturnType, typename... Args, size_t... Is>
+  static void invokeChainableWithRuntime(
+      Derived *obj, ReturnType (Derived::*method)(jsi::Runtime &, Args...),
+      jsi::Runtime &runtime, const jsi::Value *args, std::index_sequence<Is...>,
+      size_t count) {
+    (obj->*method)(runtime,
+                   RNJsi::JSIConverter<std::decay_t<Args>>::fromJSI(
+                       runtime, args[Is], Is >= count)...);
   }
 
   std::shared_ptr<RNSkPlatformContext> _context;