@shopify/react-native-skia 2.2.10 → 2.2.12

package/cpp/api/JsiSkParagraph.h

@@ -95,46 +95,47 @@ public:
     std::vector<para::LineMetrics> metrics;
     getObject()->getLineMetrics(metrics);
     auto returnValue = jsi::Array(runtime, metrics.size());
-    
+
     for (size_t i = 0; i < metrics.size(); ++i) {
       auto lineMetrics = jsi::Object(runtime);
-      
+
       // Text indices
-      lineMetrics.setProperty(runtime, "startIndex", 
+      lineMetrics.setProperty(runtime, "startIndex",
                               static_cast<double>(metrics[i].fStartIndex));
-      lineMetrics.setProperty(runtime, "endIndex", 
+      lineMetrics.setProperty(runtime, "endIndex",
                               static_cast<double>(metrics[i].fEndIndex));
-      lineMetrics.setProperty(runtime, "endExcludingWhitespaces", 
-                              static_cast<double>(metrics[i].fEndExcludingWhitespaces));
-      lineMetrics.setProperty(runtime, "endIncludingNewline", 
-                              static_cast<double>(metrics[i].fEndIncludingNewline));
-      
+      lineMetrics.setProperty(
+          runtime, "endExcludingWhitespaces",
+          static_cast<double>(metrics[i].fEndExcludingWhitespaces));
+      lineMetrics.setProperty(
+          runtime, "endIncludingNewline",
+          static_cast<double>(metrics[i].fEndIncludingNewline));
+
       // Line break info
-      lineMetrics.setProperty(runtime, "isHardBreak", 
-                              metrics[i].fHardBreak);
-      
+      lineMetrics.setProperty(runtime, "isHardBreak", metrics[i].fHardBreak);
+
       // Vertical metrics
-      lineMetrics.setProperty(runtime, "ascent", 
+      lineMetrics.setProperty(runtime, "ascent",
                               static_cast<double>(metrics[i].fAscent));
-      lineMetrics.setProperty(runtime, "descent", 
+      lineMetrics.setProperty(runtime, "descent",
                               static_cast<double>(metrics[i].fDescent));
-      lineMetrics.setProperty(runtime, "height", 
+      lineMetrics.setProperty(runtime, "height",
                               static_cast<double>(metrics[i].fHeight));
-      
+
       // Horizontal metrics
-      lineMetrics.setProperty(runtime, "width", 
+      lineMetrics.setProperty(runtime, "width",
                               static_cast<double>(metrics[i].fWidth));
-      lineMetrics.setProperty(runtime, "left", 
+      lineMetrics.setProperty(runtime, "left",
                               static_cast<double>(metrics[i].fLeft));
-      
+
       // Position
-      lineMetrics.setProperty(runtime, "baseline", 
+      lineMetrics.setProperty(runtime, "baseline",
                               static_cast<double>(metrics[i].fBaseline));
-      
+
       // Line number
-      lineMetrics.setProperty(runtime, "lineNumber", 
+      lineMetrics.setProperty(runtime, "lineNumber",
                               static_cast<double>(metrics[i].fLineNumber));
-      
+
       returnValue.setValueAtIndex(runtime, i, lineMetrics);
     }
     return returnValue;
@@ -170,6 +171,8 @@ public:
                        JSI_EXPORT_FUNC(JsiSkParagraph, getLineMetrics),
                        JSI_EXPORT_FUNC(JsiSkParagraph, dispose))
 
+  size_t getMemoryPressure() const override { return 8192; }
+
   explicit JsiSkParagraph(std::shared_ptr<RNSkPlatformContext> context,
                           para::ParagraphBuilder *paragraphBuilder)
       : JsiSkWrappingSharedPtrHostObject<para::Paragraph>(

package/cpp/api/JsiSkParagraphBuilder.h

@@ -35,9 +35,10 @@ public:
   JSI_API_TYPENAME("ParagraphBuilder");
 
   JSI_HOST_FUNCTION(build) {
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkParagraph>(getContext(), _builder.get()));
+    auto paragraph =
+        std::make_shared<JsiSkParagraph>(getContext(), _builder.get());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, paragraph,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(reset) {
@@ -109,6 +110,8 @@ public:
                        JSI_EXPORT_FUNC(JsiSkParagraphBuilder, pushStyle),
                        JSI_EXPORT_FUNC(JsiSkParagraphBuilder, pop))
 
+  size_t getMemoryPressure() const override { return 4096; }
+
   explicit JsiSkParagraphBuilder(std::shared_ptr<RNSkPlatformContext> context,
                                  para::ParagraphStyle paragraphStyle,
                                  sk_sp<SkFontMgr> fontManager)

package/cpp/api/JsiSkParagraphBuilderFactory.h

@@ -39,13 +39,16 @@ public:
                   : nullptr;
 
     // Create the paragraph builder
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkParagraphBuilder>(
-                     getContext(), paragraphStyle, fontMgr));
+    auto builder = std::make_shared<JsiSkParagraphBuilder>(
+        getContext(), paragraphStyle, fontMgr);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, builder,
+                                                       getContext());
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkParagraphBuilderFactory, Make))
 
+  size_t getMemoryPressure() const override { return 3072; }
+
   explicit JsiSkParagraphBuilderFactory(
       std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/JsiSkPath.h

@@ -173,15 +173,17 @@ public:
 
   JSI_HOST_FUNCTION(computeTightBounds) {
     auto result = getObject()->computeTightBounds();
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkRect>(getContext(), std::move(result)));
+    auto hostObjectInstance = std::make_shared<JsiSkRect>(getContext(), result);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   // TODO-API: Should this be a property?
   JSI_HOST_FUNCTION(getBounds) {
     auto result = getObject()->getBounds();
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkRect>(getContext(), std::move(result)));
+    auto hostObjectInstance = std::make_shared<JsiSkRect>(getContext(), result);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(conicTo) {
@@ -330,8 +332,9 @@ public:
   JSI_HOST_FUNCTION(getPoint) {
     auto index = arguments[0].asNumber();
     auto point = getObject()->getPoint(index);
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPoint>(getContext(), point));
+    auto hostObjectInstance = std::make_shared<JsiSkPoint>(getContext(), point);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(toSVGString) {
@@ -473,8 +476,10 @@ public:
 
   JSI_HOST_FUNCTION(copy) {
     const auto *path = getObject().get();
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), SkPath(*path)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), SkPath(*path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(op) {
@@ -509,8 +514,10 @@ public:
     if (!succeed) {
       return nullptr;
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(result));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
   JSI_HOST_FUNCTION(toCmds) {
     auto path = *getObject();
@@ -633,19 +640,30 @@ public:
       : JsiSkWrappingSharedPtrHostObject<SkPath>(
             std::move(context), std::make_shared<SkPath>(std::move(path))) {}
 
+  size_t getMemoryPressure() const override {
+    auto path = getObject();
+    if (!path)
+      return 0;
+
+    // SkPath provides approximateBytesUsed() to estimate memory usage
+    return path->approximateBytesUsed();
+  }
+
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkPath &path) {
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPath>(std::move(context), path));
+    auto hostObjectInstance = std::make_shared<JsiSkPath>(context, path);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, context);
   }
 
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             SkPath &&path) {
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkPath>(std::move(context), std::move(path)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(context, std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, context);
   }
 };
 

package/cpp/api/JsiSkPathEffect.h

@@ -25,6 +25,8 @@ public:
       : JsiSkWrappingSkPtrHostObject<SkPathEffect>(std::move(context),
                                                    std::move(pathEffect)) {}
 
+  size_t getMemoryPressure() const override { return 2048; }
+
   EXPORT_JSI_API_TYPENAME(JsiSkPathEffect, PathEffect)
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathEffect, dispose))
 };

package/cpp/api/JsiSkPathEffectFactory.h

@@ -29,9 +29,10 @@ class JsiSkPathEffectFactory : public JsiSkHostObject {
 public:
   JSI_HOST_FUNCTION(MakeCorner) {
     int radius = arguments[0].asNumber();
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(), SkCornerPathEffect::Make(radius)));
+    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+        getContext(), SkCornerPathEffect::Make(radius));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeDash) {
@@ -48,39 +49,40 @@ public:
             ? arguments[1].asNumber()
             : 0;
     auto i = SkSpan(intervals.data(), intervals.size());
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(), SkDashPathEffect::Make(i, phase)));
+    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+        getContext(), SkDashPathEffect::Make(i, phase));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeDiscrete) {
     int segLength = arguments[0].asNumber();
     int dec = arguments[1].asNumber();
     int seedAssist = arguments[2].asNumber();
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(),
-                     SkDiscretePathEffect::Make(segLength, dec, seedAssist)));
+    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+        getContext(), SkDiscretePathEffect::Make(segLength, dec, seedAssist));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeCompose) {
     auto outer = JsiSkPathEffect::fromValue(runtime, arguments[0]);
     auto inner = JsiSkPathEffect::fromValue(runtime, arguments[1]);
-
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(), SkPathEffect::MakeCompose(
-                                       std::move(outer), std::move(inner))));
+    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+        getContext(),
+        SkPathEffect::MakeCompose(std::move(outer), std::move(inner)));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeSum) {
     auto outer = JsiSkPathEffect::fromValue(runtime, arguments[0]);
     auto inner = JsiSkPathEffect::fromValue(runtime, arguments[1]);
-
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(), SkPathEffect::MakeSum(std::move(outer),
-                                                         std::move(inner))));
+    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+        getContext(),
+        SkPathEffect::MakeSum(std::move(outer), std::move(inner)));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakePath1D) {
@@ -89,27 +91,28 @@ public:
     auto phase = arguments[2].asNumber();
     auto style =
         static_cast<SkPath1DPathEffect::Style>(arguments[3].asNumber());
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(),
-                     SkPath1DPathEffect::Make(*path, advance, phase, style)));
+    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+        getContext(), SkPath1DPathEffect::Make(*path, advance, phase, style));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakePath2D) {
     auto matrix = JsiSkMatrix::fromValue(runtime, arguments[0]);
     auto path = JsiSkPath::fromValue(runtime, arguments[1]);
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(), SkPath2DPathEffect::Make(*matrix, *path)));
+    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+        getContext(), SkPath2DPathEffect::Make(*matrix, *path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeLine2D) {
     auto width = arguments[0].asNumber();
     auto matrix = JsiSkMatrix::fromValue(runtime, arguments[1]);
-
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(), SkLine2DPathEffect::Make(width, *matrix)));
+    auto pathEffect = std::make_shared<JsiSkPathEffect>(
+        getContext(), SkLine2DPathEffect::Make(width, *matrix));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pathEffect,
+                                                       getContext());
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeCorner),
@@ -119,7 +122,9 @@ public:
                        JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeSum),
                        JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeLine2D),
                        JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath1D),
-                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath2D), )
+                       JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath2D))
+
+  size_t getMemoryPressure() const override { return 1024; }
 
   explicit JsiSkPathEffectFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/JsiSkPathFactory.h

@@ -32,8 +32,10 @@ class JsiSkPathFactory : public JsiSkHostObject {
 
 public:
   JSI_HOST_FUNCTION(Make) {
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), SkPath()));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), SkPath());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromSVGString) {
@@ -45,8 +47,10 @@ public:
       return jsi::Value(nullptr);
     }
 
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(result));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromOp) {
@@ -58,8 +62,10 @@ public:
     if (!success) {
       return jsi::Value(nullptr);
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(result));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromCmds) {
@@ -144,8 +150,10 @@ public:
       }
       }
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromText) {
@@ -156,10 +164,14 @@ public:
     SkPath path;
     SkTextUtils::GetPath(text.c_str(), strlen(text.c_str()),
                          SkTextEncoding::kUTF8, x, y, *font, &path);
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathFactory, Make),
                        JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromSVGString),
                        JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromOp),

package/cpp/api/JsiSkPicture.h

@@ -39,8 +39,9 @@ public:
 
     // Create shader
     auto shader = getObject()->makeShader(tmx, tmy, fm, m, tr);
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkShader>(getContext(), shader));
+    auto shaderObj = std::make_shared<JsiSkShader>(getContext(), shader);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(serialize) {
@@ -67,5 +68,15 @@ public:
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPicture, makeShader),
                        JSI_EXPORT_FUNC(JsiSkPicture, serialize),
                        JSI_EXPORT_FUNC(JsiSkPicture, dispose))
+
+  size_t getMemoryPressure() const override {
+    auto picture = getObject();
+    if (!picture) {
+      return 0;
+    }
+    // SkPicture provides approximateBytesUsed() method to estimate memory usage
+    auto bytesUsed = picture->approximateBytesUsed();
+    return bytesUsed;
+  }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkPictureFactory.h

@@ -35,8 +35,10 @@ public:
         SkData::MakeWithCopy(buffer.data(runtime), buffer.size(runtime));
     auto picture = SkPicture::MakeFromData(data.get());
     if (picture != nullptr) {
-      return jsi::Object::createFromHostObject(
-          runtime, std::make_shared<JsiSkPicture>(getContext(), picture));
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPicture>(getContext(), std::move(picture));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
     } else {
       return jsi::Value::undefined();
     }
@@ -44,6 +46,8 @@ public:
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPictureFactory, MakePicture))
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   explicit JsiSkPictureFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}
 };

package/cpp/api/JsiSkPictureRecorder.h

@@ -37,14 +37,17 @@ public:
       SkRect rect = SkRect::Make(size);
       canvas = getObject()->beginRecording(rect, nullptr);
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkCanvas>(getContext(), canvas));
+    auto canvasObj = std::make_shared<JsiSkCanvas>(getContext(), canvas);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, canvasObj,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(finishRecordingAsPicture) {
     auto picture = getObject()->finishRecordingAsPicture();
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPicture>(getContext(), picture));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPicture>(getContext(), std::move(picture));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   EXPORT_JSI_API_TYPENAME(JsiSkPictureRecorder, PictureRecorder)
@@ -54,11 +57,16 @@ public:
                                        finishRecordingAsPicture),
                        JSI_EXPORT_FUNC(JsiSkPictureRecorder, dispose))
 
+  size_t getMemoryPressure() const override {
+    return sizeof(SkPictureRecorder);
+  }
+
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {
     return JSI_HOST_FUNCTION_LAMBDA {
-      return jsi::Object::createFromHostObject(
-          runtime, std::make_shared<JsiSkPictureRecorder>(context));
+      auto recorder = std::make_shared<JsiSkPictureRecorder>(context);
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, recorder,
+                                                         context);
     };
   }
 };

package/cpp/api/JsiSkPoint.h

@@ -57,10 +57,13 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkPoint &point) {
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPoint>(std::move(context), point));
+    auto pointObj = std::make_shared<JsiSkPoint>(std::move(context), point);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pointObj,
+                                                       context);
   }
 
+  size_t getMemoryPressure() const override { return sizeof(SkPoint); }
+
   /**
    * Creates the function for construction a new instance of the SkPoint
    * wrapper
@@ -75,9 +78,10 @@ public:
           SkPoint::Make(arguments[0].asNumber(), arguments[1].asNumber());
 
       // Return the newly constructed object
-      return jsi::Object::createFromHostObject(
-          runtime,
-          std::make_shared<JsiSkPoint>(std::move(context), std::move(point)));
+      auto pointObj =
+          std::make_shared<JsiSkPoint>(std::move(context), std::move(point));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, pointObj,
+                                                         context);
     };
   }
 };

package/cpp/api/JsiSkRRect.h

@@ -30,9 +30,10 @@ public:
     return static_cast<double>(getObject()->getSimpleRadii().y());
   }
   JSI_PROPERTY_GET(rect) {
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkRect>(getContext(), getObject()->getBounds()));
+    auto rectObj =
+        std::make_shared<JsiSkRect>(getContext(), getObject()->getBounds());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rectObj,
+                                                       getContext());
   }
 
   JSI_API_TYPENAME("RRect");
@@ -100,10 +101,13 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkRRect &rect) {
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkRRect>(std::move(context), rect));
+    auto rrectObj = std::make_shared<JsiSkRRect>(std::move(context), rect);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rrectObj,
+                                                       context);
   }
 
+  size_t getMemoryPressure() const override { return sizeof(SkRRect); }
+
   /**
    * Creates the function for construction a new instance of the SkRect
    * wrapper
@@ -120,9 +124,10 @@ public:
       auto ry = arguments[2].asNumber();
       auto rrect = SkRRect::MakeRectXY(*rect, rx, ry);
       // Return the newly constructed object
-      return jsi::Object::createFromHostObject(
-          runtime,
-          std::make_shared<JsiSkRRect>(std::move(context), std::move(rrect)));
+      auto rrectObj =
+          std::make_shared<JsiSkRRect>(std::move(context), std::move(rrect));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rrectObj,
+                                                         context);
     };
   }
 };

package/cpp/api/JsiSkRSXform.h

@@ -84,8 +84,10 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkRSXform &rsxform) {
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkRSXform>(std::move(context), rsxform));
+    auto rsxformObj =
+        std::make_shared<JsiSkRSXform>(std::move(context), rsxform);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rsxformObj,
+                                                       context);
   }
 
   /**
@@ -103,11 +105,14 @@ public:
           arguments[2].asNumber(), arguments[3].asNumber(),
           arguments[4].asNumber(), arguments[5].asNumber());
       // Return the newly constructed object
-      return jsi::Object::createFromHostObject(
-          runtime, std::make_shared<JsiSkRSXform>(std::move(context),
-                                                  std::move(rsxform)));
+      auto rsxformObj = std::make_shared<JsiSkRSXform>(std::move(context),
+                                                       std::move(rsxform));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rsxformObj,
+                                                         context);
     };
   }
+  size_t getMemoryPressure() const override { return sizeof(SkRSXform); }
+
   /**
    * Creates the function for construction a new instance of the SkRSXform
    * wrapper
@@ -122,9 +127,10 @@ public:
           SkRSXform::Make(arguments[0].asNumber(), arguments[1].asNumber(),
                           arguments[2].asNumber(), arguments[3].asNumber());
       // Return the newly constructed object
-      return jsi::Object::createFromHostObject(
-          runtime, std::make_shared<JsiSkRSXform>(std::move(context),
-                                                  std::move(rsxform)));
+      auto rsxformObj = std::make_shared<JsiSkRSXform>(std::move(context),
+                                                       std::move(rsxform));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rsxformObj,
+                                                         context);
     };
   }
 };