@shopify/react-native-skia 2.9.1 → 2.10.0

package/cpp/api/JsiSkSurface.h

@@ -8,7 +8,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkDispatcher.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiTextureInfo.h"
 
 #include "JsiSkCanvas.h"
@@ -30,15 +30,18 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkSurface : public JsiSkWrappingSkPtrHostObject<SkSurface> {
+class JsiSkSurface
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkSurface, SkSurface> {
 private:
   std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
+  static constexpr const char *CLASS_NAME = "Surface";
+
   JsiSkSurface(std::shared_ptr<RNSkPlatformContext> context,
                sk_sp<SkSurface> surface)
-      : JsiSkWrappingSkPtrHostObject<SkSurface>(std::move(context),
-                                                std::move(surface)) {
+      : JsiSkWrappingSkPtrNativeObject<JsiSkSurface, SkSurface>(
+            std::move(context), std::move(surface)) {
     // Get the dispatcher for the current thread
     _dispatcher = Dispatcher::getDispatcher();
     // Process any pending operations
@@ -63,8 +66,6 @@ public:
     }
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkSurface, Surface)
-
   // TODO-API: Properties?
   JSI_HOST_FUNCTION(width) { return static_cast<double>(getObject()->width()); }
   JSI_HOST_FUNCTION(height) {
@@ -78,8 +79,7 @@ public:
     // Keep a reference to the owning surface so the canvas can read pixels back
     // through a snapshot on Graphite (which lacks synchronous canvas readback).
     canvas->setSurface(surface);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, canvas,
-                                                       getContext());
+    return makeJsiObject(runtime, std::move(canvas));
   }
 
   JSI_HOST_FUNCTION(flush) {
@@ -124,15 +124,12 @@ public:
     }
 #endif
     if (count > 1 && arguments[1].isObject()) {
-      auto jsiImage =
-          arguments[1].asObject(runtime).asHostObject<JsiSkImage>(runtime);
+      auto jsiImage = getJsiObject<JsiSkImage>(runtime, arguments[1]);
       jsiImage->setObject(image);
       return jsi::Value(runtime, arguments[1]);
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }
 
   JSI_HOST_FUNCTION(getNativeTextureUnstable) {
@@ -140,7 +137,7 @@ public:
     return JsiTextureInfo::toValue(runtime, texInfo);
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     if (isDisposed()) {
       return 0;
     }
@@ -196,15 +193,18 @@ public:
     return estimated;
   }
 
-  std::string getObjectType() const override { return "JsiSkSurface"; }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurface, width),
-                       JSI_EXPORT_FUNC(JsiSkSurface, height),
-                       JSI_EXPORT_FUNC(JsiSkSurface, getCanvas),
-                       JSI_EXPORT_FUNC(JsiSkSurface, makeImageSnapshot),
-                       JSI_EXPORT_FUNC(JsiSkSurface, flush),
-                       JSI_EXPORT_FUNC(JsiSkSurface, getNativeTextureUnstable),
-                       JSI_EXPORT_FUNC(JsiSkSurface, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "width", &JsiSkSurface::width);
+    installHostMethod(runtime, prototype, "height", &JsiSkSurface::height);
+    installHostMethod(runtime, prototype, "getCanvas",
+                      &JsiSkSurface::getCanvas);
+    installHostMethod(runtime, prototype, "makeImageSnapshot",
+                      &JsiSkSurface::makeImageSnapshot);
+    installHostMethod(runtime, prototype, "flush", &JsiSkSurface::flush);
+    installHostMethod(runtime, prototype, "getNativeTextureUnstable",
+                      &JsiSkSurface::getNativeTextureUnstable);
+  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkSurfaceFactory.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #include "JsiSkSurface.h"
 
@@ -20,8 +20,10 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkSurfaceFactory : public JsiSkHostObject {
+class JsiSkSurfaceFactory : public JsiSkNativeObject<JsiSkSurfaceFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "SurfaceFactory";
+
   JSI_HOST_FUNCTION(Make) {
     auto width = static_cast<int>(arguments[0].asNumber());
     auto height = static_cast<int>(arguments[1].asNumber());
@@ -30,10 +32,8 @@ public:
     if (surface == nullptr) {
       return jsi::Value::null();
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkSurface>(
+                                      getContext(), std::move(surface)));
   }
 
   JSI_HOST_FUNCTION(MakeOffscreen) {
@@ -56,21 +56,20 @@ public:
     if (surface == nullptr) {
       return jsi::Value::null();
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkSurface>(
+                                      getContext(), std::move(surface)));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurfaceFactory, Make),
-                       JSI_EXPORT_FUNC(JsiSkSurfaceFactory, MakeOffscreen))
-
-  size_t getMemoryPressure() const override { return 2048; }
+  size_t getMemoryPressure() override { return 2048; }
 
-  std::string getObjectType() const override { return "JsiSkSurfaceFactory"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "Make", &JsiSkSurfaceFactory::Make);
+    installHostMethod(runtime, prototype, "MakeOffscreen",
+                      &JsiSkSurfaceFactory::MakeOffscreen);
+  }
 
   explicit JsiSkSurfaceFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkSurfaceFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkTextBlob.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -18,14 +18,17 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkTextBlob : public JsiSkWrappingSkPtrHostObject<SkTextBlob> {
+class JsiSkTextBlob
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkTextBlob, SkTextBlob> {
 public:
+  static constexpr const char *CLASS_NAME = "TextBlob";
+
   JsiSkTextBlob(std::shared_ptr<RNSkPlatformContext> context,
                 sk_sp<SkTextBlob> shader)
-      : JsiSkWrappingSkPtrHostObject<SkTextBlob>(std::move(context),
-                                                 std::move(shader)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkTextBlob, SkTextBlob>(
+            std::move(context), std::move(shader)) {}
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto textBlob = getObject();
     if (!textBlob)
       return 0;
@@ -37,9 +40,13 @@ public:
            1024; // Area estimation + base overhead
   }
 
-  std::string getObjectType() const override { return "JsiSkTextBlob"; }
+  static sk_sp<SkTextBlob> fromValue(jsi::Runtime &runtime,
+                                     const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkTextBlob, TextBlob)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTextBlob, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkTextBlobFactory.h

@@ -7,7 +7,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkFont.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkRSXform.h"
 #include "JsiSkTextBlob.h"
 
@@ -22,16 +22,16 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkTextBlobFactory : public JsiSkHostObject {
+class JsiSkTextBlobFactory : public JsiSkNativeObject<JsiSkTextBlobFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "TextBlobFactory";
+
   JSI_HOST_FUNCTION(MakeFromText) {
     auto str = arguments[0].asString(runtime).utf8(runtime);
     auto font = JsiSkFont::fromValue(runtime, arguments[1]);
     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 makeJsiObject(runtime, std::make_shared<JsiSkTextBlob>(
+                                      getContext(), std::move(textBlob)));
   }
 
   JSI_HOST_FUNCTION(MakeFromGlyphs) {
@@ -47,10 +47,8 @@ public:
     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 makeJsiObject(runtime, std::make_shared<JsiSkTextBlob>(
+                                      getContext(), std::move(textBlob)));
   }
 
   JSI_HOST_FUNCTION(MakeFromRSXform) {
@@ -68,10 +66,8 @@ public:
     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 makeJsiObject(runtime, std::make_shared<JsiSkTextBlob>(
+                                      getContext(), std::move(textBlob)));
   }
 
   JSI_HOST_FUNCTION(MakeFromRSXformGlyphs) {
@@ -97,24 +93,25 @@ public:
     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 makeJsiObject(runtime, 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) {
+    installHostMethod(runtime, prototype, "MakeFromText",
+                      &JsiSkTextBlobFactory::MakeFromText);
+    installHostMethod(runtime, prototype, "MakeFromGlyphs",
+                      &JsiSkTextBlobFactory::MakeFromGlyphs);
+    installHostMethod(runtime, prototype, "MakeFromRSXform",
+                      &JsiSkTextBlobFactory::MakeFromRSXform);
+    installHostMethod(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

@@ -6,7 +6,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 
 #pragma clang diagnostic push
@@ -22,15 +22,15 @@ 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);
@@ -53,7 +53,7 @@ public:
     return jsiGlyphIDs;
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto typeface = getObject();
     if (!typeface) {
       return 0;
@@ -74,13 +74,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)));
   }
 
-  std::string getObjectType() const override { return "JsiSkTypeface"; }
+  static sk_sp<SkTypeface> fromValue(jsi::Runtime &runtime,
+                                     const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "getGlyphIDs",
+                      &JsiSkTypeface::getGlyphIDs);
+  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkTypefaceFactory.h

@@ -6,15 +6,17 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkTypeface.h"
 
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkTypefaceFactory : public JsiSkHostObject {
+class JsiSkTypefaceFactory : public JsiSkNativeObject<JsiSkTypefaceFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "TypefaceFactory";
+
   JSI_HOST_FUNCTION(MakeFreeTypeFaceFromData) {
     auto data = JsiSkData::fromValue(runtime, arguments[0]);
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
@@ -22,21 +24,19 @@ public:
     if (typeface == nullptr) {
       return jsi::Value::null();
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, 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) {
+    installHostMethod(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

@@ -6,7 +6,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkFontStyle.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkTypeface.h"
 
 #include "utils/RNSkLog.h"
@@ -25,16 +25,10 @@ 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))
+  static constexpr const char *CLASS_NAME = "TypefaceFontProvider";
 
   JSI_HOST_FUNCTION(registerFont) {
     sk_sp<SkTypeface> typeface =
@@ -59,10 +53,8 @@ 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 makeJsiObject(runtime, std::make_shared<JsiSkTypeface>(
+                                      getContext(), std::move(typeface)));
   }
 
   JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
@@ -76,14 +68,11 @@ public:
 
   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 +80,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);
+    installHostMethod(runtime, prototype, "registerFont",
+                      &JsiSkTypefaceFontProvider::registerFont);
+    installHostMethod(runtime, prototype, "matchFamilyStyle",
+                      &JsiSkTypefaceFontProvider::matchFamilyStyle);
+    installHostMethod(runtime, prototype, "countFamilies",
+                      &JsiSkTypefaceFontProvider::countFamilies);
+    installHostMethod(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,28 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 namespace para = skia::textlayout;
 
-class JsiSkTypefaceFontProviderFactory : public JsiSkHostObject {
+class JsiSkTypefaceFontProviderFactory
+    : public JsiSkNativeObject<JsiSkTypefaceFontProviderFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "TypefaceFontProviderFactory";
+
   JSI_HOST_FUNCTION(Make) {
-    auto provider = std::make_shared<JsiSkTypefaceFontProvider>(
-        getContext(), sk_make_sp<para::TypefaceFontProvider>());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, provider,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
+                     getContext(), sk_make_sp<para::TypefaceFontProvider>()));
   }
 
-  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) {
+    installHostMethod(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,7 @@
 #include <utility>
 #include <vector>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -18,27 +18,27 @@ 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) {
     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 makeJsiObject(runtime,
+                         std::make_shared<JsiSkRect>(getContext(), result));
   }
 
   JSI_HOST_FUNCTION(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 +47,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);
+    installHostMethod(runtime, prototype, "bounds", &JsiSkVertices::bounds);
+    installHostMethod(runtime, prototype, "uniqueID", &JsiSkVertices::uniqueID);
+  }
 
   /**
    * Creates the function for construction a new instance of the SkVertices
@@ -158,10 +163,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)));
     };
   }
 };