@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkFont.h

@@ -2,13 +2,17 @@
 
 #include <memory>
 #include <numeric>
+#include <optional>
+#include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkPaint.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRect.h"
@@ -26,41 +30,30 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFont : public JsiSkWrappingSharedPtrHostObject<SkFont> {
+class JsiSkFont : public JsiSkWrappingSharedPtrNativeObject<JsiSkFont, SkFont> {
 public:
-  JSI_HOST_FUNCTION(getGlyphWidths) {
-    auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
-    std::vector<SkGlyphID> glyphs;
-    int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
-
-    std::vector<SkScalar> widthPtrs;
-    widthPtrs.resize(glyphsSize);
-
-    glyphs.reserve(glyphsSize);
-    for (int i = 0; i < glyphsSize; i++) {
-      glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
+  static constexpr const char *CLASS_NAME = "Font";
+
+  std::vector<double>
+  getGlyphWidths(std::vector<int> glyphs,
+                 std::optional<std::shared_ptr<SkPaint>> paint) {
+    std::vector<SkGlyphID> glyphIds;
+    glyphIds.reserve(glyphs.size());
+    for (auto glyph : glyphs) {
+      glyphIds.push_back(static_cast<SkGlyphID>(glyph));
     }
-    auto widths = SkSpan(static_cast<SkScalar *>(widthPtrs.data()), glyphsSize);
-    auto g = SkSpan(glyphs.data(), glyphs.size());
-    if (count > 1) {
-      auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-      getObject()->getWidthsBounds(g, widths, {}, paint.get());
-    } else {
-      getObject()->getWidthsBounds(g, widths, {}, nullptr);
-    }
-    auto jsiWidths = jsi::Array(runtime, glyphsSize);
-    for (int i = 0; i < glyphsSize; i++) {
-      jsiWidths.setValueAtIndex(
-          runtime, i,
-          jsi::Value(
-              SkScalarToDouble(static_cast<SkScalar *>(widthPtrs.data())[i])));
-    }
-    return jsiWidths;
+    std::vector<SkScalar> widths;
+    widths.resize(glyphIds.size());
+    auto g = SkSpan(glyphIds.data(), glyphIds.size());
+    auto w = SkSpan(widths.data(), widths.size());
+    getObject()->getWidthsBounds(
+        g, w, {}, paint.has_value() ? paint.value().get() : nullptr);
+    return std::vector<double>(widths.begin(), widths.end());
   }
 
   // TODO: deprecate
-  JSI_HOST_FUNCTION(getTextWidth) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
+  int getTextWidth(std::string str,
+                   std::optional<std::shared_ptr<SkPaint>> paint) {
     auto numGlyphIDs = getObject()->countText(str.c_str(), str.length(),
                                               SkTextEncoding::kUTF8);
     std::vector<SkGlyphID> glyphs;
@@ -68,34 +61,25 @@ public:
     auto g = SkSpan(glyphs.data(), glyphs.size());
     getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
                               g);
-    std::vector<SkScalar> widthPtrs;
-    widthPtrs.resize(numGlyphIDs);
-    auto widths = SkSpan(widthPtrs.data(), widthPtrs.size());
-    if (count > 1) {
-      auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-      getObject()->getWidthsBounds(g, widths, {}, paint.get());
-    } else {
-      getObject()->getWidthsBounds(g, widths, {}, nullptr);
-    }
-    return jsi::Value(std::accumulate(widthPtrs.begin(), widthPtrs.end(), 0));
+    std::vector<SkScalar> widths;
+    widths.resize(numGlyphIDs);
+    auto w = SkSpan(widths.data(), widths.size());
+    getObject()->getWidthsBounds(
+        g, w, {}, paint.has_value() ? paint.value().get() : nullptr);
+    return std::accumulate(widths.begin(), widths.end(), 0);
   }
 
-  JSI_HOST_FUNCTION(measureText) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
+  std::shared_ptr<JsiSkRect>
+  measureText(std::string str, std::optional<std::shared_ptr<SkPaint>> paint) {
     SkRect bounds;
-    if (count > 1) {
-      auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-      getObject()->measureText(str.c_str(), str.length(), SkTextEncoding::kUTF8,
-                               &bounds, paint.get());
-    } else {
-      getObject()->measureText(str.c_str(), str.length(), SkTextEncoding::kUTF8,
-                               &bounds);
-    }
-    auto rect = std::make_shared<JsiSkRect>(getContext(), std::move(bounds));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rect,
-                                                       getContext());
+    getObject()->measureText(str.c_str(), str.length(), SkTextEncoding::kUTF8,
+                             &bounds,
+                             paint.has_value() ? paint.value().get() : nullptr);
+    return std::make_shared<JsiSkRect>(getContext(), bounds);
   }
 
+  // Stays raw: the result object has a conditionally present `bounds`
+  // property, which a typed return value cannot express.
   JSI_HOST_FUNCTION(getMetrics) {
     SkFontMetrics fm;
     getObject()->getMetrics(&fm);
@@ -112,178 +96,131 @@ public:
     return metrics;
   }
 
-  JSI_HOST_FUNCTION(getGlyphIDs) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
-    int numGlyphIDs =
-        count > 1 && !arguments[1].isNull() && !arguments[1].isUndefined()
-            ? static_cast<int>(arguments[1].asNumber())
-            : getObject()->countText(str.c_str(), str.length(),
-                                     SkTextEncoding::kUTF8);
+  std::vector<int> getGlyphIDs(std::string str, JsiOptional<int> numGlyphs) {
+    int numGlyphIDs = numGlyphs.has_value()
+                          ? *numGlyphs
+                          : getObject()->countText(str.c_str(), str.length(),
+                                                   SkTextEncoding::kUTF8);
     std::vector<SkGlyphID> glyphIDs;
     glyphIDs.resize(numGlyphIDs);
     auto g = SkSpan(static_cast<SkGlyphID *>(glyphIDs.data()), glyphIDs.size());
     getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
                               g);
-    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());
   }
 
-  JSI_HOST_FUNCTION(getGlyphIntercepts) {
-    auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
-    auto jsiPositions = arguments[1].asObject(runtime).asArray(runtime);
-    auto top = arguments[2].asNumber();
-    auto bottom = arguments[3].asNumber();
-    std::vector<SkPoint> positions;
-    int pointsSize = static_cast<int>(jsiPositions.size(runtime));
-    positions.reserve(pointsSize);
-    for (int i = 0; i < pointsSize; i++) {
-      std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
-          runtime, jsiPositions.getValueAtIndex(runtime, i).asObject(runtime));
-      positions.push_back(*point.get());
-    }
-
-    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<int> getGlyphIntercepts(std::vector<int> glyphs,
+                                      std::vector<SkPoint> positions,
+                                      double top, double bottom) {
+    std::vector<SkGlyphID> glyphIds;
+    glyphIds.reserve(glyphs.size());
+    for (auto glyph : glyphs) {
+      glyphIds.push_back(static_cast<SkGlyphID>(glyph));
     }
-
-    if (glyphs.size() > positions.size()) {
-      throw jsi::JSError(runtime, "Not enough x,y position pairs for glyphs");
-      return jsi::Value::null();
+    if (glyphIds.size() > positions.size()) {
+      throw std::runtime_error("Not enough x,y position pairs for glyphs");
     }
-    auto g = SkSpan(glyphs.data(), glyphs.size());
+    auto g = SkSpan(glyphIds.data(), glyphIds.size());
     auto p = SkSpan(positions.data(), positions.size());
     auto sects = getObject()->getIntercepts(g, p, top, bottom);
-    auto jsiSects = jsi::Array(runtime, sects.size());
-    for (int i = 0; i < sects.size(); i++) {
-      jsiSects.setValueAtIndex(runtime, i,
-                               jsi::Value(static_cast<int>(sects.at(i))));
-    }
-    return jsiSects;
+    return std::vector<int>(sects.begin(), sects.end());
   }
 
-  JSI_HOST_FUNCTION(getScaleX) {
-    return jsi::Value(SkScalarToDouble(getObject()->getScaleX()));
-  }
+  double getScaleX() { return SkScalarToDouble(getObject()->getScaleX()); }
 
-  JSI_HOST_FUNCTION(getSize) {
-    return jsi::Value(SkScalarToDouble(getObject()->getSize()));
-  }
+  double getSize() { return SkScalarToDouble(getObject()->getSize()); }
 
-  JSI_HOST_FUNCTION(getSkewX) {
-    return jsi::Value(SkScalarToDouble(getObject()->getSkewX()));
-  }
+  double getSkewX() { return SkScalarToDouble(getObject()->getSkewX()); }
 
-  JSI_HOST_FUNCTION(isEmbolden) {
-    return jsi::Value(getObject()->isEmbolden());
-  }
+  bool isEmbolden() { return getObject()->isEmbolden(); }
 
-  JSI_HOST_FUNCTION(getTypeface) {
-    return JsiSkTypeface::toValue(
-        runtime, getContext(), sk_sp<SkTypeface>(getObject()->getTypeface()));
+  std::shared_ptr<JsiSkTypeface> getTypeface() {
+    return std::make_shared<JsiSkTypeface>(
+        getContext(), sk_sp<SkTypeface>(getObject()->getTypeface()));
   }
 
-  JSI_HOST_FUNCTION(setEdging) {
-    auto edging = arguments[0].asNumber();
+  void setEdging(double edging) {
     getObject()->setEdging(static_cast<SkFont::Edging>(edging));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(embeddedBitmaps) {
-    auto embeddedBitmaps = arguments[0].getBool();
+  void setEmbeddedBitmaps(bool embeddedBitmaps) {
     getObject()->setEmbeddedBitmaps(embeddedBitmaps);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setHinting) {
-    auto hinting = arguments[0].asNumber();
+  void setHinting(double hinting) {
     getObject()->setHinting(static_cast<SkFontHinting>(hinting));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setLinearMetrics) {
-    auto linearMetrics = arguments[0].getBool();
+  void setLinearMetrics(bool linearMetrics) {
     getObject()->setLinearMetrics(linearMetrics);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setScaleX) {
-    auto scaleX = arguments[0].asNumber();
-    getObject()->setScaleX(scaleX);
-    return jsi::Value::undefined();
-  }
+  void setScaleX(double scaleX) { getObject()->setScaleX(scaleX); }
 
-  JSI_HOST_FUNCTION(setSkewX) {
-    auto skewX = arguments[0].asNumber();
-    getObject()->setSkewX(skewX);
-    return jsi::Value::undefined();
-  }
+  void setSkewX(double skewX) { getObject()->setSkewX(skewX); }
 
-  JSI_HOST_FUNCTION(setSize) {
-    auto size = arguments[0].asNumber();
-    getObject()->setSize(size);
-    return jsi::Value::undefined();
-  }
+  void setSize(double size) { getObject()->setSize(size); }
 
-  JSI_HOST_FUNCTION(setEmbolden) {
-    auto embolden = arguments[0].asNumber();
-    getObject()->setEmbolden(embolden);
-    return jsi::Value::undefined();
+  // The JS API declares booleans here, but the previous implementation read
+  // the arguments with asNumber() — keep accepting numbers.
+  void setEmbolden(double embolden) {
+    getObject()->setEmbolden(static_cast<bool>(embolden));
   }
 
-  JSI_HOST_FUNCTION(setSubpixel) {
-    auto subpixel = arguments[0].asNumber();
-    getObject()->setSubpixel(subpixel);
-    return jsi::Value::undefined();
+  void setSubpixel(double subpixel) {
+    getObject()->setSubpixel(static_cast<bool>(subpixel));
   }
 
-  JSI_HOST_FUNCTION(setTypeface) {
-    auto typeface = arguments[0].isNull()
-                        ? nullptr
-                        : JsiSkTypeface::fromValue(runtime, arguments[0]);
-    getObject()->setTypeface(typeface);
-    return jsi::Value::undefined();
+  void setTypeface(std::variant<std::nullptr_t, sk_sp<SkTypeface>> typeface) {
+    getObject()->setTypeface(
+        std::holds_alternative<std::nullptr_t>(typeface)
+            ? nullptr
+            : std::get<sk_sp<SkTypeface>>(std::move(typeface)));
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkFont, Font)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFont, getSize),
-                       JSI_EXPORT_FUNC(JsiSkFont, getMetrics),
-                       JSI_EXPORT_FUNC(JsiSkFont, getGlyphIDs),
-                       JSI_EXPORT_FUNC(JsiSkFont, getGlyphIntercepts),
-                       JSI_EXPORT_FUNC(JsiSkFont, getScaleX),
-                       JSI_EXPORT_FUNC(JsiSkFont, getSkewX),
-                       JSI_EXPORT_FUNC(JsiSkFont, getTypeface),
-                       JSI_EXPORT_FUNC(JsiSkFont, setEdging),
-                       JSI_EXPORT_FUNC(JsiSkFont, embeddedBitmaps),
-                       JSI_EXPORT_FUNC(JsiSkFont, setHinting),
-                       JSI_EXPORT_FUNC(JsiSkFont, setLinearMetrics),
-                       JSI_EXPORT_FUNC(JsiSkFont, setScaleX),
-                       JSI_EXPORT_FUNC(JsiSkFont, setSkewX),
-                       JSI_EXPORT_FUNC(JsiSkFont, setSize),
-                       JSI_EXPORT_FUNC(JsiSkFont, setEmbolden),
-                       JSI_EXPORT_FUNC(JsiSkFont, setSubpixel),
-                       JSI_EXPORT_FUNC(JsiSkFont, setTypeface),
-                       JSI_EXPORT_FUNC(JsiSkFont, getGlyphWidths),
-                       JSI_EXPORT_FUNC(JsiSkFont, getTextWidth),
-                       JSI_EXPORT_FUNC(JsiSkFont, measureText),
-                       JSI_EXPORT_FUNC(JsiSkFont, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "getSize", &JsiSkFont::getSize);
+    installHostMethod(runtime, prototype, "getMetrics", &JsiSkFont::getMetrics);
+    installMethod(runtime, prototype, "getGlyphIDs", &JsiSkFont::getGlyphIDs);
+    installMethod(runtime, prototype, "getGlyphIntercepts",
+                  &JsiSkFont::getGlyphIntercepts);
+    installMethod(runtime, prototype, "getScaleX", &JsiSkFont::getScaleX);
+    installMethod(runtime, prototype, "getSkewX", &JsiSkFont::getSkewX);
+    installMethod(runtime, prototype, "getTypeface", &JsiSkFont::getTypeface);
+    installMethod(runtime, prototype, "setEdging", &JsiSkFont::setEdging);
+    installMethod(runtime, prototype, "embeddedBitmaps",
+                  &JsiSkFont::setEmbeddedBitmaps);
+    installMethod(runtime, prototype, "setHinting", &JsiSkFont::setHinting);
+    installMethod(runtime, prototype, "setLinearMetrics",
+                  &JsiSkFont::setLinearMetrics);
+    installMethod(runtime, prototype, "setScaleX", &JsiSkFont::setScaleX);
+    installMethod(runtime, prototype, "setSkewX", &JsiSkFont::setSkewX);
+    installMethod(runtime, prototype, "setSize", &JsiSkFont::setSize);
+    installMethod(runtime, prototype, "setEmbolden", &JsiSkFont::setEmbolden);
+    installMethod(runtime, prototype, "setSubpixel", &JsiSkFont::setSubpixel);
+    installMethod(runtime, prototype, "setTypeface", &JsiSkFont::setTypeface);
+    installMethod(runtime, prototype, "getGlyphWidths",
+                  &JsiSkFont::getGlyphWidths);
+    installMethod(runtime, prototype, "getTextWidth", &JsiSkFont::getTextWidth);
+    installMethod(runtime, prototype, "measureText", &JsiSkFont::measureText);
+  }
 
   JsiSkFont(std::shared_ptr<RNSkPlatformContext> context, const SkFont &font)
-      : JsiSkWrappingSharedPtrHostObject(std::move(context),
-                                         std::make_shared<SkFont>(font)) {}
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkFont, SkFont>(
+            std::move(context), std::make_shared<SkFont>(font)) {}
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkFont), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override { return "JsiSkFont"; }
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkFont> fromValue(jsi::Runtime &runtime,
+                                           const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
   /**
    * Creates the function for construction a new instance of the SkFont
@@ -299,22 +236,16 @@ public:
       if (count == 2) {
         auto typeface = JsiSkTypeface::fromValue(runtime, arguments[0]);
         auto size = arguments[1].asNumber();
-        auto hostObjectInstance =
-            std::make_shared<JsiSkFont>(context, SkFont(typeface, size));
-        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-            runtime, hostObjectInstance, std::move(context));
+        return makeJsiObject(runtime, std::make_shared<JsiSkFont>(
+                                          context, SkFont(typeface, size)));
       } else if (count == 1) {
         auto typeface = JsiSkTypeface::fromValue(runtime, arguments[0]);
-        auto hostObjectInstance =
-            std::make_shared<JsiSkFont>(context, SkFont(typeface));
-        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-            runtime, hostObjectInstance, std::move(context));
+        return makeJsiObject(
+            runtime, std::make_shared<JsiSkFont>(context, SkFont(typeface)));
       } else {
         // Return the newly constructed object
-        auto hostObjectInstance =
-            std::make_shared<JsiSkFont>(context, SkFont());
-        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-            runtime, hostObjectInstance, std::move(context));
+        return makeJsiObject(runtime,
+                             std::make_shared<JsiSkFont>(context, SkFont()));
       }
     };
   }

package/cpp/api/JsiSkFontMgr.h

@@ -2,11 +2,14 @@
 
 #include <memory>
 #include <numeric>
+#include <string>
 #include <utility>
 #include <vector>
 
+#include "JsiSkConverters.h"
 #include "JsiSkFontStyle.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
+#include "JsiSkTypeface.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
@@ -21,61 +24,65 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFontMgr : public JsiSkWrappingSkPtrHostObject<SkFontMgr> {
+class JsiSkFontMgr
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkFontMgr, SkFontMgr> {
 public:
-  EXPORT_JSI_API_TYPENAME(JsiSkFontMgr, FontMgr)
+  static constexpr const char *CLASS_NAME = "FontMgr";
 
   JsiSkFontMgr(std::shared_ptr<RNSkPlatformContext> context,
                sk_sp<SkFontMgr> fontMgr)
-      : JsiSkWrappingSkPtrHostObject(context, fontMgr),
+      : JsiSkWrappingSkPtrNativeObject<JsiSkFontMgr, SkFontMgr>(context,
+                                                                fontMgr),
         _systemFontFamilies(context->getSystemFontFamilies()) {}
 
-  JSI_HOST_FUNCTION(countFamilies) {
+  int countFamilies() {
     return static_cast<int>(getObject()->countFamilies() +
                             _systemFontFamilies.size());
   }
 
-  JSI_HOST_FUNCTION(getFamilyName) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  std::string getFamilyName(int i) {
     auto baseFamilyCount = getObject()->countFamilies();
     if (i < baseFamilyCount) {
       SkString name;
       getObject()->getFamilyName(i, &name);
-      return jsi::String::createFromUtf8(runtime, name.c_str());
+      return std::string(name.c_str());
     }
     auto systemIndex = i - baseFamilyCount;
     if (systemIndex < static_cast<int>(_systemFontFamilies.size())) {
-      return jsi::String::createFromUtf8(runtime,
-                                         _systemFontFamilies[systemIndex]);
+      return _systemFontFamilies[systemIndex];
     }
-    throw jsi::JSError(
-        runtime,
+    throw std::runtime_error(
         "Font family index out of bounds: " + std::to_string(i) +
-            " (total families: " +
-            std::to_string(baseFamilyCount + _systemFontFamilies.size()) + ")");
+        " (total families: " +
+        std::to_string(baseFamilyCount + _systemFontFamilies.size()) + ")");
   }
 
-  JSI_HOST_FUNCTION(matchFamilyStyle) {
-    auto name = arguments[0].asString(runtime).utf8(runtime);
+  std::shared_ptr<JsiSkTypeface>
+  matchFamilyStyle(std::string name, std::shared_ptr<SkFontStyle> fontStyle) {
     // Resolve font family aliases (e.g., "System" -> ".AppleSystemUIFont" on
     // iOS)
     auto resolvedName = getContext()->resolveFontFamily(name);
-    auto fontStyle = JsiSkFontStyle::fromValue(runtime, arguments[1]);
     auto typeface =
         getObject()->matchFamilyStyle(resolvedName.c_str(), *fontStyle);
-    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 2048; }
+  size_t getMemoryPressure() override { return 2048; }
 
-  std::string getObjectType() const override { return "JsiSkFontMgr"; }
+  static sk_sp<SkFontMgr> fromValue(jsi::Runtime &runtime,
+                                    const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgr, countFamilies),
-                       JSI_EXPORT_FUNC(JsiSkFontMgr, getFamilyName),
-                       JSI_EXPORT_FUNC(JsiSkFontMgr, matchFamilyStyle))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "countFamilies",
+                  &JsiSkFontMgr::countFamilies);
+    installMethod(runtime, prototype, "getFamilyName",
+                  &JsiSkFontMgr::getFamilyName);
+    installMethod(runtime, prototype, "matchFamilyStyle",
+                  &JsiSkFontMgr::matchFamilyStyle);
+  }
 
 private:
   std::vector<std::string> _systemFontFamilies;

package/cpp/api/JsiSkFontMgrFactory.h

@@ -6,7 +6,8 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkFontMgr.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -20,8 +21,10 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFontMgrFactory : public JsiSkHostObject {
+class JsiSkFontMgrFactory : public JsiSkNativeObject<JsiSkFontMgrFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "FontMgrFactory";
+
   static sk_sp<SkFontMgr>
   getFontMgr(std::shared_ptr<RNSkPlatformContext> context) {
     static SkOnce once;
@@ -30,21 +33,19 @@ public:
     return fontMgr;
   }
 
-  JSI_HOST_FUNCTION(System) {
+  std::shared_ptr<JsiSkFontMgr> System() {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
-    auto fontMgrObj = std::make_shared<JsiSkFontMgr>(getContext(), fontMgr);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, fontMgrObj,
-                                                       getContext());
+    return std::make_shared<JsiSkFontMgr>(getContext(), fontMgr);
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgrFactory, System))
-
-  size_t getMemoryPressure() const override { return 1024; }
+  size_t getMemoryPressure() override { return 1024; }
 
-  std::string getObjectType() const override { return "JsiSkFontMgrFactory"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installMethod(runtime, prototype, "System", &JsiSkFontMgrFactory::System);
+  }
 
   explicit JsiSkFontMgrFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkFontMgrFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkFontStyle.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,13 +18,14 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFontStyle : public JsiSkWrappingSharedPtrHostObject<SkFontStyle> {
+class JsiSkFontStyle
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkFontStyle, SkFontStyle> {
 public:
-  JSI_API_TYPENAME("FontStyle");
+  static constexpr const char *CLASS_NAME = "FontStyle";
 
   JsiSkFontStyle(std::shared_ptr<RNSkPlatformContext> context,
                  const SkFontStyle &fontStyle)
-      : JsiSkWrappingSharedPtrHostObject<SkFontStyle>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkFontStyle, SkFontStyle>(
             std::move(context), std::make_shared<SkFontStyle>(fontStyle)) {}
 
   /**
@@ -33,8 +34,9 @@ public:
   static std::shared_ptr<SkFontStyle> fromValue(jsi::Runtime &runtime,
                                                 const jsi::Value &obj) {
     const auto &object = obj.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      return object.asHostObject<JsiSkFontStyle>(runtime)->getObject();
+    auto fontStyle = tryGetJsiObject<JsiSkFontStyle>(runtime, object);
+    if (fontStyle) {
+      return fontStyle->getObject();
     } else {
       auto weightProp = object.getProperty(runtime, "weight");
       auto weight = static_cast<int>(
@@ -56,11 +58,13 @@ public:
     }
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkFontStyle), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override { return "JsiSkFontStyle"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
 
   /**
   Returns the jsi object from a host object of this type
@@ -68,10 +72,8 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkFontStyle &fontStyle) {
-    auto fontStyleObj =
-        std::make_shared<JsiSkFontStyle>(std::move(context), fontStyle);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, fontStyleObj,
-                                                       context);
+    return makeJsiObject(runtime, std::make_shared<JsiSkFontStyle>(
+                                      std::move(context), fontStyle));
   }
 };
 } // namespace RNSkia