@shopify/react-native-skia 2.9.1-next.1 → 2.10.0

package/cpp/api/JsiSkPathBuilder.h

@@ -6,8 +6,8 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPath.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
@@ -27,8 +27,11 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkPathBuilder
-    : public JsiSkWrappingSharedPtrHostObject<SkPathBuilder> {
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkPathBuilder,
+                                                SkPathBuilder> {
 public:
+  static constexpr const char *CLASS_NAME = "PathBuilder";
+
   // Movement methods
   JSI_HOST_FUNCTION(moveTo) {
     SkScalar x = arguments[0].asNumber();
@@ -299,9 +302,8 @@ public:
   JSI_HOST_FUNCTION(computeBounds) {
     auto path = getObject()->snapshot();
     auto result = path.getBounds();
-    auto hostObjectInstance = std::make_shared<JsiSkRect>(getContext(), result);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkRect>(getContext(), result));
   }
 
   JSI_HOST_FUNCTION(isEmpty) {
@@ -326,73 +328,91 @@ public:
   JSI_HOST_FUNCTION(build) {
     // snapshot() returns a copy without resetting the builder
     auto path = getObject()->snapshot();
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(path));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
   }
 
   JSI_HOST_FUNCTION(detach) {
     // detach() returns the path and resets the builder
     auto path = getObject()->detach();
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(path));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
-  }
-
-  EXPORT_JSI_API_TYPENAME(JsiSkPathBuilder, PathBuilder)
-
-  JSI_EXPORT_FUNCTIONS(
-      // Movement
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, moveTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, rMoveTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, lineTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, rLineTo),
-      // Curves
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, quadTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, rQuadTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, conicTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, rConicTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, cubicTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, rCubicTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, close),
-      // Arcs
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, arcToOval),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, arcToRotated),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, rArcTo),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, arcToTangent),
-      // Shapes
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, addRect),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, addOval),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, addArc),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, addRRect),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, addCircle),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, addPoly),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, addPath),
-      // Config
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, setFillType),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, setIsVolatile),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, reset),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, offset),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, transform),
-      // Query
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, computeBounds),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, isEmpty),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, getLastPt),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, countPoints),
-      // Build
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, build),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, detach),
-      JSI_EXPORT_FUNC(JsiSkPathBuilder, dispose))
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    // Movement
+    installHostMethod(runtime, prototype, "moveTo", &JsiSkPathBuilder::moveTo);
+    installHostMethod(runtime, prototype, "rMoveTo",
+                      &JsiSkPathBuilder::rMoveTo);
+    installHostMethod(runtime, prototype, "lineTo", &JsiSkPathBuilder::lineTo);
+    installHostMethod(runtime, prototype, "rLineTo",
+                      &JsiSkPathBuilder::rLineTo);
+    // Curves
+    installHostMethod(runtime, prototype, "quadTo", &JsiSkPathBuilder::quadTo);
+    installHostMethod(runtime, prototype, "rQuadTo",
+                      &JsiSkPathBuilder::rQuadTo);
+    installHostMethod(runtime, prototype, "conicTo",
+                      &JsiSkPathBuilder::conicTo);
+    installHostMethod(runtime, prototype, "rConicTo",
+                      &JsiSkPathBuilder::rConicTo);
+    installHostMethod(runtime, prototype, "cubicTo",
+                      &JsiSkPathBuilder::cubicTo);
+    installHostMethod(runtime, prototype, "rCubicTo",
+                      &JsiSkPathBuilder::rCubicTo);
+    installHostMethod(runtime, prototype, "close", &JsiSkPathBuilder::close);
+    // Arcs
+    installHostMethod(runtime, prototype, "arcToOval",
+                      &JsiSkPathBuilder::arcToOval);
+    installHostMethod(runtime, prototype, "arcToRotated",
+                      &JsiSkPathBuilder::arcToRotated);
+    installHostMethod(runtime, prototype, "rArcTo", &JsiSkPathBuilder::rArcTo);
+    installHostMethod(runtime, prototype, "arcToTangent",
+                      &JsiSkPathBuilder::arcToTangent);
+    // Shapes
+    installHostMethod(runtime, prototype, "addRect",
+                      &JsiSkPathBuilder::addRect);
+    installHostMethod(runtime, prototype, "addOval",
+                      &JsiSkPathBuilder::addOval);
+    installHostMethod(runtime, prototype, "addArc", &JsiSkPathBuilder::addArc);
+    installHostMethod(runtime, prototype, "addRRect",
+                      &JsiSkPathBuilder::addRRect);
+    installHostMethod(runtime, prototype, "addCircle",
+                      &JsiSkPathBuilder::addCircle);
+    installHostMethod(runtime, prototype, "addPoly",
+                      &JsiSkPathBuilder::addPoly);
+    installHostMethod(runtime, prototype, "addPath",
+                      &JsiSkPathBuilder::addPath);
+    // Config
+    installHostMethod(runtime, prototype, "setFillType",
+                      &JsiSkPathBuilder::setFillType);
+    installHostMethod(runtime, prototype, "setIsVolatile",
+                      &JsiSkPathBuilder::setIsVolatile);
+    installHostMethod(runtime, prototype, "reset", &JsiSkPathBuilder::reset);
+    installHostMethod(runtime, prototype, "offset", &JsiSkPathBuilder::offset);
+    installHostMethod(runtime, prototype, "transform",
+                      &JsiSkPathBuilder::transform);
+    // Query
+    installHostMethod(runtime, prototype, "computeBounds",
+                      &JsiSkPathBuilder::computeBounds);
+    installHostMethod(runtime, prototype, "isEmpty",
+                      &JsiSkPathBuilder::isEmpty);
+    installHostMethod(runtime, prototype, "getLastPt",
+                      &JsiSkPathBuilder::getLastPt);
+    installHostMethod(runtime, prototype, "countPoints",
+                      &JsiSkPathBuilder::countPoints);
+    // Build
+    installHostMethod(runtime, prototype, "build", &JsiSkPathBuilder::build);
+    installHostMethod(runtime, prototype, "detach", &JsiSkPathBuilder::detach);
+  }
 
   JsiSkPathBuilder(std::shared_ptr<RNSkPlatformContext> context,
                    SkPathBuilder builder)
-      : JsiSkWrappingSharedPtrHostObject<SkPathBuilder>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkPathBuilder, SkPathBuilder>(
             std::move(context),
             std::make_shared<SkPathBuilder>(std::move(builder))) {}
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto builder = getObject();
     if (!builder)
       return 0;
@@ -400,15 +420,11 @@ public:
     return builder->snapshot().approximateBytesUsed();
   }
 
-  std::string getObjectType() const override { return "JsiSkPathBuilder"; }
-
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkPathBuilder &builder) {
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPathBuilder>(context, builder);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, context);
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkPathBuilder>(context, builder));
   }
 };
 

package/cpp/api/JsiSkPathBuilderFactory.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPathBuilder.h"
 
 #pragma clang diagnostic push
@@ -20,34 +20,33 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkPathBuilderFactory : public JsiSkHostObject {
+class JsiSkPathBuilderFactory
+    : public JsiSkNativeObject<JsiSkPathBuilderFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "PathBuilderFactory";
+
   JSI_HOST_FUNCTION(Make) {
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPathBuilder>(getContext(), SkPathBuilder());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkPathBuilder>(
+                                      getContext(), SkPathBuilder()));
   }
 
   JSI_HOST_FUNCTION(MakeFromPath) {
     auto path = JsiSkPath::fromValue(runtime, arguments[0]);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPathBuilder>(getContext(), SkPathBuilder(*path));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkPathBuilder>(
+                                      getContext(), SkPathBuilder(*path)));
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
+  size_t getMemoryPressure() override { return 1024; }
 
-  std::string getObjectType() const override {
-    return "JsiSkPathBuilderFactory";
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "Make",
+                      &JsiSkPathBuilderFactory::Make);
+    installHostMethod(runtime, prototype, "MakeFromPath",
+                      &JsiSkPathBuilderFactory::MakeFromPath);
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathBuilderFactory, Make),
-                       JSI_EXPORT_FUNC(JsiSkPathBuilderFactory, MakeFromPath))
-
   explicit JsiSkPathBuilderFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkPathBuilderFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkPathEffect.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -18,19 +18,29 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkPathEffect : public JsiSkWrappingSkPtrHostObject<SkPathEffect> {
+class JsiSkPathEffect
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkPathEffect, SkPathEffect> {
 public:
+  static constexpr const char *CLASS_NAME = "PathEffect";
+
   JsiSkPathEffect(std::shared_ptr<RNSkPlatformContext> context,
                   sk_sp<SkPathEffect> pathEffect)
-      : JsiSkWrappingSkPtrHostObject<SkPathEffect>(std::move(context),
-                                                   std::move(pathEffect)) {}
-
-  size_t getMemoryPressure() const override { return 2048; }
-
-  std::string getObjectType() const override { return "JsiSkPathEffect"; }
-
-  EXPORT_JSI_API_TYPENAME(JsiSkPathEffect, PathEffect)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathEffect, dispose))
+      : JsiSkWrappingSkPtrNativeObject<JsiSkPathEffect, SkPathEffect>(
+            std::move(context), std::move(pathEffect)) {}
+
+  size_t getMemoryPressure() override { return 2048; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkPathEffect> fromValue(jsi::Runtime &runtime,
+                                       const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkPathEffectFactory.h

@@ -6,7 +6,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPathEffect.h"
 
 #pragma clang diagnostic push
@@ -25,14 +25,16 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkPathEffectFactory : public JsiSkHostObject {
+class JsiSkPathEffectFactory
+    : public JsiSkNativeObject<JsiSkPathEffectFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "PathEffectFactory";
+
   JSI_HOST_FUNCTION(MakeCorner) {
     int radius = arguments[0].asNumber();
     auto pathEffect = std::make_shared<JsiSkPathEffect>(
         getContext(), SkCornerPathEffect::Make(radius));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
   JSI_HOST_FUNCTION(MakeDash) {
@@ -51,8 +53,7 @@ public:
     auto i = SkSpan(intervals.data(), intervals.size());
     auto pathEffect = std::make_shared<JsiSkPathEffect>(
         getContext(), SkDashPathEffect::Make(i, phase));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
   JSI_HOST_FUNCTION(MakeDiscrete) {
@@ -61,8 +62,7 @@ public:
     int seedAssist = arguments[2].asNumber();
     auto pathEffect = std::make_shared<JsiSkPathEffect>(
         getContext(), SkDiscretePathEffect::Make(segLength, dec, seedAssist));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
   JSI_HOST_FUNCTION(MakeCompose) {
@@ -71,8 +71,7 @@ public:
     auto pathEffect = std::make_shared<JsiSkPathEffect>(
         getContext(),
         SkPathEffect::MakeCompose(std::move(outer), std::move(inner)));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
   JSI_HOST_FUNCTION(MakeSum) {
@@ -81,8 +80,7 @@ public:
     auto pathEffect = std::make_shared<JsiSkPathEffect>(
         getContext(),
         SkPathEffect::MakeSum(std::move(outer), std::move(inner)));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
   JSI_HOST_FUNCTION(MakePath1D) {
@@ -94,8 +92,7 @@ public:
     auto pathEffect = std::make_shared<JsiSkPathEffect>(
         getContext(),
         SkPath1DPathEffect::Make(path->snapshot(), advance, phase, style));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
   JSI_HOST_FUNCTION(MakePath2D) {
@@ -103,8 +100,7 @@ public:
     auto path = JsiSkPath::fromValue(runtime, arguments[1]);
     auto pathEffect = std::make_shared<JsiSkPathEffect>(
         getContext(), SkPath2DPathEffect::Make(*matrix, path->snapshot()));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
   JSI_HOST_FUNCTION(MakeLine2D) {
@@ -112,27 +108,32 @@ public:
     auto matrix = JsiSkMatrix::fromValue(runtime, arguments[1]);
     auto pathEffect = std::make_shared<JsiSkPathEffect>(
         getContext(), SkLine2DPathEffect::Make(width, *matrix));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeCorner),
-                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeDash),
-                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeDiscrete),
-                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeCompose),
-                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeSum),
-                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeLine2D),
-                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath1D),
-                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath2D))
-
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override {
-    return "JsiSkPathEffectFactory";
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "MakeCorner",
+                      &JsiSkPathEffectFactory::MakeCorner);
+    installHostMethod(runtime, prototype, "MakeDash",
+                      &JsiSkPathEffectFactory::MakeDash);
+    installHostMethod(runtime, prototype, "MakeDiscrete",
+                      &JsiSkPathEffectFactory::MakeDiscrete);
+    installHostMethod(runtime, prototype, "MakeCompose",
+                      &JsiSkPathEffectFactory::MakeCompose);
+    installHostMethod(runtime, prototype, "MakeSum",
+                      &JsiSkPathEffectFactory::MakeSum);
+    installHostMethod(runtime, prototype, "MakeLine2D",
+                      &JsiSkPathEffectFactory::MakeLine2D);
+    installHostMethod(runtime, prototype, "MakePath1D",
+                      &JsiSkPathEffectFactory::MakePath1D);
+    installHostMethod(runtime, prototype, "MakePath2D",
+                      &JsiSkPathEffectFactory::MakePath2D);
   }
 
+  size_t getMemoryPressure() override { return 1024; }
+
   explicit JsiSkPathEffectFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkPathEffectFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia