@shopify/react-native-skia 2.9.1 → 2.10.0

package/cpp/api/JsiSkDataFactory.h

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

package/cpp/api/JsiSkFont.h

@@ -5,7 +5,7 @@
 #include <utility>
 #include <vector>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
@@ -26,8 +26,10 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFont : public JsiSkWrappingSharedPtrHostObject<SkFont> {
+class JsiSkFont : public JsiSkWrappingSharedPtrNativeObject<JsiSkFont, SkFont> {
 public:
+  static constexpr const char *CLASS_NAME = "Font";
+
   JSI_HOST_FUNCTION(getGlyphWidths) {
     auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
     std::vector<SkGlyphID> glyphs;
@@ -91,9 +93,8 @@ public:
       getObject()->measureText(str.c_str(), str.length(), SkTextEncoding::kUTF8,
                                &bounds);
     }
-    auto rect = std::make_shared<JsiSkRect>(getContext(), std::move(bounds));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rect,
-                                                       getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkRect>(getContext(), std::move(bounds)));
   }
 
   JSI_HOST_FUNCTION(getMetrics) {
@@ -251,39 +252,56 @@ public:
     return jsi::Value::undefined();
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkFont, Font)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFont, getSize),
-                       JSI_EXPORT_FUNC(JsiSkFont, getMetrics),
-                       JSI_EXPORT_FUNC(JsiSkFont, getGlyphIDs),
-                       JSI_EXPORT_FUNC(JsiSkFont, getGlyphIntercepts),
-                       JSI_EXPORT_FUNC(JsiSkFont, getScaleX),
-                       JSI_EXPORT_FUNC(JsiSkFont, getSkewX),
-                       JSI_EXPORT_FUNC(JsiSkFont, getTypeface),
-                       JSI_EXPORT_FUNC(JsiSkFont, setEdging),
-                       JSI_EXPORT_FUNC(JsiSkFont, embeddedBitmaps),
-                       JSI_EXPORT_FUNC(JsiSkFont, setHinting),
-                       JSI_EXPORT_FUNC(JsiSkFont, setLinearMetrics),
-                       JSI_EXPORT_FUNC(JsiSkFont, setScaleX),
-                       JSI_EXPORT_FUNC(JsiSkFont, setSkewX),
-                       JSI_EXPORT_FUNC(JsiSkFont, setSize),
-                       JSI_EXPORT_FUNC(JsiSkFont, setEmbolden),
-                       JSI_EXPORT_FUNC(JsiSkFont, setSubpixel),
-                       JSI_EXPORT_FUNC(JsiSkFont, setTypeface),
-                       JSI_EXPORT_FUNC(JsiSkFont, getGlyphWidths),
-                       JSI_EXPORT_FUNC(JsiSkFont, getTextWidth),
-                       JSI_EXPORT_FUNC(JsiSkFont, measureText),
-                       JSI_EXPORT_FUNC(JsiSkFont, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "getSize", &JsiSkFont::getSize);
+    installHostMethod(runtime, prototype, "getMetrics", &JsiSkFont::getMetrics);
+    installHostMethod(runtime, prototype, "getGlyphIDs",
+                      &JsiSkFont::getGlyphIDs);
+    installHostMethod(runtime, prototype, "getGlyphIntercepts",
+                      &JsiSkFont::getGlyphIntercepts);
+    installHostMethod(runtime, prototype, "getScaleX", &JsiSkFont::getScaleX);
+    installHostMethod(runtime, prototype, "getSkewX", &JsiSkFont::getSkewX);
+    installHostMethod(runtime, prototype, "getTypeface",
+                      &JsiSkFont::getTypeface);
+    installHostMethod(runtime, prototype, "setEdging", &JsiSkFont::setEdging);
+    installHostMethod(runtime, prototype, "embeddedBitmaps",
+                      &JsiSkFont::embeddedBitmaps);
+    installHostMethod(runtime, prototype, "setHinting", &JsiSkFont::setHinting);
+    installHostMethod(runtime, prototype, "setLinearMetrics",
+                      &JsiSkFont::setLinearMetrics);
+    installHostMethod(runtime, prototype, "setScaleX", &JsiSkFont::setScaleX);
+    installHostMethod(runtime, prototype, "setSkewX", &JsiSkFont::setSkewX);
+    installHostMethod(runtime, prototype, "setSize", &JsiSkFont::setSize);
+    installHostMethod(runtime, prototype, "setEmbolden",
+                      &JsiSkFont::setEmbolden);
+    installHostMethod(runtime, prototype, "setSubpixel",
+                      &JsiSkFont::setSubpixel);
+    installHostMethod(runtime, prototype, "setTypeface",
+                      &JsiSkFont::setTypeface);
+    installHostMethod(runtime, prototype, "getGlyphWidths",
+                      &JsiSkFont::getGlyphWidths);
+    installHostMethod(runtime, prototype, "getTextWidth",
+                      &JsiSkFont::getTextWidth);
+    installHostMethod(runtime, prototype, "measureText",
+                      &JsiSkFont::measureText);
+  }
 
   JsiSkFont(std::shared_ptr<RNSkPlatformContext> context, const SkFont &font)
-      : JsiSkWrappingSharedPtrHostObject(std::move(context),
-                                         std::make_shared<SkFont>(font)) {}
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkFont, SkFont>(
+            std::move(context), std::make_shared<SkFont>(font)) {}
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkFont), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override { return "JsiSkFont"; }
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkFont> fromValue(jsi::Runtime &runtime,
+                                           const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
   /**
    * Creates the function for construction a new instance of the SkFont
@@ -299,22 +317,16 @@ public:
       if (count == 2) {
         auto typeface = JsiSkTypeface::fromValue(runtime, arguments[0]);
         auto size = arguments[1].asNumber();
-        auto hostObjectInstance =
-            std::make_shared<JsiSkFont>(context, SkFont(typeface, size));
-        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-            runtime, hostObjectInstance, std::move(context));
+        return makeJsiObject(runtime, std::make_shared<JsiSkFont>(
+                                          context, SkFont(typeface, size)));
       } else if (count == 1) {
         auto typeface = JsiSkTypeface::fromValue(runtime, arguments[0]);
-        auto hostObjectInstance =
-            std::make_shared<JsiSkFont>(context, SkFont(typeface));
-        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-            runtime, hostObjectInstance, std::move(context));
+        return makeJsiObject(
+            runtime, std::make_shared<JsiSkFont>(context, SkFont(typeface)));
       } else {
         // Return the newly constructed object
-        auto hostObjectInstance =
-            std::make_shared<JsiSkFont>(context, SkFont());
-        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-            runtime, hostObjectInstance, std::move(context));
+        return makeJsiObject(runtime,
+                             std::make_shared<JsiSkFont>(context, SkFont()));
       }
     };
   }

package/cpp/api/JsiSkFontMgr.h

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "JsiSkFontStyle.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
@@ -21,13 +21,15 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFontMgr : public JsiSkWrappingSkPtrHostObject<SkFontMgr> {
+class JsiSkFontMgr
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkFontMgr, SkFontMgr> {
 public:
-  EXPORT_JSI_API_TYPENAME(JsiSkFontMgr, FontMgr)
+  static constexpr const char *CLASS_NAME = "FontMgr";
 
   JsiSkFontMgr(std::shared_ptr<RNSkPlatformContext> context,
                sk_sp<SkFontMgr> fontMgr)
-      : JsiSkWrappingSkPtrHostObject(context, fontMgr),
+      : JsiSkWrappingSkPtrNativeObject<JsiSkFontMgr, SkFontMgr>(context,
+                                                                fontMgr),
         _systemFontFamilies(context->getSystemFontFamilies()) {}
 
   JSI_HOST_FUNCTION(countFamilies) {
@@ -63,19 +65,26 @@ public:
     auto fontStyle = JsiSkFontStyle::fromValue(runtime, arguments[1]);
     auto typeface =
         getObject()->matchFamilyStyle(resolvedName.c_str(), *fontStyle);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkTypeface>(
+                                      getContext(), std::move(typeface)));
   }
 
-  size_t getMemoryPressure() const override { return 2048; }
+  size_t getMemoryPressure() override { return 2048; }
 
-  std::string getObjectType() const override { return "JsiSkFontMgr"; }
+  static sk_sp<SkFontMgr> fromValue(jsi::Runtime &runtime,
+                                    const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgr, countFamilies),
-                       JSI_EXPORT_FUNC(JsiSkFontMgr, getFamilyName),
-                       JSI_EXPORT_FUNC(JsiSkFontMgr, matchFamilyStyle))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "countFamilies",
+                      &JsiSkFontMgr::countFamilies);
+    installHostMethod(runtime, prototype, "getFamilyName",
+                      &JsiSkFontMgr::getFamilyName);
+    installHostMethod(runtime, prototype, "matchFamilyStyle",
+                      &JsiSkFontMgr::matchFamilyStyle);
+  }
 
 private:
   std::vector<std::string> _systemFontFamilies;

package/cpp/api/JsiSkFontMgrFactory.h

@@ -6,7 +6,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -20,8 +20,10 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFontMgrFactory : public JsiSkHostObject {
+class JsiSkFontMgrFactory : public JsiSkNativeObject<JsiSkFontMgrFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "FontMgrFactory";
+
   static sk_sp<SkFontMgr>
   getFontMgr(std::shared_ptr<RNSkPlatformContext> context) {
     static SkOnce once;
@@ -32,19 +34,19 @@ public:
 
   JSI_HOST_FUNCTION(System) {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
-    auto fontMgrObj = std::make_shared<JsiSkFontMgr>(getContext(), fontMgr);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, fontMgrObj,
-                                                       getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkFontMgr>(getContext(), fontMgr));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgrFactory, System))
-
-  size_t getMemoryPressure() const override { return 1024; }
+  size_t getMemoryPressure() override { return 1024; }
 
-  std::string getObjectType() const override { return "JsiSkFontMgrFactory"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "System",
+                      &JsiSkFontMgrFactory::System);
+  }
 
   explicit JsiSkFontMgrFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkFontMgrFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkFontStyle.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,13 +18,14 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFontStyle : public JsiSkWrappingSharedPtrHostObject<SkFontStyle> {
+class JsiSkFontStyle
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkFontStyle, SkFontStyle> {
 public:
-  JSI_API_TYPENAME("FontStyle");
+  static constexpr const char *CLASS_NAME = "FontStyle";
 
   JsiSkFontStyle(std::shared_ptr<RNSkPlatformContext> context,
                  const SkFontStyle &fontStyle)
-      : JsiSkWrappingSharedPtrHostObject<SkFontStyle>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkFontStyle, SkFontStyle>(
             std::move(context), std::make_shared<SkFontStyle>(fontStyle)) {}
 
   /**
@@ -33,8 +34,9 @@ public:
   static std::shared_ptr<SkFontStyle> fromValue(jsi::Runtime &runtime,
                                                 const jsi::Value &obj) {
     const auto &object = obj.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      return object.asHostObject<JsiSkFontStyle>(runtime)->getObject();
+    auto fontStyle = tryGetJsiObject<JsiSkFontStyle>(runtime, object);
+    if (fontStyle) {
+      return fontStyle->getObject();
     } else {
       auto weightProp = object.getProperty(runtime, "weight");
       auto weight = static_cast<int>(
@@ -56,11 +58,13 @@ public:
     }
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkFontStyle), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override { return "JsiSkFontStyle"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
 
   /**
   Returns the jsi object from a host object of this type
@@ -68,10 +72,8 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkFontStyle &fontStyle) {
-    auto fontStyleObj =
-        std::make_shared<JsiSkFontStyle>(std::move(context), fontStyle);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, fontStyleObj,
-                                                       context);
+    return makeJsiObject(runtime, std::make_shared<JsiSkFontStyle>(
+                                      std::move(context), fontStyle));
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -5,9 +5,9 @@
 #include <utility>
 
 #include "JsiSkDispatcher.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkImageInfo.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkShader.h"
 #include "api/third_party/base64.h"
 
@@ -15,8 +15,8 @@
 #include "utils/RNSkTypedArray.h"
 
 #if defined(SK_GRAPHITE)
-#include "rnskia/RNDawnContext.h"
 #include "include/gpu/graphite/Context.h"
+#include "rnskia/RNDawnContext.h"
 #else
 #include "include/gpu/ganesh/GrDirectContext.h"
 #endif
@@ -140,11 +140,13 @@ inline SkSamplingOptions SamplingOptionsFromValue(jsi::Runtime &runtime,
   return samplingOptions;
 }
 
-class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage> {
+class JsiSkImage : public JsiSkWrappingSkPtrNativeObject<JsiSkImage, SkImage> {
 private:
   std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
+  static constexpr const char *CLASS_NAME = "Image";
+
   // TODO-API: Properties?
   JSI_HOST_FUNCTION(width) { return static_cast<double>(getObject()->width()); }
   JSI_HOST_FUNCTION(height) {
@@ -166,10 +168,8 @@ public:
                  : nullptr;
     auto shader =
         getObject()->makeShader(tmx, tmy, SkSamplingOptions(fm, mm), m);
-    auto shaderObj =
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(shader)));
   }
 
   JSI_HOST_FUNCTION(makeShaderCubic) {
@@ -182,10 +182,8 @@ public:
                  : nullptr;
     auto shader =
         getObject()->makeShader(tmx, tmy, SkSamplingOptions({B, C}), m);
-    auto shaderObj =
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(shader)));
   }
 
   sk_sp<SkData> encodeImageData(const jsi::Value *arguments, size_t count) {
@@ -344,10 +342,8 @@ public:
     if (!rasterImage) {
       return jsi::Value::null();
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(rasterImage));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkImage>(
+                                      getContext(), std::move(rasterImage)));
   }
 
   JSI_HOST_FUNCTION(getNativeTextureUnstable) {
@@ -363,25 +359,42 @@ public:
     return jsi::Value(getObject()->isTextureBacked());
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkImage, Image)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImage, width),
-                       JSI_EXPORT_FUNC(JsiSkImage, height),
-                       JSI_EXPORT_FUNC(JsiSkImage, getImageInfo),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeShaderOptions),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeShaderCubic),
-                       JSI_EXPORT_FUNC(JsiSkImage, encodeToBytes),
-                       JSI_EXPORT_FUNC(JsiSkImage, encodeToBase64),
-                       JSI_EXPORT_FUNC(JsiSkImage, readPixels),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeNonTextureImage),
-                       JSI_EXPORT_FUNC(JsiSkImage, getNativeTextureUnstable),
-                       JSI_EXPORT_FUNC(JsiSkImage, isTextureBacked),
-                       JSI_EXPORT_FUNC(JsiSkImage, dispose))
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkImage> fromValue(jsi::Runtime &runtime,
+                                  const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "width", &JsiSkImage::width);
+    installHostMethod(runtime, prototype, "height", &JsiSkImage::height);
+    installHostMethod(runtime, prototype, "getImageInfo",
+                      &JsiSkImage::getImageInfo);
+    installHostMethod(runtime, prototype, "makeShaderOptions",
+                      &JsiSkImage::makeShaderOptions);
+    installHostMethod(runtime, prototype, "makeShaderCubic",
+                      &JsiSkImage::makeShaderCubic);
+    installHostMethod(runtime, prototype, "encodeToBytes",
+                      &JsiSkImage::encodeToBytes);
+    installHostMethod(runtime, prototype, "encodeToBase64",
+                      &JsiSkImage::encodeToBase64);
+    installHostMethod(runtime, prototype, "readPixels",
+                      &JsiSkImage::readPixels);
+    installHostMethod(runtime, prototype, "makeNonTextureImage",
+                      &JsiSkImage::makeNonTextureImage);
+    installHostMethod(runtime, prototype, "getNativeTextureUnstable",
+                      &JsiSkImage::getNativeTextureUnstable);
+    installHostMethod(runtime, prototype, "isTextureBacked",
+                      &JsiSkImage::isTextureBacked);
+  }
 
   JsiSkImage(std::shared_ptr<RNSkPlatformContext> context,
              const sk_sp<SkImage> image)
-      : JsiSkWrappingSkPtrHostObject<SkImage>(std::move(context),
-                                              std::move(image)) {
+      : JsiSkWrappingSkPtrNativeObject<JsiSkImage, SkImage>(std::move(context),
+                                                            std::move(image)) {
     // Get the dispatcher for the current thread
     _dispatcher = Dispatcher::getDispatcher();
     // Process any pending operations (e.g. deletions of previous resources)
@@ -406,7 +419,7 @@ public:
     }
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     if (isDisposed()) {
       return 0;
     }
@@ -420,8 +433,6 @@ public:
     }
     return 0;
   }
-
-  std::string getObjectType() const override { return "JsiSkImage"; }
 };
 
 } // namespace RNSkia