@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkSVGFactory.h

@@ -7,7 +7,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkSVG.h"
 #include "JsiSkTypeface.h"
 
@@ -55,8 +55,10 @@ private:
   const skresources::ImageDecodeStrategy fStrategy;
 };
 
-class JsiSkSVGFactory : public JsiSkHostObject {
+class JsiSkSVGFactory : public JsiSkNativeObject<JsiSkSVGFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "SVGFactory";
+
   // Helper function to parse asset map from JS object
   static SVGAssetProvider::AssetMap parseAssetMap(jsi::Runtime &runtime,
                                                   const jsi::Value &jsValue) {
@@ -83,15 +85,9 @@ public:
         continue;
       }
 
-      if (jsValue.isObject()) {
-        auto jsObject = jsValue.asObject(runtime);
-        if (jsObject.isHostObject(runtime)) {
-          auto hostObject = jsObject.getHostObject(runtime);
-          auto skData = std::dynamic_pointer_cast<JsiSkData>(hostObject);
-          if (skData) {
-            assets[key] = skData->getObject();
-          }
-        }
+      auto skData = tryGetJsiObject<JsiSkData>(runtime, jsValue);
+      if (skData) {
+        assets[key] = skData->getObject();
       }
     }
 
@@ -120,9 +116,8 @@ private:
     builder.setResourceProvider(provider);
 
     auto svg_dom = builder.make(*stream);
-    auto svg = std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, svg,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
   }
 
 public:
@@ -160,15 +155,17 @@ public:
                              std::move(assets));
   }
 
-  size_t getMemoryPressure() const override { return kMinMemoryPressure; }
-
-  std::string getObjectType() const override { return "JsiSkSVGFactory"; }
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromData),
-                       JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromString))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "MakeFromData",
+                      &JsiSkSVGFactory::MakeFromData);
+    installHostMethod(runtime, prototype, "MakeFromString",
+                      &JsiSkSVGFactory::MakeFromString);
+  }
 
   explicit JsiSkSVGFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkSVGFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkShader.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -19,18 +19,25 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkShader : public JsiSkWrappingSkPtrHostObject<SkShader> {
+class JsiSkShader
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkShader, SkShader> {
 public:
+  static constexpr const char *CLASS_NAME = "Shader";
+
   JsiSkShader(std::shared_ptr<RNSkPlatformContext> context,
               sk_sp<SkShader> shader)
-      : JsiSkWrappingSkPtrHostObject<SkShader>(std::move(context),
-                                               std::move(shader)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkShader, SkShader>(
+            std::move(context), std::move(shader)) {}
 
-  size_t getMemoryPressure() const override { return 1024 * 1024; }
+  size_t getMemoryPressure() override { return 1024 * 1024; }
 
-  std::string getObjectType() const override { return "JsiSkShader"; }
+  static sk_sp<SkShader> fromValue(jsi::Runtime &runtime,
+                                   const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkShader, Shader)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShader, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkShaderFactory.h

@@ -6,8 +6,13 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkColor.h"
 #include "JsiSkColorFilter.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkConverters.h"
+#include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
+#include "JsiSkPoint.h"
+#include "JsiSkShader.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -22,276 +27,192 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-int getFlag(const jsi::Value *values, int i, size_t size) {
-  if (i >= size || values[i].isUndefined()) {
-    return 0;
+class JsiSkShaderFactory : public JsiSkNativeObject<JsiSkShaderFactory> {
+public:
+  static constexpr const char *CLASS_NAME = "ShaderFactory";
+
+  std::shared_ptr<JsiSkShader>
+  MakeLinearGradient(SkPoint p1, SkPoint p2,
+                     JsiOptional<std::vector<JsiColor>> jsiColors,
+                     JsiOptional<std::vector<float>> jsiPositions,
+                     JsiOptional<double> tileMode,
+                     JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+                     JsiOptional<double> flag) {
+    SkPoint pts[] = {p1, p2};
+    auto colors = toColors(jsiColors);
+    auto positions = toPositions(jsiPositions, colors.size());
+    SkGradient::Colors gradColors(SkSpan(colors), toSpan(positions),
+                                  toTileMode(tileMode));
+    SkGradient grad(gradColors,
+                    SkGradient::Interpolation::FromFlags(toFlag(flag)));
+    sk_sp<SkShader> gradient =
+        SkShaders::LinearGradient(pts, grad, toLocalMatrix(matrix));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
-  return values[i].asNumber();
-}
 
-SkMatrix *getLocalMatrix(jsi::Runtime &runtime, const jsi::Value *values, int i,
-                         size_t size) {
-  if (i >= size || values[i].isUndefined()) {
-    return nullptr;
+  std::shared_ptr<JsiSkShader>
+  MakeRadialGradient(SkPoint center, double r,
+                     JsiOptional<std::vector<JsiColor>> jsiColors,
+                     JsiOptional<std::vector<float>> jsiPositions,
+                     JsiOptional<double> tileMode,
+                     JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+                     JsiOptional<double> flag) {
+    auto colors = toColors(jsiColors);
+    auto positions = toPositions(jsiPositions, colors.size());
+    SkGradient::Colors gradColors(SkSpan(colors), toSpan(positions),
+                                  toTileMode(tileMode));
+    SkGradient grad(gradColors,
+                    SkGradient::Interpolation::FromFlags(toFlag(flag)));
+    sk_sp<SkShader> gradient =
+        SkShaders::RadialGradient(center, r, grad, toLocalMatrix(matrix));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
-  return JsiSkMatrix::fromValue(runtime, values[i]).get();
-}
 
-SkTileMode getTileMode(const jsi::Value *values, int i, size_t size) {
-  if (i >= size || values[i].isUndefined()) {
-    return SkTileMode::kClamp;
+  std::shared_ptr<JsiSkShader>
+  MakeSweepGradient(double x, double y,
+                    JsiOptional<std::vector<JsiColor>> jsiColors,
+                    JsiOptional<std::vector<float>> jsiPositions,
+                    JsiOptional<double> tileMode,
+                    JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+                    JsiOptional<double> flag, JsiOptional<double> start,
+                    JsiOptional<double> end) {
+    auto colors = toColors(jsiColors);
+    auto positions = toPositions(jsiPositions, colors.size());
+    auto startAngle =
+        start.has_value() ? static_cast<float>(*start) : 0.0f;
+    auto endAngle = end.has_value() ? static_cast<float>(*end) : 360.0f;
+    SkGradient::Colors gradColors(SkSpan(colors), toSpan(positions),
+                                  toTileMode(tileMode));
+    SkGradient grad(gradColors,
+                    SkGradient::Interpolation::FromFlags(toFlag(flag)));
+    sk_sp<SkShader> gradient =
+        SkShaders::SweepGradient(SkPoint::Make(x, y), startAngle, endAngle,
+                                 grad, toLocalMatrix(matrix));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
-  return static_cast<SkTileMode>(values[i].asNumber());
-}
 
-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);
-    colors.reserve(size);
-    for (int i = 0; i < size; i++) {
-      SkColor color =
-          JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
-      colors.push_back(SkColor4f::FromColor(color));
-    }
+  std::shared_ptr<JsiSkShader>
+  MakeTwoPointConicalGradient(SkPoint start, double startRadius, SkPoint end,
+                              double endRadius,
+                              JsiOptional<std::vector<JsiColor>> jsiColors,
+                              JsiOptional<std::vector<float>> jsiPositions,
+                              JsiOptional<double> tileMode,
+                              JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+                              JsiOptional<double> flag) {
+    auto colors = toColors(jsiColors);
+    auto positions = toPositions(jsiPositions, colors.size());
+    SkGradient::Colors gradColors(SkSpan(colors), toSpan(positions),
+                                  toTileMode(tileMode));
+    SkGradient grad(gradColors,
+                    SkGradient::Interpolation::FromFlags(toFlag(flag)));
+    sk_sp<SkShader> gradient = SkShaders::TwoPointConicalGradient(
+        start, startRadius, end, endRadius, grad, toLocalMatrix(matrix));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
-  return colors;
-}
 
-std::vector<SkScalar> getPositions(jsi::Runtime &runtime,
-                                   const jsi::Value &value) {
-  std::vector<SkScalar> positions;
-  if (!value.isNull()) {
-    auto jsiPositions = value.asObject(runtime).asArray(runtime);
-    auto size = jsiPositions.size(runtime);
-    positions.reserve(size);
-    for (int i = 0; i < size; i++) {
-      SkScalar position = jsiPositions.getValueAtIndex(runtime, i).asNumber();
-      positions.push_back(position);
-    }
+  std::shared_ptr<JsiSkShader> MakeTurbulence(double baseFreqX,
+                                              double baseFreqY, double octaves,
+                                              double seed, double tileW,
+                                              double tileH) {
+    SkISize size = SkISize::Make(tileW, tileH);
+    sk_sp<SkShader> gradient =
+        SkShaders::MakeTurbulence(baseFreqX, baseFreqY, octaves, seed, &size);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
-  return positions;
-}
-
-class JsiSkShaderFactory : public JsiSkHostObject {
-public:
-  JSI_HOST_FUNCTION(MakeLinearGradient) {
-    auto p1 =
-        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
-    auto p2 =
-        *JsiSkPoint::fromValue(runtime, arguments[1].asObject(runtime)).get();
-    SkPoint pts[] = {p1, p2};
-
-    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");
-    }
-    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
-    if (!positions.empty() && positions.size() != colorsSize) {
-      throw std::invalid_argument(
-          "positions must be empty or have the same size as colors");
-    }
-    auto tileMode = getTileMode(arguments, 4, count);
-    auto flag = getFlag(arguments, 6, count);
-    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
 
-    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));
+  std::shared_ptr<JsiSkShader> MakeFractalNoise(double baseFreqX,
+                                                double baseFreqY,
+                                                double octaves, double seed,
+                                                double tileW, double tileH) {
+    SkISize size = SkISize::Make(tileW, tileH);
     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,
-                                                       getContext());
+        SkShaders::MakeFractalNoise(baseFreqX, baseFreqY, octaves, seed, &size);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeRadialGradient) {
-    auto center =
-        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
-    auto r = arguments[1].asNumber();
-
-    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");
-    }
-    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
-    if (!positions.empty() && positions.size() != colorsSize) {
-      throw std::invalid_argument(
-          "positions must be empty or the same size as colors");
-    }
-    auto tileMode = getTileMode(arguments, 4, count);
-    auto flag = getFlag(arguments, 6, count);
-    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
-
-    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));
+  std::shared_ptr<JsiSkShader> MakeBlend(double blendMode, sk_sp<SkShader> one,
+                                         sk_sp<SkShader> two) {
     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,
-                                                       getContext());
+        SkShaders::Blend(static_cast<SkBlendMode>(blendMode), one, two);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeSweepGradient) {
-    auto x = arguments[0].asNumber();
-    auto y = arguments[1].asNumber();
-    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");
-    }
-    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
-    if (!positions.empty() && positions.size() != colorsSize) {
-      throw std::invalid_argument(
-          "positions must be empty or the same size as colors");
-    }
-    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.0f
-                          : static_cast<float>(arguments[7].asNumber());
-    auto endAngle = (count < 9 || arguments[8].isUndefined())
-                        ? 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,
-                                                       getContext());
+  std::shared_ptr<JsiSkShader> MakeColor(JsiColor color) {
+    sk_sp<SkShader> gradient = SkShaders::Color(color);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeTwoPointConicalGradient) {
-    auto start =
-        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
-    auto startRadius = arguments[1].asNumber();
-
-    auto end =
-        *JsiSkPoint::fromValue(runtime, arguments[2].asObject(runtime)).get();
-    auto endRadius = arguments[3].asNumber();
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installMethod(runtime, prototype, "MakeLinearGradient",
+                  &JsiSkShaderFactory::MakeLinearGradient);
+    installMethod(runtime, prototype, "MakeRadialGradient",
+                  &JsiSkShaderFactory::MakeRadialGradient);
+    installMethod(runtime, prototype, "MakeSweepGradient",
+                  &JsiSkShaderFactory::MakeSweepGradient);
+    installMethod(runtime, prototype, "MakeTwoPointConicalGradient",
+                  &JsiSkShaderFactory::MakeTwoPointConicalGradient);
+    installMethod(runtime, prototype, "MakeTurbulence",
+                  &JsiSkShaderFactory::MakeTurbulence);
+    installMethod(runtime, prototype, "MakeFractalNoise",
+                  &JsiSkShaderFactory::MakeFractalNoise);
+    installMethod(runtime, prototype, "MakeBlend",
+                  &JsiSkShaderFactory::MakeBlend);
+    installMethod(runtime, prototype, "MakeColor",
+                  &JsiSkShaderFactory::MakeColor);
+  }
 
-    std::vector<SkColor4f> colors = getColors(runtime, arguments[4]);
-    auto colorsSize = colors.size();
-    if (colorsSize < 2) {
+  explicit JsiSkShaderFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkNativeObject<JsiSkShaderFactory>(std::move(context)) {}
+
+private:
+  static std::vector<SkColor4f>
+  toColors(const JsiOptional<std::vector<JsiColor>> &jsiColors) {
+    std::vector<SkColor4f> colors;
+    if (jsiColors.has_value()) {
+      colors.reserve(jsiColors->size());
+      for (const auto &color : *jsiColors) {
+        colors.push_back(SkColor4f::FromColor(color));
+      }
+    }
+    if (colors.size() < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
     }
-    std::vector<SkScalar> positions = getPositions(runtime, arguments[5]);
+    return colors;
+  }
+
+  static std::vector<float>
+  toPositions(const JsiOptional<std::vector<float>> &jsiPositions,
+              size_t colorsSize) {
+    std::vector<float> positions =
+        jsiPositions.has_value() ? *jsiPositions : std::vector<float>{};
     if (!positions.empty() && positions.size() != colorsSize) {
       throw std::invalid_argument(
-          "positions must be empty or the same size as colors");
+          "positions must be empty or have the same size as colors");
     }
-    auto tileMode = getTileMode(arguments, 6, count);
-    auto localMatrix = getLocalMatrix(runtime, arguments, 7, count);
-    auto flag = getFlag(arguments, 8, count);
-
-    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));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return positions;
   }
 
-  JSI_HOST_FUNCTION(MakeTurbulence) {
-    auto baseFreqX = arguments[0].asNumber();
-    auto baseFreqY = arguments[1].asNumber();
-    auto octaves = arguments[2].asNumber();
-    auto seed = arguments[3].asNumber();
-    auto tileW = arguments[4].asNumber();
-    auto tileH = arguments[5].asNumber();
-    SkISize size = SkISize::Make(tileW, tileH);
-    sk_sp<SkShader> gradient =
-        SkShaders::MakeTurbulence(baseFreqX, baseFreqY, octaves, seed, &size);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+  static SkSpan<const float> toSpan(const std::vector<float> &positions) {
+    return !positions.empty()
+               ? SkSpan<const float>(positions.data(), positions.size())
+               : SkSpan<const float>();
   }
 
-  JSI_HOST_FUNCTION(MakeFractalNoise) {
-    auto baseFreqX = arguments[0].asNumber();
-    auto baseFreqY = arguments[1].asNumber();
-    auto octaves = arguments[2].asNumber();
-    auto seed = arguments[3].asNumber();
-    auto tileW = arguments[4].asNumber();
-    auto tileH = arguments[5].asNumber();
-    SkISize size = SkISize::Make(tileW, tileH);
-    sk_sp<SkShader> gradient =
-        SkShaders::MakeFractalNoise(baseFreqX, baseFreqY, octaves, seed, &size);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+  static SkTileMode toTileMode(const JsiOptional<double> &tileMode) {
+    return tileMode.has_value() ? static_cast<SkTileMode>(*tileMode)
+                                : SkTileMode::kClamp;
   }
 
-  JSI_HOST_FUNCTION(MakeBlend) {
-    auto blendMode = (SkBlendMode)arguments[0].asNumber();
-    auto one = JsiSkShader::fromValue(runtime, arguments[1]);
-    auto two = JsiSkShader::fromValue(runtime, arguments[2]);
-    sk_sp<SkShader> gradient = SkShaders::Blend(blendMode, one, two);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+  static int toFlag(const JsiOptional<double> &flag) {
+    return flag.has_value() ? static_cast<int>(*flag) : 0;
   }
 
-  JSI_HOST_FUNCTION(MakeColor) {
-    auto color = JsiSkColor::fromValue(runtime, arguments[0]);
-    sk_sp<SkShader> gradient = SkShaders::Color(color);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+  static SkMatrix *
+  toLocalMatrix(const JsiOptional<std::shared_ptr<SkMatrix>> &matrix) {
+    return matrix.has_value() ? matrix->get() : nullptr;
   }
-
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkShaderFactory"; }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeLinearGradient),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeRadialGradient),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeSweepGradient),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory,
-                                       MakeTwoPointConicalGradient),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeTurbulence),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeFractalNoise),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeBlend),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeColor))
-
-  explicit JsiSkShaderFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
 };
 
 } // namespace RNSkia