@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkottieFactory.h

@@ -5,14 +5,17 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkNativeObjects.h"
 #include "JsiSkSkottie.h"
 
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkottieFactory : public JsiSkHostObject {
+class JsiSkottieFactory : public JsiSkNativeObject<JsiSkottieFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "SkottieFactory";
+
   JSI_HOST_FUNCTION(Make) {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
     auto json = arguments[0].asString(runtime).utf8(runtime);
@@ -34,13 +37,10 @@ public:
           auto jsObject = jsValue.asObject(runtime);
 
           // Check if the object is a SkData host object
-          if (jsObject.isHostObject(runtime)) {
-            auto hostObject = jsObject.getHostObject(runtime);
-            auto skData = std::dynamic_pointer_cast<JsiSkData>(hostObject);
-            if (skData) {
-              std::string k = key;
-              assets[k] = skData->getObject();
-            }
+          auto skData = tryGetJsiObject<JsiSkData>(runtime, jsObject);
+          if (skData) {
+            std::string k = key;
+            assets[k] = skData->getObject();
           }
         }
       }
@@ -51,20 +51,19 @@ public:
     if (!managedAnimation->_animation) {
       return jsi::Value::null();
     }
-    auto skottie = std::make_shared<JsiSkSkottie>(getContext(),
-                                                  std::move(managedAnimation));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, skottie,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkSkottie>(getContext(),
+                                                std::move(managedAnimation)));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkottieFactory, Make))
-
-  size_t getMemoryPressure() const override { return 4096; }
+  size_t getMemoryPressure() override { return 4096; }
 
-  std::string getObjectType() const override { return "JsiSkottieFactory"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "Make", &JsiSkottieFactory::Make);
+  }
 
   explicit JsiSkottieFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkottieFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiVideo.h

@@ -1,119 +1,83 @@
 #pragma once
 
 #include <memory>
-#include <numeric>
 #include <utility>
-#include <vector>
+#include <variant>
 
-#include "JsiSkHostObjects.h"
-#include "utils/RNSkLog.h"
+#include "JsiSkNativeObjects.h"
 #include <jsi/jsi.h>
 
-#include "JsiSkPaint.h"
-#include "JsiSkPoint.h"
-#include "JsiSkRect.h"
-#include "JsiSkTypeface.h"
+#include "JsiSkConverters.h"
+#include "JsiSkImage.h"
 
 #include "rnskia/RNSkVideo.h"
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkFont.h"
-#include "include/core/SkFontMetrics.h"
-
-#pragma clang diagnostic pop
-
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiVideo : public JsiSkWrappingSharedPtrHostObject<RNSkVideo> {
+class JsiVideo
+    : public JsiSkWrappingSharedPtrNativeObject<JsiVideo, RNSkVideo> {
 public:
-  EXPORT_JSI_API_TYPENAME(JsiVideo, Video)
+  static constexpr const char *CLASS_NAME = "Video";
 
-  JSI_HOST_FUNCTION(nextImage) {
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkImage>> nextImage() {
     double timestamp = 0;
-    auto video = getObject();
-    auto image = video->nextImage(&timestamp);
+    auto image = getObject()->nextImage(&timestamp);
     if (!image) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkImage>(getContext(), std::move(image));
   }
 
-  JSI_HOST_FUNCTION(duration) { return getObject()->duration(); }
+  double duration() { return getObject()->duration(); }
 
-  JSI_HOST_FUNCTION(framerate) { return getObject()->framerate(); }
+  double framerate() { return getObject()->framerate(); }
 
-  JSI_HOST_FUNCTION(currentTime) { return getObject()->currentTime(); }
+  double currentTime() { return getObject()->currentTime(); }
 
-  JSI_HOST_FUNCTION(isPlaying) { return getObject()->isPlaying(); }
+  bool isPlaying() { return getObject()->isPlaying(); }
 
-  JSI_HOST_FUNCTION(seek) {
-    double timestamp = arguments[0].asNumber();
-    getObject()->seek(timestamp);
-    return jsi::Value::undefined();
-  }
+  void seek(double timestamp) { getObject()->seek(timestamp); }
 
-  JSI_HOST_FUNCTION(rotation) {
-    auto context = getContext();
-    auto rot = getObject()->getRotationInDegrees();
-    return jsi::Value(static_cast<double>(rot));
+  double rotation() {
+    return static_cast<double>(getObject()->getRotationInDegrees());
   }
 
-  JSI_HOST_FUNCTION(size) {
-    auto context = getContext();
-    auto size = getObject()->getSize();
-    auto result = jsi::Object(runtime);
-    result.setProperty(runtime, "width", static_cast<double>(size.width()));
-    result.setProperty(runtime, "height", static_cast<double>(size.height()));
-    return result;
-  }
+  SkISize size() { return getObject()->getSize(); }
 
-  JSI_HOST_FUNCTION(play) {
-    getObject()->play();
-    return jsi::Value::undefined();
-  }
+  void play() { getObject()->play(); }
 
-  JSI_HOST_FUNCTION(pause) {
-    getObject()->pause();
-    return jsi::Value::undefined();
-  }
+  void pause() { getObject()->pause(); }
 
-  JSI_HOST_FUNCTION(setVolume) {
-    auto volume = arguments[0].asNumber();
+  void setVolume(double volume) {
     getObject()->setVolume(static_cast<float>(volume));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setLooping) {
-    auto looping = arguments[0].asBool();
-    getObject()->setLooping(looping);
-    return jsi::Value::undefined();
+  void setLooping(bool looping) { getObject()->setLooping(looping); }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "nextImage", &JsiVideo::nextImage);
+    installMethod(runtime, prototype, "duration", &JsiVideo::duration);
+    installMethod(runtime, prototype, "framerate", &JsiVideo::framerate);
+    installMethod(runtime, prototype, "currentTime", &JsiVideo::currentTime);
+    installMethod(runtime, prototype, "isPlaying", &JsiVideo::isPlaying);
+    installMethod(runtime, prototype, "seek", &JsiVideo::seek);
+    installMethod(runtime, prototype, "rotation", &JsiVideo::rotation);
+    installMethod(runtime, prototype, "size", &JsiVideo::size);
+    installMethod(runtime, prototype, "play", &JsiVideo::play);
+    installMethod(runtime, prototype, "pause", &JsiVideo::pause);
+    installMethod(runtime, prototype, "setVolume", &JsiVideo::setVolume);
+    installMethod(runtime, prototype, "setLooping", &JsiVideo::setLooping);
   }
 
-  JSI_EXPORT_FUNCTIONS(
-      JSI_EXPORT_FUNC(JsiVideo, nextImage), JSI_EXPORT_FUNC(JsiVideo, duration),
-      JSI_EXPORT_FUNC(JsiVideo, framerate),
-      JSI_EXPORT_FUNC(JsiVideo, currentTime),
-      JSI_EXPORT_FUNC(JsiVideo, isPlaying), JSI_EXPORT_FUNC(JsiVideo, seek),
-      JSI_EXPORT_FUNC(JsiVideo, rotation), JSI_EXPORT_FUNC(JsiVideo, size),
-      JSI_EXPORT_FUNC(JsiVideo, play), JSI_EXPORT_FUNC(JsiVideo, pause),
-      JSI_EXPORT_FUNC(JsiVideo, setVolume),
-      JSI_EXPORT_FUNC(JsiVideo, setLooping), JSI_EXPORT_FUNC(JsiVideo, dispose))
-
   JsiVideo(std::shared_ptr<RNSkPlatformContext> context,
            std::shared_ptr<RNSkVideo> video)
-      : JsiSkWrappingSharedPtrHostObject(std::move(context), std::move(video)) {
-  }
-
-  size_t getMemoryPressure() const override { return 32768; }
+      : JsiSkWrappingSharedPtrNativeObject<JsiVideo, RNSkVideo>(
+            std::move(context), std::move(video)) {}
 
-  std::string getObjectType() const override { return "JsiVideo"; }
+  size_t getMemoryPressure() override { return 32768; }
 
   /**
    * Creates the function for construction a new instance of the SkFont
@@ -128,10 +92,8 @@ public:
       auto url = arguments[0].asString(runtime).utf8(runtime);
       auto video = context->createVideo(url);
       // Return the newly constructed object
-      auto videoObj =
-          std::make_shared<JsiVideo>(std::move(context), std::move(video));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, videoObj,
-                                                         context);
+      return makeJsiObject(runtime, std::make_shared<JsiVideo>(
+                                        std::move(context), std::move(video)));
     };
   }
 };

package/cpp/api/recorder/Convertor.h

@@ -394,8 +394,7 @@ SkSamplingOptions getPropertyValue(jsi::Runtime &runtime,
 template <>
 SkFont getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
   if (value.isObject()) {
-    auto font =
-        value.asObject(runtime).asHostObject<JsiSkFont>(runtime)->getObject();
+    auto font = getJsiObject<JsiSkFont>(runtime, value)->getObject();
     return SkFont(*font);
   }
   throw std::runtime_error("Invalid prop value for SkFont received");
@@ -427,9 +426,7 @@ GlyphData getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
 template <>
 SkRSXform getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
   if (value.isObject()) {
-    auto form = value.asObject(runtime)
-                    .asHostObject<JsiSkRSXform>(runtime)
-                    ->getObject();
+    auto form = getJsiObject<JsiSkRSXform>(runtime, value)->getObject();
     return SkRSXform::Make(form->fSCos, form->fSSin, form->fTx, form->fTy);
   }
   throw std::runtime_error("Invalid prop value for SkRSXform received");
@@ -438,13 +435,11 @@ SkRSXform getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
 template <>
 sk_sp<SkSVGDOM> getPropertyValue(jsi::Runtime &runtime,
                                  const jsi::Value &value) {
-  if (value.isObject() && value.asObject(runtime).isHostObject(runtime)) {
-    auto ptr = std::dynamic_pointer_cast<JsiSkSVG>(
-        value.asObject(runtime).asHostObject(runtime));
-    if (ptr != nullptr) {
-      return ptr->getObject();
-    }
-  } else if (value.isNull()) {
+  auto ptr = tryGetJsiObject<JsiSkSVG>(runtime, value);
+  if (ptr != nullptr) {
+    return ptr->getObject();
+  }
+  if (value.isNull()) {
     return nullptr;
   }
   throw std::runtime_error(
@@ -454,13 +449,11 @@ sk_sp<SkSVGDOM> getPropertyValue(jsi::Runtime &runtime,
 template <>
 sk_sp<skottie::Animation> getPropertyValue(jsi::Runtime &runtime,
                                            const jsi::Value &value) {
-  if (value.isObject() && value.asObject(runtime).isHostObject(runtime)) {
-    auto ptr = std::dynamic_pointer_cast<JsiSkSkottie>(
-        value.asObject(runtime).asHostObject(runtime));
-    if (ptr != nullptr) {
-      return ptr->getObject()->_animation;
-    }
-  } else if (value.isNull()) {
+  auto ptr = tryGetJsiObject<JsiSkSkottie>(runtime, value);
+  if (ptr != nullptr) {
+    return ptr->getObject()->_animation;
+  }
+  if (value.isNull()) {
     return nullptr;
   }
   throw std::runtime_error(
@@ -470,13 +463,11 @@ sk_sp<skottie::Animation> getPropertyValue(jsi::Runtime &runtime,
 template <>
 sk_sp<SkImageFilter> getPropertyValue(jsi::Runtime &runtime,
                                       const jsi::Value &value) {
-  if (value.isObject() && value.asObject(runtime).isHostObject(runtime)) {
-    auto ptr = std::dynamic_pointer_cast<JsiSkImageFilter>(
-        value.asObject(runtime).asHostObject(runtime));
-    if (ptr != nullptr) {
-      return ptr->getObject();
-    }
-  } else if (value.isNull()) {
+  auto ptr = tryGetJsiObject<JsiSkImageFilter>(runtime, value);
+  if (ptr != nullptr) {
+    return ptr->getObject();
+  }
+  if (value.isNull()) {
     return nullptr;
   }
   throw std::runtime_error(
@@ -487,9 +478,7 @@ template <>
 sk_sp<SkPicture> getPropertyValue(jsi::Runtime &runtime,
                                   const jsi::Value &value) {
   if (value.isObject()) {
-    auto picture = value.asObject(runtime)
-                       .asHostObject<JsiSkPicture>(runtime)
-                       ->getObject();
+    auto picture = getJsiObject<JsiSkPicture>(runtime, value)->getObject();
     return picture;
   }
   throw std::runtime_error("Invalid prop value for SkTextBlob received");
@@ -498,8 +487,7 @@ sk_sp<SkPicture> getPropertyValue(jsi::Runtime &runtime,
 template <>
 SkPaint getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
   if (value.isObject()) {
-    auto paint =
-        value.asObject(runtime).asHostObject<JsiSkPaint>(runtime)->getObject();
+    auto paint = getJsiObject<JsiSkPaint>(runtime, value)->getObject();
     return SkPaint(*paint);
   }
   throw std::runtime_error("Invalid prop value for SkPaint received");
@@ -508,28 +496,15 @@ SkPaint getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
 template <>
 std::shared_ptr<JsiSkParagraph> getPropertyValue(jsi::Runtime &runtime,
                                                  const jsi::Value &value) {
-  if (value.isObject()) {
-    auto hostObject = value.asObject(runtime).asHostObject(runtime);
-    if (!hostObject) {
-      return nullptr;
-    }
-    auto para = std::dynamic_pointer_cast<JsiSkParagraph>(hostObject);
-    if (!para) {
-      return nullptr;
-    }
-    // Return a shared_ptr instead of raw pointer
-    return para;
-  }
-  return nullptr;
+  // Return a shared_ptr instead of raw pointer
+  return tryGetJsiObject<JsiSkParagraph>(runtime, value);
 }
 
 template <>
 sk_sp<SkTextBlob> getPropertyValue(jsi::Runtime &runtime,
                                    const jsi::Value &value) {
   if (value.isObject()) {
-    auto blob = value.asObject(runtime)
-                    .asHostObject<JsiSkTextBlob>(runtime)
-                    ->getObject();
+    auto blob = getJsiObject<JsiSkTextBlob>(runtime, value)->getObject();
     return blob;
   }
   throw std::runtime_error("Invalid prop value for SkTextBlob received");
@@ -539,9 +514,7 @@ template <>
 sk_sp<SkRuntimeEffect> getPropertyValue(jsi::Runtime &runtime,
                                         const jsi::Value &value) {
   if (value.isObject()) {
-    auto effect = value.asObject(runtime)
-                      .asHostObject<JsiSkRuntimeEffect>(runtime)
-                      ->getObject();
+    auto effect = getJsiObject<JsiSkRuntimeEffect>(runtime, value)->getObject();
     return effect;
   }
   throw std::runtime_error("Invalid prop value for SkRuntimeEffect received");
@@ -552,8 +525,7 @@ sk_sp<SkImage> getPropertyValue(jsi::Runtime &runtime,
                                 const jsi::Value &value) {
 
   if (value.isObject()) {
-    auto effect =
-        value.asObject(runtime).asHostObject<JsiSkImage>(runtime)->getObject();
+    auto effect = getJsiObject<JsiSkImage>(runtime, value)->getObject();
     return effect;
   } else if (value.isNull()) {
     return nullptr;
@@ -564,11 +536,9 @@ sk_sp<SkImage> getPropertyValue(jsi::Runtime &runtime,
 template <>
 SkMatrix getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
   if (value.isObject()) {
-    auto object = value.asObject(runtime);
-
-    if (object.isHostObject(runtime)) {
-      auto matrix =
-          object.asHostObject<JsiSkMatrix>(runtime)->getObject().get();
+    auto ptr = tryGetJsiObject<JsiSkMatrix>(runtime, value);
+    if (ptr != nullptr) {
+      auto matrix = ptr->getObject().get();
       return SkMatrix(*matrix);
     } else {
       return JsiSkMatrix::getMatrix(runtime, value);
@@ -1008,10 +978,10 @@ Layer getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
   if (value.isBool()) {
     Layer layer = value.asBool();
     return layer;
-  } else if (value.isObject() &&
-             value.asObject(runtime).isHostObject(runtime)) {
-    auto paint =
-        value.asObject(runtime).asHostObject<JsiSkPaint>(runtime)->getObject();
+  }
+  auto ptr = tryGetJsiObject<JsiSkPaint>(runtime, value);
+  if (ptr != nullptr) {
+    auto paint = ptr->getObject();
     Layer layer = SkPaint(*paint);
     return layer;
   }

package/cpp/api/recorder/DataTypes.h

@@ -51,12 +51,9 @@ std::shared_ptr<SkRect> processRect(jsi::Runtime &runtime,
                                     const jsi::Value &value) {
   if (value.isObject()) {
     auto object = value.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      auto ptr = std::dynamic_pointer_cast<JsiSkRect>(
-          value.asObject(runtime).asHostObject(runtime));
-      if (ptr != nullptr) {
-        return ptr->getObject();
-      }
+    auto ptr = tryGetJsiObject<JsiSkRect>(runtime, object);
+    if (ptr != nullptr) {
+      return ptr->getObject();
     } else if (object.hasProperty(runtime, "x") &&
                object.hasProperty(runtime, "y") &&
                object.hasProperty(runtime, "width") &&
@@ -88,12 +85,9 @@ std::shared_ptr<SkRRect> processRRect(jsi::Runtime &runtime,
                                       const jsi::Value &value) {
   if (value.isObject()) {
     auto object = value.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      auto ptr = std::dynamic_pointer_cast<JsiSkRRect>(
-          value.asObject(runtime).asHostObject(runtime));
-      if (ptr != nullptr) {
-        return ptr->getObject();
-      }
+    auto ptr = tryGetJsiObject<JsiSkRRect>(runtime, object);
+    if (ptr != nullptr) {
+      return ptr->getObject();
     } else if (object.hasProperty(runtime, "rect") &&
                object.hasProperty(runtime, "rx") &&
                object.hasProperty(runtime, "ry")) {
@@ -136,10 +130,8 @@ std::shared_ptr<SkPath> processPath(jsi::Runtime &runtime,
     } else {
       throw std::runtime_error("Could not parse path from string.");
     }
-  } else if (value.isObject() &&
-             value.asObject(runtime).isHostObject(runtime)) {
-    auto ptr = std::dynamic_pointer_cast<JsiSkPath>(
-        value.asObject(runtime).asHostObject(runtime));
+  } else {
+    auto ptr = tryGetJsiObject<JsiSkPath>(runtime, value);
     if (ptr != nullptr) {
       return std::make_shared<SkPath>(ptr->getObject()->snapshot());
     }

package/cpp/api/recorder/JsiRecorder.h

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "api/JsiSkCanvas.h"
-#include "api/JsiSkHostObjects.h"
+#include "api/JsiSkNativeObjects.h"
 #include "api/JsiSkPicture.h"
 
 #include "DrawingCtx.h"
@@ -19,11 +19,14 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiRecorder : public JsiSkWrappingSharedPtrHostObject<Recorder> {
+class JsiRecorder
+    : public JsiSkWrappingSharedPtrNativeObject<JsiRecorder, Recorder> {
 public:
+  static constexpr const char *CLASS_NAME = "Recorder";
+
   JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkWrappingSharedPtrHostObject(std::move(context),
-                                         std::make_shared<Recorder>()) {
+      : JsiSkWrappingSharedPtrNativeObject<JsiRecorder, Recorder>(
+            std::move(context), std::make_shared<Recorder>()) {
     getObject()->_context = getContext();
   }
 
@@ -61,7 +64,8 @@ public:
 
     // Get the JsiSkPicture from the argument
     auto pictureObject = arguments[0].asObject(runtime);
-    auto pictureHostObject = pictureObject.asHostObject<JsiSkPicture>(runtime);
+    auto pictureHostObject =
+        tryGetJsiObject<JsiSkPicture>(runtime, pictureObject);
     if (!pictureHostObject) {
       throw jsi::JSError(runtime, "Invalid Picture object provided to play()");
     }
@@ -302,65 +306,89 @@ public:
     return jsi::Value::undefined();
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiRecorder, Recorder)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiRecorder, saveGroup),
-                       JSI_EXPORT_FUNC(JsiRecorder, restoreGroup),
-                       JSI_EXPORT_FUNC(JsiRecorder, savePaint),
-                       JSI_EXPORT_FUNC(JsiRecorder, restorePaint),
-                       JSI_EXPORT_FUNC(JsiRecorder, restorePaintDeclaration),
-                       JSI_EXPORT_FUNC(JsiRecorder, materializePaint),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushPathEffect),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushImageFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushColorFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushShader),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushBlurMaskFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, composePathEffect),
-                       JSI_EXPORT_FUNC(JsiRecorder, composeColorFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, composeImageFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, saveCTM),
-                       JSI_EXPORT_FUNC(JsiRecorder, restoreCTM),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPaint),
-                       JSI_EXPORT_FUNC(JsiRecorder, saveLayer),
-                       JSI_EXPORT_FUNC(JsiRecorder, saveBackdropFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawBox),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawImage),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawCircle),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPoints),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPath),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawRect),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawRRect),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawOval),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawLine),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPatch),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawVertices),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawDiffRect),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawText),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawTextPath),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawTextBlob),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawGlyphs),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPicture),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawImageSVG),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawParagraph),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawAtlas),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawSkottie),
-                       JSI_EXPORT_FUNC(JsiRecorder, play),
-                       JSI_EXPORT_FUNC(JsiRecorder, applyUpdates),
-                       JSI_EXPORT_FUNC(JsiRecorder, reset))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "saveGroup", &JsiRecorder::saveGroup);
+    installHostMethod(runtime, prototype, "restoreGroup",
+                      &JsiRecorder::restoreGroup);
+    installHostMethod(runtime, prototype, "savePaint", &JsiRecorder::savePaint);
+    installHostMethod(runtime, prototype, "restorePaint",
+                      &JsiRecorder::restorePaint);
+    installHostMethod(runtime, prototype, "restorePaintDeclaration",
+                      &JsiRecorder::restorePaintDeclaration);
+    installHostMethod(runtime, prototype, "materializePaint",
+                      &JsiRecorder::materializePaint);
+    installHostMethod(runtime, prototype, "pushPathEffect",
+                      &JsiRecorder::pushPathEffect);
+    installHostMethod(runtime, prototype, "pushImageFilter",
+                      &JsiRecorder::pushImageFilter);
+    installHostMethod(runtime, prototype, "pushColorFilter",
+                      &JsiRecorder::pushColorFilter);
+    installHostMethod(runtime, prototype, "pushShader",
+                      &JsiRecorder::pushShader);
+    installHostMethod(runtime, prototype, "pushBlurMaskFilter",
+                      &JsiRecorder::pushBlurMaskFilter);
+    installHostMethod(runtime, prototype, "composePathEffect",
+                      &JsiRecorder::composePathEffect);
+    installHostMethod(runtime, prototype, "composeColorFilter",
+                      &JsiRecorder::composeColorFilter);
+    installHostMethod(runtime, prototype, "composeImageFilter",
+                      &JsiRecorder::composeImageFilter);
+    installHostMethod(runtime, prototype, "saveCTM", &JsiRecorder::saveCTM);
+    installHostMethod(runtime, prototype, "restoreCTM",
+                      &JsiRecorder::restoreCTM);
+    installHostMethod(runtime, prototype, "drawPaint", &JsiRecorder::drawPaint);
+    installHostMethod(runtime, prototype, "saveLayer", &JsiRecorder::saveLayer);
+    installHostMethod(runtime, prototype, "saveBackdropFilter",
+                      &JsiRecorder::saveBackdropFilter);
+    installHostMethod(runtime, prototype, "drawBox", &JsiRecorder::drawBox);
+    installHostMethod(runtime, prototype, "drawImage", &JsiRecorder::drawImage);
+    installHostMethod(runtime, prototype, "drawCircle",
+                      &JsiRecorder::drawCircle);
+    installHostMethod(runtime, prototype, "drawPoints",
+                      &JsiRecorder::drawPoints);
+    installHostMethod(runtime, prototype, "drawPath", &JsiRecorder::drawPath);
+    installHostMethod(runtime, prototype, "drawRect", &JsiRecorder::drawRect);
+    installHostMethod(runtime, prototype, "drawRRect", &JsiRecorder::drawRRect);
+    installHostMethod(runtime, prototype, "drawOval", &JsiRecorder::drawOval);
+    installHostMethod(runtime, prototype, "drawLine", &JsiRecorder::drawLine);
+    installHostMethod(runtime, prototype, "drawPatch", &JsiRecorder::drawPatch);
+    installHostMethod(runtime, prototype, "drawVertices",
+                      &JsiRecorder::drawVertices);
+    installHostMethod(runtime, prototype, "drawDiffRect",
+                      &JsiRecorder::drawDiffRect);
+    installHostMethod(runtime, prototype, "drawText", &JsiRecorder::drawText);
+    installHostMethod(runtime, prototype, "drawTextPath",
+                      &JsiRecorder::drawTextPath);
+    installHostMethod(runtime, prototype, "drawTextBlob",
+                      &JsiRecorder::drawTextBlob);
+    installHostMethod(runtime, prototype, "drawGlyphs",
+                      &JsiRecorder::drawGlyphs);
+    installHostMethod(runtime, prototype, "drawPicture",
+                      &JsiRecorder::drawPicture);
+    installHostMethod(runtime, prototype, "drawImageSVG",
+                      &JsiRecorder::drawImageSVG);
+    installHostMethod(runtime, prototype, "drawParagraph",
+                      &JsiRecorder::drawParagraph);
+    installHostMethod(runtime, prototype, "drawAtlas", &JsiRecorder::drawAtlas);
+    installHostMethod(runtime, prototype, "drawSkottie",
+                      &JsiRecorder::drawSkottie);
+    installHostMethod(runtime, prototype, "play", &JsiRecorder::play);
+    installHostMethod(runtime, prototype, "applyUpdates",
+                      &JsiRecorder::applyUpdates);
+    installHostMethod(runtime, prototype, "reset", &JsiRecorder::reset);
+  }
 
   // This has no basis in reality but since since these are private long-lived
   // objects, we think it is more than fine.
-  size_t getMemoryPressure() const override { return 5 * 1024 * 1024; }
-
-  std::string getObjectType() const override { return "JsiRecorder"; }
+  size_t getMemoryPressure() override { return 5 * 1024 * 1024; }
 
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {
     return JSI_HOST_FUNCTION_LAMBDA {
       // Return the newly constructed object
       auto recorder = std::make_shared<JsiRecorder>(std::move(context));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, recorder,
-                                                         context);
+      return makeJsiObject(runtime, std::move(recorder));
     };
   }
 };

package/cpp/api/recorder/RNRecorder.h

@@ -17,8 +17,8 @@
 #include "ImageFilters.h"
 #include "Paint.h"
 #include "PathEffects.h"
-#include "rnskia/RNSkPlatformContext.h"
 #include "Shaders.h"
+#include "rnskia/RNSkPlatformContext.h"
 
 namespace RNSkia {