@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkRect.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,50 +18,46 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkRect : public JsiSkWrappingSharedPtrHostObject<SkRect> {
+class JsiSkRect : public JsiSkWrappingSharedPtrNativeObject<JsiSkRect, SkRect> {
 public:
-  JSI_PROPERTY_GET(x) { return static_cast<double>(getObject()->x()); }
-  JSI_PROPERTY_GET(y) { return static_cast<double>(getObject()->y()); }
-  JSI_PROPERTY_GET(width) { return static_cast<double>(getObject()->width()); }
-  JSI_PROPERTY_GET(height) {
-    return static_cast<double>(getObject()->height());
+  static constexpr const char *CLASS_NAME = "Rect";
+
+  double getX() { return static_cast<double>(getObject()->x()); }
+  double getY() { return static_cast<double>(getObject()->y()); }
+  double getWidth() { return static_cast<double>(getObject()->width()); }
+  double getHeight() { return static_cast<double>(getObject()->height()); }
+  double getLeft() { return static_cast<double>(getObject()->left()); }
+  double getTop() { return static_cast<double>(getObject()->top()); }
+  double getRight() { return static_cast<double>(getObject()->right()); }
+  double getBottom() { return static_cast<double>(getObject()->bottom()); }
+
+  void setXYWH(double x, double y, double width, double height) {
+    getObject()->setXYWH(x, y, width, height);
   }
-  JSI_PROPERTY_GET(left) { return static_cast<double>(getObject()->left()); }
-  JSI_PROPERTY_GET(top) { return static_cast<double>(getObject()->top()); }
-  JSI_PROPERTY_GET(right) { return static_cast<double>(getObject()->right()); }
-  JSI_PROPERTY_GET(bottom) {
-    return static_cast<double>(getObject()->bottom());
-  }
-
-  JSI_API_TYPENAME("Rect");
-
-  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkRect, x),
-                              JSI_EXPORT_PROP_GET(JsiSkRect, y),
-                              JSI_EXPORT_PROP_GET(JsiSkRect, width),
-                              JSI_EXPORT_PROP_GET(JsiSkRect, height),
-                              JSI_EXPORT_PROP_GET(JsiSkRect, __typename__))
 
-  JSI_HOST_FUNCTION(setXYWH) {
-    getObject()->setXYWH(arguments[0].asNumber(), arguments[1].asNumber(),
-                         arguments[2].asNumber(), arguments[3].asNumber());
-    return jsi::Value::undefined();
+  void setLTRB(double left, double top, double right, double bottom) {
+    getObject()->setLTRB(left, top, right, bottom);
   }
 
-  JSI_HOST_FUNCTION(setLTRB) {
-    getObject()->setLTRB(arguments[0].asNumber(), arguments[1].asNumber(),
-                         arguments[2].asNumber(), arguments[3].asNumber());
-    return jsi::Value::undefined();
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installGetter(runtime, prototype, "x", &JsiSkRect::getX);
+    installGetter(runtime, prototype, "y", &JsiSkRect::getY);
+    installGetter(runtime, prototype, "width", &JsiSkRect::getWidth);
+    installGetter(runtime, prototype, "height", &JsiSkRect::getHeight);
+    installGetter(runtime, prototype, "left", &JsiSkRect::getLeft);
+    installGetter(runtime, prototype, "top", &JsiSkRect::getTop);
+    installGetter(runtime, prototype, "right", &JsiSkRect::getRight);
+    installGetter(runtime, prototype, "bottom", &JsiSkRect::getBottom);
+    installMethod(runtime, prototype, "setXYWH", &JsiSkRect::setXYWH);
+    installMethod(runtime, prototype, "setLTRB", &JsiSkRect::setLTRB);
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRect, setXYWH),
-                       JSI_EXPORT_FUNC(JsiSkRect, setLTRB),
-                       JSI_EXPORT_FUNC(JsiSkRect, dispose))
-
   /**
    Constructor
    */
   JsiSkRect(std::shared_ptr<RNSkPlatformContext> context, const SkRect &rect)
-      : JsiSkWrappingSharedPtrHostObject<SkRect>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkRect, SkRect>(
             std::move(context), std::make_shared<SkRect>(rect)) {}
 
   /**
@@ -70,8 +66,9 @@ public:
   static std::shared_ptr<SkRect> fromValue(jsi::Runtime &runtime,
                                            const jsi::Value &obj) {
     const auto &object = obj.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      return object.asHostObject<JsiSkRect>(runtime)->getObject();
+    auto rect = tryGetJsiObject<JsiSkRect>(runtime, object);
+    if (rect) {
+      return rect->getObject();
     } else {
       auto x = object.getProperty(runtime, "x").asNumber();
       auto y = object.getProperty(runtime, "y").asNumber();
@@ -87,25 +84,20 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkRect &rect) {
-    auto rectObj = std::make_shared<JsiSkRect>(std::move(context), rect);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rectObj,
-                                                       context);
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkRect>(std::move(context), rect));
   }
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             SkRect &&rect) {
-    auto rectObj =
-        std::make_shared<JsiSkRect>(std::move(context), std::move(rect));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rectObj,
-                                                       context);
+    return makeJsiObject(runtime, std::make_shared<JsiSkRect>(
+                                      std::move(context), std::move(rect)));
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkRect), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override { return "JsiSkRect"; }
-
   /**
    * Creates the function for construction a new instance of the SkRect
    * wrapper
@@ -122,10 +114,8 @@ public:
                            arguments[2].asNumber(), arguments[3].asNumber());
 
       // Return the newly constructed object
-      auto rectObj =
-          std::make_shared<JsiSkRect>(std::move(context), std::move(rect));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rectObj,
-                                                         context);
+      return makeJsiObject(runtime, std::make_shared<JsiSkRect>(
+                                        std::move(context), std::move(rect)));
     };
   }
 };

package/cpp/api/JsiSkRuntimeEffect.h

@@ -5,8 +5,9 @@
 #include <utility>
 #include <vector>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkConverters.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkShader.h"
 
 #include <jsi/jsi.h>
@@ -36,115 +37,111 @@ struct RuntimeEffectUniform {
   bool isInteger;
 };
 
-class JsiSkRuntimeEffect
-    : public JsiSkWrappingSkPtrHostObject<SkRuntimeEffect> {
-public:
-  JSI_HOST_FUNCTION(makeShader) {
-    auto uniforms = castUniforms(runtime, arguments[0]);
-
-    auto matrix =
-        count >= 2 && !arguments[1].isUndefined() && !arguments[1].isNull()
-            ? JsiSkMatrix::fromValue(runtime, arguments[1]).get()
-            : nullptr;
-
-    // Create and return shader as host object
-    auto shader =
-        getObject()->makeShader(std::move(uniforms), nullptr, 0, matrix);
-
-    auto shaderObj =
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+} // namespace RNSkia
+
+namespace rnwgpu {
+
+// RuntimeEffectUniform -> {columns, rows, slot, isInteger}
+template <> struct JSIConverter<RNSkia::RuntimeEffectUniform> {
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          const RNSkia::RuntimeEffectUniform &u) {
+    jsi::Object result(runtime);
+    result.setProperty(runtime, "columns", u.columns);
+    result.setProperty(runtime, "rows", u.rows);
+    result.setProperty(runtime, "slot", u.slot);
+    result.setProperty(runtime, "isInteger", u.isInteger);
+    return result;
   }
+};
 
-  JSI_HOST_FUNCTION(makeShaderWithChildren) {
-    auto uniforms = castUniforms(runtime, arguments[0]);
-
-    // Children
-    std::vector<sk_sp<SkShader>> children;
-    auto jsiChildren = arguments[1].asObject(runtime).asArray(runtime);
-    auto jsiChildCount = jsiChildren.size(runtime);
-    children.reserve(jsiChildCount);
-    for (int i = 0; i < jsiChildCount; i++) {
-      auto shader = jsiChildren.getValueAtIndex(runtime, i)
-                        .asObject(runtime)
-                        .asHostObject<JsiSkShader>(runtime)
-                        ->getObject();
-      children.push_back(shader);
-    }
+} // namespace rnwgpu
 
-    auto matrix =
-        count >= 3 && !arguments[2].isUndefined() && !arguments[2].isNull()
-            ? JsiSkMatrix::fromValue(runtime, arguments[2]).get()
-            : nullptr;
+namespace RNSkia {
 
-    // Create and return shader as host object
-    auto shader = getObject()->makeShader(std::move(uniforms), children.data(),
-                                          children.size(), matrix);
+class JsiSkRuntimeEffect
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkRuntimeEffect,
+                                            SkRuntimeEffect> {
+public:
+  static constexpr const char *CLASS_NAME = "RuntimeEffect";
+
+  std::shared_ptr<JsiSkShader>
+  makeShader(std::vector<double> uniformValues,
+             JsiOptional<std::shared_ptr<SkMatrix>> matrix) {
+    auto uniforms = castUniforms(uniformValues);
+    auto shader = getObject()->makeShader(
+        std::move(uniforms), nullptr, 0,
+        matrix.has_value() ? matrix->get() : nullptr);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(shader));
+  }
 
-    auto shaderObj =
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+  std::shared_ptr<JsiSkShader>
+  makeShaderWithChildren(std::vector<double> uniformValues,
+                         std::vector<sk_sp<SkShader>> children,
+                         JsiOptional<std::shared_ptr<SkMatrix>> matrix) {
+    auto uniforms = castUniforms(uniformValues);
+    auto shader = getObject()->makeShader(
+        std::move(uniforms), children.data(), children.size(),
+        matrix.has_value() ? matrix->get() : nullptr);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(shader));
   }
 
-  JSI_HOST_FUNCTION(getUniformCount) {
+  int getUniformCount() {
     return static_cast<int>(getObject()->uniforms().size());
   }
 
-  JSI_HOST_FUNCTION(getUniformFloatCount) {
+  int getUniformFloatCount() {
     return static_cast<int>(getObject()->uniformSize() / sizeof(float));
   }
 
-  JSI_HOST_FUNCTION(getUniformName) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  std::string getUniformName(int i) {
     if (i < 0 || i >= getObject()->uniforms().size()) {
-      throw jsi::JSError(runtime, "invalid uniform index");
+      throw std::runtime_error("invalid uniform index");
     }
     auto it = getObject()->uniforms().begin() + i;
-    return jsi::String::createFromAscii(runtime, std::string(it->name));
+    return std::string(it->name);
   }
 
-  JSI_HOST_FUNCTION(getUniform) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  RuntimeEffectUniform getUniform(int i) {
     if (i < 0 || i >= getObject()->uniforms().size()) {
-      throw jsi::JSError(runtime, "invalid uniform index");
+      throw std::runtime_error("invalid uniform index");
     }
     auto it = getObject()->uniforms().begin() + i;
-    auto result = jsi::Object(runtime);
-    RuntimeEffectUniform su = fromUniform(*it);
-    result.setProperty(runtime, "columns", su.columns);
-    result.setProperty(runtime, "rows", su.rows);
-    result.setProperty(runtime, "slot", su.slot);
-    result.setProperty(runtime, "isInteger", su.isInteger);
-    return result;
+    return fromUniform(*it);
   }
 
-  JSI_HOST_FUNCTION(source) {
-    return jsi::String::createFromAscii(runtime, getObject()->source());
+  std::string source() { return std::string(getObject()->source()); }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "makeShader",
+                  &JsiSkRuntimeEffect::makeShader);
+    installMethod(runtime, prototype, "makeShaderWithChildren",
+                  &JsiSkRuntimeEffect::makeShaderWithChildren);
+    installMethod(runtime, prototype, "getUniformCount",
+                  &JsiSkRuntimeEffect::getUniformCount);
+    installMethod(runtime, prototype, "getUniformFloatCount",
+                  &JsiSkRuntimeEffect::getUniformFloatCount);
+    installMethod(runtime, prototype, "getUniformName",
+                  &JsiSkRuntimeEffect::getUniformName);
+    installMethod(runtime, prototype, "getUniform",
+                  &JsiSkRuntimeEffect::getUniform);
+    installMethod(runtime, prototype, "source", &JsiSkRuntimeEffect::source);
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkRuntimeEffect, RuntimeEffect)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRuntimeEffect, makeShader),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeEffect,
-                                       makeShaderWithChildren),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniformCount),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeEffect,
-                                       getUniformFloatCount),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniformName),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniform),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeEffect, source),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeEffect, dispose))
-
   JsiSkRuntimeEffect(std::shared_ptr<RNSkPlatformContext> context,
                      sk_sp<SkRuntimeEffect> rt)
-      : JsiSkWrappingSkPtrHostObject<SkRuntimeEffect>(std::move(context),
-                                                      std::move(rt)) {}
-
-  size_t getMemoryPressure() const override { return 4096; }
+      : JsiSkWrappingSkPtrNativeObject<JsiSkRuntimeEffect, SkRuntimeEffect>(
+            std::move(context), std::move(rt)) {}
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkRuntimeEffect> fromValue(jsi::Runtime &runtime,
+                                          const jsi::Value &obj) {
+    return getJsiObject<JsiSkRuntimeEffect>(runtime, obj)->getObject();
+  }
 
-  std::string getObjectType() const override { return "JsiSkRuntimeEffect"; }
+  size_t getMemoryPressure() override { return 4096; }
 
   static RuntimeEffectUniform fromUniform(const SkRuntimeEffect::Uniform &u) {
     RuntimeEffectUniform su;
@@ -197,17 +194,13 @@ public:
   }
 
 private:
-  sk_sp<SkData> castUniforms(jsi::Runtime &runtime, const jsi::Value &value) {
-    auto jsiUniforms = value.asObject(runtime).asArray(runtime);
-    auto jsiUniformsSize = jsiUniforms.size(runtime);
-
+  sk_sp<SkData> castUniforms(const std::vector<double> &values) {
     // verify size of input uniforms
-    if (jsiUniformsSize * sizeof(float) != getObject()->uniformSize()) {
-      std::string msg =
+    if (values.size() * sizeof(float) != getObject()->uniformSize()) {
+      throw std::runtime_error(
           "Uniforms size differs from effect's uniform size. Received " +
-          std::to_string(jsiUniformsSize) + " expected " +
-          std::to_string(getObject()->uniformSize() / sizeof(float));
-      throw jsi::JSError(runtime, msg.c_str());
+          std::to_string(values.size()) + " expected " +
+          std::to_string(getObject()->uniformSize() / sizeof(float)));
     }
 
     auto uniforms = SkData::MakeUninitialized(getObject()->uniformSize());
@@ -219,7 +212,7 @@ private:
       RuntimeEffectUniform reu = fromUniform(*it);
       for (std::size_t j = 0; j < reu.columns * reu.rows; ++j) {
         const std::size_t offset = reu.slot + j;
-        float fValue = jsiUniforms.getValueAtIndex(runtime, offset).asNumber();
+        float fValue = static_cast<float>(values[offset]);
         int iValue = static_cast<int>(fValue);
         auto value = reu.isInteger ? SkBits2Float(iValue) : fValue;
         memcpy(SkTAddOffset<void>(uniforms->writable_data(),

package/cpp/api/JsiSkRuntimeEffectFactory.h

@@ -6,43 +6,39 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkRuntimeEffect.h"
 
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkRuntimeEffectFactory : public JsiSkHostObject {
+class JsiSkRuntimeEffectFactory
+    : public JsiSkNativeObject<JsiSkRuntimeEffectFactory> {
 public:
-  JSI_HOST_FUNCTION(Make) {
-    auto sksl = arguments[0].asString(runtime).utf8(runtime);
+  static constexpr const char *CLASS_NAME = "RuntimeEffectFactory";
+
+  std::shared_ptr<JsiSkRuntimeEffect> Make(std::string sksl) {
     auto result = SkRuntimeEffect::MakeForShader(SkString(sksl));
     auto effect = result.effect;
     auto errorText = result.errorText;
     if (!effect) {
-      throw jsi::JSError(runtime, std::string("Error in sksl:\n" +
-                                              std::string(errorText.c_str()))
-                                      .c_str());
-      return jsi::Value::null();
+      throw std::runtime_error("Error in sksl:\n" +
+                               std::string(errorText.c_str()));
     }
-    auto runtimeEffect =
-        std::make_shared<JsiSkRuntimeEffect>(getContext(), std::move(effect));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, runtimeEffect,
-                                                       getContext());
+    return std::make_shared<JsiSkRuntimeEffect>(getContext(),
+                                                std::move(effect));
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
+  size_t getMemoryPressure() override { return 1024; }
 
-  std::string getObjectType() const override {
-    return "JsiSkRuntimeEffectFactory";
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installMethod(runtime, prototype, "Make", &JsiSkRuntimeEffectFactory::Make);
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRuntimeEffectFactory, Make))
-
   explicit JsiSkRuntimeEffectFactory(
       std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkRuntimeEffectFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkRuntimeShaderBuilder.h

@@ -1,12 +1,13 @@
 #pragma once
 
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -21,34 +22,39 @@ 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) {
-    auto name = arguments[0].asString(runtime).utf8(runtime);
-    auto jsiValue = arguments[1].asObject(runtime).asArray(runtime);
-    auto size = jsiValue.size(runtime);
-    std::vector<SkScalar> value;
-    value.reserve(size);
-    for (int i = 0; i < size; i++) {
-      auto e = jsiValue.getValueAtIndex(runtime, i).asNumber();
-      value.push_back(e);
-    }
+  void setUniform(std::string name, std::vector<float> value) {
     getObject()
         ->uniform(name.c_str())
-        .set(value.data(), static_cast<int>(size));
-    return jsi::Value::undefined();
+        .set(value.data(), static_cast<int>(value.size()));
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "setUniform",
+                  &JsiSkRuntimeShaderBuilder::setUniform);
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRuntimeShaderBuilder, setUniform),
-                       JSI_EXPORT_FUNC(JsiSkRuntimeShaderBuilder, dispose))
+  /**
+    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 +62,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 +83,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,38 +18,40 @@ 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) {
+  double width() {
     return static_cast<double>(getObject()->containerSize().width());
   }
 
-  JSI_HOST_FUNCTION(height) {
+  double height() {
     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);
+    installMethod(runtime, prototype, "width", &JsiSkSVG::width);
+    installMethod(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