@shopify/react-native-skia 2.9.1-next.1 → 2.10.0

package/cpp/api/JsiSkMatrix.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,10 +18,13 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkMatrix : public JsiSkWrappingSharedPtrHostObject<SkMatrix> {
+class JsiSkMatrix
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkMatrix, SkMatrix> {
 public:
+  static constexpr const char *CLASS_NAME = "Matrix";
+
   JsiSkMatrix(std::shared_ptr<RNSkPlatformContext> context, SkMatrix m)
-      : JsiSkWrappingSharedPtrHostObject<SkMatrix>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkMatrix, SkMatrix>(
             context, std::make_shared<SkMatrix>(std::move(m))) {}
 
   static SkMatrix getMatrix(jsi::Runtime &runtime, const jsi::Value &value) {
@@ -57,10 +60,9 @@ public:
   }
 
   JSI_HOST_FUNCTION(concat) {
-    if (arguments[0].isObject() &&
-        arguments[0].asObject(runtime).isHostObject(runtime)) {
-      auto m3 = JsiSkMatrix::fromValue(runtime, arguments[0]);
-      getObject()->preConcat(*m3);
+    auto matrix = tryGetJsiObject<JsiSkMatrix>(runtime, arguments[0]);
+    if (matrix) {
+      getObject()->preConcat(*matrix->getObject());
     } else {
       auto m3 = JsiSkMatrix::getMatrix(runtime, arguments[0]);
       getObject()->preConcat(m3);
@@ -138,40 +140,40 @@ public:
   }
 #pragma clang diagnostic pop
 
-  EXPORT_JSI_API_TYPENAME(JsiSkMatrix, Matrix)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkMatrix, concat),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, translate),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, postTranslate),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, scale),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, postScale),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, skew),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, postSkew),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, rotate),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, postRotate),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, identity),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, get),
-                       JSI_EXPORT_FUNC(JsiSkMatrix, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "concat", &JsiSkMatrix::concat);
+    installHostMethod(runtime, prototype, "translate", &JsiSkMatrix::translate);
+    installHostMethod(runtime, prototype, "postTranslate",
+                      &JsiSkMatrix::postTranslate);
+    installHostMethod(runtime, prototype, "scale", &JsiSkMatrix::scale);
+    installHostMethod(runtime, prototype, "postScale", &JsiSkMatrix::postScale);
+    installHostMethod(runtime, prototype, "skew", &JsiSkMatrix::skew);
+    installHostMethod(runtime, prototype, "postSkew", &JsiSkMatrix::postSkew);
+    installHostMethod(runtime, prototype, "rotate", &JsiSkMatrix::rotate);
+    installHostMethod(runtime, prototype, "postRotate",
+                      &JsiSkMatrix::postRotate);
+    installHostMethod(runtime, prototype, "identity", &JsiSkMatrix::identity);
+    installHostMethod(runtime, prototype, "get", &JsiSkMatrix::get);
+  }
 
   /**
    * Returns the underlying object from a host object of this type
    */
   static std::shared_ptr<SkMatrix> fromValue(jsi::Runtime &runtime,
                                              const jsi::Value &obj) {
-    const auto &object = obj.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      return object.asHostObject<JsiSkMatrix>(runtime)->getObject();
+    auto matrix = tryGetJsiObject<JsiSkMatrix>(runtime, obj);
+    if (matrix) {
+      return matrix->getObject();
     } else {
       return std::make_shared<SkMatrix>(JsiSkMatrix::getMatrix(runtime, obj));
     }
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkMatrix), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override { return "JsiSkMatrix"; }
-
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {
     return JSI_HOST_FUNCTION_LAMBDA {
@@ -181,10 +183,8 @@ public:
       } else {
         matrix = SkMatrix::I();
       }
-      auto hostObjectInstance =
-          std::make_shared<JsiSkMatrix>(context, std::move(matrix));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, context);
+      return makeJsiObject(
+          runtime, std::make_shared<JsiSkMatrix>(context, std::move(matrix)));
     };
   }
 };

package/cpp/api/JsiSkNativeObjects.h

@@ -0,0 +1,419 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "jsi/NativeObject.h"
+#include "rnskia/RNSkPlatformContext.h"
+#include "utils/RNSkLog.h"
+
+#define STR_CAT_NX(A, B) A##B
+#define STR_CAT(A, B) STR_CAT_NX(A, B)
+#define STR_GET get_
+#define STR_SET set_
+
+/**
+ * Creates a new Host function declaration as a lambda with all deps passed
+ * with implicit lambda capture clause
+ */
+#define JSI_HOST_FUNCTION_LAMBDA                                               \
+  [=](jsi::Runtime & runtime, const jsi::Value &thisValue,                     \
+      const jsi::Value *arguments, size_t count) -> jsi::Value
+
+/**
+ * Creates a new Host function declaration
+ */
+#define JSI_HOST_FUNCTION(NAME)                                                \
+  jsi::Value NAME(jsi::Runtime &runtime, const jsi::Value &thisValue,          \
+                  const jsi::Value *arguments, size_t count)
+
+/**
+ * Creates a new property setter function declaration
+ */
+#define JSI_PROPERTY_SET(NAME)                                                 \
+  void STR_CAT(STR_SET, NAME)(jsi::Runtime & runtime, const jsi::Value &value)
+
+/**
+ * Creates a new property getter function declaration
+ */
+#define JSI_PROPERTY_GET(NAME)                                                 \
+  jsi::Value STR_CAT(STR_GET, NAME)(jsi::Runtime & runtime)
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+// Minimum memory pressure reported for any native object — aliased from the
+// NativeObject infrastructure so dispose() and create() agree on the floor.
+static constexpr size_t kMinMemoryPressure = rnwgpu::kMinMemoryPressure;
+
+/**
+ * Creates the JS object for a wrapper instance (a class based on the
+ * NativeObject pattern below).
+ */
+template <typename T>
+jsi::Value makeJsiObject(jsi::Runtime &runtime, std::shared_ptr<T> instance) {
+  return T::create(runtime, std::move(instance));
+}
+
+/**
+ * Returns the wrapper instance backing the given JS object or nullptr if the
+ * object is not backed by the requested type.
+ */
+template <typename T>
+std::shared_ptr<T> tryGetJsiObject(jsi::Runtime &runtime,
+                                   const jsi::Object &object) {
+  if (object.hasNativeState<T>(runtime)) {
+    return object.getNativeState<T>(runtime);
+  }
+  return nullptr;
+}
+
+template <typename T>
+std::shared_ptr<T> tryGetJsiObject(jsi::Runtime &runtime,
+                                   const jsi::Value &value) {
+  if (!value.isObject()) {
+    return nullptr;
+  }
+  auto object = value.asObject(runtime);
+  return tryGetJsiObject<T>(runtime, object);
+}
+
+/**
+ * Returns the wrapper instance backing the given JS value or throws a JS
+ * error if the value is not backed by the requested type.
+ */
+template <typename T>
+std::shared_ptr<T> getJsiObject(jsi::Runtime &runtime,
+                                const jsi::Value &value) {
+  auto result = tryGetJsiObject<T>(runtime, value);
+  if (result == nullptr) {
+    throw jsi::JSError(runtime, "Expected a Skia object of a different type.");
+  }
+  return result;
+}
+
+/**
+ * Base class for Skia API objects implemented with the NativeObject /
+ * jsi::NativeState pattern (see jsi/NativeObject.h). Instead of a HostObject
+ * intercepting every property access, methods and properties live on a shared
+ * per-runtime prototype and the C++ instance is attached to plain JS objects
+ * as native state.
+ *
+ * Derived classes must provide:
+ * - `static constexpr const char *CLASS_NAME` — the public __typename__
+ *   (e.g. "Rect"); also used as the boxing brand, so it must be unique.
+ * - `static void definePrototype(jsi::Runtime&, jsi::Object& prototype)` —
+ *   installs methods/getters. The shared pieces (`__typename__`, `__box()`
+ *   and the boxing reconstructor) are installed by
+ *   NativeObject::installPrototype; wrapping classes additionally call
+ *   `installCommon(runtime, proto)` to install dispose().
+ *
+ * The existing JSI_HOST_FUNCTION / JSI_PROPERTY_GET / JSI_PROPERTY_SET method
+ * bodies keep working unchanged; they are installed on the prototype with the
+ * installHostMethod / installHostGetter / installHostSetter helpers below,
+ * which resolve the C++ instance from `this` via native state.
+ */
+template <typename Derived>
+class JsiSkNativeObject : public rnwgpu::NativeObject<Derived> {
+public:
+  explicit JsiSkNativeObject(std::shared_ptr<RNSkPlatformContext> context)
+      : rnwgpu::NativeObject<Derived>(Derived::CLASS_NAME),
+        _context(std::move(context)) {}
+
+  /**
+   * Resolves the C++ instance backing `thisValue`. Throws a JSError if the
+   * value is not backed by this class.
+   */
+  static std::shared_ptr<Derived> fromThis(jsi::Runtime &runtime,
+                                           const jsi::Value &thisValue) {
+    return rnwgpu::NativeObject<Derived>::fromValue(runtime, thisValue);
+  }
+
+protected:
+  std::shared_ptr<RNSkPlatformContext> getContext() { return _context; }
+
+  /**
+   @Returns a reference to the argument at the given position in the arguments
+   array. Raises an error if the index is above the number of arguments.
+   */
+  static const jsi::Value &getArgument(jsi::Runtime &runtime,
+                                       const jsi::Value *arguments,
+                                       size_t count, size_t index) {
+    if (index >= count) {
+      throw jsi::JSError(runtime, "Argument index out of bounds.");
+    }
+
+    return arguments[index];
+  }
+
+  /**
+   Returns argument as number or throws
+   */
+  static double getArgumentAsNumber(jsi::Runtime &runtime,
+                                    const jsi::Value *arguments, size_t count,
+                                    size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isNumber()) {
+      throw jsi::JSError(runtime,
+                         "Expected type number for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asNumber();
+  }
+
+  /**
+   Returns argument as string or throws
+   */
+  static jsi::String getArgumentAsString(jsi::Runtime &runtime,
+                                         const jsi::Value *arguments,
+                                         size_t count, size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isString()) {
+      throw jsi::JSError(runtime,
+                         "Expected type string for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asString(runtime);
+  }
+
+  /**
+   Returns argument as object or throws
+   */
+  static jsi::Object getArgumentAsObject(jsi::Runtime &runtime,
+                                         const jsi::Value *arguments,
+                                         size_t count, size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isObject()) {
+      throw jsi::JSError(runtime,
+                         "Expected type object for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asObject(runtime);
+  }
+
+  /**
+   Returns argument as function or throws
+   */
+  static jsi::Object getArgumentAsFunction(jsi::Runtime &runtime,
+                                           const jsi::Value *arguments,
+                                           size_t count, size_t index) {
+    auto value = getArgumentAsObject(runtime, arguments, count, index);
+    if (!value.isFunction(runtime)) {
+      throw jsi::JSError(runtime,
+                         "Expected type function for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asFunction(runtime);
+  }
+
+  using HostMethod = jsi::Value (Derived::*)(jsi::Runtime &, const jsi::Value &,
+                                             const jsi::Value *, size_t);
+  using HostGetter = jsi::Value (Derived::*)(jsi::Runtime &);
+  using HostSetter = void (Derived::*)(jsi::Runtime &, const jsi::Value &);
+
+  /**
+   * Installs a method with the classic host-function signature
+   * (JSI_HOST_FUNCTION) on the prototype.
+   */
+  static void installHostMethod(jsi::Runtime &runtime, jsi::Object &prototype,
+                                const char *name, HostMethod method) {
+    auto func = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, name), 0,
+        [method](jsi::Runtime &rt, const jsi::Value &thisValue,
+                 const jsi::Value *arguments, size_t count) -> jsi::Value {
+          auto native = fromThis(rt, thisValue);
+          return ((*native).*method)(rt, thisValue, arguments, count);
+        });
+    prototype.setProperty(runtime, name, func);
+  }
+
+  /**
+   * Installs a property getter with the classic JSI_PROPERTY_GET signature on
+   * the prototype.
+   */
+  static void installHostGetter(jsi::Runtime &runtime, jsi::Object &prototype,
+                                const char *name, HostGetter getter) {
+    auto getterFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, std::string("get_") + name),
+        0,
+        [getter](jsi::Runtime &rt, const jsi::Value &thisValue,
+                 const jsi::Value *, size_t) -> jsi::Value {
+          auto native = fromThis(rt, thisValue);
+          return ((*native).*getter)(rt);
+        });
+    defineProperty(runtime, prototype, name, &getterFunc, nullptr);
+  }
+
+  /**
+   * Installs a property setter with the classic JSI_PROPERTY_SET signature on
+   * the prototype, preserving a previously installed getter.
+   */
+  static void installHostSetter(jsi::Runtime &runtime, jsi::Object &prototype,
+                                const char *name, HostSetter setter) {
+    auto setterFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, std::string("set_") + name),
+        1,
+        [setter](jsi::Runtime &rt, const jsi::Value &thisValue,
+                 const jsi::Value *arguments, size_t count) -> jsi::Value {
+          if (count < 1) {
+            throw jsi::JSError(rt, "Setter requires a value argument");
+          }
+          auto native = fromThis(rt, thisValue);
+          ((*native).*setter)(rt, arguments[0]);
+          return jsi::Value::undefined();
+        });
+    defineProperty(runtime, prototype, name, nullptr, &setterFunc);
+  }
+
+  /**
+   * Installs both getter and setter for a property on the prototype.
+   */
+  static void installHostProperty(jsi::Runtime &runtime, jsi::Object &prototype,
+                                  const char *name, HostGetter getter,
+                                  HostSetter setter) {
+    installHostGetter(runtime, prototype, name, getter);
+    installHostSetter(runtime, prototype, name, setter);
+  }
+
+private:
+  static void defineProperty(jsi::Runtime &runtime, jsi::Object &prototype,
+                             const char *name, jsi::Function *getter,
+                             jsi::Function *setter) {
+    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+    auto defineProp =
+        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+    auto getOwnPropertyDescriptor =
+        objectCtor.getPropertyAsFunction(runtime, "getOwnPropertyDescriptor");
+    auto existing = getOwnPropertyDescriptor.call(
+        runtime, prototype, jsi::String::createFromUtf8(runtime, name));
+
+    jsi::Object descriptor(runtime);
+    if (existing.isObject()) {
+      auto existingObj = existing.getObject(runtime);
+      if (existingObj.hasProperty(runtime, "get")) {
+        descriptor.setProperty(runtime, "get",
+                               existingObj.getProperty(runtime, "get"));
+      }
+      if (existingObj.hasProperty(runtime, "set")) {
+        descriptor.setProperty(runtime, "set",
+                               existingObj.getProperty(runtime, "set"));
+      }
+    }
+    if (getter != nullptr) {
+      descriptor.setProperty(runtime, "get", *getter);
+    }
+    if (setter != nullptr) {
+      descriptor.setProperty(runtime, "set", *setter);
+    }
+    descriptor.setProperty(runtime, "enumerable", true);
+    descriptor.setProperty(runtime, "configurable", true);
+    defineProp.call(runtime, prototype,
+                    jsi::String::createFromUtf8(runtime, name), descriptor);
+  }
+
+  std::shared_ptr<RNSkPlatformContext> _context;
+};
+
+/**
+ * NativeObject equivalent of JsiSkWrappingHostObject: wraps an inner object
+ * (a std::shared_ptr or sk_sp) and provides dispose() semantics.
+ */
+template <typename Derived, typename T>
+class JsiSkWrappingNativeObject : public JsiSkNativeObject<Derived> {
+public:
+  JsiSkWrappingNativeObject(std::shared_ptr<RNSkPlatformContext> context,
+                            T object)
+      : JsiSkNativeObject<Derived>(std::move(context)),
+        _object(std::move(object)) {}
+
+  /**
+   * Returns the wrapped object. Throws if the object has been disposed.
+   */
+  T getObject() { return validateObject(); }
+  const T getObject() const { return validateObject(); }
+
+  /**
+   * Updates the inner object with a new version of the object.
+   */
+  void setObject(T object) { _object = object; }
+
+  /**
+   * Returns the wrapped object from a JS value backed by this class.
+   */
+  static T objectFromValue(jsi::Runtime &runtime, const jsi::Value &value) {
+    return JsiSkNativeObject<Derived>::fromThis(runtime, value)->getObject();
+  }
+
+  /**
+   * dispose() releases the wrapped resources eagerly instead of waiting for
+   * garbage collection. Installed on the prototype via installCommon.
+   */
+  JSI_HOST_FUNCTION(dispose) {
+    if (!isDisposed()) {
+      thisValue.asObject(runtime).setExternalMemoryPressure(runtime,
+                                                            kMinMemoryPressure);
+    }
+    safeDispose();
+    return jsi::Value::undefined();
+  }
+
+  /**
+   * Installs dispose() on the prototype (the shared pieces — __typename__,
+   * __box() and the boxing reconstructor — are installed by
+   * NativeObject::installPrototype). Must be called from definePrototype().
+   */
+  static void installCommon(jsi::Runtime &runtime, jsi::Object &prototype) {
+    JsiSkNativeObject<Derived>::installHostMethod(runtime, prototype, "dispose",
+                                                  &Derived::dispose);
+  }
+
+protected:
+  /**
+   * Override to release additional resources. Called exactly once.
+   */
+  virtual void releaseResources() { setObject(nullptr); }
+
+  bool isDisposed() const {
+    return _isDisposed.load(std::memory_order_acquire);
+  }
+
+  /**
+   * Returns the wrapped object without the disposed check — for destructors
+   * and releaseResources() implementations.
+   */
+  T getObjectUnchecked() const { return _object; }
+
+private:
+  T validateObject() const {
+    if (_isDisposed.load(std::memory_order_acquire)) {
+      throw std::runtime_error("Attempted to access a disposed object.");
+    }
+    return _object;
+  }
+
+  void safeDispose() {
+    bool expected = false;
+    if (_isDisposed.compare_exchange_strong(expected, true,
+                                            std::memory_order_acq_rel)) {
+      releaseResources();
+    }
+  }
+
+  T _object;
+  std::atomic<bool> _isDisposed = {false};
+};
+
+template <typename Derived, typename T>
+using JsiSkWrappingSharedPtrNativeObject =
+    JsiSkWrappingNativeObject<Derived, std::shared_ptr<T>>;
+
+template <typename Derived, typename T>
+using JsiSkWrappingSkPtrNativeObject =
+    JsiSkWrappingNativeObject<Derived, sk_sp<T>>;
+
+} // namespace RNSkia

package/cpp/api/JsiSkPaint.h

@@ -8,9 +8,9 @@
 #include "CustomBlendModes.h"
 #include "JsiSkColor.h"
 #include "JsiSkColorFilter.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkImageFilter.h"
 #include "JsiSkMaskFilter.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPathEffect.h"
 #include "JsiSkShader.h"
 
@@ -24,9 +24,10 @@
 namespace RNSkia {
 namespace jsi = facebook::jsi;
 
-class JsiSkPaint : public JsiSkWrappingSharedPtrHostObject<SkPaint> {
+class JsiSkPaint
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkPaint, SkPaint> {
 public:
-  EXPORT_JSI_API_TYPENAME(JsiSkPaint, Paint)
+  static constexpr const char *CLASS_NAME = "Paint";
 
   JSI_HOST_FUNCTION(assign) {
     SkPaint *paint = JsiSkPaint::fromValue(runtime, arguments[0]).get();
@@ -36,10 +37,8 @@ public:
 
   JSI_HOST_FUNCTION(copy) {
     const auto *paint = getObject().get();
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPaint>(getContext(), SkPaint(*paint));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPaint>(getContext(), SkPaint(*paint)));
   }
 
   JSI_HOST_FUNCTION(reset) {
@@ -172,36 +171,60 @@ public:
     return jsi::Value::undefined();
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPaint, assign),
-                       JSI_EXPORT_FUNC(JsiSkPaint, copy),
-                       JSI_EXPORT_FUNC(JsiSkPaint, reset),
-                       JSI_EXPORT_FUNC(JsiSkPaint, getAlphaf),
-                       JSI_EXPORT_FUNC(JsiSkPaint, getColor),
-                       JSI_EXPORT_FUNC(JsiSkPaint, getStrokeCap),
-                       JSI_EXPORT_FUNC(JsiSkPaint, getStrokeJoin),
-                       JSI_EXPORT_FUNC(JsiSkPaint, getStrokeMiter),
-                       JSI_EXPORT_FUNC(JsiSkPaint, getStrokeWidth),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setPathEffect),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setShader),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setColorFilter),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setImageFilter),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setMaskFilter),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setBlendMode),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setStrokeMiter),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setStrokeJoin),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setStrokeCap),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setAntiAlias),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setDither),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setStrokeWidth),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setStyle),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setColor),
-                       JSI_EXPORT_FUNC(JsiSkPaint, setAlphaf),
-                       JSI_EXPORT_FUNC(JsiSkPaint, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "assign", &JsiSkPaint::assign);
+    installHostMethod(runtime, prototype, "copy", &JsiSkPaint::copy);
+    installHostMethod(runtime, prototype, "reset", &JsiSkPaint::reset);
+    installHostMethod(runtime, prototype, "getAlphaf", &JsiSkPaint::getAlphaf);
+    installHostMethod(runtime, prototype, "getColor", &JsiSkPaint::getColor);
+    installHostMethod(runtime, prototype, "getStrokeCap",
+                      &JsiSkPaint::getStrokeCap);
+    installHostMethod(runtime, prototype, "getStrokeJoin",
+                      &JsiSkPaint::getStrokeJoin);
+    installHostMethod(runtime, prototype, "getStrokeMiter",
+                      &JsiSkPaint::getStrokeMiter);
+    installHostMethod(runtime, prototype, "getStrokeWidth",
+                      &JsiSkPaint::getStrokeWidth);
+    installHostMethod(runtime, prototype, "setPathEffect",
+                      &JsiSkPaint::setPathEffect);
+    installHostMethod(runtime, prototype, "setShader", &JsiSkPaint::setShader);
+    installHostMethod(runtime, prototype, "setColorFilter",
+                      &JsiSkPaint::setColorFilter);
+    installHostMethod(runtime, prototype, "setImageFilter",
+                      &JsiSkPaint::setImageFilter);
+    installHostMethod(runtime, prototype, "setMaskFilter",
+                      &JsiSkPaint::setMaskFilter);
+    installHostMethod(runtime, prototype, "setBlendMode",
+                      &JsiSkPaint::setBlendMode);
+    installHostMethod(runtime, prototype, "setStrokeMiter",
+                      &JsiSkPaint::setStrokeMiter);
+    installHostMethod(runtime, prototype, "setStrokeJoin",
+                      &JsiSkPaint::setStrokeJoin);
+    installHostMethod(runtime, prototype, "setStrokeCap",
+                      &JsiSkPaint::setStrokeCap);
+    installHostMethod(runtime, prototype, "setAntiAlias",
+                      &JsiSkPaint::setAntiAlias);
+    installHostMethod(runtime, prototype, "setDither", &JsiSkPaint::setDither);
+    installHostMethod(runtime, prototype, "setStrokeWidth",
+                      &JsiSkPaint::setStrokeWidth);
+    installHostMethod(runtime, prototype, "setStyle", &JsiSkPaint::setStyle);
+    installHostMethod(runtime, prototype, "setColor", &JsiSkPaint::setColor);
+    installHostMethod(runtime, prototype, "setAlphaf", &JsiSkPaint::setAlphaf);
+  }
 
   JsiSkPaint(std::shared_ptr<RNSkPlatformContext> context, SkPaint paint)
-      : JsiSkWrappingSharedPtrHostObject<SkPaint>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkPaint, SkPaint>(
             std::move(context), std::make_shared<SkPaint>(std::move(paint))) {}
 
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkPaint> fromValue(jsi::Runtime &runtime,
+                                            const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
+
   /**
    Copy from another paint
    */
@@ -209,12 +232,10 @@ public:
     setObject(std::make_shared<SkPaint>(std::move(paint)));
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkPaint), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override { return "JsiSkPaint"; }
-
   /**
    * Creates the function for construction a new instance of the SkPaint
    * wrapper
@@ -228,9 +249,8 @@ public:
       auto paint = SkPaint();
       paint.setAntiAlias(true);
       // Return the newly constructed object
-      auto hostObjectInstance = std::make_shared<JsiSkPaint>(context, paint);
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, context);
+      return makeJsiObject(runtime,
+                           std::make_shared<JsiSkPaint>(context, paint));
     };
   }
 };