@shopify/react-native-skia 2.9.1-next.1 → 2.10.0

package/cpp/api/JsiSkColorFilterFactory.h

@@ -2,7 +2,7 @@
 
 #include "JsiSkColor.h"
 #include "JsiSkColorFilter.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include <jsi/jsi.h>
 #include <memory>
 #include <utility>
@@ -19,8 +19,11 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkColorFilterFactory : public JsiSkHostObject {
+class JsiSkColorFilterFactory
+    : public JsiSkNativeObject<JsiSkColorFilterFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "ColorFilterFactory";
+
   JSI_HOST_FUNCTION(MakeMatrix) {
     auto jsiMatrix = arguments[0].asObject(runtime).asArray(runtime);
     float matrix[20];
@@ -30,31 +33,28 @@ public:
       }
     }
     // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkColorFilters::Matrix(std::move(matrix)));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::Matrix(std::move(matrix))));
   }
 
   JSI_HOST_FUNCTION(MakeBlend) {
     auto color = JsiSkColor::fromValue(runtime, arguments[0]);
     SkBlendMode blend = (SkBlendMode)arguments[1].asNumber();
     // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkColorFilters::Blend(color, blend));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::Blend(color, blend)));
   }
 
   JSI_HOST_FUNCTION(MakeCompose) {
     auto outer = JsiSkColorFilter::fromValue(runtime, arguments[0]);
     auto inner = JsiSkColorFilter::fromValue(runtime, arguments[1]);
     // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(),
-        SkColorFilters::Compose(std::move(outer), std::move(inner)));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::Compose(std::move(outer),
+                                                           std::move(inner))));
   }
 
   JSI_HOST_FUNCTION(MakeLerp) {
@@ -62,52 +62,52 @@ public:
     auto dst = JsiSkColorFilter::fromValue(runtime, arguments[1]);
     auto src = JsiSkColorFilter::fromValue(runtime, arguments[2]);
     // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkColorFilters::Lerp(t, std::move(dst), std::move(src)));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(),
+                     SkColorFilters::Lerp(t, std::move(dst), std::move(src))));
   }
 
   JSI_HOST_FUNCTION(MakeSRGBToLinearGamma) {
     // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkColorFilters::SRGBToLinearGamma());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::SRGBToLinearGamma()));
   }
 
   JSI_HOST_FUNCTION(MakeLinearToSRGBGamma) {
     // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkColorFilters::LinearToSRGBGamma());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::LinearToSRGBGamma()));
   }
 
   JSI_HOST_FUNCTION(MakeLumaColorFilter) {
     // Return the newly constructed object
-    auto colorFilter = std::make_shared<JsiSkColorFilter>(
-        getContext(), SkLumaColorFilter::Make());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkColorFilter>(
+                                      getContext(), SkLumaColorFilter::Make()));
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override {
-    return "JsiSkColorFilterFactory";
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "MakeMatrix",
+                      &JsiSkColorFilterFactory::MakeMatrix);
+    installHostMethod(runtime, prototype, "MakeBlend",
+                      &JsiSkColorFilterFactory::MakeBlend);
+    installHostMethod(runtime, prototype, "MakeCompose",
+                      &JsiSkColorFilterFactory::MakeCompose);
+    installHostMethod(runtime, prototype, "MakeLerp",
+                      &JsiSkColorFilterFactory::MakeLerp);
+    installHostMethod(runtime, prototype, "MakeSRGBToLinearGamma",
+                      &JsiSkColorFilterFactory::MakeSRGBToLinearGamma);
+    installHostMethod(runtime, prototype, "MakeLinearToSRGBGamma",
+                      &JsiSkColorFilterFactory::MakeLinearToSRGBGamma);
+    installHostMethod(runtime, prototype, "MakeLumaColorFilter",
+                      &JsiSkColorFilterFactory::MakeLumaColorFilter);
   }
 
-  JSI_EXPORT_FUNCTIONS(
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeMatrix),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeBlend),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeCompose),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLerp),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeSRGBToLinearGamma),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLinearToSRGBGamma),
-      JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLumaColorFilter))
-
   explicit JsiSkColorFilterFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkColorFilterFactory>(std::move(context)) {}
 };
 } // namespace RNSkia

package/cpp/api/JsiSkContourMeasure.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -21,12 +21,15 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkContourMeasure
-    : public JsiSkWrappingSkPtrHostObject<SkContourMeasure> {
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkContourMeasure,
+                                            SkContourMeasure> {
 public:
+  static constexpr const char *CLASS_NAME = "ContourMeasure";
+
   JsiSkContourMeasure(std::shared_ptr<RNSkPlatformContext> context,
                       const sk_sp<SkContourMeasure> contourMeasure)
-      : JsiSkWrappingSkPtrHostObject(std::move(context),
-                                     std::move(contourMeasure)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkContourMeasure, SkContourMeasure>(
+            std::move(context), std::move(contourMeasure)) {}
 
   JSI_HOST_FUNCTION(getPosTan) {
     auto dist = arguments[0].asNumber();
@@ -37,12 +40,10 @@ public:
       throw jsi::JSError(runtime, "getPosTan() failed");
     }
     auto posTan = jsi::Array(runtime, 2);
-    auto posPoint = std::make_shared<JsiSkPoint>(getContext(), position);
-    auto pos = JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, posPoint,
-                                                           getContext());
-    auto tanPoint = std::make_shared<JsiSkPoint>(getContext(), tangent);
-    auto tan = JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, tanPoint,
-                                                           getContext());
+    auto pos = makeJsiObject(
+        runtime, std::make_shared<JsiSkPoint>(getContext(), position));
+    auto tan = makeJsiObject(
+        runtime, std::make_shared<JsiSkPoint>(getContext(), tangent));
     posTan.setValueAtIndex(runtime, 0, pos);
     posTan.setValueAtIndex(runtime, 1, tan);
     return posTan;
@@ -67,16 +68,18 @@ public:
     return JsiSkPath::toValue(runtime, getContext(), builder.snapshot());
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkContourMeasure"; }
-
-  EXPORT_JSI_API_TYPENAME(JsiSkContourMeasure, ContourMeasure)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkContourMeasure, getPosTan),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasure, length),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasure, isClosed),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasure, getSegment),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasure, dispose))
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "getPosTan",
+                      &JsiSkContourMeasure::getPosTan);
+    installHostMethod(runtime, prototype, "length",
+                      &JsiSkContourMeasure::length);
+    installHostMethod(runtime, prototype, "isClosed",
+                      &JsiSkContourMeasure::isClosed);
+    installHostMethod(runtime, prototype, "getSegment",
+                      &JsiSkContourMeasure::getSegment);
+  }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkContourMeasureIter.h

@@ -4,7 +4,7 @@
 #include <utility>
 
 #include "JsiSkContourMeasure.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -20,12 +20,16 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkContourMeasureIter
-    : public JsiSkWrappingSharedPtrHostObject<SkContourMeasureIter> {
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkContourMeasureIter,
+                                                SkContourMeasureIter> {
 public:
+  static constexpr const char *CLASS_NAME = "ContourMeasureIter";
+
   JsiSkContourMeasureIter(std::shared_ptr<RNSkPlatformContext> context,
                           const SkPath &path, bool forceClosed,
                           SkScalar resScale = 1)
-      : JsiSkWrappingSharedPtrHostObject<SkContourMeasureIter>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkContourMeasureIter,
+                                           SkContourMeasureIter>(
             std::move(context), std::make_shared<SkContourMeasureIter>(
                                     path, forceClosed, resScale)) {}
 
@@ -34,24 +38,18 @@ public:
     if (next == nullptr) {
       return jsi::Value::undefined();
     }
-    auto nextObject =
-        std::make_shared<JsiSkContourMeasure>(getContext(), std::move(next));
-
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, nextObject,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkContourMeasure>(
+                                      getContext(), std::move(next)));
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkContourMeasureIter, ContourMeasureIter)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkContourMeasureIter, next),
-                       JSI_EXPORT_FUNC(JsiSkContourMeasureIter, dispose))
-
-  size_t getMemoryPressure() const override {
-    return std::max(sizeof(SkContourMeasureIter), kMinMemoryPressure);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "next",
+                      &JsiSkContourMeasureIter::next);
   }
 
-  std::string getObjectType() const override {
-    return "JsiSkContourMeasureIter";
+  size_t getMemoryPressure() override {
+    return std::max(sizeof(SkContourMeasureIter), kMinMemoryPressure);
   }
 
   /**
@@ -68,10 +66,9 @@ public:
       auto forceClosed = arguments[1].getBool();
       auto resScale = arguments[2].asNumber();
       // Return the newly constructed object
-      auto iter = std::make_shared<JsiSkContourMeasureIter>(
-          std::move(context), path->snapshot(), forceClosed, resScale);
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, iter,
-                                                         context);
+      return makeJsiObject(runtime, std::make_shared<JsiSkContourMeasureIter>(
+                                        std::move(context), path->snapshot(),
+                                        forceClosed, resScale));
     };
   }
 };

package/cpp/api/JsiSkData.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -19,19 +19,25 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkData : public JsiSkWrappingSkPtrHostObject<SkData> {
+class JsiSkData : public JsiSkWrappingSkPtrNativeObject<JsiSkData, SkData> {
 public:
+  static constexpr const char *CLASS_NAME = "Data";
+
   JsiSkData(std::shared_ptr<RNSkPlatformContext> context, sk_sp<SkData> asset)
-      : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(asset)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkData, SkData>(std::move(context),
+                                                          std::move(asset)) {}
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto data = getObject();
     return data ? data->size() : 0;
   }
 
-  std::string getObjectType() const override { return "JsiSkData"; }
+  static sk_sp<SkData> fromValue(jsi::Runtime &runtime, const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkData, Data)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkData, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkDataFactory.h

@@ -5,16 +5,19 @@
 
 #include <jsi/jsi.h>
 
-#include "jsi/JsiPromises.h"
 #include "JsiSkData.h"
+#include "JsiSkNativeObjects.h"
 #include "api/third_party/base64.h"
+#include "jsi/JsiPromises.h"
 
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkDataFactory : public JsiSkHostObject {
+class JsiSkDataFactory : public JsiSkNativeObject<JsiSkDataFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "DataFactory";
+
   JSI_HOST_FUNCTION(fromURI) {
     auto jsiLocalUri = arguments[0].asString(runtime);
     auto localUri = jsiLocalUri.utf8(runtime);
@@ -38,10 +41,9 @@ public:
                                                 context = std::move(context),
                                                 promise = std::move(promise),
                                                 result = std::move(result)]() {
-                  auto hostObjectInstance =
-                      std::make_shared<JsiSkData>(context, std::move(result));
-                  promise->resolve(JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-                      runtime, hostObjectInstance, context));
+                  promise->resolve(makeJsiObject(
+                      runtime,
+                      std::make_shared<JsiSkData>(context, std::move(result))));
                 });
               });
         });
@@ -56,10 +58,8 @@ public:
 
     auto data =
         SkData::MakeWithCopy(buffer.data(runtime), buffer.size(runtime));
-    auto hostObjectInstance =
-        std::make_shared<JsiSkData>(getContext(), std::move(data));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkData>(getContext(), std::move(data)));
   }
 
   JSI_HOST_FUNCTION(fromBase64) {
@@ -85,22 +85,23 @@ public:
       return jsi::Value::undefined();
     }
 
-    auto hostObjectInstance =
-        std::make_shared<JsiSkData>(getContext(), std::move(data));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkData>(getContext(), std::move(data)));
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
+  size_t getMemoryPressure() override { return 1024; }
 
-  std::string getObjectType() const override { return "JsiSkDataFactory"; }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkDataFactory, fromURI),
-                       JSI_EXPORT_FUNC(JsiSkDataFactory, fromBytes),
-                       JSI_EXPORT_FUNC(JsiSkDataFactory, fromBase64))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "fromURI",
+                      &JsiSkDataFactory::fromURI);
+    installHostMethod(runtime, prototype, "fromBytes",
+                      &JsiSkDataFactory::fromBytes);
+    installHostMethod(runtime, prototype, "fromBase64",
+                      &JsiSkDataFactory::fromBase64);
+  }
 
   explicit JsiSkDataFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkDataFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkFont.h

@@ -5,7 +5,7 @@
 #include <utility>
 #include <vector>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
@@ -26,8 +26,10 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFont : public JsiSkWrappingSharedPtrHostObject<SkFont> {
+class JsiSkFont : public JsiSkWrappingSharedPtrNativeObject<JsiSkFont, SkFont> {
 public:
+  static constexpr const char *CLASS_NAME = "Font";
+
   JSI_HOST_FUNCTION(getGlyphWidths) {
     auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
     std::vector<SkGlyphID> glyphs;
@@ -91,9 +93,8 @@ public:
       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());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkRect>(getContext(), std::move(bounds)));
   }
 
   JSI_HOST_FUNCTION(getMetrics) {
@@ -251,39 +252,56 @@ public:
     return jsi::Value::undefined();
   }
 
-  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);
+    installHostMethod(runtime, prototype, "getSize", &JsiSkFont::getSize);
+    installHostMethod(runtime, prototype, "getMetrics", &JsiSkFont::getMetrics);
+    installHostMethod(runtime, prototype, "getGlyphIDs",
+                      &JsiSkFont::getGlyphIDs);
+    installHostMethod(runtime, prototype, "getGlyphIntercepts",
+                      &JsiSkFont::getGlyphIntercepts);
+    installHostMethod(runtime, prototype, "getScaleX", &JsiSkFont::getScaleX);
+    installHostMethod(runtime, prototype, "getSkewX", &JsiSkFont::getSkewX);
+    installHostMethod(runtime, prototype, "getTypeface",
+                      &JsiSkFont::getTypeface);
+    installHostMethod(runtime, prototype, "setEdging", &JsiSkFont::setEdging);
+    installHostMethod(runtime, prototype, "embeddedBitmaps",
+                      &JsiSkFont::embeddedBitmaps);
+    installHostMethod(runtime, prototype, "setHinting", &JsiSkFont::setHinting);
+    installHostMethod(runtime, prototype, "setLinearMetrics",
+                      &JsiSkFont::setLinearMetrics);
+    installHostMethod(runtime, prototype, "setScaleX", &JsiSkFont::setScaleX);
+    installHostMethod(runtime, prototype, "setSkewX", &JsiSkFont::setSkewX);
+    installHostMethod(runtime, prototype, "setSize", &JsiSkFont::setSize);
+    installHostMethod(runtime, prototype, "setEmbolden",
+                      &JsiSkFont::setEmbolden);
+    installHostMethod(runtime, prototype, "setSubpixel",
+                      &JsiSkFont::setSubpixel);
+    installHostMethod(runtime, prototype, "setTypeface",
+                      &JsiSkFont::setTypeface);
+    installHostMethod(runtime, prototype, "getGlyphWidths",
+                      &JsiSkFont::getGlyphWidths);
+    installHostMethod(runtime, prototype, "getTextWidth",
+                      &JsiSkFont::getTextWidth);
+    installHostMethod(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 +317,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

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "JsiSkFontStyle.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
@@ -21,13 +21,15 @@ 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) {
@@ -63,19 +65,26 @@ public:
     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 makeJsiObject(runtime, 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);
+    installHostMethod(runtime, prototype, "countFamilies",
+                      &JsiSkFontMgr::countFamilies);
+    installHostMethod(runtime, prototype, "getFamilyName",
+                      &JsiSkFontMgr::getFamilyName);
+    installHostMethod(runtime, prototype, "matchFamilyStyle",
+                      &JsiSkFontMgr::matchFamilyStyle);
+  }
 
 private:
   std::vector<std::string> _systemFontFamilies;