@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkColorFilterFactory.h

@@ -2,10 +2,12 @@
 
 #include "JsiSkColor.h"
 #include "JsiSkColorFilter.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkConverters.h"
+#include "JsiSkNativeObjects.h"
 #include <jsi/jsi.h>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -19,95 +21,75 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkColorFilterFactory : public JsiSkHostObject {
+class JsiSkColorFilterFactory
+    : public JsiSkNativeObject<JsiSkColorFilterFactory> {
 public:
-  JSI_HOST_FUNCTION(MakeMatrix) {
-    auto jsiMatrix = arguments[0].asObject(runtime).asArray(runtime);
-    float matrix[20];
-    for (int i = 0; i < 20; i++) {
-      if (jsiMatrix.size(runtime) > i) {
-        matrix[i] = jsiMatrix.getValueAtIndex(runtime, i).asNumber();
-      }
+  static constexpr const char *CLASS_NAME = "ColorFilterFactory";
+
+  std::shared_ptr<JsiSkColorFilter> MakeMatrix(std::vector<float> values) {
+    float matrix[20] = {0};
+    for (size_t i = 0; i < 20 && i < values.size(); i++) {
+      matrix[i] = values[i];
     }
-    // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkColorFilters::Matrix(std::move(matrix)));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+    return std::make_shared<JsiSkColorFilter>(getContext(),
+                                              SkColorFilters::Matrix(matrix));
   }
 
-  JSI_HOST_FUNCTION(MakeBlend) {
-    auto color = JsiSkColor::fromValue(runtime, arguments[0]);
-    SkBlendMode blend = (SkBlendMode)arguments[1].asNumber();
-    // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkColorFilters::Blend(color, blend));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+  std::shared_ptr<JsiSkColorFilter> MakeBlend(JsiColor color, double blend) {
+    return std::make_shared<JsiSkColorFilter>(
+        getContext(),
+        SkColorFilters::Blend(color, static_cast<SkBlendMode>(blend)));
   }
 
-  JSI_HOST_FUNCTION(MakeCompose) {
-    auto outer = JsiSkColorFilter::fromValue(runtime, arguments[0]);
-    auto inner = JsiSkColorFilter::fromValue(runtime, arguments[1]);
-    // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+  std::shared_ptr<JsiSkColorFilter> MakeCompose(sk_sp<SkColorFilter> outer,
+                                                sk_sp<SkColorFilter> inner) {
+    return std::make_shared<JsiSkColorFilter>(
         getContext(),
         SkColorFilters::Compose(std::move(outer), std::move(inner)));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
   }
 
-  JSI_HOST_FUNCTION(MakeLerp) {
-    auto t = arguments[0].asNumber();
-    auto dst = JsiSkColorFilter::fromValue(runtime, arguments[1]);
-    auto src = JsiSkColorFilter::fromValue(runtime, arguments[2]);
-    // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+  std::shared_ptr<JsiSkColorFilter> MakeLerp(double t,
+                                             sk_sp<SkColorFilter> dst,
+                                             sk_sp<SkColorFilter> src) {
+    return std::make_shared<JsiSkColorFilter>(
         getContext(), SkColorFilters::Lerp(t, std::move(dst), std::move(src)));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
   }
 
-  JSI_HOST_FUNCTION(MakeSRGBToLinearGamma) {
-    // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+  std::shared_ptr<JsiSkColorFilter> MakeSRGBToLinearGamma() {
+    return std::make_shared<JsiSkColorFilter>(
         getContext(), SkColorFilters::SRGBToLinearGamma());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
   }
 
-  JSI_HOST_FUNCTION(MakeLinearToSRGBGamma) {
-    // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+  std::shared_ptr<JsiSkColorFilter> MakeLinearToSRGBGamma() {
+    return std::make_shared<JsiSkColorFilter>(
         getContext(), SkColorFilters::LinearToSRGBGamma());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
   }
 
-  JSI_HOST_FUNCTION(MakeLumaColorFilter) {
-    // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkLumaColorFilter::Make());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+  std::shared_ptr<JsiSkColorFilter> MakeLumaColorFilter() {
+    return std::make_shared<JsiSkColorFilter>(getContext(),
+                                              SkLumaColorFilter::Make());
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override {
-    return "JsiSkColorFilterFactory";
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installMethod(runtime, prototype, "MakeMatrix",
+                  &JsiSkColorFilterFactory::MakeMatrix);
+    installMethod(runtime, prototype, "MakeBlend",
+                  &JsiSkColorFilterFactory::MakeBlend);
+    installMethod(runtime, prototype, "MakeCompose",
+                  &JsiSkColorFilterFactory::MakeCompose);
+    installMethod(runtime, prototype, "MakeLerp",
+                  &JsiSkColorFilterFactory::MakeLerp);
+    installMethod(runtime, prototype, "MakeSRGBToLinearGamma",
+                  &JsiSkColorFilterFactory::MakeSRGBToLinearGamma);
+    installMethod(runtime, prototype, "MakeLinearToSRGBGamma",
+                  &JsiSkColorFilterFactory::MakeLinearToSRGBGamma);
+    installMethod(runtime, prototype, "MakeLumaColorFilter",
+                  &JsiSkColorFilterFactory::MakeLumaColorFilter);
   }
 
-  JSI_EXPORT_FUNCTIONS(
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeMatrix),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeBlend),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeCompose),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLerp),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeSRGBToLinearGamma),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLinearToSRGBGamma),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLumaColorFilter))
-
   explicit JsiSkColorFilterFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkColorFilterFactory>(std::move(context)) {}
 };
 } // namespace RNSkia

package/cpp/api/JsiSkContourMeasure.h

@@ -2,10 +2,12 @@
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
+#include "JsiSkPoint.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -21,62 +23,53 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkContourMeasure
-    : public JsiSkWrappingSkPtrHostObject<SkContourMeasure> {
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkContourMeasure,
+                                            SkContourMeasure> {
 public:
+  static constexpr const char *CLASS_NAME = "ContourMeasure";
+
   JsiSkContourMeasure(std::shared_ptr<RNSkPlatformContext> context,
                       const sk_sp<SkContourMeasure> contourMeasure)
-      : JsiSkWrappingSkPtrHostObject(std::move(context),
-                                     std::move(contourMeasure)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkContourMeasure, SkContourMeasure>(
+            std::move(context), std::move(contourMeasure)) {}
 
-  JSI_HOST_FUNCTION(getPosTan) {
-    auto dist = arguments[0].asNumber();
+  std::vector<std::shared_ptr<JsiSkPoint>> getPosTan(double dist) {
     SkPoint position;
     SkPoint tangent;
     auto result = getObject()->getPosTan(dist, &position, &tangent);
     if (!result) {
-      throw jsi::JSError(runtime, "getPosTan() failed");
+      throw std::runtime_error("getPosTan() failed");
     }
-    auto posTan = jsi::Array(runtime, 2);
-    auto posPoint = std::make_shared<JsiSkPoint>(getContext(), position);
-    auto pos = JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, posPoint,
-                                                           getContext());
-    auto tanPoint = std::make_shared<JsiSkPoint>(getContext(), tangent);
-    auto tan = JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, tanPoint,
-                                                           getContext());
-    posTan.setValueAtIndex(runtime, 0, pos);
-    posTan.setValueAtIndex(runtime, 1, tan);
-    return posTan;
+    return {std::make_shared<JsiSkPoint>(getContext(), position),
+            std::make_shared<JsiSkPoint>(getContext(), tangent)};
   }
 
-  JSI_HOST_FUNCTION(length) {
-    return jsi::Value(SkScalarToDouble(getObject()->length()));
-  }
+  double length() { return SkScalarToDouble(getObject()->length()); }
 
-  JSI_HOST_FUNCTION(isClosed) { return jsi::Value(getObject()->isClosed()); }
+  bool isClosed() { return getObject()->isClosed(); }
 
-  JSI_HOST_FUNCTION(getSegment) {
-    auto start = arguments[0].asNumber();
-    auto end = arguments[1].asNumber();
-    auto startWithMoveTo = arguments[2].getBool();
+  std::shared_ptr<JsiSkPath> getSegment(double start, double end,
+                                        bool startWithMoveTo) {
     SkPathBuilder builder;
     auto result =
         getObject()->getSegment(start, end, &builder, startWithMoveTo);
     if (!result) {
-      throw jsi::JSError(runtime, "getSegment() failed");
+      throw std::runtime_error("getSegment() failed");
     }
-    return JsiSkPath::toValue(runtime, getContext(), builder.snapshot());
+    return std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkContourMeasure"; }
-
-  EXPORT_JSI_API_TYPENAME(JsiSkContourMeasure, ContourMeasure)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkContourMeasure, getPosTan),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasure, length),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasure, isClosed),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasure, getSegment),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasure, dispose))
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "getPosTan",
+                  &JsiSkContourMeasure::getPosTan);
+    installMethod(runtime, prototype, "length", &JsiSkContourMeasure::length);
+    installMethod(runtime, prototype, "isClosed",
+                  &JsiSkContourMeasure::isClosed);
+    installMethod(runtime, prototype, "getSegment",
+                  &JsiSkContourMeasure::getSegment);
+  }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkContourMeasureIter.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "JsiSkContourMeasure.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -20,38 +21,35 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkContourMeasureIter
-    : public JsiSkWrappingSharedPtrHostObject<SkContourMeasureIter> {
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkContourMeasureIter,
+                                                SkContourMeasureIter> {
 public:
+  static constexpr const char *CLASS_NAME = "ContourMeasureIter";
+
   JsiSkContourMeasureIter(std::shared_ptr<RNSkPlatformContext> context,
                           const SkPath &path, bool forceClosed,
                           SkScalar resScale = 1)
-      : JsiSkWrappingSharedPtrHostObject<SkContourMeasureIter>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkContourMeasureIter,
+                                           SkContourMeasureIter>(
             std::move(context), std::make_shared<SkContourMeasureIter>(
                                     path, forceClosed, resScale)) {}
 
-  JSI_HOST_FUNCTION(next) {
+  std::optional<std::shared_ptr<JsiSkContourMeasure>> next() {
     auto next = getObject()->next();
     if (next == nullptr) {
-      return jsi::Value::undefined();
+      return std::nullopt;
     }
-    auto nextObject =
-        std::make_shared<JsiSkContourMeasure>(getContext(), std::move(next));
-
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, nextObject,
-                                                       getContext());
+    return std::make_shared<JsiSkContourMeasure>(getContext(),
+                                                 std::move(next));
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkContourMeasureIter, ContourMeasureIter)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkContourMeasureIter, next),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasureIter, dispose))
-
-  size_t getMemoryPressure() const override {
-    return std::max(sizeof(SkContourMeasureIter), kMinMemoryPressure);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "next", &JsiSkContourMeasureIter::next);
   }
 
-  std::string getObjectType() const override {
-    return "JsiSkContourMeasureIter";
+  size_t getMemoryPressure() override {
+    return std::max(sizeof(SkContourMeasureIter), kMinMemoryPressure);
   }
 
   /**
@@ -68,10 +66,9 @@ public:
       auto forceClosed = arguments[1].getBool();
       auto resScale = arguments[2].asNumber();
       // Return the newly constructed object
-      auto iter = std::make_shared<JsiSkContourMeasureIter>(
-          std::move(context), path->snapshot(), forceClosed, resScale);
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, iter,
-                                                         context);
+      return makeJsiObject(runtime, std::make_shared<JsiSkContourMeasureIter>(
+                                        std::move(context), path->snapshot(),
+                                        forceClosed, resScale));
     };
   }
 };