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

package/cpp/api/JsiSkPathEffectFactory.h

@@ -1,12 +1,17 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
+#include "JsiSkMatrix.h"
 #include "JsiSkNativeObjects.h"
+#include "JsiSkPath.h"
 #include "JsiSkPathEffect.h"
 
 #pragma clang diagnostic push
@@ -30,104 +35,79 @@ class 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 makeJsiObject(runtime, std::move(pathEffect));
+  std::shared_ptr<JsiSkPathEffect> MakeCorner(int radius) {
+    return std::make_shared<JsiSkPathEffect>(getContext(),
+                                             SkCornerPathEffect::Make(radius));
   }
 
-  JSI_HOST_FUNCTION(MakeDash) {
-    auto jsiIntervals = arguments[0].asObject(runtime).asArray(runtime);
-    auto size = static_cast<int>(jsiIntervals.size(runtime));
-    std::vector<SkScalar> intervals;
-    intervals.reserve(size);
-    for (int i = 0; i < size; i++) {
-      SkScalar interval = jsiIntervals.getValueAtIndex(runtime, i).asNumber();
-      intervals.push_back(interval);
-    }
-    int phase =
-        count >= 2 && !arguments[1].isUndefined() && !arguments[1].isNull()
-            ? arguments[1].asNumber()
-            : 0;
+  std::shared_ptr<JsiSkPathEffect>
+  MakeDash(std::vector<float> intervals, JsiOptional<double> phaseValue) {
+    int phase = phaseValue.has_value() ? *phaseValue : 0;
     auto i = SkSpan(intervals.data(), intervals.size());
-    auto pathEffect = std::make_shared<JsiSkPathEffect>(
-        getContext(), SkDashPathEffect::Make(i, phase));
-    return makeJsiObject(runtime, std::move(pathEffect));
+    return std::make_shared<JsiSkPathEffect>(getContext(),
+                                             SkDashPathEffect::Make(i, phase));
   }
 
-  JSI_HOST_FUNCTION(MakeDiscrete) {
-    int segLength = arguments[0].asNumber();
-    int dec = arguments[1].asNumber();
-    int seedAssist = arguments[2].asNumber();
-    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+  std::shared_ptr<JsiSkPathEffect> MakeDiscrete(int segLength, int dec,
+                                                int seedAssist) {
+    return std::make_shared<JsiSkPathEffect>(
         getContext(), SkDiscretePathEffect::Make(segLength, dec, seedAssist));
-    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
-  JSI_HOST_FUNCTION(MakeCompose) {
-    auto outer = JsiSkPathEffect::fromValue(runtime, arguments[0]);
-    auto inner = JsiSkPathEffect::fromValue(runtime, arguments[1]);
-    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+  std::shared_ptr<JsiSkPathEffect> MakeCompose(sk_sp<SkPathEffect> outer,
+                                               sk_sp<SkPathEffect> inner) {
+    return std::make_shared<JsiSkPathEffect>(
         getContext(),
         SkPathEffect::MakeCompose(std::move(outer), std::move(inner)));
-    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
-  JSI_HOST_FUNCTION(MakeSum) {
-    auto outer = JsiSkPathEffect::fromValue(runtime, arguments[0]);
-    auto inner = JsiSkPathEffect::fromValue(runtime, arguments[1]);
-    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+  std::shared_ptr<JsiSkPathEffect> MakeSum(sk_sp<SkPathEffect> outer,
+                                           sk_sp<SkPathEffect> inner) {
+    return std::make_shared<JsiSkPathEffect>(
         getContext(),
         SkPathEffect::MakeSum(std::move(outer), std::move(inner)));
-    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
-  JSI_HOST_FUNCTION(MakePath1D) {
-    auto path = JsiSkPath::fromValue(runtime, arguments[0]);
-    auto advance = arguments[1].asNumber();
-    auto phase = arguments[2].asNumber();
-    auto style =
-        static_cast<SkPath1DPathEffect::Style>(arguments[3].asNumber());
-    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+  std::shared_ptr<JsiSkPathEffect>
+  MakePath1D(std::shared_ptr<SkPathBuilder> path, double advance, double phase,
+             double style) {
+    return std::make_shared<JsiSkPathEffect>(
         getContext(),
-        SkPath1DPathEffect::Make(path->snapshot(), advance, phase, style));
-    return makeJsiObject(runtime, std::move(pathEffect));
+        SkPath1DPathEffect::Make(
+            path->snapshot(), advance, phase,
+            static_cast<SkPath1DPathEffect::Style>(style)));
   }
 
-  JSI_HOST_FUNCTION(MakePath2D) {
-    auto matrix = JsiSkMatrix::fromValue(runtime, arguments[0]);
-    auto path = JsiSkPath::fromValue(runtime, arguments[1]);
-    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+  std::shared_ptr<JsiSkPathEffect>
+  MakePath2D(std::shared_ptr<SkMatrix> matrix,
+             std::shared_ptr<SkPathBuilder> path) {
+    return std::make_shared<JsiSkPathEffect>(
         getContext(), SkPath2DPathEffect::Make(*matrix, path->snapshot()));
-    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
-  JSI_HOST_FUNCTION(MakeLine2D) {
-    auto width = arguments[0].asNumber();
-    auto matrix = JsiSkMatrix::fromValue(runtime, arguments[1]);
-    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+  std::shared_ptr<JsiSkPathEffect>
+  MakeLine2D(double width, std::shared_ptr<SkMatrix> matrix) {
+    return std::make_shared<JsiSkPathEffect>(
         getContext(), SkLine2DPathEffect::Make(width, *matrix));
-    return makeJsiObject(runtime, std::move(pathEffect));
   }
 
   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);
+    installMethod(runtime, prototype, "MakeCorner",
+                  &JsiSkPathEffectFactory::MakeCorner);
+    installMethod(runtime, prototype, "MakeDash",
+                  &JsiSkPathEffectFactory::MakeDash);
+    installMethod(runtime, prototype, "MakeDiscrete",
+                  &JsiSkPathEffectFactory::MakeDiscrete);
+    installMethod(runtime, prototype, "MakeCompose",
+                  &JsiSkPathEffectFactory::MakeCompose);
+    installMethod(runtime, prototype, "MakeSum",
+                  &JsiSkPathEffectFactory::MakeSum);
+    installMethod(runtime, prototype, "MakeLine2D",
+                  &JsiSkPathEffectFactory::MakeLine2D);
+    installMethod(runtime, prototype, "MakePath1D",
+                  &JsiSkPathEffectFactory::MakePath1D);
+    installMethod(runtime, prototype, "MakePath2D",
+                  &JsiSkPathEffectFactory::MakePath2D);
   }
 
   size_t getMemoryPressure() override { return 1024; }

package/cpp/api/JsiSkPathFactory.h

@@ -2,13 +2,18 @@
 
 #include <algorithm>
 #include <memory>
+#include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
+#include "JsiSkFont.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkNativeObjects.h"
+#include "JsiSkPath.h"
 #include "JsiSkPathEffect.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
@@ -42,107 +47,83 @@ class JsiSkPathFactory : public JsiSkNativeObject<JsiSkPathFactory> {
   static const int CUBIC = 4;
   static const int CLOSE = 5;
 
+  using NullablePath = std::variant<std::nullptr_t, std::shared_ptr<JsiSkPath>>;
+
 public:
   static constexpr const char *CLASS_NAME = "PathFactory";
 
-  JSI_HOST_FUNCTION(Make) {
-    return makeJsiObject(runtime,
-                         std::make_shared<JsiSkPath>(getContext(), SkPath()));
+  std::shared_ptr<JsiSkPath> Make() {
+    return std::make_shared<JsiSkPath>(getContext(), SkPath());
   }
 
-  JSI_HOST_FUNCTION(MakeFromSVGString) {
-    auto svgString = arguments[0].asString(runtime).utf8(runtime);
+  std::shared_ptr<JsiSkPath> MakeFromSVGString(std::string svgString) {
     auto result = SkParsePath::FromSVGString(svgString.c_str());
     if (!result.has_value()) {
-      throw jsi::JSError(runtime, "Could not parse Svg path");
-      return jsi::Value(nullptr);
+      throw std::runtime_error("Could not parse Svg path");
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
-                                      getContext(), std::move(result.value())));
+    return std::make_shared<JsiSkPath>(getContext(),
+                                       std::move(result.value()));
   }
 
-  JSI_HOST_FUNCTION(MakeFromOp) {
-    auto one = JsiSkPath::fromValue(runtime, arguments[0])->snapshot();
-    auto two = JsiSkPath::fromValue(runtime, arguments[1])->snapshot();
-    SkPathOp op = (SkPathOp)arguments[2].asNumber();
-    auto result = Op(one, two, op);
+  NullablePath MakeFromOp(std::shared_ptr<SkPathBuilder> pathOne,
+                          std::shared_ptr<SkPathBuilder> pathTwo, double op) {
+    auto one = pathOne->snapshot();
+    auto two = pathTwo->snapshot();
+    auto result = Op(one, two, static_cast<SkPathOp>(op));
     if (!result.has_value()) {
-      return jsi::Value(nullptr);
+      return nullptr;
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
-                                      getContext(), std::move(result.value())));
+    return std::make_shared<JsiSkPath>(getContext(),
+                                       std::move(result.value()));
   }
 
-  JSI_HOST_FUNCTION(MakeFromCmds) {
+  NullablePath MakeFromCmds(std::vector<std::vector<double>> cmds) {
     SkPathBuilder builder;
-    auto cmds = arguments[0].asObject(runtime).asArray(runtime);
-    auto cmdCount = cmds.size(runtime);
-    for (int i = 0; i < cmdCount; i++) {
-      auto cmd =
-          cmds.getValueAtIndex(runtime, i).asObject(runtime).asArray(runtime);
-      if (cmd.size(runtime) < 1) {
+    for (const auto &cmd : cmds) {
+      if (cmd.size() < 1) {
         RNSkLogger::logToConsole("Invalid command found (got an empty array)");
-        return jsi::Value::null();
+        return nullptr;
       }
-      auto verb = static_cast<int>(cmd.getValueAtIndex(runtime, 0).asNumber());
+      auto verb = static_cast<int>(cmd[0]);
       switch (verb) {
       case MOVE: {
-        if (cmd.size(runtime) < 3) {
+        if (cmd.size() < 3) {
           RNSkLogger::logToConsole("Invalid move command found");
-          return jsi::Value::null();
+          return nullptr;
         }
-        auto x = cmd.getValueAtIndex(runtime, 1).asNumber();
-        auto y = cmd.getValueAtIndex(runtime, 2).asNumber();
-        builder.moveTo(x, y);
+        builder.moveTo(cmd[1], cmd[2]);
         break;
       }
       case LINE: {
-        if (cmd.size(runtime) < 3) {
+        if (cmd.size() < 3) {
           RNSkLogger::logToConsole("Invalid line command found");
-          return jsi::Value::null();
+          return nullptr;
         }
-        auto x = cmd.getValueAtIndex(runtime, 1).asNumber();
-        auto y = cmd.getValueAtIndex(runtime, 2).asNumber();
-        builder.lineTo(x, y);
+        builder.lineTo(cmd[1], cmd[2]);
         break;
       }
       case QUAD: {
-        if (cmd.size(runtime) < 5) {
+        if (cmd.size() < 5) {
           RNSkLogger::logToConsole("Invalid line command found");
-          return jsi::Value::null();
+          return nullptr;
         }
-        auto x1 = cmd.getValueAtIndex(runtime, 1).asNumber();
-        auto y1 = cmd.getValueAtIndex(runtime, 2).asNumber();
-        auto x2 = cmd.getValueAtIndex(runtime, 3).asNumber();
-        auto y2 = cmd.getValueAtIndex(runtime, 4).asNumber();
-        builder.quadTo(x1, y1, x2, y2);
+        builder.quadTo(cmd[1], cmd[2], cmd[3], cmd[4]);
         break;
       }
       case CONIC: {
-        if (cmd.size(runtime) < 6) {
+        if (cmd.size() < 6) {
           RNSkLogger::logToConsole("Invalid line command found");
-          return jsi::Value::null();
+          return nullptr;
         }
-        auto x1 = cmd.getValueAtIndex(runtime, 1).asNumber();
-        auto y1 = cmd.getValueAtIndex(runtime, 2).asNumber();
-        auto x2 = cmd.getValueAtIndex(runtime, 3).asNumber();
-        auto y2 = cmd.getValueAtIndex(runtime, 4).asNumber();
-        auto w = cmd.getValueAtIndex(runtime, 5).asNumber();
-        builder.conicTo(x1, y1, x2, y2, w);
+        builder.conicTo(cmd[1], cmd[2], cmd[3], cmd[4], cmd[5]);
         break;
       }
       case CUBIC: {
-        if (cmd.size(runtime) < 7) {
+        if (cmd.size() < 7) {
           RNSkLogger::logToConsole("Invalid line command found");
-          return jsi::Value::null();
+          return nullptr;
         }
-        auto x1 = cmd.getValueAtIndex(runtime, 1).asNumber();
-        auto y1 = cmd.getValueAtIndex(runtime, 2).asNumber();
-        auto x2 = cmd.getValueAtIndex(runtime, 3).asNumber();
-        auto y2 = cmd.getValueAtIndex(runtime, 4).asNumber();
-        auto x3 = cmd.getValueAtIndex(runtime, 5).asNumber();
-        auto y3 = cmd.getValueAtIndex(runtime, 6).asNumber();
-        builder.cubicTo(x1, y1, x2, y2, x3, y3);
+        builder.cubicTo(cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6]);
         break;
       }
       case CLOSE: {
@@ -151,102 +132,68 @@ public:
       }
       default: {
         RNSkLogger::logToConsole("Found an unknown command");
-        return jsi::Value::null();
+        return nullptr;
       }
       }
     }
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
+    return std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
   }
 
-  JSI_HOST_FUNCTION(MakeFromText) {
-    auto text = arguments[0].asString(runtime).utf8(runtime);
-    auto x = arguments[1].asNumber();
-    auto y = arguments[2].asNumber();
-    auto font = JsiSkFont::fromValue(runtime, arguments[3]);
+  std::shared_ptr<JsiSkPath> MakeFromText(std::string text, double x, double y,
+                                          std::shared_ptr<SkFont> font) {
     SkPath path;
     SkTextUtils::GetPath(text.c_str(), strlen(text.c_str()),
                          SkTextEncoding::kUTF8, x, y, *font, &path);
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
+    return std::make_shared<JsiSkPath>(getContext(), std::move(path));
   }
 
   // Static shape factories
-  JSI_HOST_FUNCTION(Rect) {
-    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-    auto direction = SkPathDirection::kCW;
-    if (count >= 2 && arguments[1].getBool()) {
-      direction = SkPathDirection::kCCW;
-    }
+  std::shared_ptr<JsiSkPath> Rect(SkRect rect, JsiOptional<bool> isCCW) {
     SkPathBuilder builder;
-    builder.addRect(*rect, direction);
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
+    builder.addRect(rect, toDirection(isCCW));
+    return std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
   }
 
-  JSI_HOST_FUNCTION(Oval) {
-    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();
+  std::shared_ptr<JsiSkPath> Oval(SkRect rect, JsiOptional<bool> isCCW,
+                                  JsiOptional<double> startIndex) {
     SkPathBuilder builder;
-    builder.addOval(*rect, direction, startIndex);
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
+    builder.addOval(rect, toDirection(isCCW),
+                    startIndex.has_value()
+                        ? static_cast<unsigned>(*startIndex)
+                        : 0);
+    return std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
   }
 
-  JSI_HOST_FUNCTION(Circle) {
-    auto x = arguments[0].asNumber();
-    auto y = arguments[1].asNumber();
-    auto r = arguments[2].asNumber();
+  std::shared_ptr<JsiSkPath> Circle(double x, double y, double r) {
     SkPathBuilder builder;
     builder.addCircle(x, y, r);
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
+    return std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
   }
 
-  JSI_HOST_FUNCTION(RRect) {
-    auto rrect = JsiSkRRect::fromValue(runtime, arguments[0]);
-    auto direction = SkPathDirection::kCW;
-    if (count >= 2 && arguments[1].getBool()) {
-      direction = SkPathDirection::kCCW;
-    }
+  std::shared_ptr<JsiSkPath> RRect(std::shared_ptr<SkRRect> rrect,
+                                   JsiOptional<bool> isCCW) {
     SkPathBuilder builder;
-    builder.addRRect(*rrect, direction);
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
+    builder.addRRect(*rrect, toDirection(isCCW));
+    return std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
   }
 
-  JSI_HOST_FUNCTION(Line) {
-    auto p1 = JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime));
-    auto p2 = JsiSkPoint::fromValue(runtime, arguments[1].asObject(runtime));
+  std::shared_ptr<JsiSkPath> Line(SkPoint p1, SkPoint p2) {
     SkPathBuilder builder;
-    builder.moveTo(*p1);
-    builder.lineTo(*p2);
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
+    builder.moveTo(p1);
+    builder.lineTo(p2);
+    return std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
   }
 
-  JSI_HOST_FUNCTION(Polygon) {
-    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());
-    }
+  std::shared_ptr<JsiSkPath> Polygon(std::vector<SkPoint> points, bool close) {
     SkPathBuilder builder;
     builder.addPolygon(SkSpan(points), close);
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
+    return std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
   }
 
   // Static path operations
+
+  // Stays raw: the options object is read leniently property by property
+  // (unknown properties and non-numeric values are ignored).
   JSI_HOST_FUNCTION(Stroke) {
     auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
     SkPath path = srcPath->snapshot();
@@ -303,128 +250,115 @@ public:
     return jsi::Value::null();
   }
 
-  JSI_HOST_FUNCTION(Trim) {
-    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
-    float start =
-        std::clamp(static_cast<float>(arguments[1].asNumber()), 0.0f, 1.0f);
-    float end =
-        std::clamp(static_cast<float>(arguments[2].asNumber()), 0.0f, 1.0f);
-    auto isComplement = arguments[3].getBool();
+  NullablePath Trim(std::shared_ptr<SkPathBuilder> srcPath, double startValue,
+                    double endValue, bool isComplement) {
+    float start = std::clamp(static_cast<float>(startValue), 0.0f, 1.0f);
+    float end = std::clamp(static_cast<float>(endValue), 0.0f, 1.0f);
     // If requesting the full path in normal mode, just return a copy
     if (start <= 0 && end >= 1 && !isComplement) {
-      SkPath result = srcPath->snapshot();
-      return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
-                                        getContext(), std::move(result)));
+      return std::make_shared<JsiSkPath>(getContext(), srcPath->snapshot());
     }
     SkPath path = srcPath->snapshot();
     auto mode = isComplement ? SkTrimPathEffect::Mode::kInverted
                              : SkTrimPathEffect::Mode::kNormal;
     auto pe = SkTrimPathEffect::Make(start, end, mode);
     if (!pe) {
-      return jsi::Value::null();
+      return nullptr;
     }
     SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
     SkPathBuilder resultBuilder;
     if (pe->filterPath(&resultBuilder, path, &rec)) {
-      auto result = resultBuilder.detach();
-      return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
-                                        getContext(), std::move(result)));
+      return std::make_shared<JsiSkPath>(getContext(), resultBuilder.detach());
     }
-    return jsi::Value::null();
+    return nullptr;
   }
 
-  JSI_HOST_FUNCTION(Simplify) {
-    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+  NullablePath Simplify(std::shared_ptr<SkPathBuilder> srcPath) {
     auto result = ::Simplify(srcPath->snapshot());
     if (result.has_value()) {
-      return makeJsiObject(
-          runtime,
-          std::make_shared<JsiSkPath>(getContext(), std::move(result.value())));
+      return std::make_shared<JsiSkPath>(getContext(),
+                                         std::move(result.value()));
     }
-    return jsi::Value::null();
+    return nullptr;
   }
 
-  JSI_HOST_FUNCTION(Dash) {
-    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
-    SkScalar on = arguments[1].asNumber();
-    SkScalar off = arguments[2].asNumber();
-    auto phase = arguments[3].asNumber();
-    SkScalar intervals[] = {on, off};
+  NullablePath Dash(std::shared_ptr<SkPathBuilder> srcPath, double on,
+                    double off, double phase) {
+    SkScalar intervals[] = {static_cast<SkScalar>(on),
+                            static_cast<SkScalar>(off)};
     auto i = SkSpan(intervals, 2);
     auto pe = SkDashPathEffect::Make(i, phase);
     if (!pe) {
-      return jsi::Value::null();
+      return nullptr;
     }
     SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
     SkPathBuilder resultBuilder;
     if (pe->filterPath(&resultBuilder, srcPath->snapshot(), &rec)) {
-      auto result = resultBuilder.detach();
-      return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
-                                        getContext(), std::move(result)));
+      return std::make_shared<JsiSkPath>(getContext(), resultBuilder.detach());
     }
-    return jsi::Value::null();
+    return nullptr;
   }
 
-  JSI_HOST_FUNCTION(AsWinding) {
-    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+  NullablePath AsWinding(std::shared_ptr<SkPathBuilder> srcPath) {
     auto result = ::AsWinding(srcPath->snapshot());
     if (result.has_value()) {
-      return makeJsiObject(
-          runtime,
-          std::make_shared<JsiSkPath>(getContext(), std::move(result.value())));
+      return std::make_shared<JsiSkPath>(getContext(),
+                                         std::move(result.value()));
     }
-    return jsi::Value::null();
+    return nullptr;
   }
 
-  JSI_HOST_FUNCTION(Interpolate) {
-    auto path1 = JsiSkPath::fromValue(runtime, arguments[0]);
-    auto path2 = JsiSkPath::fromValue(runtime, arguments[1]);
-    auto weight = arguments[2].asNumber();
-    auto p1 = path1->snapshot();
-    auto p2 = path2->snapshot();
+  NullablePath Interpolate(std::shared_ptr<SkPathBuilder> pathOne,
+                           std::shared_ptr<SkPathBuilder> pathTwo,
+                           double weight) {
+    auto p1 = pathOne->snapshot();
+    auto p2 = pathTwo->snapshot();
     SkPath result;
     auto succeed = p1.interpolate(p2, weight, &result);
     if (!succeed) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+    return std::make_shared<JsiSkPath>(getContext(), std::move(result));
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "Make", &JsiSkPathFactory::Make);
-    installHostMethod(runtime, prototype, "MakeFromSVGString",
-                      &JsiSkPathFactory::MakeFromSVGString);
-    installHostMethod(runtime, prototype, "MakeFromOp",
-                      &JsiSkPathFactory::MakeFromOp);
-    installHostMethod(runtime, prototype, "MakeFromCmds",
-                      &JsiSkPathFactory::MakeFromCmds);
-    installHostMethod(runtime, prototype, "MakeFromText",
-                      &JsiSkPathFactory::MakeFromText);
+    installMethod(runtime, prototype, "Make", &JsiSkPathFactory::Make);
+    installMethod(runtime, prototype, "MakeFromSVGString",
+                  &JsiSkPathFactory::MakeFromSVGString);
+    installMethod(runtime, prototype, "MakeFromOp",
+                  &JsiSkPathFactory::MakeFromOp);
+    installMethod(runtime, prototype, "MakeFromCmds",
+                  &JsiSkPathFactory::MakeFromCmds);
+    installMethod(runtime, prototype, "MakeFromText",
+                  &JsiSkPathFactory::MakeFromText);
     // Static shape factories
-    installHostMethod(runtime, prototype, "Rect", &JsiSkPathFactory::Rect);
-    installHostMethod(runtime, prototype, "Oval", &JsiSkPathFactory::Oval);
-    installHostMethod(runtime, prototype, "Circle", &JsiSkPathFactory::Circle);
-    installHostMethod(runtime, prototype, "RRect", &JsiSkPathFactory::RRect);
-    installHostMethod(runtime, prototype, "Line", &JsiSkPathFactory::Line);
-    installHostMethod(runtime, prototype, "Polygon",
-                      &JsiSkPathFactory::Polygon);
+    installMethod(runtime, prototype, "Rect", &JsiSkPathFactory::Rect);
+    installMethod(runtime, prototype, "Oval", &JsiSkPathFactory::Oval);
+    installMethod(runtime, prototype, "Circle", &JsiSkPathFactory::Circle);
+    installMethod(runtime, prototype, "RRect", &JsiSkPathFactory::RRect);
+    installMethod(runtime, prototype, "Line", &JsiSkPathFactory::Line);
+    installMethod(runtime, prototype, "Polygon", &JsiSkPathFactory::Polygon);
     // Static path operations
     installHostMethod(runtime, prototype, "Stroke", &JsiSkPathFactory::Stroke);
-    installHostMethod(runtime, prototype, "Trim", &JsiSkPathFactory::Trim);
-    installHostMethod(runtime, prototype, "Simplify",
-                      &JsiSkPathFactory::Simplify);
-    installHostMethod(runtime, prototype, "Dash", &JsiSkPathFactory::Dash);
-    installHostMethod(runtime, prototype, "AsWinding",
-                      &JsiSkPathFactory::AsWinding);
-    installHostMethod(runtime, prototype, "Interpolate",
-                      &JsiSkPathFactory::Interpolate);
+    installMethod(runtime, prototype, "Trim", &JsiSkPathFactory::Trim);
+    installMethod(runtime, prototype, "Simplify", &JsiSkPathFactory::Simplify);
+    installMethod(runtime, prototype, "Dash", &JsiSkPathFactory::Dash);
+    installMethod(runtime, prototype, "AsWinding",
+                  &JsiSkPathFactory::AsWinding);
+    installMethod(runtime, prototype, "Interpolate",
+                  &JsiSkPathFactory::Interpolate);
   }
 
   explicit JsiSkPathFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkNativeObject<JsiSkPathFactory>(std::move(context)) {}
+
+private:
+  static SkPathDirection toDirection(const JsiOptional<bool> &isCCW) {
+    return isCCW.has_value() && *isCCW ? SkPathDirection::kCCW
+                                       : SkPathDirection::kCW;
+  }
 };
 
 } // namespace RNSkia