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

package/cpp/api/JsiSkParagraph.h

@@ -9,7 +9,7 @@
 
 #include "JsiSkCanvas.h"
 #include "JsiSkFont.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPath.h"
 #include "JsiSkRect.h"
 
@@ -31,9 +31,10 @@ namespace para = skia::textlayout;
  * Implementation of the Paragraph object in JSI
  */
 class JsiSkParagraph
-    : public JsiSkWrappingSharedPtrHostObject<para::Paragraph> {
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkParagraph,
+                                                para::Paragraph> {
 public:
-  EXPORT_JSI_API_TYPENAME(JsiSkParagraph, Paragraph)
+  static constexpr const char *CLASS_NAME = "Paragraph";
 
   JSI_HOST_FUNCTION(layout) {
     auto width = getArgumentAsNumber(runtime, arguments, count, 0);
@@ -42,8 +43,8 @@ public:
   }
 
   JSI_HOST_FUNCTION(paint) {
-    auto jsiCanvas =
-        getArgumentAsHostObject<JsiSkCanvas>(runtime, arguments, count, 0);
+    auto jsiCanvas = getJsiObject<JsiSkCanvas>(
+        runtime, getArgument(runtime, arguments, count, 0));
     auto x = getArgumentAsNumber(runtime, arguments, count, 1);
     auto y = getArgumentAsNumber(runtime, arguments, count, 2);
     getObject()->paint(jsiCanvas->getCanvas(), x, y);
@@ -182,10 +183,8 @@ public:
               &rec);
         });
     SkPath path = builder.detach();
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(path));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
   }
 
   JSI_HOST_FUNCTION(extendedVisit) {
@@ -203,10 +202,9 @@ public:
           }
           auto value = jsi::Object(runtime);
 
-          auto fontInstance = std::make_shared<JsiSkFont>(context, info->font);
           value.setProperty(runtime, "font",
-                            JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-                                runtime, fontInstance, context));
+                            makeJsiObject(runtime, std::make_shared<JsiSkFont>(
+                                                       context, info->font)));
 
           auto origin = jsi::Object(runtime);
           origin.setProperty(runtime, "x",
@@ -269,29 +267,38 @@ public:
     return returnValue;
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkParagraph, layout),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, paint),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getMaxWidth),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getMinIntrinsicWidth),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getMaxIntrinsicWidth),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getLongestLine),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getHeight),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getRectsForPlaceholders),
-                       JSI_EXPORT_FUNC(JsiSkParagraph,
-                                       getGlyphPositionAtCoordinate),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getRectsForRange),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getLineMetrics),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, getPath),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, extendedVisit),
-                       JSI_EXPORT_FUNC(JsiSkParagraph, dispose))
-
-  size_t getMemoryPressure() const override { return 1024 * 1024; }
-
-  std::string getObjectType() const override { return "JsiSkParagraph"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "layout", &JsiSkParagraph::layout);
+    installHostMethod(runtime, prototype, "paint", &JsiSkParagraph::paint);
+    installHostMethod(runtime, prototype, "getMaxWidth",
+                      &JsiSkParagraph::getMaxWidth);
+    installHostMethod(runtime, prototype, "getMinIntrinsicWidth",
+                      &JsiSkParagraph::getMinIntrinsicWidth);
+    installHostMethod(runtime, prototype, "getMaxIntrinsicWidth",
+                      &JsiSkParagraph::getMaxIntrinsicWidth);
+    installHostMethod(runtime, prototype, "getLongestLine",
+                      &JsiSkParagraph::getLongestLine);
+    installHostMethod(runtime, prototype, "getHeight",
+                      &JsiSkParagraph::getHeight);
+    installHostMethod(runtime, prototype, "getRectsForPlaceholders",
+                      &JsiSkParagraph::getRectsForPlaceholders);
+    installHostMethod(runtime, prototype, "getGlyphPositionAtCoordinate",
+                      &JsiSkParagraph::getGlyphPositionAtCoordinate);
+    installHostMethod(runtime, prototype, "getRectsForRange",
+                      &JsiSkParagraph::getRectsForRange);
+    installHostMethod(runtime, prototype, "getLineMetrics",
+                      &JsiSkParagraph::getLineMetrics);
+    installHostMethod(runtime, prototype, "getPath", &JsiSkParagraph::getPath);
+    installHostMethod(runtime, prototype, "extendedVisit",
+                      &JsiSkParagraph::extendedVisit);
+  }
+
+  size_t getMemoryPressure() override { return 1024 * 1024; }
 
   explicit JsiSkParagraph(std::shared_ptr<RNSkPlatformContext> context,
                           para::ParagraphBuilder *paragraphBuilder)
-      : JsiSkWrappingSharedPtrHostObject<para::Paragraph>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkParagraph, para::Paragraph>(
             std::move(context), paragraphBuilder->Build()) {}
 };
 

package/cpp/api/JsiSkParagraphBuilder.h

@@ -8,7 +8,7 @@
 #include "JsiSkFont.h"
 #include "JsiSkFontMgr.h"
 #include "JsiSkFontMgrFactory.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkParagraph.h"
 #include "JsiSkParagraphStyle.h"
 #include "JsiSkTextStyle.h"
@@ -36,15 +36,13 @@ namespace para = skia::textlayout;
 /**
  Implementation of the ParagraphBuilder object in JSI
  */
-class JsiSkParagraphBuilder : public JsiSkHostObject {
+class JsiSkParagraphBuilder : public JsiSkNativeObject<JsiSkParagraphBuilder> {
 public:
-  JSI_API_TYPENAME("ParagraphBuilder");
+  static constexpr const char *CLASS_NAME = "ParagraphBuilder";
 
   JSI_HOST_FUNCTION(build) {
-    auto paragraph =
-        std::make_shared<JsiSkParagraph>(getContext(), _builder.get());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, paragraph,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkParagraph>(
+                                      getContext(), _builder.get()));
   }
 
   JSI_HOST_FUNCTION(reset) {
@@ -84,16 +82,16 @@ public:
     auto textStyle = JsiSkTextStyle::fromValue(runtime, arguments[0]);
     // Foreground paint
     if (count >= 2) {
-      auto foreground =
-          tryGetArgumentAsHostObject<JsiSkPaint>(runtime, arguments, count, 1);
+      auto foreground = tryGetJsiObject<JsiSkPaint>(
+          runtime, getArgument(runtime, arguments, count, 1));
       if (foreground) {
         textStyle.setForegroundPaint(*foreground->getObject().get());
       }
     }
     // Background paint
     if (count >= 3) {
-      auto background =
-          tryGetArgumentAsHostObject<JsiSkPaint>(runtime, arguments, count, 2);
+      auto background = tryGetJsiObject<JsiSkPaint>(
+          runtime, getArgument(runtime, arguments, count, 2));
       if (background) {
         textStyle.setBackgroundPaint(*background->getObject().get());
       }
@@ -109,21 +107,26 @@ public:
     return thisValue.asObject(runtime);
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkParagraphBuilder, build),
-                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, reset),
-                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, addText),
-                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, addPlaceholder),
-                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, pushStyle),
-                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, pop))
-
-  size_t getMemoryPressure() const override { return 1024 * 1024; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "build",
+                      &JsiSkParagraphBuilder::build);
+    installHostMethod(runtime, prototype, "reset",
+                      &JsiSkParagraphBuilder::reset);
+    installHostMethod(runtime, prototype, "addText",
+                      &JsiSkParagraphBuilder::addText);
+    installHostMethod(runtime, prototype, "addPlaceholder",
+                      &JsiSkParagraphBuilder::addPlaceholder);
+    installHostMethod(runtime, prototype, "pushStyle",
+                      &JsiSkParagraphBuilder::pushStyle);
+    installHostMethod(runtime, prototype, "pop", &JsiSkParagraphBuilder::pop);
+  }
 
-  std::string getObjectType() const override { return "JsiSkParagraphBuilder"; }
+  size_t getMemoryPressure() override { return 1024 * 1024; }
 
   explicit JsiSkParagraphBuilder(std::shared_ptr<RNSkPlatformContext> context,
                                  para::ParagraphStyle paragraphStyle,
                                  sk_sp<SkFontMgr> fontManager)
-      : JsiSkHostObject(std::move(context)) {
+      : JsiSkNativeObject<JsiSkParagraphBuilder>(std::move(context)) {
     _fontCollection = sk_make_sp<para::FontCollection>();
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
     _fontCollection->setDefaultFontManager(fontMgr);

package/cpp/api/JsiSkParagraphBuilderFactory.h

@@ -5,6 +5,7 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkNativeObjects.h"
 #include "JsiSkParagraphBuilder.h"
 #include "JsiSkParagraphStyle.h"
 
@@ -25,8 +26,11 @@ namespace para = skia::textlayout;
  Implementation of the ParagraphBuilderFactory for making ParagraphBuilder JSI
  object
  */
-class JsiSkParagraphBuilderFactory : public JsiSkHostObject {
+class JsiSkParagraphBuilderFactory
+    : public JsiSkNativeObject<JsiSkParagraphBuilderFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "ParagraphBuilderFactory";
+
   JSI_HOST_FUNCTION(Make) {
     // Get paragraph style from params
     auto paragraphStyle =
@@ -39,23 +43,20 @@ public:
                   : nullptr;
 
     // Create the paragraph builder
-    auto builder = std::make_shared<JsiSkParagraphBuilder>(
-        getContext(), paragraphStyle, fontMgr);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, builder,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkParagraphBuilder>(
+                                      getContext(), paragraphStyle, fontMgr));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkParagraphBuilderFactory, Make))
-
-  size_t getMemoryPressure() const override { return 1024 * 1024; }
-
-  std::string getObjectType() const override {
-    return "JsiSkParagraphBuilderFactory";
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "Make",
+                      &JsiSkParagraphBuilderFactory::Make);
   }
 
+  size_t getMemoryPressure() override { return 1024 * 1024; }
+
   explicit JsiSkParagraphBuilderFactory(
       std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkParagraphBuilderFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkParagraphStyle.h

@@ -42,6 +42,16 @@ public:
    textHeightBehavior?: SkTextHeightBehavior;
    textStyle?: SkTextStyle;
    */
+  // A property set to undefined or null is treated as absent, like on web.
+  static bool hasValue(jsi::Runtime &runtime, const jsi::Object &object,
+                       const char *name) {
+    if (!object.hasProperty(runtime, name)) {
+      return false;
+    }
+    auto propValue = object.getProperty(runtime, name);
+    return !propValue.isUndefined() && !propValue.isNull();
+  }
+
   static para::ParagraphStyle fromValue(jsi::Runtime &runtime,
                                         const jsi::Value &value) {
     para::ParagraphStyle retVal;
@@ -59,52 +69,52 @@ public:
 
     auto object = value.asObject(runtime);
 
-    if (object.hasProperty(runtime, "disableHinting")) {
+    if (hasValue(runtime, object, "disableHinting")) {
       auto propValue = object.getProperty(runtime, "disableHinting");
       if (asBool(runtime, propValue)) {
         retVal.turnHintingOff();
       }
     }
-    if (object.hasProperty(runtime, "ellipsis")) {
+    if (hasValue(runtime, object, "ellipsis")) {
       auto propValue = object.getProperty(runtime, "ellipsis");
       auto inStr = propValue.asString(runtime).utf8(runtime);
       std::u16string uStr;
       fromUTF8(inStr, uStr);
       retVal.setEllipsis(uStr);
     }
-    if (object.hasProperty(runtime, "heightMultiplier")) {
+    if (hasValue(runtime, object, "heightMultiplier")) {
       auto propValue = object.getProperty(runtime, "heightMultiplier");
       retVal.setHeight(propValue.asNumber());
     }
-    if (object.hasProperty(runtime, "maxLines")) {
+    if (hasValue(runtime, object, "maxLines")) {
       auto propValue = object.getProperty(runtime, "maxLines");
       if (propValue.asNumber() != 0) {
         retVal.setMaxLines(propValue.asNumber());
       }
     }
-    if (object.hasProperty(runtime, "replaceTabCharacters")) {
+    if (hasValue(runtime, object, "replaceTabCharacters")) {
       auto propValue = object.getProperty(runtime, "replaceTabCharacters");
       retVal.setReplaceTabCharacters(asBool(runtime, propValue));
     }
-    if (object.hasProperty(runtime, "textAlign")) {
+    if (hasValue(runtime, object, "textAlign")) {
       auto propValue = object.getProperty(runtime, "textAlign");
       retVal.setTextAlign(static_cast<para::TextAlign>(propValue.asNumber()));
     }
-    if (object.hasProperty(runtime, "textDirection")) {
+    if (hasValue(runtime, object, "textDirection")) {
       auto propValue = object.getProperty(runtime, "textDirection");
       retVal.setTextDirection(
           static_cast<para::TextDirection>(propValue.asNumber()));
     }
-    if (object.hasProperty(runtime, "textHeightBehavior")) {
+    if (hasValue(runtime, object, "textHeightBehavior")) {
       auto propValue = object.getProperty(runtime, "textHeightBehavior");
       retVal.setTextHeightBehavior(
           static_cast<para::TextHeightBehavior>(propValue.asNumber()));
     }
-    if (object.hasProperty(runtime, "strutStyle")) {
+    if (hasValue(runtime, object, "strutStyle")) {
       auto propValue = object.getProperty(runtime, "strutStyle");
       retVal.setStrutStyle(JsiSkStrutStyle::fromValue(runtime, propValue));
     }
-    if (object.hasProperty(runtime, "textStyle")) {
+    if (hasValue(runtime, object, "textStyle")) {
       auto propValue = object.getProperty(runtime, "textStyle");
       retVal.setTextStyle(JsiSkTextStyle::fromValue(runtime, propValue));
     }

package/cpp/api/JsiSkPath.h

@@ -9,8 +9,8 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
 #include "JsiSkRect.h"
@@ -61,7 +61,11 @@ inline void warnDeprecatedPathMethod(jsi::Runtime &runtime,
   RNSkLogger::warnToJavascriptConsole(runtime, message);
 }
 
-class JsiSkPath : public JsiSkWrappingSharedPtrHostObject<SkPathBuilder> {
+class JsiSkPath
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkPath, SkPathBuilder> {
+public:
+  static constexpr const char *CLASS_NAME = "Path";
+
 private:
   static const int MOVE = 0;
   static const int LINE = 1;
@@ -529,16 +533,14 @@ public:
   JSI_HOST_FUNCTION(computeTightBounds) {
     auto path = asPath();
     auto result = path.computeTightBounds();
-    auto hostObjectInstance = std::make_shared<JsiSkRect>(getContext(), result);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkRect>(getContext(), result));
   }
 
   JSI_HOST_FUNCTION(getBounds) {
     auto result = getObject()->computeBounds();
-    auto hostObjectInstance = std::make_shared<JsiSkRect>(getContext(), result);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkRect>(getContext(), result));
   }
 
   JSI_HOST_FUNCTION(contains) {
@@ -557,9 +559,8 @@ public:
   JSI_HOST_FUNCTION(getPoint) {
     auto index = arguments[0].asNumber();
     auto point = asPath().getPoint(index);
-    auto hostObjectInstance = std::make_shared<JsiSkPoint>(getContext(), point);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkPoint>(getContext(), point));
   }
 
   JSI_HOST_FUNCTION(isEmpty) { return jsi::Value(getObject()->isEmpty()); }
@@ -596,9 +597,8 @@ public:
 
   JSI_HOST_FUNCTION(copy) {
     auto path = asPath();
-    auto hostObjectInstance = std::make_shared<JsiSkPath>(getContext(), path);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkPath>(getContext(), path));
   }
 
   JSI_HOST_FUNCTION(isInterpolatable) {
@@ -618,10 +618,8 @@ public:
     if (!succeed) {
       return jsi::Value::null();
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(result));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
   }
 
   JSI_HOST_FUNCTION(toCmds) {
@@ -703,51 +701,76 @@ public:
     return cmds;
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkPath, Path)
-
-  JSI_EXPORT_FUNCTIONS(
-      // Mutable building methods
-      JSI_EXPORT_FUNC(JsiSkPath, moveTo), JSI_EXPORT_FUNC(JsiSkPath, rMoveTo),
-      JSI_EXPORT_FUNC(JsiSkPath, lineTo), JSI_EXPORT_FUNC(JsiSkPath, rLineTo),
-      JSI_EXPORT_FUNC(JsiSkPath, quadTo), JSI_EXPORT_FUNC(JsiSkPath, rQuadTo),
-      JSI_EXPORT_FUNC(JsiSkPath, conicTo), JSI_EXPORT_FUNC(JsiSkPath, rConicTo),
-      JSI_EXPORT_FUNC(JsiSkPath, cubicTo), JSI_EXPORT_FUNC(JsiSkPath, rCubicTo),
-      JSI_EXPORT_FUNC(JsiSkPath, close), JSI_EXPORT_FUNC(JsiSkPath, reset),
-      JSI_EXPORT_FUNC(JsiSkPath, rewind), JSI_EXPORT_FUNC(JsiSkPath, addPath),
-      JSI_EXPORT_FUNC(JsiSkPath, addArc), JSI_EXPORT_FUNC(JsiSkPath, addOval),
-      JSI_EXPORT_FUNC(JsiSkPath, addRect), JSI_EXPORT_FUNC(JsiSkPath, addRRect),
-      JSI_EXPORT_FUNC(JsiSkPath, addCircle),
-      JSI_EXPORT_FUNC(JsiSkPath, addPoly),
-      JSI_EXPORT_FUNC(JsiSkPath, arcToOval),
-      JSI_EXPORT_FUNC(JsiSkPath, arcToRotated),
-      JSI_EXPORT_FUNC(JsiSkPath, rArcTo),
-      JSI_EXPORT_FUNC(JsiSkPath, arcToTangent),
-      JSI_EXPORT_FUNC(JsiSkPath, setFillType),
-      JSI_EXPORT_FUNC(JsiSkPath, setIsVolatile),
-      // Mutable transform methods
-      JSI_EXPORT_FUNC(JsiSkPath, transform), JSI_EXPORT_FUNC(JsiSkPath, offset),
-      // Mutable path operations
-      JSI_EXPORT_FUNC(JsiSkPath, simplify), JSI_EXPORT_FUNC(JsiSkPath, op),
-      JSI_EXPORT_FUNC(JsiSkPath, makeAsWinding),
-      JSI_EXPORT_FUNC(JsiSkPath, dash), JSI_EXPORT_FUNC(JsiSkPath, stroke),
-      JSI_EXPORT_FUNC(JsiSkPath, trim),
-      // Query methods
-      JSI_EXPORT_FUNC(JsiSkPath, computeTightBounds),
-      JSI_EXPORT_FUNC(JsiSkPath, getBounds),
-      JSI_EXPORT_FUNC(JsiSkPath, contains),
-      JSI_EXPORT_FUNC(JsiSkPath, getFillType),
-      JSI_EXPORT_FUNC(JsiSkPath, isVolatile),
-      JSI_EXPORT_FUNC(JsiSkPath, getPoint), JSI_EXPORT_FUNC(JsiSkPath, isEmpty),
-      JSI_EXPORT_FUNC(JsiSkPath, countPoints),
-      JSI_EXPORT_FUNC(JsiSkPath, getLastPt),
-      JSI_EXPORT_FUNC(JsiSkPath, toSVGString),
-      JSI_EXPORT_FUNC(JsiSkPath, equals), JSI_EXPORT_FUNC(JsiSkPath, copy),
-      JSI_EXPORT_FUNC(JsiSkPath, isInterpolatable),
-      JSI_EXPORT_FUNC(JsiSkPath, interpolate),
-      JSI_EXPORT_FUNC(JsiSkPath, toCmds), JSI_EXPORT_FUNC(JsiSkPath, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    // Mutable building methods
+    installHostMethod(runtime, prototype, "moveTo", &JsiSkPath::moveTo);
+    installHostMethod(runtime, prototype, "rMoveTo", &JsiSkPath::rMoveTo);
+    installHostMethod(runtime, prototype, "lineTo", &JsiSkPath::lineTo);
+    installHostMethod(runtime, prototype, "rLineTo", &JsiSkPath::rLineTo);
+    installHostMethod(runtime, prototype, "quadTo", &JsiSkPath::quadTo);
+    installHostMethod(runtime, prototype, "rQuadTo", &JsiSkPath::rQuadTo);
+    installHostMethod(runtime, prototype, "conicTo", &JsiSkPath::conicTo);
+    installHostMethod(runtime, prototype, "rConicTo", &JsiSkPath::rConicTo);
+    installHostMethod(runtime, prototype, "cubicTo", &JsiSkPath::cubicTo);
+    installHostMethod(runtime, prototype, "rCubicTo", &JsiSkPath::rCubicTo);
+    installHostMethod(runtime, prototype, "close", &JsiSkPath::close);
+    installHostMethod(runtime, prototype, "reset", &JsiSkPath::reset);
+    installHostMethod(runtime, prototype, "rewind", &JsiSkPath::rewind);
+    installHostMethod(runtime, prototype, "addPath", &JsiSkPath::addPath);
+    installHostMethod(runtime, prototype, "addArc", &JsiSkPath::addArc);
+    installHostMethod(runtime, prototype, "addOval", &JsiSkPath::addOval);
+    installHostMethod(runtime, prototype, "addRect", &JsiSkPath::addRect);
+    installHostMethod(runtime, prototype, "addRRect", &JsiSkPath::addRRect);
+    installHostMethod(runtime, prototype, "addCircle", &JsiSkPath::addCircle);
+    installHostMethod(runtime, prototype, "addPoly", &JsiSkPath::addPoly);
+    installHostMethod(runtime, prototype, "arcToOval", &JsiSkPath::arcToOval);
+    installHostMethod(runtime, prototype, "arcToRotated",
+                      &JsiSkPath::arcToRotated);
+    installHostMethod(runtime, prototype, "rArcTo", &JsiSkPath::rArcTo);
+    installHostMethod(runtime, prototype, "arcToTangent",
+                      &JsiSkPath::arcToTangent);
+    installHostMethod(runtime, prototype, "setFillType",
+                      &JsiSkPath::setFillType);
+    installHostMethod(runtime, prototype, "setIsVolatile",
+                      &JsiSkPath::setIsVolatile);
+    // Mutable transform methods
+    installHostMethod(runtime, prototype, "transform", &JsiSkPath::transform);
+    installHostMethod(runtime, prototype, "offset", &JsiSkPath::offset);
+    // Mutable path operations
+    installHostMethod(runtime, prototype, "simplify", &JsiSkPath::simplify);
+    installHostMethod(runtime, prototype, "op", &JsiSkPath::op);
+    installHostMethod(runtime, prototype, "makeAsWinding",
+                      &JsiSkPath::makeAsWinding);
+    installHostMethod(runtime, prototype, "dash", &JsiSkPath::dash);
+    installHostMethod(runtime, prototype, "stroke", &JsiSkPath::stroke);
+    installHostMethod(runtime, prototype, "trim", &JsiSkPath::trim);
+    // Query methods
+    installHostMethod(runtime, prototype, "computeTightBounds",
+                      &JsiSkPath::computeTightBounds);
+    installHostMethod(runtime, prototype, "getBounds", &JsiSkPath::getBounds);
+    installHostMethod(runtime, prototype, "contains", &JsiSkPath::contains);
+    installHostMethod(runtime, prototype, "getFillType",
+                      &JsiSkPath::getFillType);
+    installHostMethod(runtime, prototype, "isVolatile", &JsiSkPath::isVolatile);
+    installHostMethod(runtime, prototype, "getPoint", &JsiSkPath::getPoint);
+    installHostMethod(runtime, prototype, "isEmpty", &JsiSkPath::isEmpty);
+    installHostMethod(runtime, prototype, "countPoints",
+                      &JsiSkPath::countPoints);
+    installHostMethod(runtime, prototype, "getLastPt", &JsiSkPath::getLastPt);
+    installHostMethod(runtime, prototype, "toSVGString",
+                      &JsiSkPath::toSVGString);
+    installHostMethod(runtime, prototype, "equals", &JsiSkPath::equals);
+    installHostMethod(runtime, prototype, "copy", &JsiSkPath::copy);
+    installHostMethod(runtime, prototype, "isInterpolatable",
+                      &JsiSkPath::isInterpolatable);
+    installHostMethod(runtime, prototype, "interpolate",
+                      &JsiSkPath::interpolate);
+    installHostMethod(runtime, prototype, "toCmds", &JsiSkPath::toCmds);
+  }
 
   JsiSkPath(std::shared_ptr<RNSkPlatformContext> context, SkPathBuilder builder)
-      : JsiSkWrappingSharedPtrHostObject<SkPathBuilder>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkPath, SkPathBuilder>(
             std::move(context),
             std::make_shared<SkPathBuilder>(std::move(builder))) {}
 
@@ -755,7 +778,7 @@ public:
   JsiSkPath(std::shared_ptr<RNSkPlatformContext> context, const SkPath &path)
       : JsiSkPath(std::move(context), SkPathBuilder(path)) {}
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto builder = getObject();
     if (!builder)
       return 0;
@@ -763,7 +786,13 @@ public:
     return builder->snapshot().approximateBytesUsed();
   }
 
-  std::string getObjectType() const override { return "JsiSkPath"; }
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkPathBuilder> fromValue(jsi::Runtime &runtime,
+                                                  const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
   static SkPath pathFromValue(jsi::Runtime &runtime, const jsi::Value &obj) {
     return fromValue(runtime, obj)->snapshot();
@@ -772,18 +801,14 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkPath &path) {
-    auto hostObjectInstance = std::make_shared<JsiSkPath>(context, path);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, context);
+    return makeJsiObject(runtime, std::make_shared<JsiSkPath>(context, path));
   }
 
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             SkPath &&path) {
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(context, std::move(path));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, context);
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkPath>(context, std::move(path)));
   }
 };