@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkSkottie.h

@@ -1,10 +1,17 @@
 #pragma once
 
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+
 #include <jsi/jsi.h>
 
 #include "JsiSkCanvas.h"
 #include "JsiSkColor.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkConverters.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRect.h"
 #include "api/third_party/SkottieUtils.h"
@@ -146,96 +153,71 @@ public:
   std::unique_ptr<CustomPropertyManager> _propManager = nullptr;
 };
 
-class JsiSkSkottie : public JsiSkWrappingSharedPtrHostObject<ManagedAnimation> {
+class JsiSkSkottie
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkSkottie,
+                                                ManagedAnimation> {
 public:
+  static constexpr const char *CLASS_NAME = "Skottie";
+
   // #region Properties
-  JSI_HOST_FUNCTION(duration) {
+  double duration() {
     return static_cast<double>(getObject()->_animation->duration());
   }
-  JSI_HOST_FUNCTION(fps) {
-    return static_cast<double>(getObject()->_animation->fps());
-  }
-
-  JSI_PROPERTY_GET(__typename__) {
-    return jsi::String::createFromUtf8(runtime, "Skottie");
-  }
-
-  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkSkottie, __typename__))
+  double fps() { return static_cast<double>(getObject()->_animation->fps()); }
   // #endregion
 
   // #region Methods
-  JSI_HOST_FUNCTION(seekFrame) {
+  void seekFrame(double frame,
+                 std::optional<std::shared_ptr<SkRect>> rectParam) {
     sksg::InvalidationController ic;
-    getObject()->_animation->seekFrame(arguments[0].asNumber(), &ic);
+    getObject()->_animation->seekFrame(frame, &ic);
     auto bounds = ic.bounds();
-    if (count >= 2) {
-      auto rect = JsiSkRect::fromValue(runtime, arguments[1]);
-      if (rect != nullptr) {
-        rect->setXYWH(bounds.x(), bounds.y(), bounds.width(), bounds.height());
-      }
+    if (rectParam.has_value() && *rectParam != nullptr) {
+      auto rect = *rectParam;
+      rect->setXYWH(bounds.x(), bounds.y(), bounds.width(), bounds.height());
     }
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(size) {
-    auto size = getObject()->_animation->size();
-    jsi::Object jsiSize(runtime);
-    jsiSize.setProperty(runtime, "width", size.width());
-    jsiSize.setProperty(runtime, "height", size.height());
-    return jsiSize;
-  }
+  SkSize size() { return getObject()->_animation->size(); }
 
-  JSI_HOST_FUNCTION(render) {
-    auto canvas = arguments[0]
-                      .asObject(runtime)
-                      .asHostObject<JsiSkCanvas>(runtime)
-                      ->getCanvas();
-    if (count > 1) {
-      auto rect = JsiSkRect::fromValue(runtime, arguments[1]);
-      getObject()->_animation->render(canvas, rect.get());
+  void render(std::shared_ptr<JsiSkCanvas> jsiCanvas,
+              std::optional<std::shared_ptr<SkRect>> rect) {
+    auto canvas = jsiCanvas->getCanvas();
+    if (rect.has_value()) {
+      getObject()->_animation->render(canvas, rect->get());
     } else {
       getObject()->_animation->render(canvas);
     }
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(version) {
-    return jsi::String::createFromUtf8(
-        runtime, getObject()->_animation->version().c_str());
+  std::string version() {
+    return std::string(getObject()->_animation->version().c_str());
   }
 
-  JSI_HOST_FUNCTION(setColor) {
-    if (count < 2) {
-      return jsi::Value(false);
+  bool setColor(JsiOptional<std::string> key, JsiOptional<JsiColor> color) {
+    if (!key.has_value() || !color.has_value()) {
+      return false;
     }
-    auto key = arguments[0].asString(runtime).utf8(runtime);
-    auto color = JsiSkColor::fromValue(runtime, arguments[1]);
-    return getObject()->_propManager->setColor(key, color);
+    return getObject()->_propManager->setColor(*key, *color);
   }
 
-  JSI_HOST_FUNCTION(setOpacity) {
-    if (count < 2) {
-      return jsi::Value(false);
+  bool setOpacity(JsiOptional<std::string> key, JsiOptional<double> opacity) {
+    if (!key.has_value() || !opacity.has_value()) {
+      return false;
     }
-
-    auto key = arguments[0].asString(runtime).utf8(runtime);
-    auto opacity = arguments[1].asNumber();
-    return getObject()->_propManager->setOpacity(key, opacity);
+    return getObject()->_propManager->setOpacity(*key, *opacity);
   }
 
-  JSI_HOST_FUNCTION(setText) {
-    if (count < 3) {
-      return jsi::Value(false);
+  bool setText(JsiOptional<std::string> key, JsiOptional<std::string> text,
+               JsiOptional<double> size) {
+    if (!key.has_value() || !text.has_value() || !size.has_value()) {
+      return false;
     }
-    auto key = arguments[0].asString(runtime).utf8(runtime);
-    auto text = arguments[1].asString(runtime).utf8(runtime);
-    auto size = arguments[2].asNumber();
     // preserve all other text fields
-    auto t = getObject()->_propManager->getText(key);
-    t.fText = SkString(text);
-    t.fTextSize = size;
-    return getObject()->_propManager->setText(key, t);
+    auto t = getObject()->_propManager->getText(*key);
+    t.fText = SkString(*text);
+    t.fTextSize = *size;
+    return getObject()->_propManager->setText(*key, t);
   }
 
   JSI_HOST_FUNCTION(getTextProps) {
@@ -256,27 +238,24 @@ public:
     return props;
   }
 
-  JSI_HOST_FUNCTION(setTransform) {
-    if (count < 7) {
-      return jsi::Value(false);
+  bool setTransform(JsiOptional<std::string> key, JsiOptional<SkPoint> anchor,
+                    JsiOptional<SkPoint> position, JsiOptional<SkPoint> scale,
+                    JsiOptional<double> rotation, JsiOptional<double> skew,
+                    JsiOptional<double> skewAxis) {
+    if (!key.has_value() || !anchor.has_value() || !position.has_value() ||
+        !scale.has_value() || !rotation.has_value() || !skew.has_value() ||
+        !skewAxis.has_value()) {
+      return false;
     }
 
-    auto key = arguments[0].asString(runtime).utf8(runtime);
-    auto anchor = JsiSkPoint::fromValue(runtime, arguments[1]);
-    auto position = JsiSkPoint::fromValue(runtime, arguments[2]);
-    auto scale = JsiSkPoint::fromValue(runtime, arguments[3]);
-    auto rotation = arguments[4].asNumber();
-    auto skew = arguments[5].asNumber();
-    auto skewAxis = arguments[6].asNumber();
-
     skottie::TransformPropertyValue transform;
     transform.fAnchorPoint = {anchor->x(), anchor->y()};
     transform.fPosition = {position->x(), position->y()};
     transform.fScale = {scale->x(), scale->y()};
-    transform.fRotation = rotation;
-    transform.fSkew = skew;
-    transform.fSkewAxis = skewAxis;
-    return getObject()->_propManager->setTransform(key, transform);
+    transform.fRotation = *rotation;
+    transform.fSkew = *skew;
+    transform.fSkewAxis = *skewAxis;
+    return getObject()->_propManager->setTransform(*key, transform);
   }
 
   JSI_HOST_FUNCTION(getSlotInfo) {
@@ -330,52 +309,47 @@ public:
     return slotInfoJS;
   }
 
-  JSI_HOST_FUNCTION(setColorSlot) {
-    if (count < 2) {
-      return jsi::Value(false);
+  bool setColorSlot(JsiOptional<std::string> slotID,
+                    JsiOptional<JsiColor> color) {
+    if (!slotID.has_value() || !color.has_value()) {
+      return false;
     }
-    auto slotID = arguments[0].asString(runtime).utf8(runtime);
-    auto color = JsiSkColor::fromValue(runtime, arguments[1]);
-    return getObject()->_slotManager->setColorSlot(SkString(slotID), color);
+    return getObject()->_slotManager->setColorSlot(SkString(*slotID), *color);
   }
 
-  JSI_HOST_FUNCTION(setScalarSlot) {
-    if (count < 2) {
-      return jsi::Value(false);
+  bool setScalarSlot(JsiOptional<std::string> slotID,
+                     JsiOptional<double> scalar) {
+    if (!slotID.has_value() || !scalar.has_value()) {
+      return false;
     }
-    auto slotID = arguments[0].asString(runtime).utf8(runtime);
-    auto scalar = arguments[1].asNumber();
-    return getObject()->_slotManager->setScalarSlot(SkString(slotID), scalar);
+    return getObject()->_slotManager->setScalarSlot(SkString(*slotID),
+                                                    *scalar);
   }
 
-  JSI_HOST_FUNCTION(setVec2Slot) {
-    if (count < 2) {
-      return jsi::Value(false);
+  bool setVec2Slot(JsiOptional<std::string> slotID,
+                   JsiOptional<SkPoint> point) {
+    if (!slotID.has_value() || !point.has_value()) {
+      return false;
     }
-    auto slotID = arguments[0].asString(runtime).utf8(runtime);
-    auto point = JsiSkPoint::fromValue(runtime, arguments[1]);
     SkV2 vec2{point->x(), point->y()};
-    return getObject()->_slotManager->setVec2Slot(SkString(slotID), vec2);
+    return getObject()->_slotManager->setVec2Slot(SkString(*slotID), vec2);
   }
 
-  JSI_HOST_FUNCTION(setTextSlot) {
-    if (count < 2) {
-      return jsi::Value(false);
-    }
-    auto key = arguments[0].asString(runtime).utf8(runtime);
+  // The text value argument is intentionally not declared: the raw binding
+  // never read it (the method is not implemented yet).
+  bool setTextSlot(JsiOptional<std::string> key) {
     // TODO: Implement proper text slot setting
-    return jsi::Value(false);
+    return false;
   }
 
-  JSI_HOST_FUNCTION(setImageSlot) {
-    if (count < 2) {
-      return jsi::Value(false);
+  bool setImageSlot(JsiOptional<std::string> slotID,
+                    JsiOptional<std::string> assetName) {
+    if (!slotID.has_value() || !assetName.has_value()) {
+      return false;
     }
-    auto slotID = arguments[0].asString(runtime).utf8(runtime);
-    auto assetName = arguments[1].asString(runtime).utf8(runtime);
     return getObject()->_slotManager->setImageSlot(
-        SkString(slotID), getObject()->_resourceProvider->loadImageAsset(
-                              nullptr, assetName.data(), nullptr));
+        SkString(*slotID), getObject()->_resourceProvider->loadImageAsset(
+                               nullptr, assetName->data(), nullptr));
   }
 
   JSI_HOST_FUNCTION(getColorSlot) {
@@ -389,15 +363,15 @@ public:
     return jsi::Value::null();
   }
 
-  JSI_HOST_FUNCTION(getScalarSlot) {
-    if (count < 1) {
-      return jsi::Value::null();
+  std::variant<double, std::nullptr_t>
+  getScalarSlot(JsiOptional<std::string> slotID) {
+    if (!slotID.has_value()) {
+      return nullptr;
     }
-    auto slotID = arguments[0].asString(runtime).utf8(runtime);
-    if (auto v = getObject()->_slotManager->getScalarSlot(SkString(slotID))) {
-      return jsi::Value(v.value());
+    if (auto v = getObject()->_slotManager->getScalarSlot(SkString(*slotID))) {
+      return static_cast<double>(v.value());
     }
-    return jsi::Value::null();
+    return nullptr;
   }
 
   JSI_HOST_FUNCTION(getVec2Slot) {
@@ -554,29 +528,45 @@ public:
     return transformProps;
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSkottie, duration),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, fps),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, seekFrame),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, render),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, size),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, version),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getSlotInfo),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, setColorSlot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, setScalarSlot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, setVec2Slot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, setTextSlot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, setImageSlot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getColorSlot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getScalarSlot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getVec2Slot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getTextSlot),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getColorProps),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getOpacityProps),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getTransformProps),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, getTextProps),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, setColor),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, setText),
-                       JSI_EXPORT_FUNC(JsiSkSkottie, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "duration", &JsiSkSkottie::duration);
+    installMethod(runtime, prototype, "fps", &JsiSkSkottie::fps);
+    installMethod(runtime, prototype, "seekFrame", &JsiSkSkottie::seekFrame);
+    installMethod(runtime, prototype, "render", &JsiSkSkottie::render);
+    installMethod(runtime, prototype, "size", &JsiSkSkottie::size);
+    installMethod(runtime, prototype, "version", &JsiSkSkottie::version);
+    installHostMethod(runtime, prototype, "getSlotInfo",
+                      &JsiSkSkottie::getSlotInfo);
+    installMethod(runtime, prototype, "setColorSlot",
+                  &JsiSkSkottie::setColorSlot);
+    installMethod(runtime, prototype, "setScalarSlot",
+                  &JsiSkSkottie::setScalarSlot);
+    installMethod(runtime, prototype, "setVec2Slot",
+                  &JsiSkSkottie::setVec2Slot);
+    installMethod(runtime, prototype, "setTextSlot",
+                  &JsiSkSkottie::setTextSlot);
+    installMethod(runtime, prototype, "setImageSlot",
+                  &JsiSkSkottie::setImageSlot);
+    installHostMethod(runtime, prototype, "getColorSlot",
+                      &JsiSkSkottie::getColorSlot);
+    installMethod(runtime, prototype, "getScalarSlot",
+                  &JsiSkSkottie::getScalarSlot);
+    installHostMethod(runtime, prototype, "getVec2Slot",
+                      &JsiSkSkottie::getVec2Slot);
+    installHostMethod(runtime, prototype, "getTextSlot",
+                      &JsiSkSkottie::getTextSlot);
+    installHostMethod(runtime, prototype, "getColorProps",
+                      &JsiSkSkottie::getColorProps);
+    installHostMethod(runtime, prototype, "getOpacityProps",
+                      &JsiSkSkottie::getOpacityProps);
+    installHostMethod(runtime, prototype, "getTransformProps",
+                      &JsiSkSkottie::getTransformProps);
+    installHostMethod(runtime, prototype, "getTextProps",
+                      &JsiSkSkottie::getTextProps);
+    installMethod(runtime, prototype, "setColor", &JsiSkSkottie::setColor);
+    installMethod(runtime, prototype, "setText", &JsiSkSkottie::setText);
+  }
   // #endregion
 
   /**
@@ -584,10 +574,10 @@ public:
   */
   JsiSkSkottie(std::shared_ptr<RNSkPlatformContext> context,
                std::shared_ptr<ManagedAnimation> animation)
-      : JsiSkWrappingSharedPtrHostObject<ManagedAnimation>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkSkottie, ManagedAnimation>(
             std::move(context), std::move(animation)) {}
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto animation = getObject();
     if (!animation || !animation->_animation) {
       return 1024; // Base size if no animation
@@ -615,7 +605,5 @@ public:
 
     return animationMemory + baseOverhead;
   }
-
-  std::string getObjectType() const override { return "JsiSkSkottie"; }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkSurface.h

@@ -7,8 +7,9 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkDispatcher.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiTextureInfo.h"
 
 #include "JsiSkCanvas.h"
@@ -30,15 +31,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,31 +67,26 @@ public:
     }
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkSurface, Surface)
-
   // TODO-API: Properties?
-  JSI_HOST_FUNCTION(width) { return static_cast<double>(getObject()->width()); }
-  JSI_HOST_FUNCTION(height) {
-    return static_cast<double>(getObject()->height());
-  }
+  double width() { return static_cast<double>(getObject()->width()); }
+  double height() { return static_cast<double>(getObject()->height()); }
 
-  JSI_HOST_FUNCTION(getCanvas) {
+  std::shared_ptr<JsiSkCanvas> getCanvas() {
     auto surface = getObject();
     auto canvas =
         std::make_shared<JsiSkCanvas>(getContext(), surface->getCanvas());
     // 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 canvas;
   }
 
-  JSI_HOST_FUNCTION(flush) {
+  void flush(JsiOptional<bool> syncParam) {
     auto surface = getObject();
     // When `sync` is true, block until the GPU has finished executing the
     // submitted work. Required before a native consumer on a different command
     // queue reads this surface's texture via getNativeTextureUnstable(). #3916
-    bool sync = count > 0 && arguments[0].isBool() && arguments[0].getBool();
+    bool sync = syncParam.has_value() && *syncParam;
 #if defined(SK_GRAPHITE)
     // A raster surface (e.g. Skia.Surface.Make) has no Graphite recorder;
     // only Graphite-backed surfaces need to snap and submit a recording.
@@ -102,7 +101,6 @@ public:
       dContext->flushAndSubmit(sync ? GrSyncCpu::kYes : GrSyncCpu::kNo);
     }
 #endif
-    return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(makeImageSnapshot) {
@@ -124,15 +122,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 +135,7 @@ public:
     return JsiTextureInfo::toValue(runtime, texInfo);
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     if (isDisposed()) {
       return 0;
     }
@@ -196,15 +191,17 @@ 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);
+    installMethod(runtime, prototype, "width", &JsiSkSurface::width);
+    installMethod(runtime, prototype, "height", &JsiSkSurface::height);
+    installMethod(runtime, prototype, "getCanvas", &JsiSkSurface::getCanvas);
+    installHostMethod(runtime, prototype, "makeImageSnapshot",
+                      &JsiSkSurface::makeImageSnapshot);
+    installMethod(runtime, prototype, "flush", &JsiSkSurface::flush);
+    installHostMethod(runtime, prototype, "getNativeTextureUnstable",
+                      &JsiSkSurface::getNativeTextureUnstable);
+  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkSurfaceFactory.h

@@ -2,10 +2,11 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #include "JsiSkSurface.h"
 
@@ -20,20 +21,18 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkSurfaceFactory : public JsiSkHostObject {
+class JsiSkSurfaceFactory : public JsiSkNativeObject<JsiSkSurfaceFactory> {
 public:
-  JSI_HOST_FUNCTION(Make) {
-    auto width = static_cast<int>(arguments[0].asNumber());
-    auto height = static_cast<int>(arguments[1].asNumber());
+  static constexpr const char *CLASS_NAME = "SurfaceFactory";
+
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkSurface>> Make(int width,
+                                                                   int height) {
     auto imageInfo = SkImageInfo::MakeN32Premul(width, height);
     auto surface = SkSurfaces::Raster(imageInfo);
     if (surface == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
   }
 
   JSI_HOST_FUNCTION(MakeOffscreen) {
@@ -56,21 +55,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) {
+    installMethod(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