@shopify/react-native-skia 2.9.1 → 2.10.0

package/cpp/api/JsiSkRuntimeShaderBuilder.h

@@ -6,7 +6,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -21,14 +21,18 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkRuntimeShaderBuilder
-    : public JsiSkWrappingSharedPtrHostObject<SkRuntimeShaderBuilder> {
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkRuntimeShaderBuilder,
+                                                SkRuntimeShaderBuilder> {
 public:
+  static constexpr const char *CLASS_NAME = "RuntimeShaderBuilder";
+
   /**
    Constructor
    */
   JsiSkRuntimeShaderBuilder(std::shared_ptr<RNSkPlatformContext> context,
                             const SkRuntimeShaderBuilder &rt)
-      : JsiSkWrappingSharedPtrHostObject<SkRuntimeShaderBuilder>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkRuntimeShaderBuilder,
+                                           SkRuntimeShaderBuilder>(
             std::move(context), std::make_shared<SkRuntimeShaderBuilder>(rt)) {}
 
   JSI_HOST_FUNCTION(setUniform) {
@@ -47,8 +51,19 @@ public:
     return jsi::Value::undefined();
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRuntimeShaderBuilder, setUniform),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeShaderBuilder, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "setUniform",
+                      &JsiSkRuntimeShaderBuilder::setUniform);
+  }
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkRuntimeShaderBuilder>
+  fromValue(jsi::Runtime &runtime, const jsi::Value &obj) {
+    return getJsiObject<JsiSkRuntimeShaderBuilder>(runtime, obj)->getObject();
+  }
 
   /**
     Returns the jsi object from a host object of this type
@@ -56,20 +71,14 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkRuntimeShaderBuilder &rt) {
-    auto builder =
-        std::make_shared<JsiSkRuntimeShaderBuilder>(std::move(context), rt);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, builder,
-                                                       context);
+    return makeJsiObject(runtime, std::make_shared<JsiSkRuntimeShaderBuilder>(
+                                      std::move(context), rt));
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkRuntimeShaderBuilder), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override {
-    return "JsiSkRuntimeShaderBuilder";
-  }
-
   /**
    * Creates the function for construction a new instance of the SkRect
    * wrapper
@@ -83,10 +92,8 @@ public:
       auto rt = JsiSkRuntimeEffect::fromValue(runtime, arguments[0]);
       auto rtb = SkRuntimeShaderBuilder(rt);
       // Return the newly constructed object
-      auto builder = std::make_shared<JsiSkRuntimeShaderBuilder>(
-          std::move(context), std::move(rtb));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, builder,
-                                                         context);
+      return makeJsiObject(runtime, std::make_shared<JsiSkRuntimeShaderBuilder>(
+                                        std::move(context), std::move(rtb)));
     };
   }
 };

package/cpp/api/JsiSkSVG.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,17 +18,17 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkSVG : public JsiSkWrappingSkPtrHostObject<SkSVGDOM> {
+class JsiSkSVG : public JsiSkWrappingSkPtrNativeObject<JsiSkSVG, SkSVGDOM> {
 public:
+  static constexpr const char *CLASS_NAME = "SVG";
+
   JsiSkSVG(std::shared_ptr<RNSkPlatformContext> context, sk_sp<SkSVGDOM> svgdom,
            sk_sp<skresources::ResourceProvider> resourceProvider = nullptr)
-      : JsiSkWrappingSkPtrHostObject<SkSVGDOM>(std::move(context),
-                                               std::move(svgdom)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkSVG, SkSVGDOM>(std::move(context),
+                                                           std::move(svgdom)) {}
 
   ~JsiSkSVG() = default;
 
-  EXPORT_JSI_API_TYPENAME(JsiSkSVG, SVG)
-
   JSI_HOST_FUNCTION(width) {
     return static_cast<double>(getObject()->containerSize().width());
   }
@@ -37,19 +37,21 @@ public:
     return static_cast<double>(getObject()->containerSize().height());
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSVG, width),
-                       JSI_EXPORT_FUNC(JsiSkSVG, height),
-                       JSI_EXPORT_FUNC(JsiSkSVG, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "width", &JsiSkSVG::width);
+    installHostMethod(runtime, prototype, "height", &JsiSkSVG::height);
+  }
 
   /**
     Returns the underlying object from a host object of this type
    */
   static sk_sp<SkSVGDOM> fromValue(jsi::Runtime &runtime,
                                    const jsi::Value &obj) {
-    return obj.asObject(runtime).asHostObject<JsiSkSVG>(runtime)->getObject();
+    return getJsiObject<JsiSkSVG>(runtime, obj)->getObject();
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto svgdom = getObject();
     if (!svgdom) {
       return 1024; // Base size if no SVG
@@ -72,8 +74,6 @@ public:
     return (rasterBufferSize / 4) +
            baseOverhead; // Quarter of full raster + overhead
   }
-
-  std::string getObjectType() const override { return "JsiSkSVG"; }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkSVGFactory.h

@@ -7,7 +7,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkSVG.h"
 #include "JsiSkTypeface.h"
 
@@ -55,8 +55,10 @@ private:
   const skresources::ImageDecodeStrategy fStrategy;
 };
 
-class JsiSkSVGFactory : public JsiSkHostObject {
+class JsiSkSVGFactory : public JsiSkNativeObject<JsiSkSVGFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "SVGFactory";
+
   // Helper function to parse asset map from JS object
   static SVGAssetProvider::AssetMap parseAssetMap(jsi::Runtime &runtime,
                                                   const jsi::Value &jsValue) {
@@ -83,15 +85,9 @@ public:
         continue;
       }
 
-      if (jsValue.isObject()) {
-        auto jsObject = jsValue.asObject(runtime);
-        if (jsObject.isHostObject(runtime)) {
-          auto hostObject = jsObject.getHostObject(runtime);
-          auto skData = std::dynamic_pointer_cast<JsiSkData>(hostObject);
-          if (skData) {
-            assets[key] = skData->getObject();
-          }
-        }
+      auto skData = tryGetJsiObject<JsiSkData>(runtime, jsValue);
+      if (skData) {
+        assets[key] = skData->getObject();
       }
     }
 
@@ -120,9 +116,8 @@ private:
     builder.setResourceProvider(provider);
 
     auto svg_dom = builder.make(*stream);
-    auto svg = std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, svg,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
   }
 
 public:
@@ -160,15 +155,17 @@ public:
                              std::move(assets));
   }
 
-  size_t getMemoryPressure() const override { return kMinMemoryPressure; }
-
-  std::string getObjectType() const override { return "JsiSkSVGFactory"; }
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromData),
-                       JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromString))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "MakeFromData",
+                      &JsiSkSVGFactory::MakeFromData);
+    installHostMethod(runtime, prototype, "MakeFromString",
+                      &JsiSkSVGFactory::MakeFromString);
+  }
 
   explicit JsiSkSVGFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkSVGFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkShader.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,18 +19,25 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkShader : public JsiSkWrappingSkPtrHostObject<SkShader> {
+class JsiSkShader
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkShader, SkShader> {
 public:
+  static constexpr const char *CLASS_NAME = "Shader";
+
   JsiSkShader(std::shared_ptr<RNSkPlatformContext> context,
               sk_sp<SkShader> shader)
-      : JsiSkWrappingSkPtrHostObject<SkShader>(std::move(context),
-                                               std::move(shader)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkShader, SkShader>(
+            std::move(context), std::move(shader)) {}
 
-  size_t getMemoryPressure() const override { return 1024 * 1024; }
+  size_t getMemoryPressure() override { return 1024 * 1024; }
 
-  std::string getObjectType() const override { return "JsiSkShader"; }
+  static sk_sp<SkShader> fromValue(jsi::Runtime &runtime,
+                                   const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkShader, Shader)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShader, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkShaderFactory.h

@@ -7,7 +7,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkColorFilter.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -75,8 +75,10 @@ std::vector<SkScalar> getPositions(jsi::Runtime &runtime,
   return positions;
 }
 
-class JsiSkShaderFactory : public JsiSkHostObject {
+class JsiSkShaderFactory : public JsiSkNativeObject<JsiSkShaderFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "ShaderFactory";
+
   JSI_HOST_FUNCTION(MakeLinearGradient) {
     auto p1 =
         *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
@@ -107,10 +109,8 @@ public:
     SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
     sk_sp<SkShader> gradient =
         SkShaders::LinearGradient(pts, grad, localMatrix);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(gradient)));
   }
 
   JSI_HOST_FUNCTION(MakeRadialGradient) {
@@ -141,10 +141,8 @@ public:
     SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
     sk_sp<SkShader> gradient =
         SkShaders::RadialGradient(center, r, grad, localMatrix);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(gradient)));
   }
 
   JSI_HOST_FUNCTION(MakeSweepGradient) {
@@ -179,10 +177,8 @@ public:
     SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
     sk_sp<SkShader> gradient = SkShaders::SweepGradient(
         SkPoint::Make(x, y), startAngle, endAngle, grad, localMatrix);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(gradient)));
   }
 
   JSI_HOST_FUNCTION(MakeTwoPointConicalGradient) {
@@ -218,10 +214,8 @@ public:
     sk_sp<SkShader> gradient = SkShaders::TwoPointConicalGradient(
         start, startRadius, end, endRadius, grad, localMatrix);
 
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(gradient)));
   }
 
   JSI_HOST_FUNCTION(MakeTurbulence) {
@@ -234,10 +228,8 @@ public:
     SkISize size = SkISize::Make(tileW, tileH);
     sk_sp<SkShader> gradient =
         SkShaders::MakeTurbulence(baseFreqX, baseFreqY, octaves, seed, &size);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(gradient)));
   }
 
   JSI_HOST_FUNCTION(MakeFractalNoise) {
@@ -250,10 +242,8 @@ public:
     SkISize size = SkISize::Make(tileW, tileH);
     sk_sp<SkShader> gradient =
         SkShaders::MakeFractalNoise(baseFreqX, baseFreqY, octaves, seed, &size);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(gradient)));
   }
 
   JSI_HOST_FUNCTION(MakeBlend) {
@@ -261,37 +251,40 @@ public:
     auto one = JsiSkShader::fromValue(runtime, arguments[1]);
     auto two = JsiSkShader::fromValue(runtime, arguments[2]);
     sk_sp<SkShader> gradient = SkShaders::Blend(blendMode, one, two);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(gradient)));
   }
 
   JSI_HOST_FUNCTION(MakeColor) {
     auto color = JsiSkColor::fromValue(runtime, arguments[0]);
     sk_sp<SkShader> gradient = SkShaders::Color(color);
-    auto shader =
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(gradient)));
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkShaderFactory"; }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeLinearGradient),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeRadialGradient),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeSweepGradient),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory,
-                                       MakeTwoPointConicalGradient),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeTurbulence),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeFractalNoise),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeBlend),
-                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeColor))
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "MakeLinearGradient",
+                      &JsiSkShaderFactory::MakeLinearGradient);
+    installHostMethod(runtime, prototype, "MakeRadialGradient",
+                      &JsiSkShaderFactory::MakeRadialGradient);
+    installHostMethod(runtime, prototype, "MakeSweepGradient",
+                      &JsiSkShaderFactory::MakeSweepGradient);
+    installHostMethod(runtime, prototype, "MakeTwoPointConicalGradient",
+                      &JsiSkShaderFactory::MakeTwoPointConicalGradient);
+    installHostMethod(runtime, prototype, "MakeTurbulence",
+                      &JsiSkShaderFactory::MakeTurbulence);
+    installHostMethod(runtime, prototype, "MakeFractalNoise",
+                      &JsiSkShaderFactory::MakeFractalNoise);
+    installHostMethod(runtime, prototype, "MakeBlend",
+                      &JsiSkShaderFactory::MakeBlend);
+    installHostMethod(runtime, prototype, "MakeColor",
+                      &JsiSkShaderFactory::MakeColor);
+  }
 
   explicit JsiSkShaderFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkShaderFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkSkottie.h

@@ -4,7 +4,7 @@
 
 #include "JsiSkCanvas.h"
 #include "JsiSkColor.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRect.h"
 #include "api/third_party/SkottieUtils.h"
@@ -146,8 +146,12 @@ 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) {
     return static_cast<double>(getObject()->_animation->duration());
@@ -155,12 +159,6 @@ public:
   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__))
   // #endregion
 
   // #region Methods
@@ -186,10 +184,7 @@ public:
   }
 
   JSI_HOST_FUNCTION(render) {
-    auto canvas = arguments[0]
-                      .asObject(runtime)
-                      .asHostObject<JsiSkCanvas>(runtime)
-                      ->getCanvas();
+    auto canvas = getJsiObject<JsiSkCanvas>(runtime, arguments[0])->getCanvas();
     if (count > 1) {
       auto rect = JsiSkRect::fromValue(runtime, arguments[1]);
       getObject()->_animation->render(canvas, rect.get());
@@ -554,29 +549,46 @@ 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);
+    installHostMethod(runtime, prototype, "duration", &JsiSkSkottie::duration);
+    installHostMethod(runtime, prototype, "fps", &JsiSkSkottie::fps);
+    installHostMethod(runtime, prototype, "seekFrame",
+                      &JsiSkSkottie::seekFrame);
+    installHostMethod(runtime, prototype, "render", &JsiSkSkottie::render);
+    installHostMethod(runtime, prototype, "size", &JsiSkSkottie::size);
+    installHostMethod(runtime, prototype, "version", &JsiSkSkottie::version);
+    installHostMethod(runtime, prototype, "getSlotInfo",
+                      &JsiSkSkottie::getSlotInfo);
+    installHostMethod(runtime, prototype, "setColorSlot",
+                      &JsiSkSkottie::setColorSlot);
+    installHostMethod(runtime, prototype, "setScalarSlot",
+                      &JsiSkSkottie::setScalarSlot);
+    installHostMethod(runtime, prototype, "setVec2Slot",
+                      &JsiSkSkottie::setVec2Slot);
+    installHostMethod(runtime, prototype, "setTextSlot",
+                      &JsiSkSkottie::setTextSlot);
+    installHostMethod(runtime, prototype, "setImageSlot",
+                      &JsiSkSkottie::setImageSlot);
+    installHostMethod(runtime, prototype, "getColorSlot",
+                      &JsiSkSkottie::getColorSlot);
+    installHostMethod(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);
+    installHostMethod(runtime, prototype, "setColor", &JsiSkSkottie::setColor);
+    installHostMethod(runtime, prototype, "setText", &JsiSkSkottie::setText);
+  }
   // #endregion
 
   /**
@@ -584,10 +596,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 +627,5 @@ public:
 
     return animationMemory + baseOverhead;
   }
-
-  std::string getObjectType() const override { return "JsiSkSkottie"; }
 };
 } // namespace RNSkia