@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkTextBlobFactory.h

@@ -1,13 +1,15 @@
 #pragma once
 
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkFont.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkRSXform.h"
 #include "JsiSkTextBlob.h"
 
@@ -22,99 +24,71 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkTextBlobFactory : public JsiSkHostObject {
+class JsiSkTextBlobFactory : public JsiSkNativeObject<JsiSkTextBlobFactory> {
 public:
-  JSI_HOST_FUNCTION(MakeFromText) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
-    auto font = JsiSkFont::fromValue(runtime, arguments[1]);
+  static constexpr const char *CLASS_NAME = "TextBlobFactory";
+
+  std::shared_ptr<JsiSkTextBlob> MakeFromText(std::string str,
+                                              std::shared_ptr<SkFont> font) {
     auto textBlob = SkTextBlob::MakeFromString(str.c_str(), *font);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
   }
 
-  JSI_HOST_FUNCTION(MakeFromGlyphs) {
-    auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
-    auto font = JsiSkFont::fromValue(runtime, arguments[1]);
+  std::shared_ptr<JsiSkTextBlob> MakeFromGlyphs(std::vector<int> glyphIds,
+                                                std::shared_ptr<SkFont> font) {
     int bytesPerGlyph = 2;
     std::vector<SkGlyphID> glyphs;
-    int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
-    glyphs.reserve(glyphsSize);
-    for (int i = 0; i < glyphsSize; i++) {
-      glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
+    glyphs.reserve(glyphIds.size());
+    for (auto glyph : glyphIds) {
+      glyphs.push_back(static_cast<SkGlyphID>(glyph));
     }
     auto textBlob =
         SkTextBlob::MakeFromText(glyphs.data(), glyphs.size() * bytesPerGlyph,
                                  *font, SkTextEncoding::kGlyphID);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
   }
 
-  JSI_HOST_FUNCTION(MakeFromRSXform) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
-    auto jsiRsxforms = arguments[1].asObject(runtime).asArray(runtime);
-    auto font = JsiSkFont::fromValue(runtime, arguments[2]);
-    std::vector<SkRSXform> rsxforms;
-    int rsxformsSize = static_cast<int>(jsiRsxforms.size(runtime));
-    rsxforms.reserve(rsxformsSize);
-    for (int i = 0; i < rsxformsSize; i++) {
-      auto rsxform = JsiSkRSXform::fromValue(
-          runtime, jsiRsxforms.getValueAtIndex(runtime, i));
-      rsxforms.push_back(*rsxform);
-    }
+  std::shared_ptr<JsiSkTextBlob>
+  MakeFromRSXform(std::string str, std::vector<SkRSXform> rsxforms,
+                  std::shared_ptr<SkFont> font) {
     auto x = SkSpan(rsxforms.data(), rsxforms.size());
     auto textBlob =
         SkTextBlob::MakeFromRSXform(str.c_str(), str.length(), x, *font);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
   }
 
-  JSI_HOST_FUNCTION(MakeFromRSXformGlyphs) {
-    auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
-    auto jsiRsxforms = arguments[1].asObject(runtime).asArray(runtime);
-    auto font = JsiSkFont::fromValue(runtime, arguments[2]);
+  std::shared_ptr<JsiSkTextBlob>
+  MakeFromRSXformGlyphs(std::vector<int> glyphIds,
+                        std::vector<SkRSXform> rsxforms,
+                        std::shared_ptr<SkFont> font) {
     int bytesPerGlyph = 2;
     std::vector<SkGlyphID> glyphs;
-    int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
-    glyphs.reserve(glyphsSize);
-    for (int i = 0; i < glyphsSize; i++) {
-      glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
-    }
-    std::vector<SkRSXform> rsxforms;
-    int rsxformsSize = static_cast<int>(jsiRsxforms.size(runtime));
-    rsxforms.reserve(rsxformsSize);
-    for (int i = 0; i < rsxformsSize; i++) {
-      auto rsxform = JsiSkRSXform::fromValue(
-          runtime, jsiRsxforms.getValueAtIndex(runtime, i));
-      rsxforms.push_back(*rsxform);
+    glyphs.reserve(glyphIds.size());
+    for (auto glyph : glyphIds) {
+      glyphs.push_back(static_cast<SkGlyphID>(glyph));
     }
     auto x = SkSpan(rsxforms.data(), rsxforms.size());
     auto textBlob = SkTextBlob::MakeFromRSXform(
         glyphs.data(), glyphs.size() * bytesPerGlyph, x, *font,
         SkTextEncoding::kGlyphID);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromText),
-                       JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromGlyphs),
-                       JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromRSXform),
-                       JSI_EXPORT_FUNC(JsiSkTextBlobFactory,
-                                       MakeFromRSXformGlyphs), )
-
-  size_t getMemoryPressure() const override { return 2048; }
-
-  std::string getObjectType() const override { return "JsiSkTextBlobFactory"; }
+  size_t getMemoryPressure() override { return 2048; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installMethod(runtime, prototype, "MakeFromText",
+                  &JsiSkTextBlobFactory::MakeFromText);
+    installMethod(runtime, prototype, "MakeFromGlyphs",
+                  &JsiSkTextBlobFactory::MakeFromGlyphs);
+    installMethod(runtime, prototype, "MakeFromRSXform",
+                  &JsiSkTextBlobFactory::MakeFromRSXform);
+    installMethod(runtime, prototype, "MakeFromRSXformGlyphs",
+                  &JsiSkTextBlobFactory::MakeFromRSXformGlyphs);
+  }
 
   explicit JsiSkTextBlobFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkTextBlobFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkTypeface.h

@@ -1,12 +1,14 @@
 #pragma once
 
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkConverters.h"
+#include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 
 #pragma clang diagnostic push
@@ -22,21 +24,20 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkTypeface : public JsiSkWrappingSkPtrHostObject<SkTypeface> {
+class JsiSkTypeface
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkTypeface, SkTypeface> {
 public:
-  EXPORT_JSI_API_TYPENAME(JsiSkTypeface, Typeface)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypeface, getGlyphIDs),
-                       JSI_EXPORT_FUNC(JsiSkTypeface, dispose))
+  static constexpr const char *CLASS_NAME = "Typeface";
 
   JsiSkTypeface(std::shared_ptr<RNSkPlatformContext> context,
                 sk_sp<SkTypeface> typeface)
-      : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(typeface)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkTypeface, SkTypeface>(
+            std::move(context), std::move(typeface)) {}
 
-  JSI_HOST_FUNCTION(getGlyphIDs) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
+  std::vector<int> getGlyphIDs(std::string str, JsiOptional<int> numGlyphs) {
     int numGlyphIDs =
-        count > 1 && !arguments[1].isNull() && !arguments[1].isUndefined()
-            ? static_cast<int>(arguments[1].asNumber())
+        numGlyphs.has_value()
+            ? *numGlyphs
             : getObject()->textToGlyphs(str.c_str(), str.length(),
                                         SkTextEncoding::kUTF8,
                                         SkSpan<SkGlyphID>(nullptr, 0));
@@ -45,15 +46,10 @@ public:
     getObject()->textToGlyphs(
         str.c_str(), str.length(), SkTextEncoding::kUTF8,
         SkSpan(static_cast<SkGlyphID *>(glyphIDs.data()), numGlyphIDs));
-    auto jsiGlyphIDs = jsi::Array(runtime, numGlyphIDs);
-    for (int i = 0; i < numGlyphIDs; i++) {
-      jsiGlyphIDs.setValueAtIndex(runtime, i,
-                                  jsi::Value(static_cast<int>(glyphIDs[i])));
-    }
-    return jsiGlyphIDs;
+    return std::vector<int>(glyphIDs.begin(), glyphIDs.end());
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto typeface = getObject();
     if (!typeface) {
       return 0;
@@ -74,13 +70,20 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             sk_sp<SkTypeface> tf) {
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTypeface>(context, std::move(tf));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, context);
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkTypeface>(context, std::move(tf)));
+  }
+
+  static sk_sp<SkTypeface> fromValue(jsi::Runtime &runtime,
+                                     const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
   }
 
-  std::string getObjectType() const override { return "JsiSkTypeface"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "getGlyphIDs",
+                  &JsiSkTypeface::getGlyphIDs);
+  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkTypefaceFactory.h

@@ -2,41 +2,43 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkFontMgrFactory.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkTypeface.h"
 
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkTypefaceFactory : public JsiSkHostObject {
+class JsiSkTypefaceFactory : public JsiSkNativeObject<JsiSkTypefaceFactory> {
 public:
-  JSI_HOST_FUNCTION(MakeFreeTypeFaceFromData) {
-    auto data = JsiSkData::fromValue(runtime, arguments[0]);
+  static constexpr const char *CLASS_NAME = "TypefaceFactory";
+
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkTypeface>>
+  MakeFreeTypeFaceFromData(sk_sp<SkData> data) {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
     auto typeface = fontMgr->makeFromData(std::move(data));
     if (typeface == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkTypefaceFactory"; }
+  size_t getMemoryPressure() override { return 1024; }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFactory,
-                                       MakeFreeTypeFaceFromData))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installMethod(runtime, prototype, "MakeFreeTypeFaceFromData",
+                  &JsiSkTypefaceFactory::MakeFreeTypeFaceFromData);
+  }
 
   explicit JsiSkTypefaceFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkTypefaceFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkTypefaceFontProvider.h

@@ -1,12 +1,15 @@
 #pragma once
 
 #include <memory>
+#include <optional>
+#include <string>
 #include <utility>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkFontStyle.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkTypeface.h"
 
 #include "utils/RNSkLog.h"
@@ -25,29 +28,21 @@ namespace jsi = facebook::jsi;
 namespace para = skia::textlayout;
 
 class JsiSkTypefaceFontProvider
-    : public JsiSkWrappingSkPtrHostObject<para::TypefaceFontProvider> {
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkTypefaceFontProvider,
+                                            para::TypefaceFontProvider> {
 public:
-  EXPORT_JSI_API_TYPENAME(JsiSkTypefaceFontProvider, TypefaceFontProvider)
-
-  JSI_EXPORT_FUNCTIONS(
-      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, dispose),
-      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, registerFont),
-      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, matchFamilyStyle),
-      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, countFamilies),
-      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, getFamilyName))
-
-  JSI_HOST_FUNCTION(registerFont) {
-    sk_sp<SkTypeface> typeface =
-        JsiSkTypeface::fromValue(runtime, arguments[0]);
-    SkString familyName(arguments[1].asString(runtime).utf8(runtime).c_str());
+  static constexpr const char *CLASS_NAME = "TypefaceFontProvider";
+
+  void registerFont(sk_sp<SkTypeface> typeface, std::string familyNameStr) {
+    SkString familyName(familyNameStr.c_str());
     getObject()->registerTypeface(typeface, familyName);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(matchFamilyStyle) {
-    auto name = count > 0 ? arguments[0].asString(runtime).utf8(runtime) : "";
-    auto fontStyle =
-        count > 1 ? JsiSkFontStyle::fromValue(runtime, arguments[1]) : nullptr;
+  std::shared_ptr<JsiSkTypeface>
+  matchFamilyStyle(std::optional<std::string> nameParam,
+                   std::optional<std::shared_ptr<SkFontStyle>> fontStyleParam) {
+    auto name = nameParam.value_or("");
+    auto fontStyle = fontStyleParam.value_or(nullptr);
     if (name == "" || fontStyle == nullptr) {
       throw std::runtime_error("matchFamilyStyle requires a name and a style");
     }
@@ -59,31 +54,24 @@ public:
     if (!typeface) {
       throw std::runtime_error("Could not find font style for " + name);
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
   }
 
-  JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
+  int countFamilies() { return getObject()->countFamilies(); }
 
-  JSI_HOST_FUNCTION(getFamilyName) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  std::string getFamilyName(int i) {
     SkString name;
     getObject()->getFamilyName(i, &name);
-    return jsi::String::createFromUtf8(runtime, name.c_str());
+    return std::string(name.c_str());
   }
 
   JsiSkTypefaceFontProvider(std::shared_ptr<RNSkPlatformContext> context,
                             sk_sp<para::TypefaceFontProvider> tfProvider)
-      : JsiSkWrappingSkPtrHostObject(std::move(context),
-                                     std::move(tfProvider)) {}
-
-  size_t getMemoryPressure() const override { return 4096; }
+      : JsiSkWrappingSkPtrNativeObject<JsiSkTypefaceFontProvider,
+                                       para::TypefaceFontProvider>(
+            std::move(context), std::move(tfProvider)) {}
 
-  std::string getObjectType() const override {
-    return "JsiSkTypefaceFontProvider";
-  }
+  size_t getMemoryPressure() override { return 4096; }
 
   /**
    Returns the jsi object from a host object of this type
@@ -91,10 +79,26 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             sk_sp<para::TypefaceFontProvider> tfProvider) {
-    auto provider = std::make_shared<JsiSkTypefaceFontProvider>(
-        std::move(context), std::move(tfProvider));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, provider,
-                                                       context);
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkTypefaceFontProvider>(
+                             std::move(context), std::move(tfProvider)));
+  }
+
+  static sk_sp<para::TypefaceFontProvider> fromValue(jsi::Runtime &runtime,
+                                                     const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "registerFont",
+                  &JsiSkTypefaceFontProvider::registerFont);
+    installMethod(runtime, prototype, "matchFamilyStyle",
+                  &JsiSkTypefaceFontProvider::matchFamilyStyle);
+    installMethod(runtime, prototype, "countFamilies",
+                  &JsiSkTypefaceFontProvider::countFamilies);
+    installMethod(runtime, prototype, "getFamilyName",
+                  &JsiSkTypefaceFontProvider::getFamilyName);
   }
 };
 

package/cpp/api/JsiSkTypefaceFontProviderFactory.h

@@ -6,7 +6,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkTypefaceFontProvider.h"
 
 namespace RNSkia {
@@ -14,26 +14,27 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 namespace para = skia::textlayout;
 
-class JsiSkTypefaceFontProviderFactory : public JsiSkHostObject {
+class JsiSkTypefaceFontProviderFactory
+    : public JsiSkNativeObject<JsiSkTypefaceFontProviderFactory> {
 public:
-  JSI_HOST_FUNCTION(Make) {
-    auto provider = std::make_shared<JsiSkTypefaceFontProvider>(
+  static constexpr const char *CLASS_NAME = "TypefaceFontProviderFactory";
+
+  std::shared_ptr<JsiSkTypefaceFontProvider> Make() {
+    return std::make_shared<JsiSkTypefaceFontProvider>(
         getContext(), sk_make_sp<para::TypefaceFontProvider>());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, provider,
-                                                       getContext());
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFontProviderFactory, Make))
-
-  size_t getMemoryPressure() const override { return 2048; }
+  size_t getMemoryPressure() override { return 2048; }
 
-  std::string getObjectType() const override {
-    return "JsiSkTypefaceFontProviderFactory";
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installMethod(runtime, prototype, "Make",
+                  &JsiSkTypefaceFontProviderFactory::Make);
   }
 
   explicit JsiSkTypefaceFontProviderFactory(
       std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkTypefaceFontProviderFactory>(
+            std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkVertices.h

@@ -5,7 +5,8 @@
 #include <utility>
 #include <vector>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
+#include "JsiSkRect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -18,27 +19,24 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkVertices : public JsiSkWrappingSkPtrHostObject<SkVertices> {
+class JsiSkVertices
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkVertices, SkVertices> {
 public:
+  static constexpr const char *CLASS_NAME = "Vertices";
+
   JsiSkVertices(std::shared_ptr<RNSkPlatformContext> context,
                 sk_sp<SkVertices> vertices)
-      : JsiSkWrappingSkPtrHostObject<SkVertices>(std::move(context),
-                                                 std::move(vertices)) {}
-
-  EXPORT_JSI_API_TYPENAME(JsiSkVertices, Vertices)
+      : JsiSkWrappingSkPtrNativeObject<JsiSkVertices, SkVertices>(
+            std::move(context), std::move(vertices)) {}
 
-  JSI_HOST_FUNCTION(bounds) {
+  std::shared_ptr<JsiSkRect> bounds() {
     const auto &result = getObject()->bounds();
-    auto hostObjectInstance = std::make_shared<JsiSkRect>(getContext(), result);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkRect>(getContext(), result);
   }
 
-  JSI_HOST_FUNCTION(uniqueID) {
-    return static_cast<double>(getObject()->uniqueID());
-  }
+  double uniqueID() { return static_cast<double>(getObject()->uniqueID()); }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto vertices = getObject();
     if (!vertices)
       return 0;
@@ -47,11 +45,16 @@ public:
     return vertices->approximateSize();
   }
 
-  std::string getObjectType() const override { return "JsiSkVertices"; }
+  static sk_sp<SkVertices> fromValue(jsi::Runtime &runtime,
+                                     const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkVertices, bounds),
-                       JSI_EXPORT_FUNC(JsiSkVertices, uniqueID),
-                       JSI_EXPORT_FUNC(JsiSkVertices, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "bounds", &JsiSkVertices::bounds);
+    installMethod(runtime, prototype, "uniqueID", &JsiSkVertices::uniqueID);
+  }
 
   /**
    * Creates the function for construction a new instance of the SkVertices
@@ -158,10 +161,8 @@ public:
                                texs.size() > 0 ? texs.data() : nullptr,
                                colors.size() > 0 ? colors.data() : nullptr,
                                indicesSize, indices.data());
-      auto hostObjectInstance =
-          std::make_shared<JsiSkVertices>(context, std::move(vertices));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, context);
+      return makeJsiObject(runtime, std::make_shared<JsiSkVertices>(
+                                        context, std::move(vertices)));
     };
   }
 };

package/cpp/api/JsiSkiaContext.h

@@ -3,15 +3,18 @@
 #include <memory>
 #include <numeric>
 #include <utility>
+#include <variant>
 #include <vector>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkConverters.h"
+#include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
 #include "JsiSkPaint.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRect.h"
+#include "JsiSkSurface.h"
 #include "JsiSkTypeface.h"
 
 #include "rnskia/RNWindowContext.h"
@@ -28,36 +31,34 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkiaContext : public JsiSkWrappingSharedPtrHostObject<WindowContext> {
+class JsiSkiaContext
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkiaContext, WindowContext> {
 public:
-  EXPORT_JSI_API_TYPENAME(JsiSkiaContext, SkiaContext)
+  static constexpr const char *CLASS_NAME = "SkiaContext";
 
-  JSI_HOST_FUNCTION(getSurface) {
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkSurface>> getSurface() {
     auto surface = getObject()->getSurface();
     if (surface == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
   }
 
-  JSI_HOST_FUNCTION(present) {
-    getObject()->present();
-    return jsi::Value::undefined();
-  }
+  void present() { getObject()->present(); }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkiaContext, getSurface),
-                       JSI_EXPORT_FUNC(JsiSkiaContext, present))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "getSurface",
+                  &JsiSkiaContext::getSurface);
+    installMethod(runtime, prototype, "present", &JsiSkiaContext::present);
+  }
 
   JsiSkiaContext(std::shared_ptr<RNSkPlatformContext> context,
                  std::shared_ptr<WindowContext> ctx)
-      : JsiSkWrappingSharedPtrHostObject(std::move(context), std::move(ctx)) {}
-
-  size_t getMemoryPressure() const override { return 10 * 1024 * 1024; }
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkiaContext, WindowContext>(
+            std::move(context), std::move(ctx)) {}
 
-  std::string getObjectType() const override { return "JsiSkiaContext"; }
+  size_t getMemoryPressure() override { return 10 * 1024 * 1024; }
 
   /**
    * Creates the function for construction a new instance of the SkFont
@@ -84,10 +85,8 @@ public:
             "Couldn't create a Skia context from the native surface");
       }
       // Return the newly constructed object
-      auto hostObjectInstance =
-          std::make_shared<JsiSkiaContext>(context, std::move(result));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, context);
+      return makeJsiObject(runtime, std::make_shared<JsiSkiaContext>(
+                                        context, std::move(result)));
     };
   }
 };