@shopify/react-native-skia 2.9.1-next.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/JsiSkTextStyle.h

@@ -26,6 +26,16 @@ namespace para = skia::textlayout;
  */
 class JsiSkTextStyle {
 public:
+  // A property set to undefined or null is treated as absent, like on web.
+  static bool hasValue(jsi::Runtime &runtime, const jsi::Object &object,
+                       const char *name) {
+    if (!object.hasProperty(runtime, name)) {
+      return false;
+    }
+    auto propValue = object.getProperty(runtime, name);
+    return !propValue.isUndefined() && !propValue.isNull();
+  }
+
   static para::TextStyle fromValue(jsi::Runtime &runtime,
                                    const jsi::Value &value) {
 
@@ -43,35 +53,35 @@ public:
 
     auto object = value.asObject(runtime);
 
-    if (object.hasProperty(runtime, "backgroundColor")) {
+    if (hasValue(runtime, object, "backgroundColor")) {
       auto propValue = object.getProperty(runtime, "backgroundColor");
       SkPaint p;
       p.setColor(JsiSkColor::fromValue(runtime, propValue));
       retVal.setBackgroundPaint(p);
     }
-    if (object.hasProperty(runtime, "color")) {
+    if (hasValue(runtime, object, "color")) {
       auto propValue = object.getProperty(runtime, "color");
       retVal.setColor(JsiSkColor::fromValue(runtime, propValue));
     }
-    if (object.hasProperty(runtime, "decoration")) {
+    if (hasValue(runtime, object, "decoration")) {
       auto propValue = object.getProperty(runtime, "decoration");
       retVal.setDecoration(
           static_cast<para::TextDecoration>(propValue.asNumber()));
     }
-    if (object.hasProperty(runtime, "decorationColor")) {
+    if (hasValue(runtime, object, "decorationColor")) {
       auto propValue = object.getProperty(runtime, "decorationColor");
       retVal.setDecorationColor(JsiSkColor::fromValue(runtime, propValue));
     }
-    if (object.hasProperty(runtime, "decorationThickness")) {
+    if (hasValue(runtime, object, "decorationThickness")) {
       auto propValue = object.getProperty(runtime, "decorationThickness");
       retVal.setDecorationThicknessMultiplier(propValue.asNumber());
     }
-    if (object.hasProperty(runtime, "decorationStyle")) {
+    if (hasValue(runtime, object, "decorationStyle")) {
       auto propValue = object.getProperty(runtime, "decorationStyle");
       retVal.setDecorationStyle(
           static_cast<para::TextDecorationStyle>(propValue.asNumber()));
     }
-    if (object.hasProperty(runtime, "fontFamilies")) {
+    if (hasValue(runtime, object, "fontFamilies")) {
       auto propValue = object.getProperty(runtime, "fontFamilies")
                            .asObject(runtime)
                            .asArray(runtime);
@@ -85,7 +95,7 @@ public:
       }
       retVal.setFontFamilies(families);
     }
-    if (object.hasProperty(runtime, "fontFeatures")) {
+    if (hasValue(runtime, object, "fontFeatures")) {
       auto propValue = object.getProperty(runtime, "fontFeatures")
                            .asObject(runtime)
                            .asArray(runtime);
@@ -100,58 +110,58 @@ public:
         retVal.addFontFeature(SkString(name), value);
       }
     }
-    if (object.hasProperty(runtime, "fontSize")) {
+    if (hasValue(runtime, object, "fontSize")) {
       auto propValue = object.getProperty(runtime, "fontSize");
       retVal.setFontSize(propValue.asNumber());
     }
-    if (object.hasProperty(runtime, "fontStyle")) {
+    if (hasValue(runtime, object, "fontStyle")) {
       auto propValue =
           object.getProperty(runtime, "fontStyle").asObject(runtime);
       auto weight = static_cast<SkFontStyle::Weight>(
-          propValue.hasProperty(runtime, "weight")
+          hasValue(runtime, propValue, "weight")
               ? propValue.getProperty(runtime, "weight").asNumber()
               : static_cast<double>(SkFontStyle::Weight::kNormal_Weight));
 
       auto width = static_cast<SkFontStyle::Width>(
-          propValue.hasProperty(runtime, "width")
+          hasValue(runtime, propValue, "width")
               ? propValue.getProperty(runtime, "width").asNumber()
               : static_cast<double>(SkFontStyle::Width::kNormal_Width));
 
       auto slant = static_cast<SkFontStyle::Slant>(
-          propValue.hasProperty(runtime, "slant")
+          hasValue(runtime, propValue, "slant")
               ? propValue.getProperty(runtime, "slant").asNumber()
               : static_cast<double>(SkFontStyle::Slant::kUpright_Slant));
 
       retVal.setFontStyle(SkFontStyle(weight, width, slant));
     }
-    if (object.hasProperty(runtime, "foregroundColor")) {
+    if (hasValue(runtime, object, "foregroundColor")) {
       auto propValue = object.getProperty(runtime, "foregroundColor");
       SkPaint p;
       p.setColor(JsiSkColor::fromValue(runtime, propValue));
       retVal.setForegroundColor(p);
     }
-    if (object.hasProperty(runtime, "heightMultiplier")) {
+    if (hasValue(runtime, object, "heightMultiplier")) {
       auto propValue = object.getProperty(runtime, "heightMultiplier");
       retVal.setHeight(propValue.asNumber());
       retVal.setHeightOverride(true);
     }
-    if (object.hasProperty(runtime, "halfLeading")) {
+    if (hasValue(runtime, object, "halfLeading")) {
       auto propValue = object.getProperty(runtime, "halfLeading");
       retVal.setHalfLeading(propValue.getBool());
     }
-    if (object.hasProperty(runtime, "letterSpacing")) {
+    if (hasValue(runtime, object, "letterSpacing")) {
       auto propValue = object.getProperty(runtime, "letterSpacing");
       retVal.setLetterSpacing(propValue.asNumber());
     }
-    if (object.hasProperty(runtime, "wordSpacing")) {
+    if (hasValue(runtime, object, "wordSpacing")) {
       auto propValue = object.getProperty(runtime, "wordSpacing");
       retVal.setWordSpacing(propValue.asNumber());
     }
-    if (object.hasProperty(runtime, "locale")) {
+    if (hasValue(runtime, object, "locale")) {
       auto propValue = object.getProperty(runtime, "locale");
       retVal.setLocale(SkString(propValue.asString(runtime).utf8(runtime)));
     }
-    if (object.hasProperty(runtime, "shadows")) {
+    if (hasValue(runtime, object, "shadows")) {
       auto propValue = object.getProperty(runtime, "shadows")
                            .asObject(runtime)
                            .asArray(runtime);
@@ -159,24 +169,24 @@ public:
       retVal.resetShadows();
       for (size_t i = 0; i < size; ++i) {
         auto element = propValue.getValueAtIndex(runtime, i).asObject(runtime);
-        auto color = element.hasProperty(runtime, "color")
+        auto color = hasValue(runtime, element, "color")
                          ? JsiSkColor::fromValue(
                                runtime, element.getProperty(runtime, "color"))
                          : SK_ColorBLACK;
         SkPoint offset =
-            element.hasProperty(runtime, "offset")
+            hasValue(runtime, element, "offset")
                 ? *JsiSkPoint::fromValue(runtime,
                                          element.getProperty(runtime, "offset"))
                        .get()
                 : SkPoint::Make(0, 0);
         auto blurSigma =
-            element.hasProperty(runtime, "blurRadius")
+            hasValue(runtime, element, "blurRadius")
                 ? element.getProperty(runtime, "blurRadius").asNumber()
                 : 0;
         retVal.addShadow(para::TextShadow(color, offset, blurSigma));
       }
     }
-    if (object.hasProperty(runtime, "textBaseline")) {
+    if (hasValue(runtime, object, "textBaseline")) {
       auto propValue = object.getProperty(runtime, "textBaseline");
       retVal.setTextBaseline(
           static_cast<para::TextBaseline>(propValue.asNumber()));

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