@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkPathBuilder.h

@@ -6,8 +6,9 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkConverters.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPath.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
@@ -27,372 +28,249 @@ 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();
-    SkScalar y = arguments[1].asNumber();
-    getObject()->moveTo(x, y);
-    return thisValue.getObject(runtime);
-  }
+  void moveTo(double x, double y) { getObject()->moveTo(x, y); }
 
-  JSI_HOST_FUNCTION(rMoveTo) {
-    SkScalar x = arguments[0].asNumber();
-    SkScalar y = arguments[1].asNumber();
-    getObject()->rMoveTo({x, y});
-    return thisValue.getObject(runtime);
+  void rMoveTo(double x, double y) {
+    getObject()->rMoveTo({static_cast<SkScalar>(x), static_cast<SkScalar>(y)});
   }
 
-  JSI_HOST_FUNCTION(lineTo) {
-    SkScalar x = arguments[0].asNumber();
-    SkScalar y = arguments[1].asNumber();
-    getObject()->lineTo(x, y);
-    return thisValue.getObject(runtime);
-  }
+  void lineTo(double x, double y) { getObject()->lineTo(x, y); }
 
-  JSI_HOST_FUNCTION(rLineTo) {
-    SkScalar x = arguments[0].asNumber();
-    SkScalar y = arguments[1].asNumber();
-    getObject()->rLineTo(x, y);
-    return thisValue.getObject(runtime);
-  }
+  void rLineTo(double x, double y) { getObject()->rLineTo(x, y); }
 
   // Curve methods
-  JSI_HOST_FUNCTION(quadTo) {
-    auto x1 = arguments[0].asNumber();
-    auto y1 = arguments[1].asNumber();
-    auto x2 = arguments[2].asNumber();
-    auto y2 = arguments[3].asNumber();
+  void quadTo(double x1, double y1, double x2, double y2) {
     getObject()->quadTo(x1, y1, x2, y2);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(rQuadTo) {
-    auto x1 = arguments[0].asNumber();
-    auto y1 = arguments[1].asNumber();
-    auto x2 = arguments[2].asNumber();
-    auto y2 = arguments[3].asNumber();
+  void rQuadTo(double x1, double y1, double x2, double y2) {
     getObject()->rQuadTo(x1, y1, x2, y2);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(conicTo) {
-    auto x1 = arguments[0].asNumber();
-    auto y1 = arguments[1].asNumber();
-    auto x2 = arguments[2].asNumber();
-    auto y2 = arguments[3].asNumber();
-    auto w = arguments[4].asNumber();
+  void conicTo(double x1, double y1, double x2, double y2, double w) {
     getObject()->conicTo(x1, y1, x2, y2, w);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(rConicTo) {
-    auto x1 = arguments[0].asNumber();
-    auto y1 = arguments[1].asNumber();
-    auto x2 = arguments[2].asNumber();
-    auto y2 = arguments[3].asNumber();
-    auto w = arguments[4].asNumber();
+  void rConicTo(double x1, double y1, double x2, double y2, double w) {
     getObject()->rConicTo(x1, y1, x2, y2, w);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(cubicTo) {
-    auto x1 = arguments[0].asNumber();
-    auto y1 = arguments[1].asNumber();
-    auto x2 = arguments[2].asNumber();
-    auto y2 = arguments[3].asNumber();
-    auto x3 = arguments[4].asNumber();
-    auto y3 = arguments[5].asNumber();
+  void cubicTo(double x1, double y1, double x2, double y2, double x3,
+               double y3) {
     getObject()->cubicTo(x1, y1, x2, y2, x3, y3);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(rCubicTo) {
-    auto x1 = arguments[0].asNumber();
-    auto y1 = arguments[1].asNumber();
-    auto x2 = arguments[2].asNumber();
-    auto y2 = arguments[3].asNumber();
-    auto x3 = arguments[4].asNumber();
-    auto y3 = arguments[5].asNumber();
+  void rCubicTo(double x1, double y1, double x2, double y2, double x3,
+                double y3) {
     getObject()->rCubicTo(x1, y1, x2, y2, x3, y3);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(close) {
-    getObject()->close();
-    return thisValue.getObject(runtime);
-  }
+  void close() { getObject()->close(); }
 
   // Arc methods
-  JSI_HOST_FUNCTION(arcToOval) {
-    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-    auto start = arguments[1].asNumber();
-    auto sweep = arguments[2].asNumber();
-    auto forceMoveTo = arguments[3].getBool();
+  void arcToOval(std::shared_ptr<SkRect> rect, double start, double sweep,
+                 bool forceMoveTo) {
     getObject()->arcTo(*rect, start, sweep, forceMoveTo);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(arcToRotated) {
-    auto rx = arguments[0].asNumber();
-    auto ry = arguments[1].asNumber();
-    auto xAxisRotate = arguments[2].asNumber();
-    auto useSmallArc = arguments[3].getBool();
+  void arcToRotated(double rx, double ry, double xAxisRotate, bool useSmallArc,
+                    bool isCCW, double x, double y) {
     auto arcSize = useSmallArc ? SkPathBuilder::ArcSize::kSmall_ArcSize
                                : SkPathBuilder::ArcSize::kLarge_ArcSize;
-    auto sweep =
-        arguments[4].getBool() ? SkPathDirection::kCCW : SkPathDirection::kCW;
-    auto x = arguments[5].asNumber();
-    auto y = arguments[6].asNumber();
+    auto sweep = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
     getObject()->arcTo(SkPoint::Make(rx, ry), xAxisRotate, arcSize, sweep,
                        SkPoint::Make(x, y));
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(rArcTo) {
-    auto rx = arguments[0].asNumber();
-    auto ry = arguments[1].asNumber();
-    auto xAxisRotate = arguments[2].asNumber();
-    auto useSmallArc = arguments[3].getBool();
+  void rArcTo(double rx, double ry, double xAxisRotate, bool useSmallArc,
+              bool isCCW, double dx, double dy) {
     auto arcSize = useSmallArc ? SkPathBuilder::ArcSize::kSmall_ArcSize
                                : SkPathBuilder::ArcSize::kLarge_ArcSize;
-    auto sweep =
-        arguments[4].getBool() ? SkPathDirection::kCCW : SkPathDirection::kCW;
-    auto dx = arguments[5].asNumber();
-    auto dy = arguments[6].asNumber();
+    auto sweep = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
     SkPoint r(rx, ry);
     SkVector d(dx, dy);
     getObject()->rArcTo(r, xAxisRotate, arcSize, sweep, d);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(arcToTangent) {
-    auto x1 = arguments[0].asNumber();
-    auto y1 = arguments[1].asNumber();
-    auto x2 = arguments[2].asNumber();
-    auto y2 = arguments[3].asNumber();
-    auto r = arguments[4].asNumber();
+  void arcToTangent(double x1, double y1, double x2, double y2, double r) {
     getObject()->arcTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2), r);
-    return thisValue.getObject(runtime);
   }
 
   // Shape methods
-  JSI_HOST_FUNCTION(addRect) {
-    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-    auto direction = SkPathDirection::kCW;
-    if (count >= 2 && arguments[1].getBool()) {
-      direction = SkPathDirection::kCCW;
-    }
-    getObject()->addRect(*rect, direction);
-    return thisValue.getObject(runtime);
+  void addRect(std::shared_ptr<SkRect> rect, JsiOptional<bool> isCCW) {
+    getObject()->addRect(*rect, toDirection(isCCW));
   }
 
-  JSI_HOST_FUNCTION(addOval) {
-    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-    auto direction = SkPathDirection::kCW;
-    if (count >= 2 && arguments[1].getBool()) {
-      direction = SkPathDirection::kCCW;
-    }
-    unsigned startIndex = count < 3 ? 0 : arguments[2].asNumber();
-    getObject()->addOval(*rect, direction, startIndex);
-    return thisValue.getObject(runtime);
+  void addOval(std::shared_ptr<SkRect> rect, JsiOptional<bool> isCCW,
+               JsiOptional<double> startIndex) {
+    getObject()->addOval(*rect, toDirection(isCCW),
+                         startIndex.has_value()
+                             ? static_cast<unsigned>(*startIndex)
+                             : 0);
   }
 
-  JSI_HOST_FUNCTION(addArc) {
-    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-    auto start = arguments[1].asNumber();
-    auto sweep = arguments[2].asNumber();
+  void addArc(std::shared_ptr<SkRect> rect, double start, double sweep) {
     getObject()->addArc(*rect, start, sweep);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(addRRect) {
-    auto rrect = JsiSkRRect::fromValue(runtime, arguments[0]);
-    auto direction = SkPathDirection::kCW;
-    if (count >= 2 && arguments[1].getBool()) {
-      direction = SkPathDirection::kCCW;
-    }
-    getObject()->addRRect(*rrect, direction);
-    return thisValue.getObject(runtime);
+  void addRRect(std::shared_ptr<SkRRect> rrect, JsiOptional<bool> isCCW) {
+    getObject()->addRRect(*rrect, toDirection(isCCW));
   }
 
-  JSI_HOST_FUNCTION(addCircle) {
-    auto x = arguments[0].asNumber();
-    auto y = arguments[1].asNumber();
-    auto r = arguments[2].asNumber();
-    auto direction = SkPathDirection::kCW;
-    if (count >= 4 && arguments[3].getBool()) {
-      direction = SkPathDirection::kCCW;
-    }
-    getObject()->addCircle(x, y, r, direction);
-    return thisValue.getObject(runtime);
+  void addCircle(double x, double y, double r, JsiOptional<bool> isCCW) {
+    getObject()->addCircle(x, y, r, toDirection(isCCW));
   }
 
-  JSI_HOST_FUNCTION(addPoly) {
-    std::vector<SkPoint> points;
-    auto jsiPoints = arguments[0].asObject(runtime).asArray(runtime);
-    auto close = arguments[1].getBool();
-    auto pointsSize = jsiPoints.size(runtime);
-    points.reserve(pointsSize);
-    for (int i = 0; i < pointsSize; i++) {
-      std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
-          runtime, jsiPoints.getValueAtIndex(runtime, i).asObject(runtime));
-      points.push_back(*point.get());
-    }
+  void addPoly(std::vector<SkPoint> points, bool close) {
     getObject()->addPolygon(SkSpan(points.data(), points.size()), close);
-    return thisValue.getObject(runtime);
   }
 
-  JSI_HOST_FUNCTION(addPath) {
-    auto src = JsiSkPath::fromValue(runtime, arguments[0]);
+  void addPath(std::shared_ptr<SkPathBuilder> src,
+               JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+               JsiOptional<bool> extend) {
     auto srcPath = src->snapshot();
-    auto matrix =
-        count > 1 && !arguments[1].isUndefined() && !arguments[1].isNull()
-            ? JsiSkMatrix::fromValue(runtime, arguments[1])
-            : nullptr;
-    auto mode = count > 2 && arguments[2].isBool() && arguments[2].getBool()
-                    ? SkPath::kExtend_AddPathMode
-                    : SkPath::kAppend_AddPathMode;
-    if (matrix == nullptr) {
-      getObject()->addPath(srcPath, mode);
+    auto mode = extend.has_value() && *extend ? SkPath::kExtend_AddPathMode
+                                              : SkPath::kAppend_AddPathMode;
+    if (matrix.has_value()) {
+      getObject()->addPath(srcPath, **matrix, mode);
     } else {
-      getObject()->addPath(srcPath, *matrix, mode);
+      getObject()->addPath(srcPath, mode);
     }
-    return thisValue.getObject(runtime);
   }
 
   // Configuration methods
-  JSI_HOST_FUNCTION(setFillType) {
-    auto ft = (SkPathFillType)arguments[0].asNumber();
-    getObject()->setFillType(ft);
-    return thisValue.getObject(runtime);
+  void setFillType(double ft) {
+    getObject()->setFillType(static_cast<SkPathFillType>(ft));
   }
 
-  JSI_HOST_FUNCTION(setIsVolatile) {
-    auto v = arguments[0].getBool();
-    getObject()->setIsVolatile(v);
-    return thisValue.getObject(runtime);
-  }
+  void setIsVolatile(bool v) { getObject()->setIsVolatile(v); }
 
-  JSI_HOST_FUNCTION(reset) {
-    getObject()->reset();
-    return thisValue.getObject(runtime);
-  }
+  void reset() { getObject()->reset(); }
 
-  JSI_HOST_FUNCTION(offset) {
-    SkScalar dx = arguments[0].asNumber();
-    SkScalar dy = arguments[1].asNumber();
-    getObject()->offset(dx, dy);
-    return thisValue.getObject(runtime);
-  }
+  void offset(double dx, double dy) { getObject()->offset(dx, dy); }
 
-  JSI_HOST_FUNCTION(transform) {
-    auto m3 = *JsiSkMatrix::fromValue(runtime, arguments[0]);
+  void transform(std::shared_ptr<SkMatrix> m3) {
     // Create a path from current state, transform, then rebuild
-    auto path = getObject()->snapshot().makeTransform(m3);
+    auto path = getObject()->snapshot().makeTransform(*m3);
     *getObject() = SkPathBuilder(path);
-    return thisValue.getObject(runtime);
   }
 
   // Query methods
-  JSI_HOST_FUNCTION(computeBounds) {
+  std::shared_ptr<JsiSkRect> 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 std::make_shared<JsiSkRect>(getContext(), path.getBounds());
   }
 
-  JSI_HOST_FUNCTION(isEmpty) {
-    return jsi::Value(getObject()->snapshot().isEmpty());
-  }
+  bool isEmpty() { return getObject()->snapshot().isEmpty(); }
 
-  JSI_HOST_FUNCTION(getLastPt) {
-    SkPoint last;
+  SkPoint getLastPt() {
+    SkPoint last = SkPoint::Make(0, 0);
     getObject()->snapshot().getLastPt(&last);
-    auto point = jsi::Object(runtime);
-    point.setProperty(runtime, "x", static_cast<double>(last.fX));
-    point.setProperty(runtime, "y", static_cast<double>(last.fY));
-    return point;
+    return last;
   }
 
-  JSI_HOST_FUNCTION(countPoints) {
-    auto points = getObject()->snapshot().countPoints();
-    return jsi::Value(points);
-  }
+  int countPoints() { return getObject()->snapshot().countPoints(); }
 
   // Build methods
-  JSI_HOST_FUNCTION(build) {
+  std::shared_ptr<JsiSkPath> 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 std::make_shared<JsiSkPath>(getContext(), std::move(path));
   }
 
-  JSI_HOST_FUNCTION(detach) {
+  std::shared_ptr<JsiSkPath> 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());
+    return std::make_shared<JsiSkPath>(getContext(), std::move(path));
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    // Movement
+    installChainableMethod(runtime, prototype, "moveTo",
+                           &JsiSkPathBuilder::moveTo);
+    installChainableMethod(runtime, prototype, "rMoveTo",
+                           &JsiSkPathBuilder::rMoveTo);
+    installChainableMethod(runtime, prototype, "lineTo",
+                           &JsiSkPathBuilder::lineTo);
+    installChainableMethod(runtime, prototype, "rLineTo",
+                           &JsiSkPathBuilder::rLineTo);
+    // Curves
+    installChainableMethod(runtime, prototype, "quadTo",
+                           &JsiSkPathBuilder::quadTo);
+    installChainableMethod(runtime, prototype, "rQuadTo",
+                           &JsiSkPathBuilder::rQuadTo);
+    installChainableMethod(runtime, prototype, "conicTo",
+                           &JsiSkPathBuilder::conicTo);
+    installChainableMethod(runtime, prototype, "rConicTo",
+                           &JsiSkPathBuilder::rConicTo);
+    installChainableMethod(runtime, prototype, "cubicTo",
+                           &JsiSkPathBuilder::cubicTo);
+    installChainableMethod(runtime, prototype, "rCubicTo",
+                           &JsiSkPathBuilder::rCubicTo);
+    installChainableMethod(runtime, prototype, "close",
+                           &JsiSkPathBuilder::close);
+    // Arcs
+    installChainableMethod(runtime, prototype, "arcToOval",
+                           &JsiSkPathBuilder::arcToOval);
+    installChainableMethod(runtime, prototype, "arcToRotated",
+                           &JsiSkPathBuilder::arcToRotated);
+    installChainableMethod(runtime, prototype, "rArcTo",
+                           &JsiSkPathBuilder::rArcTo);
+    installChainableMethod(runtime, prototype, "arcToTangent",
+                           &JsiSkPathBuilder::arcToTangent);
+    // Shapes
+    installChainableMethod(runtime, prototype, "addRect",
+                           &JsiSkPathBuilder::addRect);
+    installChainableMethod(runtime, prototype, "addOval",
+                           &JsiSkPathBuilder::addOval);
+    installChainableMethod(runtime, prototype, "addArc",
+                           &JsiSkPathBuilder::addArc);
+    installChainableMethod(runtime, prototype, "addRRect",
+                           &JsiSkPathBuilder::addRRect);
+    installChainableMethod(runtime, prototype, "addCircle",
+                           &JsiSkPathBuilder::addCircle);
+    installChainableMethod(runtime, prototype, "addPoly",
+                           &JsiSkPathBuilder::addPoly);
+    installChainableMethod(runtime, prototype, "addPath",
+                           &JsiSkPathBuilder::addPath);
+    // Config
+    installChainableMethod(runtime, prototype, "setFillType",
+                           &JsiSkPathBuilder::setFillType);
+    installChainableMethod(runtime, prototype, "setIsVolatile",
+                           &JsiSkPathBuilder::setIsVolatile);
+    installChainableMethod(runtime, prototype, "reset",
+                           &JsiSkPathBuilder::reset);
+    installChainableMethod(runtime, prototype, "offset",
+                           &JsiSkPathBuilder::offset);
+    installChainableMethod(runtime, prototype, "transform",
+                           &JsiSkPathBuilder::transform);
+    // Query
+    installMethod(runtime, prototype, "computeBounds",
+                  &JsiSkPathBuilder::computeBounds);
+    installMethod(runtime, prototype, "isEmpty", &JsiSkPathBuilder::isEmpty);
+    installMethod(runtime, prototype, "getLastPt",
+                  &JsiSkPathBuilder::getLastPt);
+    installMethod(runtime, prototype, "countPoints",
+                  &JsiSkPathBuilder::countPoints);
+    // Build
+    installMethod(runtime, prototype, "build", &JsiSkPathBuilder::build);
+    installMethod(runtime, prototype, "detach", &JsiSkPathBuilder::detach);
   }
 
-  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))
-
   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 +278,17 @@ 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));
+  }
+
+private:
+  static SkPathDirection toDirection(const JsiOptional<bool> &isCCW) {
+    return isCCW.has_value() && *isCCW ? SkPathDirection::kCCW
+                                       : SkPathDirection::kCW;
   }
 };
 

package/cpp/api/JsiSkPathBuilderFactory.h

@@ -5,7 +5,9 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkConverters.h"
+#include "JsiSkNativeObjects.h"
+#include "JsiSkPath.h"
 #include "JsiSkPathBuilder.h"
 
 #pragma clang diagnostic push
@@ -20,34 +22,31 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkPathBuilderFactory : public JsiSkHostObject {
+class JsiSkPathBuilderFactory
+    : public JsiSkNativeObject<JsiSkPathBuilderFactory> {
 public:
-  JSI_HOST_FUNCTION(Make) {
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPathBuilder>(getContext(), SkPathBuilder());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+  static constexpr const char *CLASS_NAME = "PathBuilderFactory";
+
+  std::shared_ptr<JsiSkPathBuilder> Make() {
+    return 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());
+  std::shared_ptr<JsiSkPathBuilder>
+  MakeFromPath(std::shared_ptr<SkPathBuilder> path) {
+    return 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) {
+    installMethod(runtime, prototype, "Make", &JsiSkPathBuilderFactory::Make);
+    installMethod(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