@shopify/react-native-skia 2.5.5 → 2.6.1

package/cpp/api/JsiSkPathFactory.h

@@ -1,19 +1,31 @@
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include <jsi/jsi.h>
 
 #include "JsiSkHostObjects.h"
+#include "JsiSkMatrix.h"
 #include "JsiSkPathEffect.h"
+#include "JsiSkPoint.h"
+#include "JsiSkRRect.h"
+#include "JsiSkRect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
 #include "RNSkLog.h"
 #include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkPathUtils.h"
+#include "include/core/SkStrokeRec.h"
+#include "include/effects/SkDashPathEffect.h"
+#include "include/effects/SkTrimPathEffect.h"
 #include "include/pathops/SkPathOps.h"
+#include "include/utils/SkTextUtils.h"
 
 #pragma clang diagnostic pop
 
@@ -40,36 +52,33 @@ public:
 
   JSI_HOST_FUNCTION(MakeFromSVGString) {
     auto svgString = arguments[0].asString(runtime).utf8(runtime);
-    SkPath result;
-
-    if (!SkParsePath::FromSVGString(svgString.c_str(), &result)) {
+    auto result = SkParsePath::FromSVGString(svgString.c_str());
+    if (!result.has_value()) {
       throw jsi::JSError(runtime, "Could not parse Svg path");
       return jsi::Value(nullptr);
     }
-
     auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(result));
+        std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
         runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromOp) {
-    SkPath one = *JsiSkPath::fromValue(runtime, arguments[0]).get();
-    SkPath two = *JsiSkPath::fromValue(runtime, arguments[1]).get();
+    auto one = JsiSkPath::fromValue(runtime, arguments[0])->snapshot();
+    auto two = JsiSkPath::fromValue(runtime, arguments[1])->snapshot();
     SkPathOp op = (SkPathOp)arguments[2].asNumber();
-    SkPath result;
-    bool success = Op(one, two, op, &result);
-    if (!success) {
+    auto result = Op(one, two, op);
+    if (!result.has_value()) {
       return jsi::Value(nullptr);
     }
     auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(result));
+        std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
         runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromCmds) {
-    SkPath path;
+    SkPathBuilder builder;
     auto cmds = arguments[0].asObject(runtime).asArray(runtime);
     auto cmdCount = cmds.size(runtime);
     for (int i = 0; i < cmdCount; i++) {
@@ -88,7 +97,7 @@ public:
         }
         auto x = cmd.getValueAtIndex(runtime, 1).asNumber();
         auto y = cmd.getValueAtIndex(runtime, 2).asNumber();
-        path.moveTo(x, y);
+        builder.moveTo(x, y);
         break;
       }
       case LINE: {
@@ -98,7 +107,7 @@ public:
         }
         auto x = cmd.getValueAtIndex(runtime, 1).asNumber();
         auto y = cmd.getValueAtIndex(runtime, 2).asNumber();
-        path.lineTo(x, y);
+        builder.lineTo(x, y);
         break;
       }
       case QUAD: {
@@ -110,7 +119,7 @@ public:
         auto y1 = cmd.getValueAtIndex(runtime, 2).asNumber();
         auto x2 = cmd.getValueAtIndex(runtime, 3).asNumber();
         auto y2 = cmd.getValueAtIndex(runtime, 4).asNumber();
-        path.quadTo(x1, y1, x2, y2);
+        builder.quadTo(x1, y1, x2, y2);
         break;
       }
       case CONIC: {
@@ -123,7 +132,7 @@ public:
         auto x2 = cmd.getValueAtIndex(runtime, 3).asNumber();
         auto y2 = cmd.getValueAtIndex(runtime, 4).asNumber();
         auto w = cmd.getValueAtIndex(runtime, 5).asNumber();
-        path.conicTo(x1, y1, x2, y2, w);
+        builder.conicTo(x1, y1, x2, y2, w);
         break;
       }
       case CUBIC: {
@@ -137,11 +146,11 @@ public:
         auto y2 = cmd.getValueAtIndex(runtime, 4).asNumber();
         auto x3 = cmd.getValueAtIndex(runtime, 5).asNumber();
         auto y3 = cmd.getValueAtIndex(runtime, 6).asNumber();
-        path.cubicTo(x1, y1, x2, y2, x3, y3);
+        builder.cubicTo(x1, y1, x2, y2, x3, y3);
         break;
       }
       case CLOSE: {
-        path.close();
+        builder.close();
         break;
       }
       default: {
@@ -151,7 +160,7 @@ public:
       }
     }
     auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
         runtime, hostObjectInstance, getContext());
   }
@@ -170,6 +179,250 @@ public:
         runtime, hostObjectInstance, getContext());
   }
 
+  // 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;
+    }
+    SkPathBuilder builder;
+    builder.addRect(*rect, direction);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  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();
+    SkPathBuilder builder;
+    builder.addOval(*rect, direction, startIndex);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  JSI_HOST_FUNCTION(Circle) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    auto r = arguments[2].asNumber();
+    SkPathBuilder builder;
+    builder.addCircle(x, y, r);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  JSI_HOST_FUNCTION(RRect) {
+    auto rrect = JsiSkRRect::fromValue(runtime, arguments[0]);
+    auto direction = SkPathDirection::kCW;
+    if (count >= 2 && arguments[1].getBool()) {
+      direction = SkPathDirection::kCCW;
+    }
+    SkPathBuilder builder;
+    builder.addRRect(*rrect, direction);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  JSI_HOST_FUNCTION(Line) {
+    auto p1 = JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime));
+    auto p2 = JsiSkPoint::fromValue(runtime, arguments[1].asObject(runtime));
+    SkPathBuilder builder;
+    builder.moveTo(*p1);
+    builder.lineTo(*p2);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  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());
+    }
+    SkPathBuilder builder;
+    builder.addPolygon(SkSpan(points), close);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  // Static path operations
+  JSI_HOST_FUNCTION(Stroke) {
+    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+    SkPath path = srcPath->snapshot();
+    SkPaint p;
+    p.setStyle(SkPaint::kStroke_Style);
+
+    if (count > 1 && !arguments[1].isUndefined()) {
+      auto opts = arguments[1].asObject(runtime);
+
+      auto jsiCap = opts.getProperty(runtime, "cap");
+      if (!jsiCap.isUndefined()) {
+        auto cap = (SkPaint::Cap)jsiCap.asNumber();
+        p.setStrokeCap(cap);
+      }
+
+      auto jsiJoin = opts.getProperty(runtime, "join");
+      if (!jsiJoin.isUndefined()) {
+        auto join = (SkPaint::Join)jsiJoin.asNumber();
+        p.setStrokeJoin(join);
+      }
+
+      auto jsiWidth = opts.getProperty(runtime, "width");
+      if (!jsiWidth.isUndefined()) {
+        auto width = jsiWidth.asNumber();
+        p.setStrokeWidth(width);
+      }
+
+      auto jsiMiterLimit = opts.getProperty(runtime, "miter_limit");
+      if (!jsiMiterLimit.isUndefined()) {
+        auto miter_limit = jsiMiterLimit.asNumber();
+        p.setStrokeMiter(miter_limit);
+      }
+
+      auto jsiPrecision = opts.getProperty(runtime, "precision");
+      auto precision = jsiPrecision.isUndefined() ? 1 : jsiPrecision.asNumber();
+      SkPathBuilder resultBuilder;
+      auto ctm = SkMatrix::Scale(precision, precision);
+      auto success =
+          skpathutils::FillPathWithPaint(path, p, &resultBuilder, nullptr, ctm);
+      if (success) {
+        auto hostObjectInstance =
+            std::make_shared<JsiSkPath>(getContext(), resultBuilder.snapshot());
+        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+            runtime, hostObjectInstance, getContext());
+      }
+    } else {
+      SkPathBuilder resultBuilder;
+      auto success = skpathutils::FillPathWithPaint(path, p, &resultBuilder);
+      if (success) {
+        auto hostObjectInstance =
+            std::make_shared<JsiSkPath>(getContext(), resultBuilder.snapshot());
+        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+            runtime, hostObjectInstance, getContext());
+      }
+    }
+    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();
+    // If requesting the full path in normal mode, just return a copy
+    if (start <= 0 && end >= 1 && !isComplement) {
+      SkPath result = srcPath->snapshot();
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    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();
+    }
+    SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
+    SkPathBuilder resultBuilder;
+    if (pe->filterPath(&resultBuilder, path, &rec)) {
+      auto result = resultBuilder.detach();
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    return jsi::Value::null();
+  }
+
+  JSI_HOST_FUNCTION(Simplify) {
+    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+    auto result = ::Simplify(srcPath->snapshot());
+    if (result.has_value()) {
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    return jsi::Value::null();
+  }
+
+  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};
+    auto i = SkSpan(intervals, 2);
+    auto pe = SkDashPathEffect::Make(i, phase);
+    if (!pe) {
+      return jsi::Value::null();
+    }
+    SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
+    SkPathBuilder resultBuilder;
+    if (pe->filterPath(&resultBuilder, srcPath->snapshot(), &rec)) {
+      auto result = resultBuilder.detach();
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    return jsi::Value::null();
+  }
+
+  JSI_HOST_FUNCTION(AsWinding) {
+    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+    auto result = ::AsWinding(srcPath->snapshot());
+    if (result.has_value()) {
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    return jsi::Value::null();
+  }
+
+  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();
+    SkPath result;
+    auto succeed = p1.interpolate(p2, weight, &result);
+    if (!succeed) {
+      return jsi::Value::null();
+    }
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(result));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
   size_t getMemoryPressure() const override { return 1024; }
 
   std::string getObjectType() const override { return "JsiSkPathFactory"; }
@@ -178,7 +431,21 @@ public:
                        JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromSVGString),
                        JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromOp),
                        JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromCmds),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromText))
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromText),
+                       // Static shape factories
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Rect),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Oval),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Circle),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, RRect),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Line),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Polygon),
+                       // Static path operations
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Stroke),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Trim),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Simplify),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Dash),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, AsWinding),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Interpolate))
 
   explicit JsiSkPathFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/JsiSkShader.h

@@ -11,7 +11,7 @@
 #pragma clang diagnostic ignored "-Wdocumentation"
 
 #include "include/core/SkShader.h"
-#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkGradient.h"
 
 #pragma clang diagnostic pop
 

package/cpp/api/JsiSkShaderFactory.h

@@ -44,8 +44,9 @@ SkTileMode getTileMode(const jsi::Value *values, int i, size_t size) {
   return static_cast<SkTileMode>(values[i].asNumber());
 }
 
-std::vector<SkColor> getColors(jsi::Runtime &runtime, const jsi::Value &value) {
-  std::vector<SkColor> colors;
+std::vector<SkColor4f> getColors(jsi::Runtime &runtime,
+                                 const jsi::Value &value) {
+  std::vector<SkColor4f> colors;
   if (!value.isNull()) {
     auto jsiColors = value.asObject(runtime).asArray(runtime);
     auto size = jsiColors.size(runtime);
@@ -53,7 +54,7 @@ std::vector<SkColor> getColors(jsi::Runtime &runtime, const jsi::Value &value) {
     for (int i = 0; i < size; i++) {
       SkColor color =
           JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
-      colors.push_back(color);
+      colors.push_back(SkColor4f::FromColor(color));
     }
   }
   return colors;
@@ -83,7 +84,7 @@ public:
         *JsiSkPoint::fromValue(runtime, arguments[1].asObject(runtime)).get();
     SkPoint pts[] = {p1, p2};
 
-    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
     auto colorsSize = colors.size();
     if (colorsSize < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
@@ -97,9 +98,15 @@ public:
     auto flag = getFlag(arguments, 6, count);
     auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
 
-    sk_sp<SkShader> gradient = SkGradientShader::MakeLinear(
-        pts, colors.data(), !positions.empty() ? positions.data() : nullptr,
-        static_cast<int>(colorsSize), tileMode, flag, localMatrix);
+    SkGradient::Colors gradColors(
+        SkSpan(colors),
+        !positions.empty()
+            ? SkSpan<const float>(positions.data(), positions.size())
+            : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    sk_sp<SkShader> gradient =
+        SkShaders::LinearGradient(pts, grad, localMatrix);
     auto shader =
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
@@ -111,7 +118,7 @@ public:
         *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
     auto r = arguments[1].asNumber();
 
-    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
     auto colorsSize = colors.size();
     if (colorsSize < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
@@ -125,10 +132,15 @@ public:
     auto flag = getFlag(arguments, 6, count);
     auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
 
-    sk_sp<SkShader> gradient = SkGradientShader::MakeRadial(
-        center, r, colors.data(),
-        !positions.empty() ? positions.data() : nullptr,
-        static_cast<int>(colorsSize), tileMode, flag, localMatrix);
+    SkGradient::Colors gradColors(
+        SkSpan(colors),
+        !positions.empty()
+            ? SkSpan<const float>(positions.data(), positions.size())
+            : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    sk_sp<SkShader> gradient =
+        SkShaders::RadialGradient(center, r, grad, localMatrix);
     auto shader =
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
@@ -138,7 +150,7 @@ public:
   JSI_HOST_FUNCTION(MakeSweepGradient) {
     auto x = arguments[0].asNumber();
     auto y = arguments[1].asNumber();
-    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
     auto colorsSize = colors.size();
     if (colorsSize < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
@@ -151,15 +163,22 @@ public:
     auto tileMode = getTileMode(arguments, 4, count);
     auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
     auto flag = getFlag(arguments, 6, count);
-    auto startAngle =
-        (count < 8 || arguments[7].isUndefined()) ? 0 : arguments[7].asNumber();
+    auto startAngle = (count < 8 || arguments[7].isUndefined())
+                          ? 0.0f
+                          : static_cast<float>(arguments[7].asNumber());
     auto endAngle = (count < 9 || arguments[8].isUndefined())
-                        ? 360
-                        : arguments[8].asNumber();
-    sk_sp<SkShader> gradient = SkGradientShader::MakeSweep(
-        x, y, colors.data(), !positions.empty() ? positions.data() : nullptr,
-        static_cast<int>(colorsSize), tileMode, startAngle, endAngle, flag,
-        localMatrix);
+                        ? 360.0f
+                        : static_cast<float>(arguments[8].asNumber());
+
+    SkGradient::Colors gradColors(
+        SkSpan(colors),
+        !positions.empty()
+            ? SkSpan<const float>(positions.data(), positions.size())
+            : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    sk_sp<SkShader> gradient = SkShaders::SweepGradient(
+        SkPoint::Make(x, y), startAngle, endAngle, grad, localMatrix);
     auto shader =
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
@@ -175,7 +194,7 @@ public:
         *JsiSkPoint::fromValue(runtime, arguments[2].asObject(runtime)).get();
     auto endRadius = arguments[3].asNumber();
 
-    std::vector<SkColor> colors = getColors(runtime, arguments[4]);
+    std::vector<SkColor4f> colors = getColors(runtime, arguments[4]);
     auto colorsSize = colors.size();
     if (colorsSize < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
@@ -189,10 +208,15 @@ public:
     auto localMatrix = getLocalMatrix(runtime, arguments, 7, count);
     auto flag = getFlag(arguments, 8, count);
 
-    sk_sp<SkShader> gradient = SkGradientShader::MakeTwoPointConical(
-        start, startRadius, end, endRadius, colors.data(),
-        !positions.empty() ? positions.data() : nullptr,
-        static_cast<int>(colorsSize), tileMode, flag, localMatrix);
+    SkGradient::Colors gradColors(
+        SkSpan(colors),
+        !positions.empty()
+            ? SkSpan<const float>(positions.data(), positions.size())
+            : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    sk_sp<SkShader> gradient = SkShaders::TwoPointConicalGradient(
+        start, startRadius, end, endRadius, grad, localMatrix);
 
     auto shader =
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient));

package/cpp/api/JsiSkSurfaceFactory.h

@@ -51,7 +51,8 @@ public:
       }
     }
     auto context = getContext();
-    auto surface = context->makeOffscreenSurface(width, height, useP3ColorSpace);
+    auto surface =
+        context->makeOffscreenSurface(width, height, useP3ColorSpace);
     if (surface == nullptr) {
       return jsi::Value::null();
     }

package/cpp/api/recorder/DataTypes.h

@@ -141,7 +141,7 @@ std::shared_ptr<SkPath> processPath(jsi::Runtime &runtime,
     auto ptr = std::dynamic_pointer_cast<JsiSkPath>(
         value.asObject(runtime).asHostObject(runtime));
     if (ptr != nullptr) {
-      return ptr->getObject();
+      return std::make_shared<SkPath>(ptr->getObject()->snapshot());
     }
   }
   return nullptr;

package/cpp/api/recorder/Drawings.h

@@ -8,6 +8,9 @@
 #include "ImageFit.h"
 #include "RNSkPlatformContext.h"
 
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkStrokeRec.h"
+
 namespace RNSkia {
 
 struct CircleCmdProps {
@@ -123,12 +126,13 @@ public:
             SkTrimPathEffect::Make(start, end, SkTrimPathEffect::Mode::kNormal);
         if (pe != nullptr) {
           SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
-          if (!pe->filterPath(&filteredPath, filteredPath, &rec, nullptr)) {
+          SkPathBuilder filteredBuilder;
+          if (!pe->filterPath(&filteredBuilder, filteredPath, &rec)) {
             throw std::runtime_error(
                 "Failed trimming path with parameters start: " +
                 std::to_string(start) + ", end: " + std::to_string(end));
           }
-          filteredPath.swap(filteredPath);
+          filteredPath = filteredBuilder.detach();
         } else {
           throw std::runtime_error(
               "Failed trimming path with parameters start: " +
@@ -162,14 +166,11 @@ public:
           strokePaint.setStrokeMiter(stroke.miter_limit.value());
         }
 
-        float precision = stroke.precision.value_or(1.0f);
-
-        auto strokedPath = std::make_shared<SkPath>();
-        if (!skpathutils::FillPathWithPaint(*p, strokePaint, strokedPath.get(),
-                                            nullptr, precision)) {
+        SkPathBuilder resultBuilder;
+        if (!skpathutils::FillPathWithPaint(*p, strokePaint, &resultBuilder)) {
           throw std::runtime_error("Failed to apply stroke to path");
         }
-        pathToUse = std::const_pointer_cast<const SkPath>(strokedPath);
+        pathToUse = std::make_shared<const SkPath>(resultBuilder.snapshot());
       } else {
         pathToUse = std::const_pointer_cast<const SkPath>(p);
       }
@@ -935,7 +936,8 @@ public:
     convertProperty(runtime, object, "sprites", props.sprites, variables);
     convertProperty(runtime, object, "transforms", props.transforms, variables);
     convertProperty(runtime, object, "colors", props.colors, variables);
-    convertProperty(runtime, object, "colorBlendMode", props.blendMode, variables);
+    convertProperty(runtime, object, "colorBlendMode", props.blendMode,
+                    variables);
     convertProperty(runtime, object, "sampling", props.sampling, variables);
   }