@shopify/react-native-skia 2.10.0 → 2.10.2

package/cpp/api/JsiSkPathBuilder.h

@@ -6,6 +6,7 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkNativeObjects.h"
 #include "JsiSkPath.h"
@@ -33,377 +34,234 @@ 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();
-    return makeJsiObject(runtime,
-                         std::make_shared<JsiSkRect>(getContext(), result));
+    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();
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
+    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();
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
+    return 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);
+    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
-    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);
+    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
-    installHostMethod(runtime, prototype, "arcToOval",
-                      &JsiSkPathBuilder::arcToOval);
-    installHostMethod(runtime, prototype, "arcToRotated",
-                      &JsiSkPathBuilder::arcToRotated);
-    installHostMethod(runtime, prototype, "rArcTo", &JsiSkPathBuilder::rArcTo);
-    installHostMethod(runtime, prototype, "arcToTangent",
-                      &JsiSkPathBuilder::arcToTangent);
+    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
-    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);
+    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
-    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);
+    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
-    installHostMethod(runtime, prototype, "computeBounds",
-                      &JsiSkPathBuilder::computeBounds);
-    installHostMethod(runtime, prototype, "isEmpty",
-                      &JsiSkPathBuilder::isEmpty);
-    installHostMethod(runtime, prototype, "getLastPt",
-                      &JsiSkPathBuilder::getLastPt);
-    installHostMethod(runtime, prototype, "countPoints",
-                      &JsiSkPathBuilder::countPoints);
+    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
-    installHostMethod(runtime, prototype, "build", &JsiSkPathBuilder::build);
-    installHostMethod(runtime, prototype, "detach", &JsiSkPathBuilder::detach);
+    installMethod(runtime, prototype, "build", &JsiSkPathBuilder::build);
+    installMethod(runtime, prototype, "detach", &JsiSkPathBuilder::detach);
   }
 
   JsiSkPathBuilder(std::shared_ptr<RNSkPlatformContext> context,
@@ -426,6 +284,12 @@ public:
     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;
+  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkPathBuilderFactory.h

@@ -5,7 +5,9 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkNativeObjects.h"
+#include "JsiSkPath.h"
 #include "JsiSkPathBuilder.h"
 
 #pragma clang diagnostic push
@@ -25,24 +27,22 @@ class JsiSkPathBuilderFactory
 public:
   static constexpr const char *CLASS_NAME = "PathBuilderFactory";
 
-  JSI_HOST_FUNCTION(Make) {
-    return makeJsiObject(runtime, std::make_shared<JsiSkPathBuilder>(
-                                      getContext(), SkPathBuilder()));
+  std::shared_ptr<JsiSkPathBuilder> Make() {
+    return std::make_shared<JsiSkPathBuilder>(getContext(), SkPathBuilder());
   }
 
-  JSI_HOST_FUNCTION(MakeFromPath) {
-    auto path = JsiSkPath::fromValue(runtime, arguments[0]);
-    return makeJsiObject(runtime, std::make_shared<JsiSkPathBuilder>(
-                                      getContext(), SkPathBuilder(*path)));
+  std::shared_ptr<JsiSkPathBuilder>
+  MakeFromPath(std::shared_ptr<SkPathBuilder> path) {
+    return std::make_shared<JsiSkPathBuilder>(getContext(),
+                                              SkPathBuilder(*path));
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "Make",
-                      &JsiSkPathBuilderFactory::Make);
-    installHostMethod(runtime, prototype, "MakeFromPath",
-                      &JsiSkPathBuilderFactory::MakeFromPath);
+    installMethod(runtime, prototype, "Make", &JsiSkPathBuilderFactory::Make);
+    installMethod(runtime, prototype, "MakeFromPath",
+                  &JsiSkPathBuilderFactory::MakeFromPath);
   }
 
   explicit JsiSkPathBuilderFactory(std::shared_ptr<RNSkPlatformContext> context)