@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkPaint.h

@@ -7,10 +7,11 @@
 
 #include "CustomBlendModes.h"
 #include "JsiSkColor.h"
+#include "JsiSkConverters.h"
 #include "JsiSkColorFilter.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkImageFilter.h"
 #include "JsiSkMaskFilter.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPathEffect.h"
 #include "JsiSkShader.h"
 
@@ -24,184 +25,148 @@
 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();
-    *getObject() = *paint;
-    return jsi::Value::undefined();
-  }
+  void assign(std::shared_ptr<SkPaint> paint) { *getObject() = *paint; }
 
-  JSI_HOST_FUNCTION(copy) {
+  std::shared_ptr<JsiSkPaint> 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 std::make_shared<JsiSkPaint>(getContext(), SkPaint(*paint));
   }
 
-  JSI_HOST_FUNCTION(reset) {
-    getObject()->reset();
-    return jsi::Value::undefined();
-  }
+  void reset() { getObject()->reset(); }
 
-  JSI_HOST_FUNCTION(getColor) {
-    return JsiSkColor::toValue(runtime, getObject()->getColor());
-  }
+  JsiColor getColor() { return {getObject()->getColor()}; }
 
-  JSI_HOST_FUNCTION(getStrokeCap) {
+  double getStrokeCap() {
     return static_cast<double>(getObject()->getStrokeCap());
   }
 
-  JSI_HOST_FUNCTION(getStrokeJoin) {
+  double getStrokeJoin() {
     return static_cast<double>(getObject()->getStrokeJoin());
   }
 
-  JSI_HOST_FUNCTION(getStrokeMiter) {
+  double getStrokeMiter() {
     return static_cast<double>(getObject()->getStrokeMiter());
   }
 
-  JSI_HOST_FUNCTION(getStrokeWidth) {
+  double getStrokeWidth() {
     return static_cast<double>(getObject()->getStrokeWidth());
   }
 
-  JSI_HOST_FUNCTION(getAlphaf) {
-    float alphaf = getObject()->getAlphaf();
-    return jsi::Value(SkScalarToDouble(alphaf));
-  }
+  double getAlphaf() { return SkScalarToDouble(getObject()->getAlphaf()); }
 
-  JSI_HOST_FUNCTION(setColor) {
-    SkColor color = JsiSkColor::fromValue(runtime, arguments[0]);
-    getObject()->setColor(color);
-    return jsi::Value::undefined();
-  }
+  void setColor(JsiColor color) { getObject()->setColor(color); }
 
-  JSI_HOST_FUNCTION(setAlphaf) {
-    SkScalar alpha = arguments[0].asNumber();
-    getObject()->setAlphaf(alpha);
-    return jsi::Value::undefined();
-  }
+  void setAlphaf(double alpha) { getObject()->setAlphaf(alpha); }
 
-  JSI_HOST_FUNCTION(setAntiAlias) {
-    bool antiAliased = arguments[0].getBool();
+  void setAntiAlias(bool antiAliased) {
     getObject()->setAntiAlias(antiAliased);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setDither) {
-    bool dithered = arguments[0].getBool();
-    getObject()->setDither(dithered);
-    return jsi::Value::undefined();
-  }
+  void setDither(bool dithered) { getObject()->setDither(dithered); }
 
-  JSI_HOST_FUNCTION(setStrokeWidth) {
-    SkScalar width = arguments[0].asNumber();
-    getObject()->setStrokeWidth(width);
-    return jsi::Value::undefined();
-  }
+  void setStrokeWidth(double width) { getObject()->setStrokeWidth(width); }
 
-  JSI_HOST_FUNCTION(setStyle) {
-    auto style = arguments[0].asNumber();
+  void setStyle(double style) {
     getObject()->setStyle(static_cast<SkPaint::Style>(style));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setStrokeCap) {
-    auto cap = arguments[0].asNumber();
+  void setStrokeCap(double cap) {
     getObject()->setStrokeCap(static_cast<SkPaint::Cap>(cap));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setStrokeJoin) {
-    int join = arguments[0].asNumber();
+  void setStrokeJoin(int join) {
     getObject()->setStrokeJoin(static_cast<SkPaint::Join>(join));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setStrokeMiter) {
-    int limit = arguments[0].asNumber();
-    getObject()->setStrokeMiter(limit);
-    return jsi::Value::undefined();
-  }
+  void setStrokeMiter(int limit) { getObject()->setStrokeMiter(limit); }
 
-  JSI_HOST_FUNCTION(setBlendMode) {
-    int blendModeValue = static_cast<int>(arguments[0].asNumber());
+  void setBlendMode(int blendModeValue) {
     applyBlendMode(*getObject(), blendModeValue);
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(setMaskFilter) {
-    auto maskFilter = arguments[0].isNull() || arguments[0].isUndefined()
-                          ? nullptr
-                          : JsiSkMaskFilter::fromValue(runtime, arguments[0]);
-    getObject()->setMaskFilter(std::move(maskFilter));
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(setImageFilter) {
-    auto imageFilter = arguments[0].isNull() || arguments[0].isUndefined()
-                           ? nullptr
-                           : JsiSkImageFilter::fromValue(runtime, arguments[0]);
-    getObject()->setImageFilter(std::move(imageFilter));
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(setColorFilter) {
-    auto colorFilter = arguments[0].isNull() || arguments[0].isUndefined()
-                           ? nullptr
-                           : JsiSkColorFilter::fromValue(runtime, arguments[0]);
-    getObject()->setColorFilter(std::move(colorFilter));
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(setShader) {
-    auto shader = arguments[0].isNull() || arguments[0].isUndefined()
-                      ? nullptr
-                      : JsiSkShader::fromValue(runtime, arguments[0]);
-    getObject()->setShader(std::move(shader));
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(setPathEffect) {
-    auto pathEffect = arguments[0].isNull() || arguments[0].isUndefined()
-                          ? nullptr
-                          : JsiSkPathEffect::fromValue(runtime, arguments[0]);
-    getObject()->setPathEffect(std::move(pathEffect));
-    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))
+  }
+
+  void setMaskFilter(JsiOptional<sk_sp<SkMaskFilter>> maskFilter) {
+    getObject()->setMaskFilter(
+        maskFilter.has_value() ? std::move(*maskFilter) : nullptr);
+  }
+
+  void setImageFilter(JsiOptional<sk_sp<SkImageFilter>> imageFilter) {
+    getObject()->setImageFilter(
+        imageFilter.has_value() ? std::move(*imageFilter) : nullptr);
+  }
+
+  void setColorFilter(JsiOptional<sk_sp<SkColorFilter>> colorFilter) {
+    getObject()->setColorFilter(
+        colorFilter.has_value() ? std::move(*colorFilter) : nullptr);
+  }
+
+  void setShader(JsiOptional<sk_sp<SkShader>> shader) {
+    getObject()->setShader(shader.has_value() ? std::move(*shader) : nullptr);
+  }
+
+  void setPathEffect(JsiOptional<sk_sp<SkPathEffect>> pathEffect) {
+    getObject()->setPathEffect(
+        pathEffect.has_value() ? std::move(*pathEffect) : nullptr);
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "assign", &JsiSkPaint::assign);
+    installMethod(runtime, prototype, "copy", &JsiSkPaint::copy);
+    installMethod(runtime, prototype, "reset", &JsiSkPaint::reset);
+    installMethod(runtime, prototype, "getAlphaf", &JsiSkPaint::getAlphaf);
+    installMethod(runtime, prototype, "getColor", &JsiSkPaint::getColor);
+    installMethod(runtime, prototype, "getStrokeCap",
+                  &JsiSkPaint::getStrokeCap);
+    installMethod(runtime, prototype, "getStrokeJoin",
+                  &JsiSkPaint::getStrokeJoin);
+    installMethod(runtime, prototype, "getStrokeMiter",
+                  &JsiSkPaint::getStrokeMiter);
+    installMethod(runtime, prototype, "getStrokeWidth",
+                  &JsiSkPaint::getStrokeWidth);
+    installMethod(runtime, prototype, "setPathEffect",
+                  &JsiSkPaint::setPathEffect);
+    installMethod(runtime, prototype, "setShader", &JsiSkPaint::setShader);
+    installMethod(runtime, prototype, "setColorFilter",
+                  &JsiSkPaint::setColorFilter);
+    installMethod(runtime, prototype, "setImageFilter",
+                  &JsiSkPaint::setImageFilter);
+    installMethod(runtime, prototype, "setMaskFilter",
+                  &JsiSkPaint::setMaskFilter);
+    installMethod(runtime, prototype, "setBlendMode",
+                  &JsiSkPaint::setBlendMode);
+    installMethod(runtime, prototype, "setStrokeMiter",
+                  &JsiSkPaint::setStrokeMiter);
+    installMethod(runtime, prototype, "setStrokeJoin",
+                  &JsiSkPaint::setStrokeJoin);
+    installMethod(runtime, prototype, "setStrokeCap",
+                  &JsiSkPaint::setStrokeCap);
+    installMethod(runtime, prototype, "setAntiAlias",
+                  &JsiSkPaint::setAntiAlias);
+    installMethod(runtime, prototype, "setDither", &JsiSkPaint::setDither);
+    installMethod(runtime, prototype, "setStrokeWidth",
+                  &JsiSkPaint::setStrokeWidth);
+    installMethod(runtime, prototype, "setStyle", &JsiSkPaint::setStyle);
+    installMethod(runtime, prototype, "setColor", &JsiSkPaint::setColor);
+    installMethod(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 +174,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 +191,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));
     };
   }
 };

package/cpp/api/JsiSkParagraph.h

@@ -3,13 +3,14 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include <jsi/jsi.h>
 
 #include "JsiSkCanvas.h"
 #include "JsiSkFont.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPath.h"
 #include "JsiSkRect.h"
 
@@ -31,65 +32,51 @@ 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);
-    getObject()->layout(width);
-    return jsi::Value::undefined();
-  }
+  void layout(double width) { getObject()->layout(width); }
 
-  JSI_HOST_FUNCTION(paint) {
-    auto jsiCanvas =
-        getArgumentAsHostObject<JsiSkCanvas>(runtime, arguments, count, 0);
-    auto x = getArgumentAsNumber(runtime, arguments, count, 1);
-    auto y = getArgumentAsNumber(runtime, arguments, count, 2);
+  void paint(std::shared_ptr<JsiSkCanvas> jsiCanvas, double x, double y) {
     getObject()->paint(jsiCanvas->getCanvas(), x, y);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(getHeight) {
-    return static_cast<double>(getObject()->getHeight());
-  }
+  double getHeight() { return static_cast<double>(getObject()->getHeight()); }
 
-  JSI_HOST_FUNCTION(getMaxWidth) {
+  double getMaxWidth() {
     return static_cast<double>(getObject()->getMaxWidth());
   }
 
-  JSI_HOST_FUNCTION(getMaxIntrinsicWidth) {
+  double getMaxIntrinsicWidth() {
     return static_cast<double>(getObject()->getMaxIntrinsicWidth());
   }
 
-  JSI_HOST_FUNCTION(getMinIntrinsicWidth) {
+  double getMinIntrinsicWidth() {
     return static_cast<double>(getObject()->getMinIntrinsicWidth());
   }
 
-  JSI_HOST_FUNCTION(getLongestLine) {
+  double getLongestLine() {
     return static_cast<double>(getObject()->getLongestLine());
   }
 
-  JSI_HOST_FUNCTION(getGlyphPositionAtCoordinate) {
-    auto dx = getArgumentAsNumber(runtime, arguments, count, 0);
-    auto dy = getArgumentAsNumber(runtime, arguments, count, 1);
+  int getGlyphPositionAtCoordinate(double dx, double dy) {
     auto result = getObject()->getGlyphPositionAtCoordinate(dx, dy);
     return result.position;
   }
 
-  JSI_HOST_FUNCTION(getRectsForRange) {
-    auto start = getArgumentAsNumber(runtime, arguments, count, 0);
-    auto end = getArgumentAsNumber(runtime, arguments, count, 1);
+  std::vector<std::shared_ptr<JsiSkRect>> getRectsForRange(double start,
+                                                           double end) {
     auto result =
         getObject()->getRectsForRange(start, end, para::RectHeightStyle::kTight,
                                       para::RectWidthStyle::kTight);
-    auto returnValue = jsi::Array(runtime, result.size());
-    for (size_t i = 0; i < result.size(); ++i) {
-      returnValue.setValueAtIndex(
-          runtime, i,
-          JsiSkRect::toValue(runtime, getContext(), result[i].rect));
+    std::vector<std::shared_ptr<JsiSkRect>> rects;
+    rects.reserve(result.size());
+    for (const auto &box : result) {
+      rects.push_back(std::make_shared<JsiSkRect>(getContext(), box.rect));
     }
-    return returnValue;
+    return rects;
   }
 
   JSI_HOST_FUNCTION(getLineMetrics) {
@@ -142,14 +129,13 @@ public:
     return returnValue;
   }
 
-  JSI_HOST_FUNCTION(getPath) {
-    auto lineNumber =
-        static_cast<int>(getArgumentAsNumber(runtime, arguments, count, 0));
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkPath>>
+  getPath(int lineNumber) {
     auto paragraph = getObject();
     // Paragraph::getPath does not bounds-check the line number.
     if (lineNumber < 0 ||
         static_cast<size_t>(lineNumber) >= paragraph->lineNumber()) {
-      return jsi::Value::null();
+      return nullptr;
     }
     // Paragraph::getPath resets its path builder after every visual run, so
     // for lines shaped as multiple runs (e.g. through font fallback) it only
@@ -182,10 +168,7 @@ 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 std::make_shared<JsiSkPath>(getContext(), std::move(path));
   }
 
   JSI_HOST_FUNCTION(extendedVisit) {
@@ -203,10 +186,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 +251,37 @@ 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);
+    installMethod(runtime, prototype, "layout", &JsiSkParagraph::layout);
+    installMethod(runtime, prototype, "paint", &JsiSkParagraph::paint);
+    installMethod(runtime, prototype, "getMaxWidth",
+                  &JsiSkParagraph::getMaxWidth);
+    installMethod(runtime, prototype, "getMinIntrinsicWidth",
+                  &JsiSkParagraph::getMinIntrinsicWidth);
+    installMethod(runtime, prototype, "getMaxIntrinsicWidth",
+                  &JsiSkParagraph::getMaxIntrinsicWidth);
+    installMethod(runtime, prototype, "getLongestLine",
+                  &JsiSkParagraph::getLongestLine);
+    installMethod(runtime, prototype, "getHeight", &JsiSkParagraph::getHeight);
+    installHostMethod(runtime, prototype, "getRectsForPlaceholders",
+                      &JsiSkParagraph::getRectsForPlaceholders);
+    installMethod(runtime, prototype, "getGlyphPositionAtCoordinate",
+                  &JsiSkParagraph::getGlyphPositionAtCoordinate);
+    installMethod(runtime, prototype, "getRectsForRange",
+                  &JsiSkParagraph::getRectsForRange);
+    installHostMethod(runtime, prototype, "getLineMetrics",
+                      &JsiSkParagraph::getLineMetrics);
+    installMethod(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()) {}
 };