@shopify/react-native-skia 0.0.135

package/cpp/api/JsiSkPathEffectFactory.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkPathEffect.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkCornerPathEffect.h>
+#include <SkDashPathEffect.h>
+#include <SkDiscretePathEffect.h>
+#include <SkPathEffect.h>
+#include "include/effects/Sk1DPathEffect.h"
+#include "include/effects/Sk2DPathEffect.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPathEffectFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeCorner) {
+    int radius = arguments[0].asNumber();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPathEffect>(
+                     getContext(), SkCornerPathEffect::Make(radius)));
+  }
+
+  JSI_HOST_FUNCTION(MakeDash) {
+    auto jsiIntervals = arguments[0].asObject(runtime).asArray(runtime);
+    auto size = (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;
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPathEffect>(
+                     getContext(),
+                     SkDashPathEffect::Make(intervals.data(), size, phase)));
+  }
+
+  JSI_HOST_FUNCTION(MakeDiscrete) {
+    int segLength = arguments[0].asNumber();
+    int dec = arguments[1].asNumber();
+    int seedAssist = arguments[2].asNumber();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPathEffect>(
+                     getContext(),
+                     SkDiscretePathEffect::Make(segLength, dec, seedAssist)));
+  }
+
+  JSI_HOST_FUNCTION(MakeCompose) {
+    auto outer = JsiSkPathEffect::fromValue(runtime, arguments[0]);
+    auto inner = JsiSkPathEffect::fromValue(runtime, arguments[1]);
+
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkPathEffect::MakeCompose(std::move(outer), std::move(inner))));
+  }
+
+  JSI_HOST_FUNCTION(MakeSum) {
+    auto outer = JsiSkPathEffect::fromValue(runtime, arguments[0]);
+    auto inner = JsiSkPathEffect::fromValue(runtime, arguments[1]);
+
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkPathEffect::MakeSum(std::move(outer), std::move(inner))));
+  }
+
+  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());
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkPath1DPathEffect::Make(*path, advance, phase, style)));
+  }
+
+  JSI_HOST_FUNCTION(MakePath2D) {
+    auto matrix = JsiSkMatrix::fromValue(runtime, arguments[0]);
+    auto path = JsiSkPath::fromValue(runtime, arguments[1]);
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkPath2DPathEffect::Make(*matrix, *path)));
+  }
+
+  JSI_HOST_FUNCTION(MakeLine2D) {
+    auto width = arguments[0].asNumber();
+    auto matrix = JsiSkMatrix::fromValue(runtime, arguments[1]);
+
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkLine2DPathEffect::Make(width, *matrix)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeCorner),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeDash),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeDiscrete),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeCompose),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeSum),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeLine2D),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath1D),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath2D),
+   )
+
+  JsiSkPathEffectFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkPathFactory.h

@@ -0,0 +1,172 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkPathEffect.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPath.h>
+#include <SkPathOps.h>
+#include <RNSkLog.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPathFactory : public JsiSkHostObject {
+
+  static const int MOVE = 0;
+  static const int LINE = 1;
+  static const int QUAD = 2;
+  static const int CONIC = 3;
+  static const int CUBIC = 4;
+  static const int CLOSE = 5;
+
+public:
+  JSI_HOST_FUNCTION(Make) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), SkPath()));
+  }
+
+  JSI_HOST_FUNCTION(MakeFromSVGString) {
+    auto svgString = arguments[0].asString(runtime).utf8(runtime);
+    SkPath result;
+
+    if (!SkParsePath::FromSVGString(svgString.c_str(), &result)) {
+      jsi::detail::throwJSError(runtime, "Could not parse Svg path");
+      return jsi::Value(nullptr);
+    }
+
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+  }
+
+  JSI_HOST_FUNCTION(MakeFromOp) {
+    SkPath one = *JsiSkPath::fromValue(runtime, arguments[0]).get();
+    SkPath two = *JsiSkPath::fromValue(runtime, arguments[1]).get();
+    SkPathOp op = (SkPathOp)arguments[2].asNumber();
+    SkPath result;
+    bool success = Op(one, two, op, &result);
+    if (!success) {
+      return jsi::Value(nullptr);
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+  }
+
+  JSI_HOST_FUNCTION(MakeFromCmds) {
+    SkPath path;
+    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) {
+        RNSkLogger::logToConsole("Invalid command found (got an empty array)");
+        return jsi::Value::null();
+      }
+      auto verb = static_cast<int>(cmd.getValueAtIndex(runtime, 0).asNumber());
+      switch (verb) {
+        case MOVE: {
+          if (cmd.size(runtime) < 3) {
+            RNSkLogger::logToConsole( "Invalid move command found");
+            return jsi::Value::null();
+          }
+          auto x = cmd.getValueAtIndex(runtime, 1).asNumber();
+          auto y = cmd.getValueAtIndex(runtime, 2).asNumber();
+          path.moveTo(x, y);
+          break;
+        }
+        case LINE: {
+          if (cmd.size(runtime) < 3) {
+            RNSkLogger::logToConsole("Invalid line command found");
+            return jsi::Value::null();
+          }
+          auto x = cmd.getValueAtIndex(runtime, 1).asNumber();
+          auto y = cmd.getValueAtIndex(runtime, 2).asNumber();
+          path.lineTo(x, y);
+          break;
+        }
+        case QUAD: {
+          if (cmd.size(runtime) < 5) {
+            RNSkLogger::logToConsole("Invalid line command found");
+            return jsi::Value::null();
+          }
+          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();
+          path.quadTo(x1, y1, x2, y2);
+          break;
+        }
+        case CONIC: {
+          if (cmd.size(runtime) < 6) {
+            RNSkLogger::logToConsole("Invalid line command found");
+            return jsi::Value::null();
+          }
+          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();
+          path.conicTo(x1, y1, x2, y2, w);
+          break;
+        }
+        case CUBIC: {
+          if (cmd.size(runtime) < 7) {
+            RNSkLogger::logToConsole("Invalid line command found");
+            return jsi::Value::null();
+          }
+          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();
+          path.cubicTo(x1, y1, x2, y2, x3, y3);
+          break;
+        }
+        case CLOSE: {
+          path.close();
+          break;
+        }
+        default: {
+          RNSkLogger::logToConsole("Found an unknown command");
+          return jsi::Value::null();
+        }
+      }
+    }
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
+  }
+
+  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]);
+    SkPath path;
+    SkTextUtils::GetPath(text.c_str(), strlen(text.c_str()),
+                         SkTextEncoding::kUTF8, x, y, *font, &path);
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));;
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathFactory, Make),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromSVGString),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromOp),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromCmds),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromText))
+
+  JsiSkPathFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkPicture.h

@@ -0,0 +1,71 @@
+
+#pragma once
+
+#include "JsiSkHostObjects.h"
+#include <JsiSkData.h>
+#include <JsiSkShader.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPicture.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPicture : public JsiSkWrappingSkPtrHostObject<SkPicture> {
+public:
+
+  JsiSkPicture(std::shared_ptr<RNSkPlatformContext> context, const sk_sp<SkPicture> picture)
+      : JsiSkWrappingSkPtrHostObject<SkPicture>(context, picture) {};
+  
+  JSI_HOST_FUNCTION(makeShader) {
+    auto tmx = (SkTileMode)arguments[0].asNumber();
+    auto tmy = (SkTileMode)arguments[1].asNumber();
+    auto fm = (SkFilterMode)arguments[2].asNumber();
+    auto m = count > 3 && !arguments[3].isUndefined() ?
+      JsiSkMatrix::fromValue(runtime, arguments[3]).get() : nullptr;
+    
+    auto tr = count > 4 && !arguments[4].isUndefined() ?
+      JsiSkRect::fromValue(runtime, arguments[4]).get() : nullptr;
+    
+    // Create shader
+    auto shader = getObject()->makeShader(tmx, tmy, fm, m, tr);
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkShader>(getContext(), shader));
+  }
+  
+  JSI_HOST_FUNCTION(serialize) {
+    auto data = getObject()->serialize();
+    auto arrayCtor = runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
+    size_t size = data->size();
+
+    jsi::Object array = arrayCtor.callAsConstructor(runtime, static_cast<double>(size)).getObject(runtime);
+    jsi::ArrayBuffer buffer = array
+                                  .getProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
+                                  .asObject(runtime)
+                                  .getArrayBuffer(runtime);
+
+    auto bfrPtr = reinterpret_cast<uint8_t *>(buffer.data(runtime));
+    memcpy(bfrPtr, data->bytes(), size);
+    return array;  
+  }
+  
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPicture, makeShader),
+                       JSI_EXPORT_FUNC(JsiSkPicture, serialize))
+
+  /**
+   Returns the underlying object from a host object of this type
+  */
+  static sk_sp<SkPicture> fromValue(jsi::Runtime &runtime,
+                                            const jsi::Value &obj) {
+    return obj.asObject(runtime)
+        .asHostObject<JsiSkPicture>(runtime)
+        .get()
+        ->getObject();
+  }    
+};
+} // namespace RNSkia

package/cpp/api/JsiSkPictureFactory.h

@@ -0,0 +1,50 @@
+
+#pragma once
+
+#include "JsiSkColorFilter.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkData.h"
+#include "JsiSkPicture.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPicture.h>
+#include <SkData.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPictureFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakePicture) {
+    if(!arguments[0].isObject()) {
+      jsi::detail::throwJSError(runtime, "Expected arraybuffer as first parameter");
+    }
+    auto array = arguments[0].asObject(runtime);
+    jsi::ArrayBuffer buffer = array
+            .getProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
+            .asObject(runtime)
+            .getArrayBuffer(runtime);
+
+    sk_sp<SkData> data = SkData::MakeWithCopy(buffer.data(runtime), buffer.size(runtime));
+    auto picture = SkPicture::MakeFromData(data.get());
+    if(picture != nullptr) {
+      return jsi::Object::createFromHostObject(
+          runtime,
+          std::make_shared<JsiSkPicture>(getContext(), picture));
+    } else {
+      return jsi::Value::undefined();
+    }
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPictureFactory, MakePicture))
+
+  JsiSkPictureFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(context) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkPictureRecorder.h

@@ -0,0 +1,53 @@
+
+#pragma once
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkRect.h"
+#include "JsiSkPicture.h"
+#include "JsiSkCanvas.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPictureRecorder.h>
+#include <SkBBHFactory.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPictureRecorder : public JsiSkWrappingSharedPtrHostObject<SkPictureRecorder> {
+public:
+
+  JsiSkPictureRecorder(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkWrappingSharedPtrHostObject<SkPictureRecorder>(
+            context, std::make_shared<SkPictureRecorder>()){};
+
+  JSI_HOST_FUNCTION(beginRecording) {
+    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
+    SkRTreeFactory factory;
+    auto canvas = getObject()->beginRecording(*rect, &factory);
+    return jsi::Object::createFromHostObject(
+      runtime, std::make_shared<JsiSkCanvas>(getContext(), canvas));
+  }
+  
+  JSI_HOST_FUNCTION(finishRecordingAsPicture) {
+    auto picture = getObject()->finishRecordingAsPicture();
+    return jsi::Object::createFromHostObject(
+      runtime, std::make_shared<JsiSkPicture>(getContext(), picture));
+  }
+  
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPictureRecorder, beginRecording),
+                       JSI_EXPORT_FUNC(JsiSkPictureRecorder, finishRecordingAsPicture))
+  
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+      return JSI_HOST_FUNCTION_LAMBDA {
+        return jsi::Object::createFromHostObject(
+                runtime, std::make_shared<JsiSkPictureRecorder>(context));
+      };
+  }
+};
+} // namespace RNSkia

package/cpp/api/JsiSkPoint.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPoint.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPoint : public JsiSkWrappingSharedPtrHostObject<SkPoint> {
+public:
+
+  JSI_PROPERTY_GET(x) { return static_cast<double>(getObject()->x()); }
+
+  JSI_PROPERTY_GET(y) { return static_cast<double>(getObject()->y()); }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkPoint, x),
+                              JSI_EXPORT_PROP_GET(JsiSkPoint, y))
+
+  JsiSkPoint(std::shared_ptr<RNSkPlatformContext> context, const SkPoint &point)
+      : JsiSkWrappingSharedPtrHostObject<SkPoint>(
+            std::move(context), std::make_shared<SkPoint>(point)){}
+
+  /**
+  Returns the underlying object from a host object of this type
+ */
+  static std::shared_ptr<SkPoint> fromValue(jsi::Runtime &runtime,
+                                            const jsi::Value &obj) {
+    const auto& object = obj.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      return object
+              .asHostObject<JsiSkPoint>(runtime)
+              ->getObject();
+    } else {
+      auto x = object.getProperty(runtime, "x").asNumber();
+      auto y = object.getProperty(runtime, "y").asNumber();
+      return std::make_shared<SkPoint>(SkPoint::Make(x, y));
+    }
+  }
+
+  /**
+  Returns the jsi object from a host object of this type
+ */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            const SkPoint &point) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPoint>(std::move(context), point));
+  }
+
+  /**
+   * Creates the function for construction a new instance of the SkPoint
+   * wrapper
+   * @param context platform context
+   * @return A function for creating a new host object wrapper for the SkPoint
+   * class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      auto point =
+          SkPoint::Make(arguments[0].asNumber(), arguments[1].asNumber());
+
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkPoint>(std::move(context), std::move(point)));
+    };
+  }
+};
+} // namespace RNSkia

package/cpp/api/JsiSkRRect.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRRect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkRRect : public JsiSkWrappingSharedPtrHostObject<SkRRect> {
+public:
+  JSI_PROPERTY_GET(rx) {
+    return static_cast<double>(getObject()->getSimpleRadii().x());
+  }
+  JSI_PROPERTY_GET(ry) {
+    return static_cast<double>(getObject()->getSimpleRadii().y());
+  }
+  JSI_PROPERTY_GET(rect) {
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkRect>(getContext(), getObject()->getBounds()));
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkRRect, rx),
+                              JSI_EXPORT_PROP_GET(JsiSkRRect, ry),
+                              JSI_EXPORT_PROP_GET(JsiSkRRect, rect))
+
+  JsiSkRRect(std::shared_ptr<RNSkPlatformContext> context, const SkRRect &rect)
+      : JsiSkWrappingSharedPtrHostObject<SkRRect>(
+            std::move(context), std::make_shared<SkRRect>(rect)){}
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkRRect> fromValue(jsi::Runtime &runtime,
+                                            const jsi::Value &obj) {
+
+    const auto& object = obj.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      return obj.asObject(runtime)
+              .asHostObject<JsiSkRRect>(runtime)
+              ->getObject();
+    } else {
+      auto rect = JsiSkRect::fromValue(runtime, object.getProperty(runtime, "rect"));
+      auto rx = object.getProperty(runtime, "rx").asNumber();
+      auto ry = object.getProperty(runtime, "ry").asNumber();
+      return std::make_shared<SkRRect>(SkRRect::MakeRectXY(*rect, rx, ry));
+    }
+  }
+
+  /**
+    Returns the jsi object from a host object of this type
+   */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            const SkRRect &rect) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRRect>(std::move(context), rect));
+  }
+
+  /**
+   * Creates the function for construction a new instance of the SkRect
+   * wrapper
+   * @param context platform context
+   * @return A function for creating a new host object wrapper for the SkRect
+   * class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      // Set up the rect
+      auto rect = JsiSkRect::fromValue(runtime, arguments[0]).get();
+      auto rx = arguments[1].asNumber();
+      auto ry = arguments[2].asNumber();
+      auto rrect = SkRRect::MakeRectXY(*rect, rx, ry);
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkRRect>(std::move(context), std::move(rrect)));
+    };
+  }
+};
+} // namespace RNSkia